def _get_entries_for_test(self):
column_entries = []
def collect_entries(iter, entry):
column_entries.append(entry)
# Test that the data from a subscription is loaded into the store.
my_subs_tab = MySubscriptionsTab(self.backend, self.consumer, self.facts,
None, self.cert_dir)
my_subs_tab.store.add_map = collect_entries
my_subs_tab.update_subscriptions()
return column_entries
def _get_entries_for_test(self):
column_entries = []
def collect_entries(iter, entry):
column_entries.append(entry)
# Test that the data from a subscription is loaded into the store.
my_subs_tab = MySubscriptionsTab(self.backend, self.consumer,
self.facts, None, self.cert_dir)
my_subs_tab.store.add_map = collect_entries
my_subs_tab.update_subscriptions()
return column_entries
def test_no_subscriptions_unregister_button_is_blank(self):
cert_dir = StubCertificateDirectory([])
my_subs_tab = MySubscriptionsTab(self.backend,
None,
cert_dir,
StubProductDirectory([]))
self.assertFalse(my_subs_tab.unsubscribe_button.get_property('sensitive'))
def setUp(self):
self.uep = StubUEP
self.backend = StubBackend()
self.consumer = Mock()
self.facts = StubFacts({})
self.cert1 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10",
stacking_id=None)
self.cert_dir = StubCertificateDirectory([self.cert1])
self.my_subs_tab = MySubscriptionsTab(self.backend, self.consumer,
self.facts, None, self.cert_dir,
StubProductDirectory([]))
def setUp(self):
super(MySubscriptionsTabTest, self).setUp()
self.uep = StubUEP
self.backend = StubBackend()
self.cert1 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10", ent_id='prod2')
self.cert2 = StubEntitlementCertificate(
StubProduct('product3'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10", ent_id='prod3')
self.cert_dir = StubCertificateDirectory([self.cert1, self.cert2])
self.my_subs_tab = MySubscriptionsTab(self.backend,
None,
self.cert_dir,
StubProductDirectory([]))
def setUp(self):
super(MySubscriptionsTabTest, self).setUp()
self.uep = StubUEP
self.backend = StubBackend()
self.cert1 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10", ent_id='prod2')
self.cert2 = StubEntitlementCertificate(
StubProduct('product3'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10", ent_id='prod3')
self.cert_dir = StubCertificateDirectory([self.cert1, self.cert2])
self.my_subs_tab = MySubscriptionsTab(self.backend,
None,
self.cert_dir,
StubProductDirectory([]))
class MySubscriptionsTabTest(SubManFixture):
def setUp(self):
super(MySubscriptionsTabTest, self).setUp()
self.uep = StubUEP
self.backend = StubBackend()
self.cert1 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10", ent_id='prod2')
self.cert2 = StubEntitlementCertificate(
StubProduct('product3'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10", ent_id='prod3')
self.cert_dir = StubCertificateDirectory([self.cert1, self.cert2])
self.my_subs_tab = MySubscriptionsTab(self.backend,
None,
self.cert_dir,
StubProductDirectory([]))
def tearDown(self):
pass
def test_get_entry_image_expired(self):
cert = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2011, 1, 1),
quantity="10", stacking_id=None)
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(EXPIRED_IMG, image)
def test_get_entry_image_expiring(self):
tomorrow = datetime.datetime.now() + datetime.timedelta(days=1)
cert = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=tomorrow,
quantity="10", stacking_id=None)
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(EXPIRING_IMG, image)
def test_get_entry_image_warning(self):
ending = datetime.datetime.now() + datetime.timedelta(days=300)
cert = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=ending,
quantity="10", ent_id='ent')
self.my_subs_tab.backend.cs.reasons.get_subscription_reasons = Mock(return_value=['Some detail'])
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(WARNING_IMG, image)
def test_image_rank_both_none(self):
self.assertFalse(self.my_subs_tab.image_ranks_higher(None, None))
def test_image_rank_new_image_none(self):
self.assertFalse(self.my_subs_tab.image_ranks_higher(EXPIRING_IMG, None))
def test_image_rank_new_image_lower(self):
self.assertFalse(self.my_subs_tab.image_ranks_higher(EXPIRED_IMG, EXPIRING_IMG))
def test_image_rank_new_image_higher(self):
self.assertTrue(self.my_subs_tab.image_ranks_higher(EXPIRING_IMG, EXPIRED_IMG))
def test_image_rank_old_image_none(self):
self.assertTrue(self.my_subs_tab.image_ranks_higher(None, EXPIRED_IMG))
def test_image_rank_warn_none(self):
self.assertTrue(self.my_subs_tab.image_ranks_higher(None, WARNING_IMG))
def test_image_rank_warn_expiring(self):
self.assertTrue(self.my_subs_tab.image_ranks_higher(WARNING_IMG, EXPIRING_IMG))
def test_image_rank_warn_expired(self):
self.assertTrue(self.my_subs_tab.image_ranks_higher(WARNING_IMG, EXPIRED_IMG))
def test_correct_cert_data_inserted_into_store(self):
self.cert1.order.stacking_id = None
self.cert2.order.stacking_id = None
column_entries = self._get_entries_for_test()
self.assertEquals(2, len(column_entries))
self._assert_entry_1(column_entries[0])
self._assert_entry_2(column_entries[1])
def test_stacking_entry_not_inserted_when_stacking_id_exists(self):
self.cert1.order.stacking_id = 1234
self.cert2.order.stacking_id = None
column_entries = self._get_entries_for_test()
# single entry with stacking_id: no stacking entry
self.assertEquals(2, len(column_entries))
self._assert_entry_1(column_entries[0])
self._assert_entry_2(column_entries[1])
def test_stacking_entry_inserted_when_stacking_id_exists(self):
self.cert1.order.stacking_id = 1234
self.cert2.order.stacking_id = 1234
column_entries = self._get_entries_for_test()
self.assertEquals(3, len(column_entries))
self._assert_group_entry(column_entries[0])
self._assert_entry_1(column_entries[1])
self._assert_entry_2(column_entries[2])
def test_no_subscriptions_unregister_button_is_blank(self):
cert_dir = StubCertificateDirectory([])
my_subs_tab = MySubscriptionsTab(self.backend,
None,
cert_dir,
StubProductDirectory([]))
self.assertFalse(my_subs_tab.unsubscribe_button.get_property('sensitive'))
def test_unselect_unregister_button_is_blank(self):
self.my_subs_tab.on_no_selection()
self.assertFalse(self.my_subs_tab.unsubscribe_button.get_property('sensitive'))
def _get_entries_for_test(self):
column_entries = []
def collect_entries(tree_iter, entry):
column_entries.append(entry)
# Test that the data from a subscription is loaded into the store.
self.my_subs_tab.store.add_map = collect_entries
self.my_subs_tab.update_subscriptions()
return column_entries
def _assert_entry_1(self, entry):
self.assertEquals(self.cert1.order.name, entry['subscription'])
self.assertEquals(self.cert1.valid_range.begin(), entry['start_date'])
self.assertEquals(self.cert1.valid_range.end(), entry['expiration_date'])
self.assertEquals("0 / 1", entry['installed_text'])
self.assertEquals(0, entry['installed_value'])
# The quantity/serial column is of type string, so when we fetch it from the
# widget, it is a str.
self.assertEquals(str(self.cert1.order.quantity_used), entry['quantity'])
self.assertEquals(str(self.cert1.serial), entry['serial'])
self.assertFalse(entry['is_group_row'])
def _assert_entry_2(self, entry):
self.assertEquals(self.cert2.order.name, entry['subscription'])
self.assertEquals(self.cert2.valid_range.begin(), entry['start_date'])
self.assertEquals(self.cert2.valid_range.end(), entry['expiration_date'])
self.assertEquals("0 / 1", entry['installed_text'])
self.assertEquals(0, entry['installed_value'])
self.assertEquals(str(self.cert2.order.quantity_used), entry['quantity'])
self.assertEquals(str(self.cert2.serial), entry['serial'])
self.assertFalse(entry['is_group_row'])
def _assert_group_entry(self, entry):
self.assertEquals("Stack of %s and 1 other" % self.cert1.order.name,
entry['subscription'])
self.assertFalse('start_date' in entry)
self.assertFalse('expiration_date' in entry)
self.assertFalse('installed_text' in entry)
self.assertEquals(0.0, entry['installed_value'])
self.assertFalse('quantity' in entry)
self.assertFalse('serial' in entry)
self.assertTrue(entry['is_group_row'])
class MySubscriptionsTabTest(unittest.TestCase):
def setUp(self):
self.uep = StubUEP
self.backend = StubBackend()
self.consumer = Mock()
self.facts = StubFacts({})
self.cert1 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10",
stacking_id=None)
self.cert_dir = StubCertificateDirectory([self.cert1])
self.my_subs_tab = MySubscriptionsTab(self.backend, self.consumer,
self.facts, None, self.cert_dir,
StubProductDirectory([]))
def tearDown(self):
pass
def test_get_entry_image_expired(self):
cert = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2011, 1, 1),
quantity="10",
stacking_id=None)
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(EXPIRED_IMG, image)
def test_get_entry_image_warning(self):
tomorrow = datetime.datetime.now() + datetime.timedelta(days=1)
cert = StubEntitlementCertificate(StubProduct('product2'),
start_date=datetime.datetime(
2010, 1, 1),
end_date=tomorrow,
quantity="10",
stacking_id=None)
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(WARNING_IMG, image)
def test_image_rank_both_none(self):
self.assertFalse(self.my_subs_tab.image_ranks_higher(None, None))
def test_image_rank_new_image_none(self):
self.assertFalse(self.my_subs_tab.image_ranks_higher(
WARNING_IMG, None))
def test_image_rank_new_image_lower(self):
self.assertFalse(
self.my_subs_tab.image_ranks_higher(EXPIRED_IMG, WARNING_IMG))
def test_image_rank_new_image_higher(self):
self.assertTrue(
self.my_subs_tab.image_ranks_higher(WARNING_IMG, EXPIRED_IMG))
def test_image_rank_old_image_none(self):
self.assertTrue(self.my_subs_tab.image_ranks_higher(None, EXPIRED_IMG))
def test_correct_cert_data_inserted_into_store(self):
self.cert1.order.stacking_id = None
column_entries = self._get_entries_for_test()
self.assertEquals(1, len(column_entries))
entry = column_entries[0]
self._assert_entry(entry)
def test_stacking_entry_inserted_when_stacking_id_exists(self):
self.cert1.order.stacking_id = 1234
column_entries = self._get_entries_for_test()
self.assertEquals(2, len(column_entries))
self._assert_group_entry(column_entries[0])
self._assert_entry(column_entries[1])
def _get_entries_for_test(self):
column_entries = []
def collect_entries(iter, entry):
column_entries.append(entry)
# Test that the data from a subscription is loaded into the store.
self.my_subs_tab.store.add_map = collect_entries
self.my_subs_tab.update_subscriptions()
return column_entries
def _assert_entry(self, entry):
self.assertEquals(self.cert1.order.name, entry['subscription'])
self.assertEquals(self.cert1.valid_range.begin(), entry['start_date'])
self.assertEquals(self.cert1.valid_range.end(),
entry['expiration_date'])
self.assertEquals("0 / 1", entry['installed_text'])
self.assertEquals(0, entry['installed_value'])
self.assertEquals(self.cert1.order.quantity_used, entry['quantity'])
self.assertEquals(self.cert1.serial, entry['serial'])
self.assertFalse(entry['is_group_row'])
def _assert_group_entry(self, entry):
self.assertEquals(self.cert1.products[0].name, entry['subscription'])
self.assertFalse('start_date' in entry)
self.assertFalse('expiration_date' in entry)
self.assertFalse('installed_text' in entry)
self.assertEquals(0.0, entry['installed_value'])
self.assertFalse('quantity' in entry)
self.assertFalse('serial' in entry)
self.assertTrue(entry['is_group_row'])
def __init__(self,
backend=None,
facts=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
# Log the server version asynchronously
ga_GLib.idle_add(self.log_server_version,
self.backend.cp_provider.get_consumer_auth_cp())
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(self.facts)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked",
self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.facts,
self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False,
False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# TODO: why is this defined in the init scope?
# When something causes cert_sorter to upate it's state, refresh the gui
# The cert directories being updated will cause this (either noticed
# from a timer, or via cert_sort.force_cert_check).
def on_cert_sorter_cert_change():
# Update installed products
self.installed_tab.update_products()
self.installed_tab._set_validity_status()
# Update attached subs
self.my_subs_tab.update_subscriptions()
# Update main window
self.refresh()
# Reset repos dialog, see bz 1132919
self.repos_dialog = RepositoriesDialog(self.backend,
self._get_window())
self.backend.cs.add_callback(on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
ga_GLib.timeout_add(2000, self._on_cert_check_timer)
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def __init__(self, backend=None,
ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
rhsm_cfg = config.initConfig()
proxy_server = rhsm_cfg.get("server", "proxy_hostname")
proxy_port = int(rhsm_cfg.get("server", "proxy_port") or config.DEFAULT_PROXY_PORT)
def show_proxy_error_dialog(proxy_auth_required=False):
"""
When proxy server is set in configuration and it is not
possible to connect to proxy server, then open dialog
for setting proxy server.
"""
if proxy_auth_required:
proxy_user = rhsm_cfg.get("server", "proxy_user")
proxy_password = rhsm_cfg.get("server", "proxy_password")
if proxy_user or proxy_password:
err_msg = _("Wrong proxy username or password, please check your settings.")
else:
err_msg = _("Proxy authentication required, please check your settings.")
else:
err_msg = _("Proxy connection failed, please check your settings.")
print_error(err_msg)
error_dialog = messageWindow.ContinueDialog(err_msg, self._get_window())
error_dialog.connect("response", self._on_proxy_error_dialog_response)
self.network_config_dialog = networkConfig.NetworkConfigDialog()
# Sub-man gui will be terminated after saving settings and it is
# necessary to start it once again.
self.network_config_dialog.saveButton.connect("clicked", self._exit)
self.network_config_dialog.cancelButton.connect("clicked", self._exit)
self.backend = backend or Backend()
cp = self.backend.cp_provider.get_consumer_auth_cp()
if proxy_server:
if not utils.test_proxy_reachability(proxy_server, proxy_port):
show_proxy_error_dialog()
return
try:
# Try to send to the simplest Rest API call to Candlepin server.
# This result will be used for getting version of Candlepin server.
# See self.log_server_version.
cp.supports_resource("status")
except socket.error as err:
# See https://tools.ietf.org/html/rfc7235#section-4.3
if "407 Proxy Authentication Required" in err.message:
show_proxy_error_dialog(proxy_auth_required=True)
return
self.identity = require(IDENTITY)
log.debug("Client Versions: %s " % get_client_versions())
ga_GLib.idle_add(self.log_server_version, cp)
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
ga_Gtk.Window.set_default_icon_name("subscription-manager")
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(update_callback=self._handle_facts_updated)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend,
self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False, False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# various state tracking for async operations
self._show_overrides = False
self._can_redeem = False
self.backend.cs.add_callback(self.on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
cert_monitor_thread = threading.Thread(target=self._cert_check_timer, name="CertMonitorThread")
cert_monitor_thread.daemon = True
cert_monitor_thread.start()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
enabled_yum_plugins = YumPluginManager.enable_pkg_plugins()
if len(enabled_yum_plugins) > 0:
messageWindow.InfoDialog(
YumPluginManager.warning_message(enabled_yum_plugins),
self._get_window(),
_("Warning - subscription-manager plugins were automatically enabled")
)
def __init__(self, backend=None,
ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
if not self.test_proxy_connection():
print_error(_("Proxy connection failed, please check your settings."))
error_dialog = messageWindow.ContinueDialog(_("Proxy connection failed, please check your settings."),
self._get_window())
error_dialog.connect("response", self._on_proxy_error_dialog_response)
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked", self._exit)
self.network_config_dialog.cancelButton.connect("clicked", self._exit)
return
self.backend = backend or Backend()
self.identity = require(IDENTITY)
log.debug("Client Versions: %s " % get_client_versions())
# Log the server version asynchronously
ga_GLib.idle_add(self.log_server_version, self.backend.cp_provider.get_consumer_auth_cp())
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
ga_Gtk.Window.set_default_icon_name("subscription-manager")
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(update_callback=self._handle_facts_updated)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend,
self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False, False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# various state tracking for async operations
self._show_overrides = False
self._can_redeem = False
self.backend.cs.add_callback(self.on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
cert_monitor_thread = threading.Thread(target=self._cert_check_timer, name="CertMonitorThread")
cert_monitor_thread.daemon = True
cert_monitor_thread.start()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
class MainWindow(widgets.SubmanBaseWidget):
"""
The new RHSM main window.
"""
widget_names = ['main_window', 'notebook', 'system_name_label',
'register_menu_item', 'unregister_menu_item',
'redeem_menu_item', 'settings_menu_item', 'repos_menu_item']
gui_file = "mainwindow"
def log_server_version(self, uep):
server_versions = get_server_versions(uep)
log.debug("Server Versions: %s" % server_versions)
# Remove this from the GTK main loop
return False
def __init__(self, backend=None, facts=None,
ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
# Log the server version asynchronously
ga_GLib.idle_add(self.log_server_version, self.backend.cp_provider.get_consumer_auth_cp())
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(self.facts)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend,
self.facts,
self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False, False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# TODO: why is this defined in the init scope?
# When something causes cert_sorter to upate it's state, refresh the gui
# The cert directories being updated will cause this (either noticed
# from a timer, or via cert_sort.force_cert_check).
def on_cert_sorter_cert_change():
# Update installed products
self.installed_tab.update_products()
self.installed_tab._set_validity_status()
# Update attached subs
self.my_subs_tab.update_subscriptions()
# Update main window
self.refresh()
# Reset repos dialog, see bz 1132919
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
self.backend.cs.add_callback(on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
ga_GLib.timeout_add(2000, self._on_cert_check_timer)
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def registered(self):
return self.identity.is_valid()
def _on_cert_check_timer(self):
self.backend.on_cert_check_timer()
return True
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def on_registration_changed(self):
# Show the All Subscriptions tab if registered, hide it otherwise:
if self.registered() and self.notebook.get_n_pages() == 2:
self.notebook.append_page(self.all_subs_tab.get_content(),
ga_Gtk.Label(self.all_subs_tab.get_label()))
elif not self.registered() and self.notebook.get_n_pages() == 3:
self.notebook.set_current_page(0)
self.notebook.remove_page(2)
# we've unregistered, clear pools from all subscriptions tab
# so it's correct if we reshow it
self.all_subs_tab.sub_details.clear()
self.all_subs_tab.clear_pools()
self.installed_tab.set_registered(self.registered())
self._show_buttons()
self._show_redemption_buttons()
def refresh(self):
""" Refresh the UI. """
# Always run on startup, when there is no last_uuid
if not hasattr(self, 'last_uuid') or self.identity.uuid != self.last_uuid:
self.last_uuid = self.identity.uuid
self.on_registration_changed()
self.all_subs_tab.refresh()
self.installed_tab.refresh()
self.my_subs_tab.refresh()
def _get_window(self):
"""
Return the window containing this widget (might be different for
firstboot).
"""
return self.main_window
def _show_buttons(self):
"""
Renders the Tools buttons dynamically.
"""
is_registered = self.registered()
if is_registered:
#self.register_menu_item.hide()
self.register_menu_item.set_sensitive(False)
self.unregister_menu_item.set_sensitive(True)
self.settings_menu_item.set_sensitive(True) # preferences
else:
self.register_menu_item.set_sensitive(True)
self.unregister_menu_item.set_sensitive(False)
self.settings_menu_item.set_sensitive(False)
show_overrides = False
try:
cp = self.backend.cp_provider.get_consumer_auth_cp()
# This can throw an exception if we cannot connect to the server, bz 1058374
show_overrides = is_registered and cp.supports_resource('content_overrides')
except Exception, e:
log.debug("Failed to check if the server supports resource content_overrides")
log.debug(e)
if show_overrides:
self.repos_menu_item.set_sensitive(True)
else:
self.repos_menu_item.set_sensitive(False)
class MainWindow(widgets.SubmanBaseWidget):
"""
The new RHSM main window.
"""
widget_names = [
'main_window', 'notebook', 'system_name_label', 'register_menu_item',
'unregister_menu_item', 'redeem_menu_item', 'settings_menu_item',
'repos_menu_item', 'import_cert_menu_item'
]
gui_file = "mainwindow"
def log_server_version(self, uep):
server_versions = get_server_versions(uep)
log.debug("Server Versions: %s" % server_versions)
# Remove this from the GTK main loop
return False
def _on_proxy_error_dialog_response(self, window, response):
if response:
self.network_config_dialog.show()
else:
system_exit(os.EX_UNAVAILABLE)
def _exit(self, *args):
system_exit(0)
def __init__(self,
backend=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
# When proxy server is set in configuration and it is not
# possible to connect to proxy server, then open dialog
# for setting proxy server.
if not utils.test_proxy_reachability():
print_error(
_("Proxy connection failed, please check your settings."))
error_dialog = messageWindow.ContinueDialog(
_("Proxy connection failed, please check your settings."),
self._get_window())
error_dialog.connect("response",
self._on_proxy_error_dialog_response)
self.network_config_dialog = networkConfig.NetworkConfigDialog()
# Sub-man gui will be terminated after saving settings and it is
# necessary to start it once again.
self.network_config_dialog.saveButton.connect(
"clicked", self._exit)
self.network_config_dialog.cancelButton.connect(
"clicked", self._exit)
return
self.backend = backend or Backend()
self.identity = require(IDENTITY)
log.debug("Client Versions: %s " % get_client_versions())
# Log the server version asynchronously
ga_GLib.idle_add(self.log_server_version,
self.backend.cp_provider.get_consumer_auth_cp())
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
ga_Gtk.Window.set_default_icon_name("subscription-manager")
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(
update_callback=self._handle_facts_updated)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked",
self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False,
False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# various state tracking for async operations
self._show_overrides = False
self._can_redeem = False
self.backend.cs.add_callback(self.on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
cert_monitor_thread = threading.Thread(target=self._cert_check_timer,
name="CertMonitorThread")
cert_monitor_thread.daemon = True
cert_monitor_thread.start()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
enabled_yum_plugins = YumPluginManager.enable_yum_plugins()
if len(enabled_yum_plugins) > 0:
messageWindow.InfoDialog(
YumPluginManager.warning_message(enabled_yum_plugins),
self._get_window(),
_("Warning - subscription-manager plugins were automatically enabled"
))
def registered(self):
return self.identity.is_valid()
def _cert_check_timer(self):
while True:
self.backend.on_cert_check_timer()
time.sleep(2.0)
def _cert_change_update(self):
# Update installed products
self.installed_tab.refresh()
# Update attached subs
self.my_subs_tab.refresh()
# Update main window
self.refresh()
# Reset repos dialog, see bz 1132919
self.repos_dialog = RepositoriesDialog(self.backend,
self._get_window())
# When something causes cert_sorter to update it's state, refresh the gui
# The cert directories being updated will cause this (either noticed
# from a timer, or via cert_sort.force_cert_check).
def on_cert_sorter_cert_change(self):
# gather data used in GUI refresh
self._show_overrides = self._should_show_overrides()
self._can_redeem = self._should_show_redeem()
self.installed_tab.update()
self.my_subs_tab.update_subscriptions(
update_gui=False
) # don't update GUI since we're in a different thread
# queue up in the main thread since the cert check may be done by another thread.
ga_GLib.idle_add(self._cert_change_update)
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def on_registration_changed(self):
# Show the All Subscriptions tab if registered, hide it otherwise:
if self.registered() and self.notebook.get_n_pages() == 2:
self.notebook.append_page(
self.all_subs_tab.get_content(),
ga_Gtk.Label(self.all_subs_tab.get_label()))
elif not self.registered() and self.notebook.get_n_pages() == 3:
self.notebook.set_current_page(0)
self.notebook.remove_page(2)
# we've unregistered, clear pools from all subscriptions tab
# so it's correct if we reshow it
self.all_subs_tab.sub_details.clear()
self.all_subs_tab.clear_pools()
self.installed_tab.set_registered(self.registered())
self._show_buttons()
self._show_redemption_buttons()
def refresh(self):
""" Refresh the UI. """
# Always run on startup, when there is no last_uuid
if not hasattr(self,
'last_uuid') or self.identity.uuid != self.last_uuid:
self.last_uuid = self.identity.uuid
self.on_registration_changed()
self.all_subs_tab.refresh()
self.installed_tab.refresh()
self.my_subs_tab.refresh()
def _get_window(self):
"""
Return the window containing this widget (might be different for
firstboot).
"""
return self.main_window
def _show_buttons(self):
"""
Renders the Tools buttons dynamically.
"""
is_registered = self.registered()
if is_registered:
#self.register_menu_item.hide()
self.register_menu_item.set_sensitive(False)
self.unregister_menu_item.set_sensitive(True)
self.settings_menu_item.set_sensitive(True) # preferences
self.import_cert_menu_item.set_sensitive(False)
else:
self.register_menu_item.set_sensitive(True)
self.unregister_menu_item.set_sensitive(False)
self.settings_menu_item.set_sensitive(False)
self.import_cert_menu_item.set_sensitive(True)
if self._show_overrides:
self.repos_menu_item.set_sensitive(True)
else:
self.repos_menu_item.set_sensitive(False)
def _should_show_overrides(self):
is_registered = self.registered()
show_overrides = False
try:
cp = self.backend.cp_provider.get_consumer_auth_cp()
# This can throw an exception if we cannot connect to the server, bz 1058374
show_overrides = is_registered and cp.supports_resource(
'content_overrides')
except Exception as e:
log.debug(
"Failed to check if the server supports resource content_overrides"
)
log.debug(e)
return show_overrides
def _show_redemption_buttons(self):
if self._can_redeem:
self.redeem_menu_item.set_sensitive(True)
else:
self.redeem_menu_item.set_sensitive(False)
def _should_show_redeem(self):
# Check if consumer can redeem a subscription - if an identity cert exists
can_redeem = False
if self.identity.uuid:
try:
consumer = self.backend.cp_provider.get_consumer_auth_cp(
).getConsumer(self.identity.uuid, None, None)
can_redeem = consumer['canActivate']
except Exception:
can_redeem = False
return can_redeem
def _register_item_clicked(self, widget):
registration_dialog = registergui.RegisterDialog(self.backend)
registration_dialog.register_dialog.connect('destroy',
self._on_dialog_destroy,
widget)
registration_dialog.window.set_transient_for(self._get_window())
if registration_dialog and widget:
widget.set_sensitive(False)
registration_dialog.initialize()
registration_dialog.show()
def _on_dialog_destroy(self, obj, widget):
# bz#1382897 make sure register menu item is left in appropriate state
if (widget is not self.register_menu_item
or not self.registered()) and widget:
widget.set_sensitive(True)
return False
def _preferences_item_clicked(self, widget):
try:
self.preferences_dialog.show()
except Exception as e:
handle_gui_exception(
e,
_("Error in preferences dialog."
"Please see /var/log/rhsm/rhsm.log for more information."),
self._get_window())
def _repos_item_clicked(self, widget):
try:
self.repos_dialog.show()
except Exception as e:
handle_gui_exception(
e,
_("Error in repos dialog. "
"Please see /var/log/rhsm/rhsm.log for more information."),
self._get_window())
def _on_unregister_prompt_response(self, dialog, response):
if not response:
log.debug("unregister prompt not confirmed. cancelling")
return
log.info("Proceeding with un-registration: %s", self.identity.uuid)
self._perform_unregister()
def _perform_unregister(self):
try:
reset_resolver()
unregister.UnregisterService(
self.backend.cp_provider.get_consumer_auth_cp()).unregister()
except Exception as e:
log.error("Error unregistering system with entitlement platform.")
handle_gui_exception(
e,
_("<b>Errors were encountered during unregister.</b>") +
"\n%s\n" +
_("Please see /var/log/rhsm/rhsm.log for more information."),
self.main_window,
log_msg="Consumer may need to be manually cleaned up: %s" %
self.identity.uuid)
# managerlib.unregister removes product and entitlement directories
self.backend.product_dir.__init__()
self.backend.entitlement_dir.__init__()
# We have new credentials, restart virt-who
restart_virt_who()
self.backend.cs.force_cert_check()
def _unregister_item_clicked(self, widget):
log.info("Unregister button pressed, asking for confirmation.")
prompt = messageWindow.YesNoDialog(
_("<b>Are you sure you want to unregister?</b>"),
self._get_window())
prompt.connect('response', self._on_unregister_prompt_response)
def _proxy_config_item_clicked(self, widget):
self.network_config_dialog.set_parent_window(self._get_window())
self.network_config_dialog.show()
def _facts_item_clicked(self, widget):
self.system_facts_dialog.set_parent_window(self._get_window())
self.system_facts_dialog.show()
def _import_cert_item_clicked(self, widget):
self.import_sub_dialog.set_parent_window(self._get_window())
self.import_sub_dialog.show()
def _update_certificates_button_clicked(self, widget):
autobind_wizard = registergui.AutobindWizardDialog(self.backend)
autobind_wizard.register_dialog.connect('destroy',
self._on_dialog_destroy,
widget)
autobind_wizard.window.set_transient_for(self._get_window())
if autobind_wizard and widget:
widget.set_sensitive(False)
autobind_wizard.initialize()
autobind_wizard.show()
def _redeem_item_clicked(self, widget):
self.redeem_dialog.set_parent_window(self._get_window())
self.redeem_dialog.show()
def _getting_started_item_clicked(self, widget):
try:
# try to open documentation in yelp
ga_Gtk.show_uri(None, 'ghelp:subscription-manager', time.time())
except Exception as e:
# if we can't open it, it's probably because the user didn't
# install the docs, or yelp. no need to bother them.
log.warn("Unable to open help documentation: %s", e)
def _about_item_clicked(self, widget):
about = AboutDialog(self._get_window(), self.backend)
about.show()
def _online_docs_item_clicked(self, widget):
browser = None
for possible_browser in PREFERRED_BROWSERS:
try:
browser = webbrowser.get(possible_browser)
break
except webbrowser.Error:
pass
if browser is None:
utils.show_error_window(NO_BROWSER_MESSAGE %
(self._get_online_doc_url()))
else:
webbrowser.open_new(self._get_online_doc_url())
def _quit_item_clicked(self):
self.hide()
def _config_changed(self, widget):
# update the backend's UEP in case we changed proxy
# config. We specify all these settings since they
# are new and the default UEP init won't get them
# (it's default args are set at class init time)
self.backend.update()
def _check_rhn_classic(self):
if ClassicCheck().is_registered_with_classic():
prompt = messageWindow.ContinueDialog(
linkify(get_branding().REGISTERED_TO_OTHER_WARNING),
self.main_window, _("System Already Registered"))
prompt.connect('response', self._on_rhn_classic_response)
def _on_rhn_classic_response(self, dialog, response):
if not response:
self.main_window.hide()
def _get_online_doc_url(self):
lang, encoding = locale.getdefaultlocale()
if lang is not None:
url = ONLINE_DOC_URL_TEMPLATE % (lang.replace("_", "-"))
else:
url = ONLINE_DOC_FALLBACK_URL
try:
urllib.request.urlopen(url)
except urllib.error.URLError:
# Use the default if there is no translation.
url = ONLINE_DOC_FALLBACK_URL
return url
def _handle_facts_updated(self):
# see bz 1323271 - update compliance on update of facts
self.backend.cs.load()
self.backend.cs.notify()
def __init__(self,
backend=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
rhsm_cfg = config.initConfig()
proxy_server = rhsm_cfg.get("server", "proxy_hostname")
proxy_port = int(
rhsm_cfg.get("server", "proxy_port") or config.DEFAULT_PROXY_PORT)
def show_proxy_error_dialog(proxy_auth_required=False):
"""
When proxy server is set in configuration and it is not
possible to connect to proxy server, then open dialog
for setting proxy server.
"""
if proxy_auth_required:
proxy_user = rhsm_cfg.get("server", "proxy_user")
proxy_password = rhsm_cfg.get("server", "proxy_password")
if proxy_user or proxy_password:
err_msg = _(
"Wrong proxy username or password, please check your settings."
)
else:
err_msg = _(
"Proxy authentication required, please check your settings."
)
else:
err_msg = _(
"Proxy connection failed, please check your settings.")
print_error(err_msg)
error_dialog = messageWindow.ContinueDialog(
err_msg, self._get_window())
error_dialog.connect("response",
self._on_proxy_error_dialog_response)
self.network_config_dialog = networkConfig.NetworkConfigDialog()
# Sub-man gui will be terminated after saving settings and it is
# necessary to start it once again.
self.network_config_dialog.saveButton.connect(
"clicked", self._exit)
self.network_config_dialog.cancelButton.connect(
"clicked", self._exit)
self.backend = backend or Backend()
cp = self.backend.cp_provider.get_consumer_auth_cp()
if proxy_server:
if not utils.test_proxy_reachability(proxy_server, proxy_port):
show_proxy_error_dialog()
return
try:
# Try to send to the simplest Rest API call to Candlepin server.
# This result will be used for getting version of Candlepin server.
# See self.log_server_version.
cp.supports_resource("status")
except socket.error as err:
# See https://tools.ietf.org/html/rfc7235#section-4.3
if "407 Proxy Authentication Required" in err.message:
show_proxy_error_dialog(proxy_auth_required=True)
return
self.identity = require(IDENTITY)
log.debug("Client Versions: %s " % get_client_versions())
ga_GLib.idle_add(self.log_server_version, cp)
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
ga_Gtk.Window.set_default_icon_name("subscription-manager")
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(
update_callback=self._handle_facts_updated)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked",
self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False,
False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# various state tracking for async operations
self._show_overrides = False
self._can_redeem = False
self.backend.cs.add_callback(self.on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
cert_monitor_thread = threading.Thread(target=self._cert_check_timer,
name="CertMonitorThread")
cert_monitor_thread.daemon = True
cert_monitor_thread.start()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
enabled_yum_plugins = YumPluginManager.enable_pkg_plugins()
if len(enabled_yum_plugins) > 0:
messageWindow.InfoDialog(
YumPluginManager.warning_message(enabled_yum_plugins),
self._get_window(),
_("Warning - subscription-manager plugins were automatically enabled"
))
class MySubscriptionsTabTest(SubManFixture):
def setUp(self):
super(MySubscriptionsTabTest, self).setUp()
self.uep = StubUEP
self.backend = StubBackend()
self.cert1 = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10",
ent_id='prod2')
self.cert2 = StubEntitlementCertificate(
StubProduct('product3'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2060, 1, 1),
quantity="10",
ent_id='prod3')
self.cert_dir = StubCertificateDirectory([self.cert1, self.cert2])
self.my_subs_tab = MySubscriptionsTab(self.backend, None,
self.cert_dir,
StubProductDirectory([]))
def tearDown(self):
pass
def test_get_entry_image_expired(self):
cert = StubEntitlementCertificate(
StubProduct('product2'),
start_date=datetime.datetime(2010, 1, 1),
end_date=datetime.datetime(2011, 1, 1),
quantity="10",
stacking_id=None)
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(EXPIRED_IMG, image)
def test_get_entry_image_expiring(self):
tomorrow = datetime.datetime.now() + datetime.timedelta(days=1)
cert = StubEntitlementCertificate(StubProduct('product2'),
start_date=datetime.datetime(
2010, 1, 1),
end_date=tomorrow,
quantity="10",
stacking_id=None)
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(EXPIRING_IMG, image)
def test_get_entry_image_warning(self):
ending = datetime.datetime.now() + datetime.timedelta(days=300)
cert = StubEntitlementCertificate(StubProduct('product2'),
start_date=datetime.datetime(
2010, 1, 1),
end_date=ending,
quantity="10",
ent_id='ent')
self.my_subs_tab.backend.cs.reasons.get_subscription_reasons = Mock(
return_value=['Some detail'])
image = self.my_subs_tab._get_entry_image(cert)
self.assertEqual(WARNING_IMG, image)
def test_image_rank_both_none(self):
self.assertFalse(self.my_subs_tab.image_ranks_higher(None, None))
def test_image_rank_new_image_none(self):
self.assertFalse(
self.my_subs_tab.image_ranks_higher(EXPIRING_IMG, None))
def test_image_rank_new_image_lower(self):
self.assertFalse(
self.my_subs_tab.image_ranks_higher(EXPIRED_IMG, EXPIRING_IMG))
def test_image_rank_new_image_higher(self):
self.assertTrue(
self.my_subs_tab.image_ranks_higher(EXPIRING_IMG, EXPIRED_IMG))
def test_image_rank_old_image_none(self):
self.assertTrue(self.my_subs_tab.image_ranks_higher(None, EXPIRED_IMG))
def test_image_rank_warn_none(self):
self.assertTrue(self.my_subs_tab.image_ranks_higher(None, WARNING_IMG))
def test_image_rank_warn_expiring(self):
self.assertTrue(
self.my_subs_tab.image_ranks_higher(WARNING_IMG, EXPIRING_IMG))
def test_image_rank_warn_expired(self):
self.assertTrue(
self.my_subs_tab.image_ranks_higher(WARNING_IMG, EXPIRED_IMG))
def test_correct_cert_data_inserted_into_store(self):
self.cert1.order.stacking_id = None
self.cert2.order.stacking_id = None
column_entries = self._get_entries_for_test()
self.assertEquals(2, len(column_entries))
self._assert_entry_1(column_entries[0])
self._assert_entry_2(column_entries[1])
def test_stacking_entry_not_inserted_when_stacking_id_exists(self):
self.cert1.order.stacking_id = 1234
self.cert2.order.stacking_id = None
column_entries = self._get_entries_for_test()
# single entry with stacking_id: no stacking entry
self.assertEquals(2, len(column_entries))
self._assert_entry_1(column_entries[0])
self._assert_entry_2(column_entries[1])
def test_stacking_entry_inserted_when_stacking_id_exists(self):
self.cert1.order.stacking_id = 1234
self.cert2.order.stacking_id = 1234
column_entries = self._get_entries_for_test()
self.assertEquals(3, len(column_entries))
self._assert_group_entry(column_entries[0])
self._assert_entry_1(column_entries[1])
self._assert_entry_2(column_entries[2])
def test_no_subscriptions_unregister_button_is_blank(self):
cert_dir = StubCertificateDirectory([])
my_subs_tab = MySubscriptionsTab(self.backend, None, cert_dir,
StubProductDirectory([]))
self.assertFalse(
my_subs_tab.unsubscribe_button.get_property('sensitive'))
def test_unselect_unregister_button_is_blank(self):
self.my_subs_tab.on_no_selection()
self.assertFalse(
self.my_subs_tab.unsubscribe_button.get_property('sensitive'))
def _get_entries_for_test(self):
column_entries = []
def collect_entries(tree_iter, entry):
column_entries.append(entry)
# Test that the data from a subscription is loaded into the store.
self.my_subs_tab.store.add_map = collect_entries
self.my_subs_tab.update_subscriptions()
return column_entries
def _assert_entry_1(self, entry):
self.assertEquals(self.cert1.order.name, entry['subscription'])
self.assertEquals(self.cert1.valid_range.begin(), entry['start_date'])
self.assertEquals(self.cert1.valid_range.end(),
entry['expiration_date'])
self.assertEquals("0 / 1", entry['installed_text'])
self.assertEquals(0, entry['installed_value'])
# The quantity/serial column is of type string, so when we fetch it from the
# widget, it is a str.
self.assertEquals(str(self.cert1.order.quantity_used),
entry['quantity'])
self.assertEquals(str(self.cert1.serial), entry['serial'])
self.assertFalse(entry['is_group_row'])
def _assert_entry_2(self, entry):
self.assertEquals(self.cert2.order.name, entry['subscription'])
self.assertEquals(self.cert2.valid_range.begin(), entry['start_date'])
self.assertEquals(self.cert2.valid_range.end(),
entry['expiration_date'])
self.assertEquals("0 / 1", entry['installed_text'])
self.assertEquals(0, entry['installed_value'])
self.assertEquals(str(self.cert2.order.quantity_used),
entry['quantity'])
self.assertEquals(str(self.cert2.serial), entry['serial'])
self.assertFalse(entry['is_group_row'])
def _assert_group_entry(self, entry):
self.assertEquals("Stack of %s and 1 other" % self.cert1.order.name,
entry['subscription'])
self.assertFalse('start_date' in entry)
self.assertFalse('expiration_date' in entry)
self.assertFalse('installed_text' in entry)
self.assertEquals(0.0, entry['installed_value'])
self.assertFalse('quantity' in entry)
self.assertFalse('serial' in entry)
self.assertTrue(entry['is_group_row'])
def __init__(self,
backend=None,
consumer=None,
facts=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade')
self.backend = backend or Backend()
self.consumer = consumer or Consumer()
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
log.debug("Client Versions: %s " % get_client_versions())
log.debug("Server Versions: %s " %
get_server_versions(self.backend.uep))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(
self.backend, self.consumer, self.facts)
self.registration_dialog = registergui.RegisterScreen(
self.backend,
self.consumer,
self.facts,
callbacks=[self.registration_changed])
self.preferences_dialog = PreferencesDialog(self.backend,
self.consumer,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect(
"clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend, self.consumer)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.consumer,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.consumer,
self.facts,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.consumer,
self.facts, self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False,
False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate":
self._register_item_clicked,
"on_unregister_menu_item_activate":
self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate":
self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate":
self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_about_menu_item_activate":
self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate":
gtk.main_quit,
})
def on_identity_change(filemonitor):
self.consumer.reload()
self.refresh()
self.backend.monitor_identity(on_identity_change)
self.main_window.show_all()
self.refresh()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
class MainWindow(widgets.GladeWidget):
"""
The new RHSM main window.
"""
widget_names = [
'main_window', 'notebook', 'system_name_label', 'next_update_label',
'register_menu_item', 'unregister_menu_item', 'redeem_menu_item'
]
def __init__(self,
backend=None,
consumer=None,
facts=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade')
self.backend = backend or Backend()
self.consumer = consumer or Consumer()
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
log.debug("Client Versions: %s " % get_client_versions())
log.debug("Server Versions: %s " %
get_server_versions(self.backend.uep))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(
self.backend, self.consumer, self.facts)
self.registration_dialog = registergui.RegisterScreen(
self.backend,
self.consumer,
self.facts,
callbacks=[self.registration_changed])
self.preferences_dialog = PreferencesDialog(self.backend,
self.consumer,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect(
"clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend, self.consumer)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.consumer,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.consumer,
self.facts,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.consumer,
self.facts, self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False,
False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate":
self._register_item_clicked,
"on_unregister_menu_item_activate":
self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate":
self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate":
self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_about_menu_item_activate":
self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate":
gtk.main_quit,
})
def on_identity_change(filemonitor):
self.consumer.reload()
self.refresh()
self.backend.monitor_identity(on_identity_change)
self.main_window.show_all()
self.refresh()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def registered(self):
return self.consumer.is_valid()
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def registration_changed(self):
log.debug("Registration changed, updating main window.")
self.consumer.reload()
self.refresh()
def refresh(self):
""" Refresh the UI. """
# Show the All Subscriptions tab if registered, hide it otherwise:
if self.registered() and self.notebook.get_n_pages() == 2:
self.notebook.append_page(self.all_subs_tab.get_content(),
gtk.Label(self.all_subs_tab.get_label()))
elif not self.registered() and self.notebook.get_n_pages() == 3:
self.notebook.set_current_page(0)
self.notebook.remove_page(2)
self.all_subs_tab.refresh()
self.installed_tab.refresh()
self.my_subs_tab.refresh()
self.installed_tab.set_registered(self.registered())
self._show_buttons()
self._show_redemption_buttons()
def _get_window(self):
"""
Return the window containing this widget (might be different for
firstboot).
"""
return self.main_window
def _show_buttons(self):
"""
Renders the Tools buttons dynamically.
"""
if self.registered():
self.register_menu_item.hide()
self.unregister_menu_item.show()
else:
self.register_menu_item.show()
self.unregister_menu_item.hide()
def _show_redemption_buttons(self):
# Check if consumer can redeem a subscription - if an identity cert exists
can_redeem = False
if self.consumer.uuid:
try:
consumer = self.backend.uep.getConsumer(
self.consumer.uuid, None, None)
can_redeem = consumer['canActivate']
except:
can_redeem = False
if can_redeem:
self.redeem_menu_item.show()
else:
self.redeem_menu_item.hide()
def _register_item_clicked(self, widget):
self.registration_dialog.set_parent_window(self._get_window())
self.registration_dialog.show()
def _preferences_item_clicked(self, widget):
try:
self.preferences_dialog.show()
except Exception, e:
handle_gui_exception(
e,
_("Error in preferences dialog. Please see /var/log/rhsm/rhsm.log for more information."
), self._get_window())
class MainWindow(widgets.GladeWidget):
"""
The new RHSM main window.
"""
def __init__(self,
backend=None,
consumer=None,
facts=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade', [
'main_window', 'notebook', 'system_name_label',
'next_update_label', 'next_update_title', 'register_menu_item',
'unregister_menu_item', 'redeem_menu_item'
])
self.backend = backend or Backend()
self.consumer = consumer or Consumer()
self.facts = facts or Facts()
log.debug("Versions: %s " % get_version_dict(self.backend.uep))
self.product_dir = prod_dir or ProductDirectory()
self.entitlement_dir = ent_dir or EntitlementDirectory()
self.system_facts_dialog = factsgui.SystemFactsDialog(
self.backend, self.consumer, self.facts)
self.registration_dialog = registergui.RegisterScreen(
self.backend,
self.consumer,
self.facts,
callbacks=[self.registration_changed])
self.preferences_dialog = PreferencesDialog(self.backend,
self.consumer,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect(
"clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend, self.consumer)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.consumer,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.consumer,
self.facts,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.consumer,
self.facts, self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False,
False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate":
self._register_item_clicked,
"on_unregister_menu_item_activate":
self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate":
self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate":
self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_about_menu_item_activate":
self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate":
gtk.main_quit,
})
def on_identity_change(filemonitor):
self.refresh()
self.backend.monitor_identity(on_identity_change)
self.main_window.show_all()
self.refresh()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def registered(self):
return ConsumerIdentity.existsAndValid()
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def registration_changed(self, skip_auto_bind):
log.debug("Registration changed, updating main window.")
self.consumer.reload()
# If we are now registered, load the Autobind wizard.
if self.registered() and not skip_auto_bind:
try:
autobind_wizard = AutobindWizard(
self.backend, self.consumer, self.facts,
self._get_window(), self._on_sla_back_button_press,
self._on_sla_cancel_button_press)
autobind_wizard.show()
except Exception, e:
# If an exception occurs here, refresh the UI so that
# it remains in the correct state an then raise the
# exception again.
self.refresh()
raise e
return
self.refresh()
class MainWindow(widgets.GladeWidget):
"""
The new RHSM main window.
"""
widget_names = ['main_window', 'notebook', 'system_name_label',
'register_menu_item', 'unregister_menu_item',
'redeem_menu_item', 'settings_menu_item']
def __init__(self, backend=None, facts=None,
ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade')
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
log.debug("Server Versions: %s " % get_server_versions(self.backend.cp_provider.get_consumer_auth_cp()))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(self.backend,
self.facts)
self.registration_dialog = registergui.RegisterScreen(self.backend, self.facts,
self._get_window())
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend,
self.facts,
self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False, False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": gtk.main_quit,
})
def on_cert_change():
# Update installed products
self.installed_tab.update_products()
self.installed_tab._set_validity_status()
# Update attached subs
self.my_subs_tab.update_subscriptions()
# Update main window
self.refresh()
self.backend.cs.add_callback(on_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def registered(self):
return self.identity.is_valid()
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def on_registration_changed(self):
# Show the All Subscriptions tab if registered, hide it otherwise:
if self.registered() and self.notebook.get_n_pages() == 2:
self.notebook.append_page(self.all_subs_tab.get_content(),
gtk.Label(self.all_subs_tab.get_label()))
elif not self.registered() and self.notebook.get_n_pages() == 3:
self.notebook.set_current_page(0)
self.notebook.remove_page(2)
# we've unregistered, clear pools from all subscriptions tab
# so it's correct if we reshow it
self.all_subs_tab.sub_details.clear()
self.all_subs_tab.clear_pools()
self.installed_tab.set_registered(self.registered())
self._show_buttons()
self._show_redemption_buttons()
def refresh(self):
""" Refresh the UI. """
# Always run on startup, when there is no last_uuid
if not hasattr(self, 'last_uuid') or self.identity.uuid != self.last_uuid:
self.last_uuid = self.identity.uuid
self.on_registration_changed()
self.all_subs_tab.refresh()
self.installed_tab.refresh()
self.my_subs_tab.refresh()
def _get_window(self):
"""
Return the window containing this widget (might be different for
firstboot).
"""
return self.main_window
def _show_buttons(self):
"""
Renders the Tools buttons dynamically.
"""
if self.registered():
self.register_menu_item.hide()
self.unregister_menu_item.show()
self.settings_menu_item.show() # preferences
else:
self.register_menu_item.show()
self.unregister_menu_item.hide()
self.settings_menu_item.hide()
def _show_redemption_buttons(self):
# Check if consumer can redeem a subscription - if an identity cert exists
can_redeem = False
if self.identity.uuid:
try:
consumer = self.backend.cp_provider.get_consumer_auth_cp().getConsumer(self.identity.uuid, None, None)
can_redeem = consumer['canActivate']
except Exception:
can_redeem = False
if can_redeem:
self.redeem_menu_item.show()
else:
self.redeem_menu_item.hide()
def _register_item_clicked(self, widget):
self.registration_dialog.show()
def _preferences_item_clicked(self, widget):
try:
self.preferences_dialog.show()
except Exception, e:
handle_gui_exception(e, _("Error in preferences dialog."
"Please see /var/log/rhsm/rhsm.log for more information."),
self._get_window())
def __init__(self, backend=None, facts=None,
ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade')
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
log.debug("Server Versions: %s " % get_server_versions(self.backend.cp_provider.get_consumer_auth_cp()))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(self.backend,
self.facts)
self.registration_dialog = registergui.RegisterScreen(self.backend, self.facts,
self._get_window())
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend,
self.facts,
self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False, False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": gtk.main_quit,
})
def on_cert_change():
# Update installed products
self.installed_tab.update_products()
self.installed_tab._set_validity_status()
# Update attached subs
self.my_subs_tab.update_subscriptions()
# Update main window
self.refresh()
self.backend.cs.add_callback(on_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
class MainWindow(widgets.GladeWidget):
"""
The new RHSM main window.
"""
widget_names = [
"main_window",
"notebook",
"system_name_label",
"next_update_label",
"register_menu_item",
"unregister_menu_item",
"redeem_menu_item",
]
def __init__(
self, backend=None, consumer=None, facts=None, ent_dir=None, prod_dir=None, auto_launch_registration=False
):
super(MainWindow, self).__init__("mainwindow.glade")
self.backend = backend or Backend()
self.consumer = consumer or Consumer()
self.facts = facts or Facts(self.backend.entitlement_dir, self.backend.product_dir)
log.debug("Client Versions: %s " % get_client_versions())
log.debug("Server Versions: %s " % get_server_versions(self.backend.uep))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(self.backend, self.consumer, self.facts)
self.registration_dialog = registergui.RegisterScreen(
self.backend, self.consumer, self.facts, callbacks=[self.registration_changed]
)
self.preferences_dialog = PreferencesDialog(self.backend, self.consumer, self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend, self.consumer)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES, gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(
self.backend,
self.consumer,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir,
)
self.my_subs_tab = MySubscriptionsTab(
self.backend,
self.consumer,
self.facts,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir,
)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.consumer, self.facts, self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False, False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(), gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect(
{
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": gtk.main_quit,
}
)
def on_identity_change(filemonitor):
self.consumer.reload()
self.refresh()
self.backend.monitor_identity(on_identity_change)
self.main_window.show_all()
self.refresh()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def registered(self):
return self.consumer.is_valid()
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def registration_changed(self):
log.debug("Registration changed, updating main window.")
self.consumer.reload()
self.refresh()
def refresh(self):
""" Refresh the UI. """
# Show the All Subscriptions tab if registered, hide it otherwise:
if self.registered() and self.notebook.get_n_pages() == 2:
self.notebook.append_page(self.all_subs_tab.get_content(), gtk.Label(self.all_subs_tab.get_label()))
elif not self.registered() and self.notebook.get_n_pages() == 3:
self.notebook.set_current_page(0)
self.notebook.remove_page(2)
self.all_subs_tab.refresh()
self.installed_tab.refresh()
self.my_subs_tab.refresh()
self.installed_tab.set_registered(self.registered())
self._show_buttons()
self._show_redemption_buttons()
def _get_window(self):
"""
Return the window containing this widget (might be different for
firstboot).
"""
return self.main_window
def _show_buttons(self):
"""
Renders the Tools buttons dynamically.
"""
if self.registered():
self.register_menu_item.hide()
self.unregister_menu_item.show()
else:
self.register_menu_item.show()
self.unregister_menu_item.hide()
def _show_redemption_buttons(self):
# Check if consumer can redeem a subscription - if an identity cert exists
can_redeem = False
if self.consumer.uuid:
try:
consumer = self.backend.uep.getConsumer(self.consumer.uuid, None, None)
can_redeem = consumer["canActivate"]
except:
can_redeem = False
if can_redeem:
self.redeem_menu_item.show()
else:
self.redeem_menu_item.hide()
def _register_item_clicked(self, widget):
self.registration_dialog.set_parent_window(self._get_window())
self.registration_dialog.show()
def _preferences_item_clicked(self, widget):
try:
self.preferences_dialog.show()
except Exception, e:
handle_gui_exception(
e,
_("Error in preferences dialog. Please see /var/log/rhsm/rhsm.log for more information."),
self._get_window(),
)
def __init__(self, backend=None, facts=None,
ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
# Log the server version asynchronously
ga_GLib.idle_add(self.log_server_version, self.backend.cp_provider.get_consumer_auth_cp())
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(self.facts)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend,
self.facts,
self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False, False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# TODO: why is this defined in the init scope?
# When something causes cert_sorter to upate it's state, refresh the gui
# The cert directories being updated will cause this (either noticed
# from a timer, or via cert_sort.force_cert_check).
def on_cert_sorter_cert_change():
# Update installed products
self.installed_tab.update_products()
self.installed_tab._set_validity_status()
# Update attached subs
self.my_subs_tab.update_subscriptions()
# Update main window
self.refresh()
# Reset repos dialog, see bz 1132919
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
self.backend.cs.add_callback(on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
ga_GLib.timeout_add(2000, self._on_cert_check_timer)
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
class MainWindow(widgets.GladeWidget):
"""
The new RHSM main window.
"""
def __init__(self, backend=None, consumer=None,
facts=None, ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade',
['main_window', 'notebook', 'system_name_label',
'next_update_label', 'next_update_title', 'register_menu_item',
'unregister_menu_item', 'redeem_menu_item'])
self.backend = backend or Backend()
self.consumer = consumer or Consumer()
self.facts = facts or Facts()
log.debug("Versions: %s " % get_version_dict(self.backend.uep))
self.product_dir = prod_dir or ProductDirectory()
self.entitlement_dir = ent_dir or EntitlementDirectory()
self.system_facts_dialog = factsgui.SystemFactsDialog(self.backend, self.consumer,
self.facts)
self.registration_dialog = registergui.RegisterScreen(self.backend,
self.consumer, self.facts,
callbacks=[self.registration_changed])
self.preferences_dialog = PreferencesDialog(self.backend, self.consumer,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend, self.consumer)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend, self.consumer,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend, self.consumer,
self.facts, self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.consumer,
self.facts, self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False, False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": gtk.main_quit,
})
def on_identity_change(filemonitor):
self.refresh()
self.backend.monitor_identity(on_identity_change)
self.main_window.show_all()
self.refresh()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def registered(self):
return ConsumerIdentity.existsAndValid()
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def registration_changed(self, skip_auto_bind):
log.debug("Registration changed, updating main window.")
self.consumer.reload()
# If we are now registered, load the Autobind wizard.
if self.registered() and not skip_auto_bind:
try:
autobind_wizard = AutobindWizard(self.backend, self.consumer, self.facts,
self._get_window(), self._on_sla_back_button_press,
self._on_sla_cancel_button_press)
autobind_wizard.show()
except Exception, e:
# If an exception occurs here, refresh the UI so that
# it remains in the correct state an then raise the
# exception again.
self.refresh()
raise e
return
self.refresh()
class MainWindow(widgets.SubmanBaseWidget):
"""
The new RHSM main window.
"""
widget_names = ['main_window', 'notebook', 'system_name_label',
'register_menu_item', 'unregister_menu_item',
'redeem_menu_item', 'settings_menu_item', 'repos_menu_item',
'import_cert_menu_item']
gui_file = "mainwindow"
def log_server_version(self, uep):
server_versions = get_server_versions(uep)
log.debug("Server Versions: %s" % server_versions)
# Remove this from the GTK main loop
return False
def _on_proxy_error_dialog_response(self, window, response):
if response:
self.network_config_dialog.show()
else:
system_exit(os.EX_UNAVAILABLE)
def _exit(self, *args):
system_exit(0)
def __init__(self, backend=None,
ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
rhsm_cfg = config.initConfig()
proxy_server = rhsm_cfg.get("server", "proxy_hostname")
proxy_port = int(rhsm_cfg.get("server", "proxy_port") or config.DEFAULT_PROXY_PORT)
def show_proxy_error_dialog(proxy_auth_required=False):
"""
When proxy server is set in configuration and it is not
possible to connect to proxy server, then open dialog
for setting proxy server.
"""
if proxy_auth_required:
proxy_user = rhsm_cfg.get("server", "proxy_user")
proxy_password = rhsm_cfg.get("server", "proxy_password")
if proxy_user or proxy_password:
err_msg = _("Wrong proxy username or password, please check your settings.")
else:
err_msg = _("Proxy authentication required, please check your settings.")
else:
err_msg = _("Proxy connection failed, please check your settings.")
print_error(err_msg)
error_dialog = messageWindow.ContinueDialog(err_msg, self._get_window())
error_dialog.connect("response", self._on_proxy_error_dialog_response)
self.network_config_dialog = networkConfig.NetworkConfigDialog()
# Sub-man gui will be terminated after saving settings and it is
# necessary to start it once again.
self.network_config_dialog.saveButton.connect("clicked", self._exit)
self.network_config_dialog.cancelButton.connect("clicked", self._exit)
self.backend = backend or Backend()
cp = self.backend.cp_provider.get_consumer_auth_cp()
if proxy_server:
if not utils.test_proxy_reachability(proxy_server, proxy_port):
show_proxy_error_dialog()
return
try:
# Try to send to the simplest Rest API call to Candlepin server.
# This result will be used for getting version of Candlepin server.
# See self.log_server_version.
cp.supports_resource("status")
except socket.error as err:
# See https://tools.ietf.org/html/rfc7235#section-4.3
if "407 Proxy Authentication Required" in err.message:
show_proxy_error_dialog(proxy_auth_required=True)
return
self.identity = require(IDENTITY)
log.debug("Client Versions: %s " % get_client_versions())
ga_GLib.idle_add(self.log_server_version, cp)
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
ga_Gtk.Window.set_default_icon_name("subscription-manager")
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(update_callback=self._handle_facts_updated)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend,
self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False, False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# various state tracking for async operations
self._show_overrides = False
self._can_redeem = False
self.backend.cs.add_callback(self.on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
cert_monitor_thread = threading.Thread(target=self._cert_check_timer, name="CertMonitorThread")
cert_monitor_thread.daemon = True
cert_monitor_thread.start()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
enabled_yum_plugins = YumPluginManager.enable_pkg_plugins()
if len(enabled_yum_plugins) > 0:
messageWindow.InfoDialog(
YumPluginManager.warning_message(enabled_yum_plugins),
self._get_window(),
_("Warning - subscription-manager plugins were automatically enabled")
)
def registered(self):
return self.identity.is_valid()
def _cert_check_timer(self):
while True:
self.backend.on_cert_check_timer()
time.sleep(2.0)
def _cert_change_update(self):
# Update installed products
self.installed_tab.refresh()
# Update attached subs
self.my_subs_tab.refresh()
# Update main window
self.refresh()
# Reset repos dialog, see bz 1132919
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
# When something causes cert_sorter to update it's state, refresh the gui
# The cert directories being updated will cause this (either noticed
# from a timer, or via cert_sort.force_cert_check).
def on_cert_sorter_cert_change(self):
# gather data used in GUI refresh
self._show_overrides = self._should_show_overrides()
self._can_redeem = self._should_show_redeem()
self.installed_tab.update()
self.my_subs_tab.update_subscriptions(update_gui=False) # don't update GUI since we're in a different thread
# queue up in the main thread since the cert check may be done by another thread.
ga_GLib.idle_add(self._cert_change_update)
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def on_registration_changed(self):
# Show the All Subscriptions tab if registered, hide it otherwise:
if self.registered() and self.notebook.get_n_pages() == 2:
self.notebook.append_page(self.all_subs_tab.get_content(),
ga_Gtk.Label(self.all_subs_tab.get_label()))
elif not self.registered() and self.notebook.get_n_pages() == 3:
self.notebook.set_current_page(0)
self.notebook.remove_page(2)
# we've unregistered, clear pools from all subscriptions tab
# so it's correct if we reshow it
self.all_subs_tab.sub_details.clear()
self.all_subs_tab.clear_pools()
self.installed_tab.set_registered(self.registered())
self._show_buttons()
self._show_redemption_buttons()
def refresh(self):
""" Refresh the UI. """
# Always run on startup, when there is no last_uuid
if not hasattr(self, 'last_uuid') or self.identity.uuid != self.last_uuid:
self.last_uuid = self.identity.uuid
self.on_registration_changed()
self.all_subs_tab.refresh()
self.installed_tab.refresh()
self.my_subs_tab.refresh()
def _get_window(self):
"""
Return the window containing this widget (might be different for
firstboot).
"""
return self.main_window
def _show_buttons(self):
"""
Renders the Tools buttons dynamically.
"""
is_registered = self.registered()
if is_registered:
#self.register_menu_item.hide()
self.register_menu_item.set_sensitive(False)
self.unregister_menu_item.set_sensitive(True)
self.settings_menu_item.set_sensitive(True) # preferences
self.import_cert_menu_item.set_sensitive(False)
else:
self.register_menu_item.set_sensitive(True)
self.unregister_menu_item.set_sensitive(False)
self.settings_menu_item.set_sensitive(False)
self.import_cert_menu_item.set_sensitive(True)
if self._show_overrides:
self.repos_menu_item.set_sensitive(True)
else:
self.repos_menu_item.set_sensitive(False)
def _should_show_overrides(self):
is_registered = self.registered()
show_overrides = False
try:
cp = self.backend.cp_provider.get_consumer_auth_cp()
# This can throw an exception if we cannot connect to the server, bz 1058374
show_overrides = is_registered and cp.supports_resource('content_overrides')
except Exception as e:
log.debug("Failed to check if the server supports resource content_overrides")
log.debug(e)
return show_overrides
def _show_redemption_buttons(self):
if self._can_redeem:
self.redeem_menu_item.set_sensitive(True)
else:
self.redeem_menu_item.set_sensitive(False)
def _should_show_redeem(self):
# Check if consumer can redeem a subscription - if an identity cert exists
can_redeem = False
if self.identity.uuid:
try:
consumer = self.backend.cp_provider.get_consumer_auth_cp().getConsumer(self.identity.uuid, None, None)
can_redeem = consumer['canActivate']
except Exception:
can_redeem = False
return can_redeem
def _register_item_clicked(self, widget):
registration_dialog = registergui.RegisterDialog(self.backend)
registration_dialog.register_dialog.connect('destroy',
self._on_dialog_destroy,
widget)
registration_dialog.window.set_transient_for(self._get_window())
if registration_dialog and widget:
widget.set_sensitive(False)
registration_dialog.initialize()
registration_dialog.show()
def _on_dialog_destroy(self, obj, widget):
# bz#1382897 make sure register menu item is left in appropriate state
if (widget is not self.register_menu_item or not self.registered()) and widget:
widget.set_sensitive(True)
return False
def _preferences_item_clicked(self, widget):
try:
self.preferences_dialog.show()
except Exception as e:
handle_gui_exception(e, _("Error in preferences dialog."
"Please see /var/log/rhsm/rhsm.log for more information."),
self._get_window())
def _repos_item_clicked(self, widget):
try:
self.repos_dialog.show()
except Exception as e:
handle_gui_exception(e, _("Error in repos dialog. "
"Please see /var/log/rhsm/rhsm.log for more information."),
self._get_window())
def _on_unregister_prompt_response(self, dialog, response):
if not response:
log.debug("unregister prompt not confirmed. cancelling")
return
log.debug("Proceeding with un-registration: %s", self.identity.uuid)
self._perform_unregister()
def _perform_unregister(self):
try:
reset_resolver()
unregister.UnregisterService(self.backend.cp_provider.get_consumer_auth_cp()).unregister()
except Exception as e:
log.error("Error unregistering system with entitlement platform.")
handle_gui_exception(e, _("<b>Errors were encountered during unregister.</b>") +
"\n%s\n" +
_("Please see /var/log/rhsm/rhsm.log for more information."),
self.main_window,
log_msg="Consumer may need to be manually cleaned up: %s" %
self.identity.uuid)
# managerlib.unregister removes product and entitlement directories
self.backend.product_dir.__init__()
self.backend.entitlement_dir.__init__()
# We have new credentials, restart virt-who
restart_virt_who()
self.backend.cs.force_cert_check()
def _unregister_item_clicked(self, widget):
log.debug("Unregister button pressed, asking for confirmation.")
prompt = messageWindow.YesNoDialog(
_("<b>Are you sure you want to unregister?</b>"),
self._get_window())
prompt.connect('response', self._on_unregister_prompt_response)
def _proxy_config_item_clicked(self, widget):
self.network_config_dialog.set_parent_window(self._get_window())
self.network_config_dialog.show()
def _facts_item_clicked(self, widget):
self.system_facts_dialog.set_parent_window(self._get_window())
self.system_facts_dialog.show()
def _import_cert_item_clicked(self, widget):
self.import_sub_dialog.set_parent_window(self._get_window())
self.import_sub_dialog.show()
def _update_certificates_button_clicked(self, widget):
autobind_wizard = registergui.AutobindWizardDialog(self.backend)
autobind_wizard.register_dialog.connect('destroy',
self._on_dialog_destroy,
widget)
autobind_wizard.window.set_transient_for(self._get_window())
if autobind_wizard and widget:
widget.set_sensitive(False)
autobind_wizard.initialize()
autobind_wizard.show()
def _redeem_item_clicked(self, widget):
self.redeem_dialog.set_parent_window(self._get_window())
self.redeem_dialog.show()
def _getting_started_item_clicked(self, widget):
try:
# try to open documentation in yelp
ga_Gtk.show_uri(None, 'ghelp:subscription-manager', time.time())
except Exception as e:
# if we can't open it, it's probably because the user didn't
# install the docs, or yelp. no need to bother them.
log.warn("Unable to open help documentation: %s", e)
def _about_item_clicked(self, widget):
about = AboutDialog(self._get_window(), self.backend)
about.show()
def _online_docs_item_clicked(self, widget):
browser = None
for possible_browser in PREFERRED_BROWSERS:
try:
browser = webbrowser.get(possible_browser)
break
except webbrowser.Error:
pass
if browser is None:
utils.show_error_window(NO_BROWSER_MESSAGE % (self._get_online_doc_url()))
else:
webbrowser.open_new(self._get_online_doc_url())
def _quit_item_clicked(self):
self.hide()
def _config_changed(self, widget):
# update the backend's UEP in case we changed proxy
# config. We specify all these settings since they
# are new and the default UEP init won't get them
# (it's default args are set at class init time)
self.backend.update()
def _check_rhn_classic(self):
if ClassicCheck().is_registered_with_classic():
prompt = messageWindow.ContinueDialog(
linkify(get_branding().REGISTERED_TO_OTHER_WARNING),
self.main_window, _("System Already Registered"))
prompt.connect('response', self._on_rhn_classic_response)
def _on_rhn_classic_response(self, dialog, response):
if not response:
self.main_window.hide()
def _get_online_doc_url(self):
lang, encoding = locale.getdefaultlocale()
if lang is not None:
url = ONLINE_DOC_URL_TEMPLATE % (lang.replace("_", "-").lower())
else:
url = ONLINE_DOC_FALLBACK_URL
try:
urllib.request.urlopen(url)
except urllib.error.URLError:
# Use the default if there is no translation.
url = ONLINE_DOC_FALLBACK_URL
return url
def _handle_facts_updated(self):
# see bz 1323271 - update compliance on update of facts
self.backend.cs.load()
self.backend.cs.notify()
class MainWindow(widgets.GladeWidget):
"""
The new RHSM main window.
"""
widget_names = [
'main_window', 'notebook', 'system_name_label', 'register_menu_item',
'unregister_menu_item', 'redeem_menu_item', 'settings_menu_item'
]
def __init__(self,
backend=None,
facts=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade')
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
log.debug("Server Versions: %s " % get_server_versions(
self.backend.cp_provider.get_consumer_auth_cp()))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(
self.backend, self.facts)
self.registration_dialog = registergui.RegisterScreen(
self.backend, self.facts, self._get_window())
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect(
"clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.facts,
self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False,
False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate":
self._register_item_clicked,
"on_unregister_menu_item_activate":
self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate":
self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate":
self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_about_menu_item_activate":
self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate":
gtk.main_quit,
})
def on_cert_change():
# Update installed products
self.installed_tab.update_products()
self.installed_tab._set_validity_status()
# Update attached subs
self.my_subs_tab.update_subscriptions()
# Update main window
self.refresh()
self.backend.cs.add_callback(on_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def registered(self):
return self.identity.is_valid()
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def on_registration_changed(self):
# Show the All Subscriptions tab if registered, hide it otherwise:
if self.registered() and self.notebook.get_n_pages() == 2:
self.notebook.append_page(self.all_subs_tab.get_content(),
gtk.Label(self.all_subs_tab.get_label()))
elif not self.registered() and self.notebook.get_n_pages() == 3:
self.notebook.set_current_page(0)
self.notebook.remove_page(2)
# we've unregistered, clear pools from all subscriptions tab
# so it's correct if we reshow it
self.all_subs_tab.sub_details.clear()
self.all_subs_tab.clear_pools()
self.installed_tab.set_registered(self.registered())
self._show_buttons()
self._show_redemption_buttons()
def refresh(self):
""" Refresh the UI. """
# Always run on startup, when there is no last_uuid
if not hasattr(self,
'last_uuid') or self.identity.uuid != self.last_uuid:
self.last_uuid = self.identity.uuid
self.on_registration_changed()
self.all_subs_tab.refresh()
self.installed_tab.refresh()
self.my_subs_tab.refresh()
def _get_window(self):
"""
Return the window containing this widget (might be different for
firstboot).
"""
return self.main_window
def _show_buttons(self):
"""
Renders the Tools buttons dynamically.
"""
if self.registered():
self.register_menu_item.hide()
self.unregister_menu_item.show()
self.settings_menu_item.show() # preferences
else:
self.register_menu_item.show()
self.unregister_menu_item.hide()
self.settings_menu_item.hide()
def _show_redemption_buttons(self):
# Check if consumer can redeem a subscription - if an identity cert exists
can_redeem = False
if self.identity.uuid:
try:
consumer = self.backend.cp_provider.get_consumer_auth_cp(
).getConsumer(self.identity.uuid, None, None)
can_redeem = consumer['canActivate']
except Exception:
can_redeem = False
if can_redeem:
self.redeem_menu_item.show()
else:
self.redeem_menu_item.hide()
def _register_item_clicked(self, widget):
self.registration_dialog.show()
def _preferences_item_clicked(self, widget):
try:
self.preferences_dialog.show()
except Exception, e:
handle_gui_exception(
e,
_("Error in preferences dialog."
"Please see /var/log/rhsm/rhsm.log for more information."),
self._get_window())
class MainWindow(widgets.SubmanBaseWidget):
"""
The new RHSM main window.
"""
widget_names = [
'main_window', 'notebook', 'system_name_label', 'register_menu_item',
'unregister_menu_item', 'redeem_menu_item', 'settings_menu_item',
'repos_menu_item'
]
gui_file = "mainwindow"
def log_server_version(self, uep):
server_versions = get_server_versions(uep)
log.debug("Server Versions: %s" % server_versions)
# Remove this from the GTK main loop
return False
def __init__(self,
backend=None,
facts=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
# Log the server version asynchronously
ga_GLib.idle_add(self.log_server_version,
self.backend.cp_provider.get_consumer_auth_cp())
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(self.facts)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked",
self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.facts,
self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False,
False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# TODO: why is this defined in the init scope?
# When something causes cert_sorter to upate it's state, refresh the gui
# The cert directories being updated will cause this (either noticed
# from a timer, or via cert_sort.force_cert_check).
def on_cert_sorter_cert_change():
# Update installed products
self.installed_tab.update_products()
self.installed_tab._set_validity_status()
# Update attached subs
self.my_subs_tab.update_subscriptions()
# Update main window
self.refresh()
# Reset repos dialog, see bz 1132919
self.repos_dialog = RepositoriesDialog(self.backend,
self._get_window())
self.backend.cs.add_callback(on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
ga_GLib.timeout_add(2000, self._on_cert_check_timer)
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def registered(self):
return self.identity.is_valid()
def _on_cert_check_timer(self):
self.backend.on_cert_check_timer()
return True
def _on_sla_back_button_press(self):
self._perform_unregister()
self._register_item_clicked(None)
def _on_sla_cancel_button_press(self):
self._perform_unregister()
def on_registration_changed(self):
# Show the All Subscriptions tab if registered, hide it otherwise:
if self.registered() and self.notebook.get_n_pages() == 2:
self.notebook.append_page(
self.all_subs_tab.get_content(),
ga_Gtk.Label(self.all_subs_tab.get_label()))
elif not self.registered() and self.notebook.get_n_pages() == 3:
self.notebook.set_current_page(0)
self.notebook.remove_page(2)
# we've unregistered, clear pools from all subscriptions tab
# so it's correct if we reshow it
self.all_subs_tab.sub_details.clear()
self.all_subs_tab.clear_pools()
self.installed_tab.set_registered(self.registered())
self._show_buttons()
self._show_redemption_buttons()
def refresh(self):
""" Refresh the UI. """
# Always run on startup, when there is no last_uuid
if not hasattr(self,
'last_uuid') or self.identity.uuid != self.last_uuid:
self.last_uuid = self.identity.uuid
self.on_registration_changed()
self.all_subs_tab.refresh()
self.installed_tab.refresh()
self.my_subs_tab.refresh()
def _get_window(self):
"""
Return the window containing this widget (might be different for
firstboot).
"""
return self.main_window
def _show_buttons(self):
"""
Renders the Tools buttons dynamically.
"""
is_registered = self.registered()
if is_registered:
#self.register_menu_item.hide()
self.register_menu_item.set_sensitive(False)
self.unregister_menu_item.set_sensitive(True)
self.settings_menu_item.set_sensitive(True) # preferences
else:
self.register_menu_item.set_sensitive(True)
self.unregister_menu_item.set_sensitive(False)
self.settings_menu_item.set_sensitive(False)
show_overrides = False
try:
cp = self.backend.cp_provider.get_consumer_auth_cp()
# This can throw an exception if we cannot connect to the server, bz 1058374
show_overrides = is_registered and cp.supports_resource(
'content_overrides')
except Exception, e:
log.debug(
"Failed to check if the server supports resource content_overrides"
)
log.debug(e)
if show_overrides:
self.repos_menu_item.set_sensitive(True)
else:
self.repos_menu_item.set_sensitive(False)
def __init__(self,
backend=None,
facts=None,
ent_dir=None,
prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade')
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
log.debug("Server Versions: %s " % get_server_versions(
self.backend.cp_provider.get_consumer_auth_cp()))
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(
self.backend, self.facts)
self.registration_dialog = registergui.RegisterScreen(
self.backend, self.facts, self._get_window())
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect(
"clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.facts,
self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False,
False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate":
self._register_item_clicked,
"on_unregister_menu_item_activate":
self._unregister_item_clicked,
"on_import_cert_menu_item_activate":
self._import_cert_item_clicked,
"on_view_facts_menu_item_activate":
self._facts_item_clicked,
"on_proxy_config_menu_item_activate":
self._proxy_config_item_clicked,
"on_redeem_menu_item_activate":
self._redeem_item_clicked,
"on_preferences_menu_item_activate":
self._preferences_item_clicked,
"on_about_menu_item_activate":
self._about_item_clicked,
"on_getting_started_menu_item_activate":
self._getting_started_item_clicked,
"on_online_docs_menu_item_activate":
self._online_docs_item_clicked,
"on_quit_menu_item_activate":
gtk.main_quit,
})
def on_cert_change():
# Update installed products
self.installed_tab.update_products()
self.installed_tab._set_validity_status()
# Update attached subs
self.my_subs_tab.update_subscriptions()
# Update main window
self.refresh()
self.backend.cs.add_callback(on_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def __init__(self, backend=None, consumer=None,
facts=None, ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__('mainwindow.glade',
['main_window', 'notebook', 'system_name_label',
'next_update_label', 'next_update_title', 'register_menu_item',
'unregister_menu_item', 'redeem_menu_item'])
self.backend = backend or Backend()
self.consumer = consumer or Consumer()
self.facts = facts or Facts()
log.debug("Versions: %s " % get_version_dict(self.backend.uep))
self.product_dir = prod_dir or ProductDirectory()
self.entitlement_dir = ent_dir or EntitlementDirectory()
self.system_facts_dialog = factsgui.SystemFactsDialog(self.backend, self.consumer,
self.facts)
self.registration_dialog = registergui.RegisterScreen(self.backend,
self.consumer, self.facts,
callbacks=[self.registration_changed])
self.preferences_dialog = PreferencesDialog(self.backend, self.consumer,
self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.xml.get_widget("closeButton").connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend, self.consumer)
self.installed_tab_icon = gtk.Image()
self.installed_tab_icon.set_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_MENU)
self.installed_tab = InstalledProductsTab(self.backend, self.consumer,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend, self.consumer,
self.facts, self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend, self.consumer,
self.facts, self.main_window)
hbox = gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False)
hbox.pack_start(gtk.Label(self.installed_tab.get_label()), False, False)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
gtk.Label(self.my_subs_tab.get_label()))
self.glade.signal_autoconnect({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": gtk.main_quit,
})
def on_identity_change(filemonitor):
self.refresh()
self.backend.monitor_identity(on_identity_change)
self.main_window.show_all()
self.refresh()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
def __init__(self, backend=None, facts=None,
ent_dir=None, prod_dir=None,
auto_launch_registration=False):
super(MainWindow, self).__init__()
if not self.test_proxy_connection():
print_error(_("Proxy connection failed, please check your settings."))
error_dialog = messageWindow.ContinueDialog(_("Proxy connection failed, please check your settings."),
self._get_window())
error_dialog.connect("response", self._on_proxy_error_dialog_response)
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked", self._exit)
self.network_config_dialog.cancelButton.connect("clicked", self._exit)
return
self.backend = backend or Backend()
self.identity = require(IDENTITY)
self.facts = facts or Facts(self.backend.entitlement_dir,
self.backend.product_dir)
# We need to make sure facts are loaded immediately, some GUI operations
# are done in separate threads, and if facts try to load in another
# thread the virt guest detection code breaks due to hwprobe's use of
# signals.
self.facts.get_facts()
log.debug("Client Versions: %s " % get_client_versions())
# Log the server version asynchronously
ga_GLib.idle_add(self.log_server_version, self.backend.cp_provider.get_consumer_auth_cp())
settings = self.main_window.get_settings()
# prevent gtk from trying to save a list of recently used files, which
# as root, causes gtk warning:
# "Attempting to set the permissions of `/root/.local/share/recently-used.xbel'
# The __name__ use is just for the 'origin' value gtk uses to store
# where a Gtk.Settings value was set.
settings.set_long_property('gtk-recent-files-max-age', 0,
"%s:%s" % (__name__, type(self).__name__))
ga_Gtk.Window.set_default_icon_name("subscription-manager")
self.product_dir = prod_dir or self.backend.product_dir
self.entitlement_dir = ent_dir or self.backend.entitlement_dir
self.system_facts_dialog = factsgui.SystemFactsDialog(self.facts, update_callback=self._handle_facts_updated)
self.preferences_dialog = PreferencesDialog(self.backend,
self._get_window())
self.repos_dialog = RepositoriesDialog(self.backend, self._get_window())
self.import_sub_dialog = ImportSubDialog()
self.network_config_dialog = networkConfig.NetworkConfigDialog()
self.network_config_dialog.saveButton.connect("clicked", self._config_changed)
self.redeem_dialog = redeem.RedeemDialog(self.backend)
self.installed_tab_icon = ga_Gtk.Image()
self.installed_tab_icon.set_from_stock(ga_Gtk.STOCK_YES,
ga_Gtk.IconSize.MENU)
self.installed_tab = InstalledProductsTab(self.backend,
self.facts,
self.installed_tab_icon,
self,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.my_subs_tab = MySubscriptionsTab(self.backend,
self.main_window,
ent_dir=self.entitlement_dir,
prod_dir=self.product_dir)
self.all_subs_tab = AllSubscriptionsTab(self.backend,
self.facts,
self.main_window)
hbox = ga_Gtk.HBox(spacing=6)
hbox.pack_start(self.installed_tab_icon, False, False, 0)
hbox.pack_start(ga_Gtk.Label(self.installed_tab.get_label()), False, False, 0)
self.notebook.append_page(self.installed_tab.get_content(), hbox)
hbox.show_all()
self.notebook.append_page(self.my_subs_tab.get_content(),
ga_Gtk.Label(self.my_subs_tab.get_label()))
self.connect_signals({
"on_register_menu_item_activate": self._register_item_clicked,
"on_unregister_menu_item_activate": self._unregister_item_clicked,
"on_import_cert_menu_item_activate": self._import_cert_item_clicked,
"on_view_facts_menu_item_activate": self._facts_item_clicked,
"on_proxy_config_menu_item_activate": self._proxy_config_item_clicked,
"on_redeem_menu_item_activate": self._redeem_item_clicked,
"on_preferences_menu_item_activate": self._preferences_item_clicked,
"on_repos_menu_item_activate": self._repos_item_clicked,
"on_about_menu_item_activate": self._about_item_clicked,
"on_getting_started_menu_item_activate": self._getting_started_item_clicked,
"on_online_docs_menu_item_activate": self._online_docs_item_clicked,
"on_quit_menu_item_activate": ga_Gtk.main_quit,
})
# various state tracking for async operations
self._show_overrides = False
self._can_redeem = False
self.backend.cs.add_callback(self.on_cert_sorter_cert_change)
self.main_window.show_all()
# Check to see if already registered to old RHN/Spacewalk
# and show dialog if so
self._check_rhn_classic()
# Update everything with compliance data
self.backend.cs.notify()
# managergui needs cert_sort.cert_monitor.run_check() to run
# on a timer to detect cert changes from outside the gui
# (via rhsmdd for example, or manually provisioned).
cert_monitor_thread = threading.Thread(target=self._cert_check_timer, name="CertMonitorThread")
cert_monitor_thread.daemon = True
cert_monitor_thread.start()
if auto_launch_registration and not self.registered():
self._register_item_clicked(None)
