def add_tools_channel(server_id, action_id, dry_run=0): log_debug(3) if (not dry_run): subscribe_to_tools_channel(server_id) else: log_debug(4, "dry run requested") raise ShadowAction("Subscribed guest to tools channel.")
def schedule_deploy(server_id, action_id, dry_run=0): log_debug(2, server_id, action_id) s = rhnServer.search(server_id) # Schedule an rhncfg install new_action_id = server_kickstart.schedule_rhncfg_install(server_id, action_id, scheduler=None) new_action_id_2 = rhnAction.schedule_server_action( server_id, action_type='configfiles.deploy', action_name="Activation Key Config Auto-Deploy", delta_time=0, scheduler=None, org_id=s.server['org_id'], prerequisite=new_action_id, ) if (not dry_run): h = rhnSQL.prepare(_query_copy_revs_from_shadow_action) h.execute(action_id=action_id, new_action_id=new_action_id_2, server_id=server_id) else: log_debug(4, "dry run requested") log_debug(4, "scheduled config deploy for activation key") raise ShadowAction("Config deploy scheduled")
def schedule_virt_host_pkg_install(server_id, action_id, dry_run=0): """ ShadowAction that schedules a package installation action for the rhn-virtualization-host and osad packages. """ log_debug(3) virt_host_package_name = "mgr-virtualization-host" messaging_package_name = "mgr-osad" tools_channel = SubscribedChannel(server_id, "rhn-tools") found_tools_channel = tools_channel.is_subscribed_to_channel() if not found_tools_channel: raise InvalidAction("System not subscribed to the Tools channel.") rhn_v12n_package = ChannelPackage(server_id, virt_host_package_name) if not rhn_v12n_package.exists(): raise InvalidAction( "Could not find the mgr-virtualization-host package.") messaging_package = ChannelPackage(server_id, messaging_package_name) if not messaging_package.exists(): raise InvalidAction("Could not find the mgr-osad package.") try: rhn_v12n_install_scheduler = PackageInstallScheduler( server_id, action_id, rhn_v12n_package) messaging_package = PackageInstallScheduler(server_id, action_id, messaging_package) if (not dry_run): rhn_v12n_install_scheduler.schedule_package_install() messaging_package.schedule_package_install() else: log_debug(4, "dry run requested") except NoActionInfo: nai = sys.exc_info()[1] raise_with_tb(InvalidAction(str(nai)), sys.exc_info()[2]) except PackageNotFound: pnf = sys.exc_info()[1] raise_with_tb(InvalidAction(str(pnf)), sys.exc_info()[2]) except Exception: e = sys.exc_info()[1] raise_with_tb(InvalidAction(str(e)), sys.exc_info()[2]) log_debug( 3, "Completed scheduling install of mgr-virtualization-host and mgr-osad!" ) raise ShadowAction( "Scheduled installation of Virtualization Host packages.")
def schedule_pkg_install(server_id, action_id, dry_run=0): s = rhnServer.search(server_id) new_action_id = rhnAction.schedule_server_action( server_id, action_type='packages.update', action_name="Activation Key Package Auto-Install", delta_time=0, scheduler=None, org_id=s.server['org_id'], ) if (not dry_run): h = rhnSQL.prepare(_query_copy_pkgs_from_shadow_action) h.execute(action_id=action_id, new_action_id=new_action_id) else: log_debug(4, "dry run requested") log_debug(4, "scheduled pkg install for activation key") raise ShadowAction("Package install scheduled")
try: install_scheduler = PackageInstallScheduler(server_id, action_id, rhn_v12n_package) if (not dry_run): install_scheduler.schedule_package_install() else: log_debug(4, "dry run requested") except NoActionInfo, nai: raise InvalidAction(str(nai)), None, sys.exc_info()[2] except PackageNotFound, pnf: raise InvalidAction(str(pnf)), None, sys.exc_info()[2] except Exception, e: raise InvalidAction(str(e)), None, sys.exc_info()[2] log_debug(3, "Completed scheduling install of rhn-virtualization-guest!") raise ShadowAction( "Scheduled installation of RHN Virtualization Guest packages.") def initiate(server_id, action_id, dry_run=0): log_debug(3) h = rhnSQL.prepare(_query_initiate_guest) h.execute(action_id=action_id) row = h.fetchone_dict() if not row: raise InvalidAction("Kickstart action without an associated kickstart") kickstart_host = row['kickstart_host'] virt_type = row['virt_type'] name = row['guest_name'] boot_image = "spacewalk-koan"
def schedule_sync(server_id, action_id, dry_run=0): log_debug(3, server_id, action_id) if dry_run: raise ShadowAction("dry run requested - skipping") kickstart_session_id = server_kickstart.get_kickstart_session_id( server_id, action_id) if kickstart_session_id is None: raise InvalidAction("Could not find kickstart session ID") row = server_kickstart.get_kickstart_session_info(kickstart_session_id, server_id) deploy_configs = (row['deploy_configs'] == 'Y') ks_package_profile = server_kickstart.get_kisckstart_session_package_profile( kickstart_session_id) # if the session doesn't have a pkg profile, try from the ks profile itself if not ks_package_profile: ks_package_profile = server_kickstart.get_kickstart_profile_package_profile( kickstart_session_id) if not ks_package_profile: log_debug(4, "No kickstart package profile") # No profile to bring this system to if deploy_configs: # We have to deploy configs, so pass in a server profile server_profile = server_kickstart.get_server_package_profile( server_id) else: # No configs to be deployed server_profile = None server_kickstart.schedule_config_deploy(server_id, action_id, kickstart_session_id, server_profile=server_profile) raise ShadowAction( "Package sync not scheduled, missing kickstart " "package profile; proceeding with configfiles.deploy") server_profile = server_kickstart.get_server_package_profile(server_id) installs, removes = server_packages.package_delta(server_profile, ks_package_profile) if not (installs or removes): log_debug(4, "No packages to be installed/removed") if not deploy_configs: server_profile = None server_kickstart.schedule_config_deploy(server_id, action_id, kickstart_session_id, server_profile=None) raise ShadowAction("Package sync not scheduled, nothing to do") log_debug(4, "Scheduling kickstart delta") server_kickstart.schedule_kickstart_delta(server_id, kickstart_session_id, installs, removes) raise ShadowAction("Package sync scheduled")
def upgrade(serverId, actionId, dry_run=0): log_debug(3) if dry_run: # can happen if future actions are requested raise ShadowAction("dry run requested - skipping") h = rhnSQL.prepare(_query_dup_data) h.execute(action_id=actionId) row = h.fetchone_dict() if not row: # No dup for this action raise InvalidAction( "distupgrade.upgrade: No action found for action id " "%s and server %s" % (actionId, serverId)) action_dup_id = row['id'] # get product info h = rhnSQL.prepare(_query_products) h.execute(action_dup_id=action_dup_id) products = h.fetchall_dict() or [] # only SLE10 products needs to be changed manually # remove all not SLE10 based products sle10_products = [] do_change = False for product in products: if product['version'] == '10': do_change = True sle10_products.append(product) # switch the channels for this server h = rhnSQL.prepare(_query_channel_changes) h.execute(action_dup_id=action_dup_id) channel_changes = h.fetchall_dict() or None if not channel_changes: # this happens in case a distupgrade failed and the # another distupgrade is scheduled to fix the installation # we do not have the original channels anymore, so we need # to execute a full "dup" without channels params = { "full_update": (row['full_update'] == 'Y'), "change_product": do_change, "products": sle10_products, "dry_run": (row['dry_run'] == 'Y') } return (params) to_subscribe = filter(lambda x: x['task'] == 'S', channel_changes) to_unsubscribe = filter(lambda x: x['task'] == 'U', channel_changes) try: unsubscribe_channels(serverId, to_unsubscribe) subscribe_channels(serverId, to_subscribe) except rhnFault, f: if f.code == 38: # channel is already subscribed, ignore it pass else: raise InvalidAction(str(f)), None, sys.exc_info()[2]
def subscribe(serverId, actionId, dry_run=0): log_debug(3) raise ShadowAction( "subscribe channel requested - internal DB operation only")