importrpm.cc

About: Paco (pacKAGE oRGANIZER) is a simple, yet powerful tool to aid package management when insta

//=======================================================================
// ImportRPM.cc
//-----------------------------------------------------------------------
// This file is part of the package paco
// Copyright (C) 2004-2007 David Rosal <[e-mail]>
// For more information visit http://paco.sourceforge.net
//=======================================================================

#include "config.h"
#include "Config.h"
#include "ImportRPM.h"
#include "MainWindow.h"
#include "globals.h"
#include <gtkmm/checkbutton.h>
#include <gtkmm/tooltips.h>
#include <gtkmm/stock.h>
#include <gtkmm/expander.h>
#include <gtkmm/scrolledwindow.h>
#include <gtkmm/box.h>
#include <gtkmm/buttonbox.h>
#include <gtkmm/sizegroup.h>
#include <glibmm/iochannel.h>

using std::string;
using std::vector;
using Glib::ustring;
using Glib::RefPtr;
using sigc::mem_fun;
using namespace Gpaco;

ImportRPM* ImportRPM::spImportRPM = NULL;


ImportRPM::ImportRPM()
:
	Gtk::Window(Gtk::WINDOW_TOPLEVEL),
	mRpm2paco(Glib::find_program_in_path("rpm2paco")),
	mProgressBar(),
	mButtonImport(Gtk::Stock::EXECUTE, "_Import"),
	mButtonClose(Gtk::Stock::CLOSE, "_Close"),
	mButtonStop(Gtk::Stock::STOP, "_Stop"),
	mTextView(),
	mpTextBuffer(mTextView.get_buffer()),
	mpTextTag(mpTextBuffer->create_tag()),
	mOptOverwrite(false),
	mOptStripRelease(false),
	mOptSync(false),
	mStop(false)
{
	g_assert(Config::logdirWritable());

	if (mRpm2paco.empty()) {
		errorDialog(NULL, "Cannot find rpm2paco executable");
		return;
	}

	set_default_size(200, -1);
	set_title("gpaco :: import RPM");
	set_modal();
	try {
		set_icon_from_file(DATADIR "/pixmaps/gpaco.png");
	}
	catch (...) { }
	
	Gtk::CheckButton* pButtonOverwrite(Gtk::manage
		(new Gtk::CheckButton("_Overwrite", true)));
	pButtonOverwrite->signal_toggled().connect
		(mem_fun(*this, &ImportRPM::onSwitchOverwrite));
	gpTips->set_tip(*pButtonOverwrite,
		"Force overwrite of already logged packages (option -f in rpm2paco)");

	Gtk::CheckButton* pButtonStripRelease(Gtk::manage
		(new Gtk::CheckButton("_Strip release", true)));
	pButtonStripRelease->signal_toggled().connect
		(mem_fun(*this, &ImportRPM::onSwitchStripRelease));
	gpTips->set_tip(*pButtonStripRelease,
		"Remove the RPM release suffix from the name of the packages, "
		"(e.g. foo-2.0.2-1 --> foo-2.0.2) (option -s in rpm2paco)");

	Gtk::CheckButton* pButtonSync(Gtk::manage
		(new Gtk::CheckButton("Sync _versions", true)));
	pButtonSync->signal_toggled().connect
		(mem_fun(*this, &ImportRPM::onSwitchSync));
	gpTips->set_tip(*pButtonSync,
		"Remove obsolete versions of the packages from the paco database "
		"(option -j in rpm2paco)");

	Gtk::HBox* pHBox(Gtk::manage(new Gtk::HBox(false, 8)));
	pHBox->pack_start(*pButtonOverwrite, Gtk::PACK_SHRINK);
	pHBox->pack_start(*pButtonStripRelease, Gtk::PACK_SHRINK);
	pHBox->pack_start(*pButtonSync, Gtk::PACK_SHRINK);

	mTextView.set_editable(false);
	mTextView.set_cursor_visible(false);
	mTextView.set_left_margin(4);
	mTextView.set_right_margin(4);
	mTextView.modify_base(Gtk::STATE_NORMAL, Gdk::Color("black"));
	
	mpTextTag->property_foreground() = "white";
	mpTextTag->property_weight() = Pango::WEIGHT_BOLD;
	mpTextTag->property_family() = "courier";
	
	Gtk::ScrolledWindow* pScrolledWindow(Gtk::manage(new Gtk::ScrolledWindow));
	pScrolledWindow->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	pScrolledWindow->add(mTextView);

	Gtk::Expander* pExpander(Gtk::manage
		(new Gtk::Expander("rpm2paco output:")));
	pExpander->add(*pScrolledWindow);
	
	mProgressBar.set_pulse_step(0.005);

	RefPtr<Gtk::SizeGroup> pSizeGroup = Gtk::SizeGroup::create
		(Gtk::SIZE_GROUP_HORIZONTAL);
	pSizeGroup->add_widget(mButtonClose);
	pSizeGroup->add_widget(mButtonStop);
	
	Gtk::HButtonBox* pHButtonBox = Gtk::manage
		(new Gtk::HButtonBox(Gtk::BUTTONBOX_EDGE));
	pHButtonBox->pack_start(mButtonImport, Gtk::PACK_SHRINK);
	pHButtonBox->pack_end(mButtonClose, Gtk::PACK_SHRINK);
	pHButtonBox->pack_end(mButtonStop, Gtk::PACK_SHRINK);

	mButtonClose.signal_clicked().connect(mem_fun
		(*this, &ImportRPM::onClose));
	mButtonStop.signal_clicked().connect(mem_fun
		(*this, &ImportRPM::onStop));
	mButtonImport.signal_clicked().connect(mem_fun
		(*this, &ImportRPM::onImport));

	Gtk::VBox* pVBox = Gtk::manage(new Gtk::VBox);
	pVBox->pack_start(*pHBox, Gtk::PACK_SHRINK, 4);
	pVBox->pack_start(mProgressBar, Gtk::PACK_SHRINK, 8);
	pVBox->pack_start(*pExpander, Gtk::PACK_EXPAND_WIDGET, 8);
	pVBox->pack_start(*pHButtonBox, Gtk::PACK_SHRINK, 4);
	
	set_border_width(8);
	add(*pVBox);

	show_all();
	mButtonStop.hide();
}


ImportRPM::~ImportRPM()
{ }


void ImportRPM::instance()
{
	g_assert(spImportRPM == NULL);
	spImportRPM = new ImportRPM();
}


// [virtual]
bool ImportRPM::on_delete_event(GdkEventAny*)
{
	mStop = true;
	onClose();
	return true;
}


void ImportRPM::onStop()
{
	g_assert(mStop == false);
	mStop = true;
}


void ImportRPM::onClose()
{
	g_assert(spImportRPM != NULL);
	delete spImportRPM;
	spImportRPM = NULL;
}


void ImportRPM::onImport()
{
	mStop = false;
	mButtonImport.set_sensitive(false);
	
	mpTextBuffer->erase(mpTextBuffer->begin(), mpTextBuffer->end());
	mpTextBuffer->insert(mpTextBuffer->end(), "\n");

	mButtonStop.show();
	mButtonClose.hide();

	vector<string> argv;
	argv.push_back(mRpm2paco);
	argv.push_back("--all");
	if (mOptOverwrite)
		argv.push_back("--force");
	if (mOptStripRelease)
		argv.push_back("--strip-release");
	if (mOptSync)
		argv.push_back("--sync-version");

	Glib::Pid pid;
	int stdOut, stdErr, status, cnt = 0;

	Glib::spawn_async_with_pipes(Glib::get_current_dir(), argv,
		Glib::SPAWN_DO_NOT_REAP_CHILD, sigc::slot<void>(), &pid,
		NULL, &stdOut, &stdErr);

	RefPtr<Glib::IOChannel> ioOut = Glib::IOChannel::create_from_fd(stdOut);
	ioOut->set_flags(Glib::IO_FLAG_NONBLOCK);
	ioOut->set_close_on_unref(true);

	RefPtr<Glib::IOChannel> ioErr = Glib::IOChannel::create_from_fd(stdErr);
	ioErr->set_flags(Glib::IO_FLAG_NONBLOCK);
	ioErr->set_close_on_unref(true);

	ustring buf;

	while (waitpid(pid, &status, WNOHANG) != pid) {
		if (mStop) {
			kill(pid, cnt++ ? SIGKILL : SIGTERM);
			Glib::usleep(30000);
		}
		else {
			mProgressBar.pulse();
			refreshMainLoop();
			if (ioOut->read(buf, 64) == Glib::IO_STATUS_NORMAL)
				output(buf);
			if (ioErr->read(buf, 1024) == Glib::IO_STATUS_NORMAL)
				output(buf);
		}
		Glib::usleep(2000);
	}

	g_return_if_fail(spImportRPM != NULL);

	if (ioOut->read_to_end(buf) == Glib::IO_STATUS_NORMAL)
		output(buf);
	
	if (!mStop && !WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS) {
		if (ioErr->read_to_end(buf) == Glib::IO_STATUS_NORMAL)
			output(buf + "\nError\n");
	}
	else
		output(ustring("\n") + (mStop ? "\nStopped" : "Done") + "\n");

	gpMainWindow->treeView().addNewPackages();
	gpMainWindow->treeView().markUnloggedPackages();

	mProgressBar.set_fraction(mStop ? 0 : 1);

	mButtonClose.show();
	mButtonStop.hide();
	mButtonImport.set_sensitive();
}


void ImportRPM::output(ustring const& str)
{
	mpTextBuffer->insert_with_tag(mpTextBuffer->end(), str, mpTextTag);
	Gtk::TextIter end = mpTextBuffer->end();
	mTextView.scroll_to(end);
	refreshMainLoop();
}


void ImportRPM::onSwitchStripRelease()
{
	mOptStripRelease = !mOptStripRelease;
}


void ImportRPM::onSwitchOverwrite()
{
	mOptOverwrite = !mOptOverwrite;
}


void ImportRPM::onSwitchSync()
{
	mOptSync = !mOptSync;
}