def entitle(self, server_id, history, virt_type=None): """ Entitle a server according to the entitlements we have configured. """ log_debug(3, self.entitlements) # check for bootstrap_entitled and unentitle first cur = check_entitlement(server_id, True) if cur and 'bootstrap_entitled' in cur: remove_ent = rhnSQL.Procedure( "rhn_entitlements.remove_server_entitlement") remove_ent(server_id, "bootstrap_entitled") entitle_server = rhnSQL.Procedure("rhn_entitlements.entitle_server") # TODO: entitle_server calls can_entitle_server, so we're doing this # twice for each successful call. Is it necessary for external error # handling or can we ditch it? can_entitle_server = rhnSQL.Function( "rhn_entitlements.can_entitle_server", rhnSQL.types.NUMBER()) can_ent = None history["entitlement"] = "" for entitlement in self.entitlements: if virt_type is not None and entitlement[0] == VIRT_ENT_LABEL: continue try: can_ent = can_entitle_server(server_id, entitlement[0]) except rhnSQL.SQLSchemaError: e = sys.exc_info()[1] can_ent = 0 try: # bugzilla #160077, skip attempting to entitle if we cant if can_ent: entitle_server(server_id, entitlement[0]) except rhnSQL.SQLSchemaError: e = sys.exc_info()[1] log_error("Token failed to entitle server", server_id, self.get_names(), entitlement[0], e.errmsg) #No idea what error may be here... raise_with_tb(rhnFault(90, e.errmsg), sys.exc_info()[2]) except rhnSQL.SQLError: e = sys.exc_info()[1] log_error("Token failed to entitle server", server_id, self.get_names(), entitlement[0], e.args) raise_with_tb(rhnFault(90, str(e)), sys.exc_info()[2]) else: history[ "entitlement"] = "Entitled as a %s member" % entitlement[1]
def __init__(self, sysid, name=None, data=None): machine_id = data.get( "machine_id") if data and "machine_id" in data else None if not name: name = "unknown" log_debug(4, "updating machine_id", sysid, name, machine_id) existing_srv_id = self.__check_if_machine_id_exists(machine_id) if not existing_srv_id or existing_srv_id == sysid: s_update = rhnSQL.prepare(""" UPDATE rhnServer SET machine_id = :machine_id WHERE id = :server_id """) s_update.execute(machine_id=machine_id, server_id=sysid) else: # this indicate a forced re-registration and we need to remove the old rhnServer log_debug( 0, "Found duplicate server. Re-registration expected. Deleting existing: ", existing_srv_id) delete_server = rhnSQL.Procedure("delete_server") try: delete_server(existing_srv_id) except rhnSQL.SQLError: log_error("Error deleting server: %s" % existing_srv_id)
def entitle(self, server_id, history, virt_type=None): """ Entitle a server according to the entitlements we have configured. """ log_debug(3, self.entitlements) entitle_server = rhnSQL.Procedure("rhn_entitlements.entitle_server") # TODO: entitle_server calls can_entitle_server, so we're doing this # twice for each successful call. Is it necessary for external error # handling or can we ditch it? can_entitle_server = rhnSQL.Function( "rhn_entitlements.can_entitle_server", rhnSQL.types.NUMBER()) can_ent = None history["entitlement"] = "" # Do a quick check to see if both virt entitlements are present. (i.e. # activation keys stacked together) If so, give preference to the more # powerful virtualization platform and remove the regular virt # entitlement from the list. found_virt = False found_virt_platform = False for entitlement in self.entitlements: if entitlement[0] == VIRT_ENT_LABEL: found_virt = True elif entitlement[0] == VIRT_PLATFORM_ENT_LABEL: found_virt_platform = True for entitlement in self.entitlements: if virt_type is not None and entitlement[0] in \ (VIRT_ENT_LABEL, VIRT_PLATFORM_ENT_LABEL): continue # If both virt entitlements are present, skip the least powerful: if found_virt and found_virt_platform and entitlement[0] == VIRT_ENT_LABEL: log_debug(1, "Virtualization and Virtualization Platform " + "entitlements both present.") log_debug(1, "Skipping Virtualization.") continue try: can_ent = can_entitle_server(server_id, entitlement[0]) except rhnSQL.SQLSchemaError, e: can_ent = 0 try: # bugzilla #160077, skip attempting to entitle if we cant if can_ent: entitle_server(server_id, entitlement[0]) except rhnSQL.SQLSchemaError, e: log_error("Token failed to entitle server", server_id, self.get_names(), entitlement[0], e.errmsg) if e.errno == 20220: # ORA-20220: (servergroup_max_members) - Server group membership # cannot exceed maximum membership raise rhnFault(91, _("Registration failed: RHN Software service entitlements exhausted: %s") % entitlement[0]), None, sys.exc_info()[2] # No idea what error may be here... raise rhnFault(90, e.errmsg), None, sys.exc_info()[2]
def get(name, modified=None, raw=None, compressed=None): # Check to see if the entry is in the database, with the right version h = _fetch_cursor(key=name, modified=modified) row = h.fetchone_dict() if not row: # Key not found return None if modified and row['delta'] != 0: # Different version log_debug(4, "database cache: different version") return None if modified is None: # The caller doesn't care about the modified time, but we do, since we # want to fetch the same version from the disk cache modified = row['modified'] if rhnCache.has_key(name, modified): # We have the value log_debug(4, "Filesystem cache HIT") return rhnCache.get(name, modified=modified, raw=raw) log_debug(4, "Filesystem cache MISS") # The disk cache doesn't have this key at all, or it's a modified value # Fetch the value from the database v = row['value'] # Update the accessed field rhnSQL.Procedure("rhn_cache_update_accessed")(name) if compressed: io = cStringIO.StringIO() io.write(rhnSQL.read_lob(v)) io.seek(0, 0) # XXX For about 40M of compressed data sometimes we get: # zlib.error: Error -3 while decompressing: incomplete dynamic bit lengths tree v = gzip.GzipFile(None, "r", 0, io) try: data = v.read() except (ValueError, IOError, gzip.zlib.error) as e: # XXX poking at gzip.zlib may not be that well-advised log_error("rhnDatabaseCache: gzip error for key %s: %s" % (name, e)) # Ignore this entry in the database cache, it has invalid data return None # We store the data in the database cache, in raw format rhnCache.set(name, data, modified=modified, raw=1) # Unpickle the data, unless raw access was requested if not raw: return cPickle.loads(data) return data
def management_remove_file(self, dict): log_debug(1) self._get_and_validate_session(dict) config_channel = dict.get('config_channel') # XXX Validate the namespace path = dict.get('path') row = rhnSQL.fetchone_dict(self._query_lookup_config_file_by_channel, org_id=self.org_id, config_channel=config_channel, path=path) if not row: raise rhnFault(4011, "File %s does not exist in channel %s" % (path, config_channel), explain=0) config_file_id = row['id'] delete_call = rhnSQL.Procedure("rhn_config.delete_file") delete_call(config_file_id) rhnSQL.commit() return {}
def management_remove_channel(self, dict): log_debug(1) self._get_and_validate_session(dict) config_channel = dict.get('config_channel') # XXX Validate the namespace row = rhnSQL.fetchone_dict(self._query_config_channel_by_label, org_id=self.org_id, label=config_channel) if not row: raise rhnFault(4009, "Channel not found") delete_call = rhnSQL.Procedure('rhn_config.delete_channel') try: delete_call(row['id']) except rhnSQL.SQLError, e: errno = e.args[0] if errno == 2292: raise rhnFault(4005, "Cannot remove non-empty channel %s" % config_channel, explain=0), None, sys.exc_info()[2] raise
def __unsubscribeServers(labels): sql = """ select distinct sc.server_id as server_id, C.id as channel_id, c.parent_channel, c.label from rhnChannel c inner join rhnServerChannel sc on c.id = sc.channel_id where c.label in (%s) order by C.parent_channel """ params, bind_params = _bind_many(labels) bind_params = ', '.join(bind_params) h = rhnSQL.prepare(sql % (bind_params)) h.execute(**params) server_channel_list = h.fetchall_dict() channel_counts = {} for i in server_channel_list: if i['label'] in channel_counts: channel_counts[i['label']] = channel_counts[i['label']] + 1 else: channel_counts[i['label']] = 1 print("\nThe following channels will have their systems unsubscribed:") channel_list = channel_counts.keys() channel_list.sort() for i in channel_list: print("%-40s %-8s" % (i, channel_counts[i])) pb = ProgressBar(prompt='Unsubscribing: ', endTag=' - complete', finalSize=len(server_channel_list), finalBarLength=40, stream=sys.stdout) pb.printAll(1) unsubscribe_server_proc = rhnSQL.Procedure("rhn_channel.unsubscribe_server") for i in server_channel_list: unsubscribe_server_proc(i['server_id'], i['channel_id']) pb.addTo(1) pb.printIncrement() pb.printComplete()
def _entitle(self, entitlement): system_entitlements = server_lib.check_entitlement(self.server["id"]) system_entitlements = system_entitlements.keys() if entitlement not in system_entitlements: entitle_server = rhnSQL.Procedure("rhn_entitlements.entitle_server") entitle_server(self.server['id'], entitlement)
def entitle(self, server_id, history, virt_type=None): """ Entitle a server according to the entitlements we have configured. """ log_debug(3, self.entitlements) entitle_server = rhnSQL.Procedure("rhn_entitlements.entitle_server") # TODO: entitle_server calls can_entitle_server, so we're doing this # twice for each successful call. Is it necessary for external error # handling or can we ditch it? can_entitle_server = rhnSQL.Function( "rhn_entitlements.can_entitle_server", rhnSQL.types.NUMBER()) can_ent = None history["entitlement"] = "" for entitlement in self.entitlements: if virt_type is not None and entitlement[0] == VIRT_ENT_LABEL: continue try: can_ent = can_entitle_server(server_id, entitlement[0]) except rhnSQL.SQLSchemaError, e: can_ent = 0 try: # bugzilla #160077, skip attempting to entitle if we cant if can_ent: entitle_server(server_id, entitlement[0]) except rhnSQL.SQLSchemaError, e: log_error("Token failed to entitle server", server_id, self.get_names(), entitlement[0], e.errmsg) #No idea what error may be here... raise rhnFault(90, e.errmsg), None, sys.exc_info()[2]
def delete_guests(server_id): """ Callback used after a successful kickstart to remove any guest virtual instances, as well as their associated servers. """ # First delete all the guest server objects: h = rhnSQL.prepare(_query_lookup_guests_for_host) h.execute(server_id=server_id) delete_server = rhnSQL.Procedure("delete_server") log_debug(4, "Deleting guests") while 1: row = h.fetchone_dict() if not row: break guest_id = row['virtual_system_id'] log_debug(4, 'Deleting guest server: %s' % guest_id) try: if guest_id is not None: delete_server(guest_id) except rhnSQL.SQLError: log_error("Error deleting server: %s" % guest_id) # Finally delete all the virtual instances: log_debug(4, "Deleting all virtual instances for host") h = rhnSQL.prepare(_query_delete_virtual_instances) h.execute(server_id=server_id) # Commit all changes: try: rhnSQL.commit() except rhnSQL.SQLError: e = sys.exc_info()[1] log_error("Error committing transaction: %s" % e) rhnSQL.rollback()
def create_new_org(username, password): f = rhnSQL.Procedure('create_new_org') username = rhnSQL.types.STRING(username) password = rhnSQL.types.STRING(password) ncl = rhnSQL.types.NUMBER ret = f(username, password, ncl()) return int(ret[2])
def update_errata_cache(server_id): """ Queue an update the the server's errata cache. This queues for Taskomatic instead of doing it in-line because updating many servers at once was problematic and lead to unresponsive Satellite and incorrectly reporting failed actions when they did not fail (see bz 1119460). """ log_debug(2, "Queueing the errata cache update", server_id) update_needed_cache = rhnSQL.Procedure("queue_server") update_needed_cache(server_id, 0)
def update_errata_cache(server_id): """ Function that updates rhnServerNeededPackageCache by deltas (as opposed to calling queue_server which removes the old entries and inserts new ones). It now also updates rhnServerNeededErrataCache, but as the entries there are a subset of rhnServerNeededPackageCache's entries, it still gives statistics regarding only rhnServerNeededPackageCache. """ log_debug(2, "Updating the errata cache", server_id) update_needed_cache = rhnSQL.Procedure("rhn_server.update_needed_cache") update_needed_cache(server_id)
def update_channel_family_counts(): update_family_counts_proc = rhnSQL.Procedure("rhn_channel.update_family_counts") h = rhnSQL.prepare(_query_private_families) h.execute() while 1: row = h.fetchone_dict() if not row: break update_family_counts_proc(row['channel_family_id'], row['org_id']) rhnSQL.commit()
def entitle(self, server_id, history, virt_type=None): for ent in self.remove_entitlements: unentitle_server = rhnSQL.Procedure( "rhn_entitlements.remove_server_entitlement") try: unentitle_server(server_id, ent) except rhnSQL.SQLSchemaError, e: log_error("Failed to unentitle server", server_id, ent, e.errmsg) raise rhnFault(90, e.errmsg), None, sys.exc_info()[2] except rhnSQL.SQLError, e: log_error("Failed to unentitle server", server_id, ent, e.args) raise rhnFault(90, str(e)), None, sys.exc_info()[2]
def push_monitoring_configs(org_id): push_configs_proc = rhnSQL.Procedure("rhn_install_org_satellites") h = rhnSQL.prepare(_query_get_sat_clusters) h.execute(customer_id=org_id) rows = h.fetchall_dict() if not rows: #since we've not found any scouts, just do nothing pass else: for row in rows: push_configs_proc(org_id, row['recid'], '1') print "Pushing scout configs to all monitoring scouts"
def entitle(self, server_id, history, virt_type=None): for ent in self.remove_entitlements: unentitle_server = rhnSQL.Procedure( "rhn_entitlements.remove_server_entitlement") try: unentitle_server(server_id, ent) except rhnSQL.SQLSchemaError: e = sys.exc_info()[1] log_error("Failed to unentitle server", server_id, ent, e.errmsg) raise_with_tb(rhnFault(90, e.errmsg), sys.exc_info()[2]) except rhnSQL.SQLError: e = sys.exc_info()[1] log_error("Failed to unentitle server", server_id, ent, e.args) raise_with_tb(rhnFault(90, str(e)), sys.exc_info()[2]) # Call parent method: ReRegistrationToken.entitle(self, server_id, history, virt_type)
def create_new_user(org_id=None, username=None, password=None, roles=None): "Create a new user" if org_id is None: org_id = create_new_org() else: org_id = lookup_org_id(org_id) if username is None: username = "******" % time.time() if password is None: password = "******" % time.time() if roles is None: roles = [] u = rhnUser.User(username, password) u.set_org_id(org_id) u.save() # The password is scrambled now - re-set it u.contact['password'] = password u.save() user_id = u.getid() # Set roles h = rhnSQL.prepare(""" select ug.id from rhnUserGroupType ugt, rhnUserGroup ug where ug.org_id = :org_id and ug.group_type = ugt.id and ugt.label = :role """) create_ugm = rhnSQL.Procedure("rhn_user.add_to_usergroup") for role in roles: h.execute(org_id=org_id, role=role) row = h.fetchone_dict() if not row: raise InvalidRoleError(org_id, role) user_group_id = row['id'] create_ugm(user_id, user_group_id) rhnSQL.commit() return u
def __remove_errata(self, errata_id, advisory): """ Remove an errata. """ channel_ids = errata_helper.channelsWithErrata(errata_id) for channel_id in channel_ids: _printLog("Removing '{0}' patch from channel '{1}'".format(advisory, channel_id)) # delete errata from channel errata_helper.deleteChannelErrata(errata_id, channel_id) # Update the errata/package cache for the servers # use procedure rhn_channel.update_needed_cache(channel_id) log_debug(2, "Update Server Cache for channel '{0}'".format(channel_id)) rhnSQL.commit() update_needed_cache = rhnSQL.Procedure("rhn_channel.update_needed_cache") update_needed_cache(channel_id) rhnSQL.commit() errata_helper.deleteErrata(errata_id)
def create_first_org(owner): """ create first org_id if needed Always returns the org_id Will not commit """ try: return get_org_id() except NoOrgIdError: # gotta create one first org then p = rhnSQL.Procedure("create_first_org") # copying logic from validate-sat-cert.pl # I.e., setting their org_id password to the pid cubed. # That password is not used by anything. pword = str(long(os.getpid())**3) # do it! p(owner, pword) # Now create the first private channel family create_first_private_chan_family() verify_family_permissions() return get_org_id()
def create_perm_cache(self): log_debug(4) create_perms = rhnSQL.Procedure("rhn_cache.update_perms_for_server") create_perms(self.server['id'])
def token_channels(server, server_arch, tokens_obj): """ Handle channel subscriptions for the registration token """ assert(isinstance(tokens_obj, ActivationTokens)) server_id, server_arch_id = server['id'], server['server_arch_id'] # what channels are associated with this token (filter only those # compatible with this server) h = rhnSQL.prepare(""" select rtc.channel_id id, c.name, c.label, c.parent_channel from rhnRegTokenChannels rtc, rhnChannel c, rhnServerChannelArchCompat scac where rtc.token_id = :token_id and rtc.channel_id = c.id and c.channel_arch_id = scac.channel_arch_id and scac.server_arch_id = :server_arch_id """) chash = {} base_channel_token = None base_channel_id = None for token in tokens_obj.tokens: token_id = token['token_id'] h.execute(token_id=token_id, server_arch_id=server_arch_id) while 1: row = h.fetchone_dict() if not row: break channel_id = row['id'] chash[channel_id] = row if row['parent_channel'] is not None: # Not a base channel continue # We only allow for one base channel if base_channel_id is not None and channel_id != base_channel_id: # Base channels conflict - are they coming from the same # token? if base_channel_token == token: log_error("Token has multiple base channels", token_id, base_channel_id) raise rhnFault(62, _("Token `%s' has more than one base channel assigned") % token['note']) raise rhnFault(63, _("Conflicting base channels")) base_channel_id = channel_id base_channel_token = token bc = chash.get(base_channel_id) log_debug(4, "base channel", bc) # get the base channel for this server # Note that we are hitting this codepath after newserver.__save() has been # run, which means we've already chosen a base channel # from rhnDistChannelMap sbc = rhnChannel.get_base_channel(server_id, none_ok=1) # prepare the return value ret = [] # now try to figure out which base channel we prefer if bc is None: if sbc is None: # we need at least one base channel definition log_error("Server has invalid release and " "token contains no base channels", server_id, tokens_obj.tokens) ret.append("System registered without a base channel") ret.append("Unsupported release-architecture combination " "(%s, %s)" % (server["release"], server_arch)) return ret else: # do we need to drop the one from sbc? if sbc and sbc["id"] != bc["id"]: # we need to prefer the token one # unsubscribe from old channel(s) rhnChannel.unsubscribe_all_channels(server_id) sbc = None # force true on the next test if sbc is None: # no base channel subscription at this point try: rhnChannel._subscribe_sql(server_id, bc["id"], commit=0) except rhnChannel.SubscriptionCountExceeded: ret.append("System registered without a base channel: " "subscription count exceeded for channel %s (%s)" % (bc["name"], bc["label"])) return ret ret.append("Subscribed to base channel '%s' (%s)" % ( bc["name"], bc["label"])) sbc = bc # attempt to subscribe all non-base channels associated with this # token subscribe_channel = rhnSQL.Procedure("rhn_channel.subscribe_server") # Use a set here to ensure uniqueness of the # channel family ids used in the loop below. channel_family_ids = set() for c in filter(lambda a: a["parent_channel"], chash.values()): # make sure this channel has the right parent if str(c["parent_channel"]) != str(sbc["id"]): ret.append("NOT subscribed to channel '%s' " "(not a child of '%s')" % ( c["name"], sbc["name"])) continue try: # don't run the EC yet # XXX: test return code when this one will start returning # a status subscribe_channel(server_id, c["id"], 0, None, 0) child = rhnChannel.Channel() child.load_by_id(c["id"]) child._load_channel_families() cfamid = child._channel_families[0] channel_family_ids.add(cfamid) except rhnSQL.SQLError, e: log_error("Failed channel subscription", server_id, c["id"], c["label"], c["name"]) ret.append("FAILED to subscribe to channel '%s'" % c["name"]) else: ret.append("Subscribed to channel '%s'" % c["name"])
child = rhnChannel.Channel() child.load_by_id(c["id"]) child._load_channel_families() cfamid = child._channel_families[0] channel_family_ids.add(cfamid) except rhnSQL.SQLError, e: log_error("Failed channel subscription", server_id, c["id"], c["label"], c["name"]) ret.append("FAILED to subscribe to channel '%s'" % c["name"]) else: ret.append("Subscribed to channel '%s'" % c["name"]) log_debug(5, "cf ids: %s" % str(channel_family_ids)) log_debug(5, "Server org_id: %s" % str(server['org_id'])) #rhn_channel.update_family_counts(channel_family_id_val, server_org_id_val) update_family_counts = rhnSQL.Procedure("rhn_channel.update_family_counts") for famid in channel_family_ids: # Update the channel family counts separately at the end here # instead of in the loop above. If you have an activation key # with lots of custom child channels you can end up repeatedly # updating the same channel family counts over and over and over # even thou you really only need todo it once. log_debug(5, "calling update fam counts: %s" % famid) update_family_counts(famid, server['org_id']) return ret _query_token_server_groups = rhnSQL.Statement(""" select rtg.server_group_id, sg.name from rhnRegTokenGroups rtg, rhnServerGroup sg where rtg.token_id = :token_id
def grant_entitlements(org_id, entitlement, quantity): activate_system_entitlement = rhnSQL.Procedure( "rhn_entitlements.activate_system_entitlement") activate_system_entitlement(org_id, entitlement, quantity)
def create_new_user(org_id=None, username=None, password=None, roles=None, encrypt_password=False): "Create a new user" if org_id is None: org_id = create_new_org() else: org_id = lookup_org_id(org_id) if username is None: username = "******" % time.time() if password is None: password = "******" % time.time() if encrypt_password: password = rhnUser.encrypt_password(password) if roles is None: roles = [] login = username oracle_contact_id = None prefix = "Mr." first_names = "First Name %3.f" % time.time() last_name = "Last Name %3.f" % time.time() genqual = None parent_company = None company = "ACME" title = "" phone = "" fax = "" email = "*****@*****.**" % username pin = 0 first_names_ol = " " last_name_ol = " " address1 = " " address2 = " " address3 = " " city = " " state = " " zip_code = " " country = " " alt_first_names = None alt_last_name = None contact_call = "N" contact_mail = "N" contact_email = "N" contact_fax = "N" f = rhnSQL.Function('create_new_user', rhnSQL.types.NUMBER()) ret = f(org_id, login, password, oracle_contact_id, prefix, first_names, last_name, genqual, parent_company, company, title, phone, fax, email, pin, first_names_ol, last_name_ol, address1, address2, address3, city, state, zip_code, country, alt_first_names, alt_last_name, contact_call, contact_mail, contact_email, contact_fax) u = rhnUser.search(username) if u is None: raise Exception("Couldn't create the new user - user not found") # Set roles h = rhnSQL.prepare(""" select ug.id from rhnUserGroupType ugt, rhnUserGroup ug where ug.org_id = :org_id and ug.group_type = ugt.id and ugt.label = :role """) create_ugm = rhnSQL.Procedure("rhn_user.add_to_usergroup") for role in roles: h.execute(org_id=org_id, role=role) row = h.fetchone_dict() if not row: raise InvalidRoleError(org_id, role) user_group_id = row['id'] create_ugm(u.getid(), user_group_id) return u
# # Copyright (c) 2008--2010 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # from spacewalk.server import rhnSQL rhnSQL.initDB("rhnuser/rhnuser@webdev") p = rhnSQL.Procedure("rhn_channel.subscribe_server") try: p(1003486745, 33) except: rhnSQL.rollback() raise rhnSQL.rollback()
def snapshot_server(server_id, reason): if CFG.ENABLE_SNAPSHOTS: return rhnSQL.Procedure("rhn_server.snapshot_server")(server_id, reason)
def __init__(self, hw=None, guest=None): log_debug(4, hw, guest) if not hw or "identifier" not in hw or not guest: # incomplete data log_debug(1, "incomplete data") return host = rhnSQL.Row("rhnServer", "digital_server_id") host.load(hw['identifier']) hid = host.get('id') guest.user = rhnUser.User("", "") guest.user.reload(guest.server['creator_id']) guestid = guest.getid() if not hid: # create a new host entry host = server_class.Server(guest.user, hw.get('arch')) host.server["name"] = hw.get('name') host.server["os"] = hw.get('os') host.server["release"] = hw.get('type') host.server["last_boot"] = time.time() host.default_description() host.virt_type = rhnVirtualization.VirtualizationType.FULLY host.virt_uuid = None fake_token = False if not rhnFlags.test("registration_token"): # we need to fake it rhnFlags.set("registration_token", 'fake') fake_token = True host.save(1, None) host.server["digital_server_id"] = hw['identifier'] entitle_server = rhnSQL.Procedure( "rhn_entitlements.entitle_server") entitle_server(host.getid(), 'foreign_entitled') host.save(1, None) if fake_token: rhnFlags.set("registration_token", None) hid = host.getid() host.reload(hid) log_debug(4, "New host created: ", host) else: host = server_class.Server(None) host.reload(hid) host.checkin(commit=0) log_debug(4, "Found host: ", host) host.reload_hardware() hostcpu = host.hardware_by_class(CPUDevice) if hostcpu and len(hostcpu) > 0: hostcpu = hostcpu[0].data else: hostcpu = None if not hostcpu or str(hostcpu.get('nrsocket')) != hw.get('total_ifls'): # update only if the number has changed log_debug(1, "update host cpu:", hw.get('total_ifls')) cpu = { 'class': 'CPU', 'desc': 'Processor', 'count': hw.get('total_ifls'), 'model_ver': '', 'speed': '0', 'cache': '', 'model_number': '', 'bogomips': '', 'socket_count': hw.get('total_ifls'), 'platform': hw.get('arch'), 'other': '', 'model_rev': '', 'model': hw.get('arch'), 'type': hw.get('type') } host.delete_hardware() host.add_hardware(cpu) host.save_hardware() h = rhnSQL.prepare(""" select host_system_id from rhnVirtualInstance where virtual_system_id = :guestid""") h.execute(guestid=guestid) row = h.fetchone_dict() if not row or not row['host_system_id']: self._insert_virtual_instance(hid, None, fakeuuid=False) self._insert_virtual_instance(hid, guestid, fakeuuid=True) elif row['host_system_id'] != hid: log_debug(4, "update_virtual_instance", hid, guestid) q_update = rhnSQL.prepare(""" UPDATE rhnVirtualInstance SET host_system_id = :host_id WHERE virtual_system_id = :guest_id AND host_system_id = :old_host_id """) q_update.execute(host_id=hid, guest_id=guestid, old_host_id=row['host_system_id'])
# # Copyright (c) 2008--2016 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # from spacewalk.server import rhnSQL rhnSQL.initDB('rhnuser/rhnuser@phx') counter = 0 while 1: #p = rhnSQL.Procedure('rhn_entitlements.get_server_entitlement') p = rhnSQL.Procedure('rhn_entitlements.upgrade_server') ret = p(1000102174) print((counter, ret)) counter = counter + 1 # if counter > 700: # time.sleep(.5)
def change_base_channel(self, new_rel, suse_products=None): log_debug(3, self.server["id"], new_rel) old_rel = self.server["release"] current_channels = rhnChannel.channels_for_server(self.server["id"]) # Extract the base channel off of old_base = [x for x in current_channels if not x['parent_channel']] # Quick sanity check base_channels_count = len(old_base) if base_channels_count == 1: old_base = old_base[0] elif base_channels_count == 0: old_base = None else: raise rhnException( "Server %s subscribed to multiple base channels" % (self.server["id"], )) # bz 442355 # Leave custom base channels alone, don't alter any of the channel subscriptions if not CFG.RESET_BASE_CHANNEL and old_base and rhnChannel.isCustomChannel( old_base["id"]): log_debug( 3, "Custom base channel detected, will not alter channel subscriptions" ) self.server["release"] = new_rel self.server.save() msg = """The SUSE Manager Update Agent has detected a change in the base version of the operating system running on your system, additionally you are subscribed to a custom channel as your base channel. Due to this configuration your channel subscriptions will not be altered. """ self.add_history( "Updated system release from %s to %s" % (old_rel, new_rel), msg) self.save_history_byid(self.server["id"]) return 1 s = rhnChannel.LiteServer().init_from_server(self) s.release = new_rel s.arch = self.archname if suse_products: s.suse_products = suse_products # Let get_server_channels deal with the errors and raise rhnFault target_channels = rhnChannel.guess_channels_for_server(s, none_ok=True) if target_channels: target_base = [ x for x in target_channels if not x['parent_channel'] ][0] else: target_base = None channels_to_subscribe = [] channels_to_unsubscribe = [] if old_base and target_base and old_base['id'] == target_base['id']: # Same base channel. Preserve the currently subscribed child # channels, just add the ones that are missing hash = {} for c in current_channels: hash[c['id']] = c for c in target_channels: channel_id = c['id'] if channel_id in hash: # Already subscribed to this one del hash[channel_id] continue # Have to subscribe to this one channels_to_subscribe.append(c) # We don't want to lose subscriptions to prior channels, so don't # do anything with hash.values() else: # Different base channel channels_to_unsubscribe = current_channels channels_to_subscribe = target_channels rhnSQL.transaction("change_base_channel") self.server["release"] = new_rel self.server.save() if not (channels_to_subscribe or channels_to_unsubscribe): # Nothing to do, just add the history entry self.add_history("Updated system release from %s to %s" % (old_rel, new_rel)) self.save_history_byid(self.server["id"]) return 1 # XXX: need a way to preserve existing subscriptions to # families so we can restore access to non-public ones. rhnChannel.unsubscribe_channels(self.server["id"], channels_to_unsubscribe) rhnChannel.subscribe_channels(self.server["id"], channels_to_subscribe) # now that we changed, recompute the errata cache for this one rhnSQL.Procedure("queue_server")(self.server["id"]) # Make a history note sub_channels = rhnChannel.channels_for_server(self.server["id"]) if sub_channels: channel_list = [a["name"] for a in sub_channels] msg = """The SUSE Manager Update Agent has detected a change in the base version of the operating system running on your system and has updated your channel subscriptions to reflect that. Your server has been automatically subscribed to the following channels:\n%s\n""" % (string.join(channel_list, "\n"), ) else: msg = """*** ERROR: *** While trying to subscribe this server to software channels: There are no channels serving release %s""" % new_rel self.add_history( "Updated system release from %s to %s" % (old_rel, new_rel), msg) self.save_history_byid(self.server["id"]) return 1