def update(serverId, actionId, dry_run=0): log_debug(3) statement = """ select r1.errata_id, r2.allow_vendor_change, e.advisory_status from rhnactionerrataupdate r1 join rhnErrata e on r1.errata_id = e.id left join rhnactionpackagedetails r2 on r1.action_id = r2.action_id where r1.action_id = :action_id """ h = rhnSQL.prepare(statement) h.execute(action_id=actionId) ret = h.fetchall_dict() if not ret: # No errata for this action raise InvalidAction("errata.update: Unknown action id " "%s for server %s" % (actionId, serverId)) retracted = [ x['errata_id'] for x in ret if x['advisory_status'] == 'retracted' ] if retracted: # Do not install retracted patches raise InvalidAction( "errata.update: Action contains retracted errata %s" % retracted) if ret[0]['allow_vendor_change'] is None or ret[0][ 'allow_vendor_change'] is False: return [x['errata_id'] for x in ret] return { "errata_ids": [x['errata_id'] for x in ret], "allow_vendor_change": (ret[0]['allow_vendor_change'] == 'Y') }
def schedule_virt_guest_pkg_install(server_id, action_id, dry_run=0): """ ShadowAction that schedules a package installation action for the rhn-virtualization-guest package. """ log_debug(3) virt_host_package_name = "rhn-virtualization-guest" 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 RHN Tools channel.") rhn_v12n_package = ChannelPackage(server_id, virt_host_package_name) if not rhn_v12n_package.exists(): raise InvalidAction( "Could not find the rhn-virtualization-guest package.") 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]
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" append_string = row['append_string'] vcpus = row['vcpus'] disk_gb = row['disk_gb'] mem_kb = row['mem_kb'] ks_session_id = row['ks_session_id'] virt_bridge = row['virt_bridge'] disk_path = row['disk_path'] cobbler_system_name = row['cobbler_system_name'] if not boot_image: raise InvalidAction("Boot image missing") return (kickstart_host, cobbler_system_name, virt_type, ks_session_id, name, mem_kb, vcpus, disk_gb, virt_bridge, disk_path, append_string)
def action(action_name, query, server_id, action_id, dry_run=0): log_debug(3, action_name, dry_run) try: uuid = _get_uuid(query, action_id) except NoRowFoundException: raise_with_tb(InvalidAction("No %s actions found." % action_name.lower()), sys.exc_info()[2]) except NoUUIDException: raise_with_tb(InvalidAction("%s action %s has no uuid associated with it." % (action_name, str(action_id))), sys.exc_info()[2]) return (uuid,)
def handle_action(serverId, actionId, packagesIn, dry_run=0): log_debug(3, serverId, actionId, dry_run) client_caps = rhnCapability.get_client_capabilities() log_debug(3, "Client Capabilities", client_caps) multiarch = 0 if client_caps and 'packages.update' in client_caps: cap_info = client_caps['packages.update'] if cap_info['version'] > 1: multiarch = 1 if not packagesIn: raise InvalidAction( "Packages scheduled in action %s for server %s could not be found." % (actionId, serverId)) packages = [] for package in packagesIn: # Fix the epoch if package['epoch'] is None: package['epoch'] = "" pkg_arch = '' if multiarch: pkg_arch = package['arch'] or '' packages.append([ package['name'], package['version'] or '', package['release'] or '', package['epoch'], pkg_arch ]) log_debug(4, packages) return packages
def deploy(serverId, actionId, dry_run=0): log_debug(3) statement = """ select aid.mem_kb, aid.vcpus, aid.bridge_device,aid.download_url, aid.proxy_server, aid.proxy_user, aid.proxy_pass from rhnActionImageDeploy aid where aid.action_id = :action_id""" h = rhnSQL.prepare(statement) h.execute(action_id = actionId) row = h.fetchone_dict() if not row: # No image for this action raise InvalidAction("image.deploy: No image found for action id " "%s and server %s" % (actionId, serverId)) for key in [ 'download_url', 'proxy_server', 'proxy_user', 'proxy_pass', 'bridge_device' ]: if row[key] == None: row[key] = "" params = { "downloadURL" : row['download_url'], "proxySettings" : { "proxyURL" : row['proxy_server'], "proxyUser" : row['proxy_user'], "proxyPass" : row['proxy_pass'] }, "memKB" : row['mem_kb'], "vCPUs" : row['vcpus'], "domainName" : "", "virtBridge" : row['bridge_device'] } return (params)
def rollback(serverId, actionId, dry_run=0): log_debug(3, dry_run) # since rhnActionTransactions table is gone, this call have to fail log_error("Invalid rollback.rollback action %s for server id %s" % (actionId, serverId)) raise InvalidAction( "Invalid rollback.rollback action %s for server id %s" % (actionId, serverId))
def setVCPUs(server_id, action_id, dry_run=0): log_debug(3, dry_run) prepared_query = rhnSQL.prepare(_query_getVCPUs) prepared_query.execute(action_id=action_id) row = prepared_query.fetchone_dict() if not row: raise InvalidAction("No VCPU actions found.") return row['uuid'], row['vcpu']
def setMemory(server_id, action_id, dry_run=0): log_debug(3, dry_run) prepared_query = rhnSQL.prepare(_query_setMemory) prepared_query.execute(action_id=action_id) row = prepared_query.fetchone_dict() if not row: raise InvalidAction("No setMemory actions found.") if 'uuid' not in row: raise InvalidAction("Set Memory action %s has no uuid." % str(action_id)) if 'memory' not in row: raise InvalidAction("setMemory action %s has no memory set." % str(action_id)) uuid = row['uuid'] memory = row['memory'] return (uuid, memory)
def schedule_virt_guest_pkg_install(server_id, action_id, dry_run=0): """ ShadowAction that schedules a package installation action for the rhn-virtualization-guest package. """ log_debug(3) virt_host_package_name = "rhn-virtualization-guest" 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 rhn-virtualization-guest package.") 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 = 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 rhn-virtualization-guest!") raise ShadowAction( "Scheduled installation of Virtualization Guest packages.")
def schedulePoller(server_id, action_id, dry_run=0): log_debug(3, dry_run) prepared_query = rhnSQL.prepare(_query_schedulePoller) prepared_query.execute(action_id=action_id) row = prepared_query.fetchone_dict() if not row: raise InvalidAction("No schedulePoller actions found.") if 'minute' not in row: raise InvalidAction("schedulePoller action %s has no minute associated with it." % str(action_id)) if 'hour' not in row: raise InvalidAction("schedulePoller action %s has no hour associated with it." % str(action_id)) if 'dom' not in row: raise InvalidAction("schedulePoller action %s has no day of the month associated with it." % str(action_id)) if 'month' not in row: raise InvalidAction("schedulePoller action %s has no month associated with it." % str(action_id)) if 'dow' not in row: raise InvalidAction("schedulePoller action %s has no day of the week associated with it." % str(action_id)) return (row['minute'], row['hour'], row['dom'], row['month'], row['dow'])
def initiate(server_id, action_id, dry_run=0): log_debug(3) h = rhnSQL.prepare(_query_initiate) h.execute(action_id=action_id) row = h.fetchone_dict() if not row: raise InvalidAction("Kickstart action without an associated kickstart") boot_image, append_string = ('spacewalk-koan', row['append_string']) static_device = row['static_device'] or "" kickstart_host = row['kickstart_host'] system_record = row['cobbler_system_name'] if system_record is None: system_record = '' if not boot_image: raise InvalidAction("Boot image missing") if not kickstart_host: raise InvalidAction("Kickstart_host missing") h = rhnSQL.prepare(_query_file_list_initiate) h.execute(action_id=action_id) files = [x['path'] for x in h.fetchall_dict() or []] return (kickstart_host, boot_image, append_string, static_device, system_record, files)
def refresh(server_id, action_id, dry_run=0): log_debug(3, dry_run) prepared_query = rhnSQL.prepare(_query_refresh) prepared_query.execute(action_id=action_id) row = prepared_query.fetchone_dict() if not row: raise NoRowFoundException() # Sanity check. If this doesn't pass then something is definitely screwed up. if not row['action_id']: raise InvalidAction("Refresh action is missing an action_id.") return ()
def update(serverId, actionId, dry_run=0): log_debug(3) statement = """ select errata_id from rhnActionErrataUpdate where action_id = :action_id""" h = rhnSQL.prepare(statement) h.execute(action_id=actionId) ret = h.fetchall_dict() if not ret: # No errata for this action raise InvalidAction("errata.update: Unknown action id " "%s for server %s" % (actionId, serverId)) return map(lambda x: x['errata_id'], ret)
def xccdf_eval(server_id, action_id, dry_run=0): log_debug(3) statement = """ select path, parameters from rhnActionScap where action_id = :action_id""" h = rhnSQL.prepare(statement) h.execute(action_id=action_id) d = h.fetchone_dict() if not d: raise InvalidAction("scap.xccdf_eval: Unknown action id " "%s for server %s" % (action_id, server_id)) return ({ 'path': d['path'], 'id': action_id, 'file_size': _scap_file_limit(server_id), 'params': rhnSQL.read_lob(d['parameters']) or '' },)
def __getV1(self, action): """ Fetches old queued actions for the client version 1. """ log_debug(3, self.server_id) actionId = action['id'] method = action["method"] if method == 'packages.update': xml = self.__packageUpdate(actionId) elif method == 'errata.update': xml = self.__errataUpdate(actionId) elif method == 'hardware.refresh_list': xml = xmlrpclib.dumps(("hardware",), methodname="client.refresh") elif method == 'packages.refresh_list': xml = xmlrpclib.dumps(("rpmlist",), methodname="client.refresh") else: # Unrecognized, skip raise InvalidAction("Action method %s unsupported by " "Update Agent Client" % method) # all good return {'id': actionId, 'version': 1, 'action': xml}
def verify(serverId, actionId, dry_run=0): log_debug(3, dry_run) h = rhnSQL.prepare(_query_action_verify_packages) h.execute(actionid=actionId) tmppackages = h.fetchall_dict() if not tmppackages: raise InvalidAction("invalid action %s for server %s" % (actionId, serverId)) packages = [] for package in tmppackages: packages.append([ package['name'], package['version'], package['release'], package['epoch'] or '', package['arch'] or '' ]) log_debug(4, packages) return packages
def setLocks(serverId, actionId, dry_run=0): log_debug(3, serverId, actionId, dry_run) client_caps = rhnCapability.get_client_capabilities() log_debug(3, "Client Capabilities", client_caps) multiarch = 0 if not client_caps or not client_caps.has_key('packages.setLocks'): raise InvalidAction("Client is not capable of locking packages.") h = rhnSQL.prepare(_query_action_setLocks) h.execute(actionid=actionId, serverid=serverId) tmppackages = h.fetchall_dict() or {} packages = [] for package in tmppackages: packages.append([ package['name'], package['version'], package['release'], package['epoch'] or '', package['arch'] or '' ]) log_debug(4, packages) return packages
def update(serverId, actionId, dry_run=0): log_debug(3) statement = """ select r1.errata_id, r2.allow_vendor_change from rhnactionerrataupdate r1 left join rhnactionpackagedetails r2 on r1.action_id = r2.action_id where r1.action_id = :action_id """ h = rhnSQL.prepare(statement) h.execute(action_id=actionId) ret = h.fetchall_dict() if not ret: # No errata for this action raise InvalidAction("errata.update: Unknown action id " "%s for server %s" % (actionId, serverId)) if ret[0]['allow_vendor_change'] is null or ret[0][ 'allow_vendor_change'] is False: return [x['errata_id'] for x in ret] return { "errata_ids": [x['errata_id'] for x in ret], "allow_vendor_change": (ret[0]['allow_vendor_change'] == 'Y') }
def runTransaction(server_id, action_id, dry_run=0): log_debug(3, server_id, action_id, dry_run) # Fetch package_delta_id h = rhnSQL.prepare(""" select package_delta_id from rhnActionPackageDelta where action_id = :action_id """) h.execute(action_id=action_id) row = h.fetchone_dict() if row is None: raise InvalidAction( "invalid packages.runTransaction action %s for server %s" % (action_id, server_id)) package_delta_id = row['package_delta_id'] # Fetch packages h = rhnSQL.prepare(""" select tro.label as operation, pn.name, pe.version, pe.release, pe.epoch, pa.label as package_arch from rhnPackageDeltaElement pde, rhnTransactionPackage rp left join rhnPackageArch pa on rp.package_arch_id = pa.id, rhnTransactionOperation tro, rhnPackageName pn, rhnPackageEVR pe where pde.package_delta_id = :package_delta_id and pde.transaction_package_id = rp.id and rp.operation = tro.id and rp.name_id = pn.id and rp.evr_id = pe.id order by tro.label, pn.name """) h.execute(package_delta_id=package_delta_id) result = [] while 1: row = h.fetchone_dict() if not row: break operation = row['operation'] # Need to map the operations into codes the client/rpm understands if operation == 'insert': operation = 'i' elif operation == 'delete': operation = 'e' elif operation == 'upgrade': operation = 'u' else: # Unsupported continue # Fix null epochs epoch = row['epoch'] if epoch is None: epoch = '' name, version, release = row['name'], row['version'], row['release'] # The package arch can be null now because of the outer join package_arch = row['package_arch'] or "" result.append([[name, version, release, epoch, package_arch], operation]) return {'packages': result}
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]
if not rhn_v12n_package.exists(): raise InvalidAction( "Could not find the rhn-virtualization-guest package.") 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:
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")