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 management_create_channel(self, dict): log_debug(1) self._get_and_validate_session(dict) config_channel = dict.get('config_channel') # XXX Validate the namespace config_channel_name = dict.get('config_channel_name') or config_channel config_channel_description = dict.get('description') or config_channel row = rhnSQL.fetchone_dict(self._query_lookup_config_channel, org_id=self.org_id, config_channel=config_channel) if row: raise rhnFault(4010, "Configuration channel %s already exists" % config_channel, explain=0) insert_call = rhnSQL.Function('rhn_config.insert_channel', rhnSQL.types.NUMBER()) config_channel_id = insert_call(self.org_id, 'normal', config_channel_name, config_channel, config_channel_description) rhnSQL.commit() return {}
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 _insert_revision(self, file): insert_call = rhnSQL.Function("rhn_config.insert_revision", rhnSQL.types.NUMBER()) file['config_revision_id'] = insert_call( file['revision'], file['config_file_id'], file.get('config_content_id', None), file['config_info_id'], file['config_file_type_id'])
def _push_config_file(self, file): config_info_query = self._query_lookup_non_symlink_config_info if self._is_link(file) and file.get("symlink"): config_info_query = self._query_lookup_symlink_config_info # Look up the config info first h = rhnSQL.prepare(config_info_query) h.execute(**file) row = h.fetchone_dict() if not row: # Hmm raise rhnException("This query should always return a row") config_info_id = row['id'] file['config_info_id'] = config_info_id # Look up the config file itself h = rhnSQL.prepare(self._query_lookup_config_file) h.execute(**file) row = h.fetchone_dict() if row: # Yay we already have this file # Later down the road, we're going to update modified for this # table file['config_file_id'] = row['id'] return # Have to insert this config file, gotta use the api to keep quotas up2date... insert_call = rhnSQL.Function("rhn_config.insert_file", rhnSQL.types.NUMBER()) file['config_file_id'] = insert_call(file['config_channel_id'], file['path'])
def join_server_group(server_id, server_group_id): """ Adds a server to a server group """ # avoid useless reparses caused by different arg types server_id = str(server_id) server_group_id = str(server_group_id) insert_call = rhnSQL.Function("rhn_server.insert_into_servergroup_maybe", rhnSQL.types.NUMBER()) ret = insert_call(server_id, server_group_id) # return the number of rows inserted - feel free to ignore return ret
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 _create_server_import_channel(self, server_id): name = "server_import Config Channel for system %d" % server_id description = "XXX" # server_import and local_override channels that # get created need to conform to this label formula: # {rhnConfigChannelType.label}-{sid} label = "server_import-%d" % server_id insert_call = rhnSQL.Function('rhn_config.insert_channel', rhnSQL.types.NUMBER()) config_channel_id = insert_call(self.org_id, 'server_import', name, label, description) h = rhnSQL.prepare(self._query_create_server_import_channel) h.execute(server_id=server_id, config_channel_id=config_channel_id, position=None) return config_channel_id
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
def entitlement_grants_service(entitlement, service): egs = rhnSQL.Function("rhn_entitlements.entitlement_grants_service", rhnSQL.types.STRING()) return egs(entitlement, service)
def test_function_1(self): "Tests function calls" p = rhnSQL.Function("logging.get_log_id", rhnSQL.types.NUMBER()) ret = p() self.failUnless(isinstance(ret, types.FloatType))
def _create_or_update_crash_file(self, server_id, crash_id, filename, path, filesize): insert_call = rhnSQL.Function("insert_crash_file", rhnSQL.types.NUMBER()) return insert_call(crash_id, filename, path, filesize)