Exemplo n.º 1
0
    def __getXmlrpcServer(self):
        """ get an xmlrpc server object
        
            WARNING: if CFG.USE_SSL is off, we are sending info
                     in the clear. 
        """
        log_debug(3)

        # build the URL
        url = CFG.RHN_PARENT or ''
        url = string.split(parseUrl(url)[1], ':')[0]
        if CFG.USE_SSL:
            url = 'https://' + url  + '/XMLRPC'
        else:
            url = 'http://' + url  + '/XMLRPC'
        log_debug(3, 'server url: %s' % url)

        if CFG.HTTP_PROXY:
            serverObj = rpclib.Server(url,
                                      proxy=CFG.HTTP_PROXY,
                                      username=CFG.HTTP_PROXY_USERNAME,
                                      password=CFG.HTTP_PROXY_PASSWORD)
        else:
            serverObj = rpclib.Server(url)
        if CFG.USE_SSL and CFG.CA_CHAIN:
            if not os.access(CFG.CA_CHAIN, os.R_OK):
                log_error('ERROR: missing or cannot access (for ca_chain): %s' % CFG.CA_CHAIN)
                raise rhnFault(1000,
                          _("RHN Proxy error (file access issues). "
                            "Please contact your system administrator. "
                            "Please refer to RHN Proxy logs."))
            serverObj.add_trusted_cert(CFG.CA_CHAIN)
        serverObj.add_header('X-RHN-Client-Version', 2)
        return serverObj
Exemplo n.º 2
0
    def getPackagePath(self, pkgFilename):
        """ OVERLOADS getPackagePath in common/rhnRepository.
            Returns complete path to an RPM file.
        """

        log_debug(3, pkgFilename)
        mappingName = "package_mapping:%s:" % self.channelName
        pickledMapping = self._cacheObj(mappingName, self.channelVersion, self.__channelPackageMapping, ())

        mapping = cPickle.loads(pickledMapping)

        # If the file name has parameters, it's a different kind of package.
        # Determine the architecture requested so we can construct an
        # appropriate filename.
        if type(pkgFilename) == types.ListType:
            arch = pkgFilename[3]
            if isSolarisArch(arch):
                pkgFilename = "%s-%s-%s.%s.pkg" % (pkgFilename[0], pkgFilename[1], pkgFilename[2], pkgFilename[3])

        if not mapping.has_key(pkgFilename):
            log_error("Package not in mapping: %s" % pkgFilename)
            raise rhnFault(17, _("Invalid RPM package requested: %s") % pkgFilename)
        filePath = "%s/%s" % (CFG.PKG_DIR, mapping[pkgFilename])
        log_debug(4, "File path", filePath)
        if not os.access(filePath, os.R_OK):
            log_debug(4, "Package not found locally: %s" % pkgFilename)
            raise NotLocalError(filePath, pkgFilename)
        return filePath
Exemplo n.º 3
0
def token_server_groups(server_id, tokens_obj):
    assert(isinstance(tokens_obj, ActivationTokens))
    h = rhnSQL.prepare(_query_token_server_groups)
    server_groups = {}
    for token in tokens_obj.tokens:
        token_id = token['token_id']
        h.execute(token_id=token_id)
        while 1:
            row = h.fetchone_dict()
            if not row:
                break
            server_group_id = row['server_group_id']
            server_groups[server_group_id] = row

    # Now try to subscribe server to group
    ret = []
    for server_group_id, sg in server_groups.items():
        log_debug(4, "token server group", sg)
        
        try:
            join_server_group(server_id, server_group_id)
        except rhnSQL.SQLError, e:
            log_error("Failed to add server to group", server_id,
                      server_group_id, sg["name"])
            raise rhnFault(80, _("Failed to add server to group %s") % 
                sg["name"])
        else:
            ret.append("Subscribed to server group '%s'" % sg["name"])
Exemplo n.º 4
0
    def _handleServerResponse(self, status):
        """ This method can be overridden by subclasses who want to handle server
            responses in their own way.  By default, we will wrap all the headers up
            and send them back to the client with an error status.  This method
            should return apache.OK if everything went according to plan.
        """
        if (status != apache.HTTP_OK) and (status != apache.HTTP_PARTIAL_CONTENT):
            # Non 200 response; have to treat it differently
            log_debug(2, "Forwarding status %s" % status)
            # Copy the incoming headers to err_headers_out
            headers = self.responseContext.getHeaders()
            if headers is not None:
                for k in headers.keys():
                    rhnLib.setHeaderValue(self.req.err_headers_out, k,
                        self._get_header(k))
            else:
                log_error('WARNING? - no incoming headers found!')
            # And that's that
            return status

        if (status == apache.HTTP_PARTIAL_CONTENT):
            return apache.HTTP_PARTIAL_CONTENT
        else:
            # apache.HTTP_OK becomes apache.OK.
            return apache.OK
Exemplo n.º 5
0
    def guest_registered(self, host_sid, guest_sid):
        host_system_slots = server_lib.check_entitlement(host_sid)
        host_system_slots = host_system_slots.keys()

        try:
            host_system_slots.remove("virtualization_host")
        except ValueError:
            pass
        try:
            host_system_slots.remove("virtualization_host_platform")
        except ValueError:
            pass

        guest_system_slots = server_lib.check_entitlement(guest_sid)
        guest_system_slots = guest_system_slots.keys()

        for entitlement in host_system_slots:
            if entitlement not in guest_system_slots:
                try:
                    procedure.rhn_entitlements.entitle_server(guest_sid,
                            entitlement)
                except rhnSQL.SQLError, e:
                    log_error("Error adding entitlement %s: %s"
                            % (entitlement, str(e)))
                    # rhnSQL.rollback()
                    return
Exemplo n.º 6
0
    def _transformKickstartRequestForBroker(self, req):

        # Get the checksum for the requested resource from the satellite.

        (status, checksum) = self._querySatelliteForChecksum(req)
        if status != apache.OK or not checksum:
            return status

        # If we got this far, we have the checksum.  Create a new URI based on
        # the checksum.

        newURI = self._generateCacheableKickstartURI(req.uri, checksum)
        if not newURI:
            # Couldn't create a cacheable URI, log an error and revert to 
            # BZ 158236 behavior.

            log_error('Could not create cacheable ks URI from "%s"' % req.uri)
            return apache.OK

        # Now we must embed the old URI into a header in the original request
        # so that the SSL Redirect has it available if the resource has not 
        # been cached yet.  We will also embed a header that holds the new URI,
        # so that the content handler can use it later.

        log_debug(3, "Generated new kickstart URI: %s" % newURI)
        req.headers_in.add(HEADER_ACTUAL_URI, req.uri)
        req.headers_in.add(HEADER_EFFECTIVE_URI, newURI)

        return apache.OK
Exemplo n.º 7
0
    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 Management service entitlements exhausted"))
                #No idea what error may be here...
                raise rhnFault(90, e.errmsg)
Exemplo n.º 8
0
 def reload(self, server, reload_all = 0):
     log_debug(4, server, "reload_all = %d" % reload_all)
     
     if not self.server.load(int(server)):
         log_error("Could not find server record for reload", server)
         raise rhnFault(29, "Could not find server record in the database")
     self.cert = None
     # it is lame that we have to do this
     h = rhnSQL.prepare("""
     select label from rhnServerArch where id = :archid
     """)
     h.execute(archid = self.server["server_arch_id"])
     data = h.fetchone_dict()
     if not data:
         raise rhnException("Found server with invalid numeric "
                            "architecture reference",
                            self.server.data)
     self.archname = data['label']
     # we don't know this one anymore (well, we could look for, but
     # why would we do that?)
     self.user = None
     
     # XXX: Fix me
     if reload_all:
         if not self.reload_packages_byid(self.server["id"]) == 0:
             return -1
         if not self.reload_hardware_byid(self.server["id"]) == 0:
             return -1       
     return 0
Exemplo n.º 9
0
    def process(self):
        log_debug(3)
        # nice thing that req has a read() method, so it makes it look just
        # like an fd
        try:
            fd = self.input.decode(self.req)
        except IOError: # client timed out
            return apache.HTTP_BAD_REQUEST

        # Read the data from the request
        _body = fd.read()
        fd.close()

        # In this case, we talk to a client (maybe through a proxy)
        # make sure we have something to decode
        if _body is None or len(_body) == 0:
            return apache.HTTP_BAD_REQUEST

        # Decode the request; avoid logging crappy responses
        try:
            params, method = self.decode(_body)
        except rpclib.ResponseError:
            log_error("Got bad XML-RPC blob of len = %d" % len(_body))
            return apache.HTTP_BAD_REQUEST
        else:
            if params is None:
                params = ()
        # make the actual function call and return the result
        return self.call_function(method, params)
Exemplo n.º 10
0
 def auth_system(self, system_id):
     """ System authentication. We override the standard function because
         we need to check additionally if this system_id is entitled for
         proxy functionality.
     """
     log_debug(3)        
     server = rhnHandler.auth_system(self, system_id)
     # if it did not blow up, we have a valid server. Check proxy
     # entitlement.
     # XXX: this needs to be moved out of the rhnServer module,
     # possibly in here
     h = rhnSQL.prepare("""
     select 1
     from rhnProxyInfo pi
     where pi.server_id = :server_id
     """)
     h.execute(server_id = self.server_id)
     row = h.fetchone_dict()
     if not row:
         # we require entitlement for this functionality
         log_error("Server not entitled for Proxy", self.server_id)
         raise rhnFault(1002, _(
             'RHN Proxy service not enabled for server profile: "%s"')
                        % server.server["name"])
     # we're fine...
     return server
Exemplo n.º 11
0
 def _init_request_processor(self, req):
     log_debug(3)
     # Override the parent class's behaviour
     # figure out what kind of request handler we need to instantiate
     if req.method == "POST":
         self._req_processor = apachePOST(self.clientVersion, req)
         return apache.OK
     if req.method == "GET":
         try:
             self._req_processor = apacheGET(self.clientVersion, req)
         except HandlerNotFoundError, e:
             log_error("Unable to handle GET request for server %s" %
                 (e.args[0], ))
             return apache.HTTP_METHOD_NOT_ALLOWED
         # We want to give the request processor the ability to override
         # the default behaviour of calling _setSessionToken
         # XXX This is a but kludgy - misa 20040827
         if hasattr(self._req_processor, 'init_request'):
             if not self._req_processor.init_request():
                 return apache.HTTP_METHOD_NOT_ALLOWED
             # Request initialized
             return apache.OK
         token = self._setSessionToken(req.headers_in)
         if token is None:
             return apache.HTTP_METHOD_NOT_ALLOWED
         return apache.OK
Exemplo n.º 12
0
    def _connectToParent(self):
        """ Handler part 1
            Should not return an error code -- simply connects.
        """

        scheme, host, port, self.uri = self._parse_url(self.rhnParent)
        self.responseContext.setConnection(self._create_connection())

        if not self.uri:
            self.uri = '/'

        log_debug(3, 'Scheme:', scheme)
        log_debug(3, 'Host:', host)
        log_debug(3, 'Port:', port)
        log_debug(3, 'URI:', self.uri)
        log_debug(3, 'HTTP proxy:', self.httpProxy)
        log_debug(3, 'HTTP proxy username:'******'HTTP proxy password:'******'CA cert:', self.caChain)

        try:
            self.responseContext.getConnection().connect()
        except socket.error, e:
            log_error("Error opening connection", self.rhnParent, e)
            Traceback(mail=0)
            raise rhnFault(1000,
              _("RHN Proxy could not successfully connect its RHN parent. "
                "Please contact your system administrator."))
Exemplo n.º 13
0
 def guest_migrated(self, old_host_sid, new_host_sid, guest_sid, guest_uuid):
     try:
         procedure.rhn_entitlements.repoll_virt_guest_entitlements(new_host_sid)
     except rhnSQL.SQLError, e:
         log_error("Error adding entitlement: %s" %str(e))
         # rhnSQL.rollback()
         return
Exemplo n.º 14
0
 def headerParserHandler(self, req):
     log_setreq(req)
     # init configuration options with proper component
     options = req.get_options()
     # if we are initializing out of a <Location> handler don't
     # freak out
     if not options.has_key("RHNComponentType"):
         # clearly nothing to do
         return apache.OK
     initCFG(options["RHNComponentType"])
     initLOG(CFG.LOG_FILE, CFG.DEBUG)
     if req.method == 'GET':
         # This is the ping method
         return apache.OK
     self.servers = rhnImport.load("upload_server/handlers",
         interface_signature='upload_class')
     if not options.has_key('SERVER'):
         log_error("SERVER not set in the apache config files!")
         return apache.HTTP_INTERNAL_SERVER_ERROR
     server_name = options['SERVER']
     if not self.servers.has_key(server_name):
         log_error("Unable to load server %s from available servers %s" % 
             (server_name, self.servers))
         return apache.HTTP_INTERNAL_SERVER_ERROR
     server_class = self.servers[server_name]
     self.server = server_class(req)
     return self._wrapper(req, "headerParserHandler")
Exemplo n.º 15
0
 def check_connection(self):
     try:
         c = self.prepare("select 1")
         c.execute()
     except: # try to reconnect, that one MUST WORK always
         log_error("DATABASE CONNECTION TO '%s' LOST" % self.database,
                   "Exception information: %s" % sys.exc_info()[1])
         self.connect() # only allow one try
Exemplo n.º 16
0
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))
Exemplo n.º 17
0
 def notify(self, indexName="server"):
     try:
         client = xmlrpclib.ServerProxy(self.addr)
         result = client.admin.updateIndex(indexName)
     except Exception, e:
         log_error("Failed to notify search service located at %s to update %s indexes" \
                 % (self.addr, indexName), e)
         return False
Exemplo n.º 18
0
    def headerParserHandler(self, req):
        ret = basePackageUpload.BasePackageUpload.headerParserHandler(self, req)
        # Optional headers
        maps = [['Null-Org', 'null_org'], ['Packaging', 'packaging']]
        for hn, sn in maps:
            header_name = "%s-%s" % (self.header_prefix, hn)
            if req.headers_in.has_key(header_name):
                setattr(self, sn, req.headers_in[header_name])

        if ret != apache.OK:
            return ret

        if CFG.SEND_MESSAGE_TO_ALL:
            rhnSQL.closeDB()
            log_debug(1, "send_message_to_all is set")
        
            rhnFlags.set("apache-return-code", apache.HTTP_NOT_FOUND)
            try:
                outage_message = open(CFG.MESSAGE_TO_ALL).read()
            except IOError:
                log_error("Missing outage message file")
                outage_message = "Outage mode"
            raise rhnFault(20001, outage_message, explain=0)

        # Init the database connection
        rhnSQL.initDB()
        use_session = 0
        if self.field_data.has_key('Auth-Session'):
            session_token = self.field_data['Auth-Session']
            use_session = 1
        else:
            encoded_auth_token = self.field_data['Auth']
        
        if not use_session:
            auth_token = self.get_auth_token(encoded_auth_token)

            if len(auth_token) < 2:
                log_debug(3, auth_token)
                raise rhnFault(105, "Unable to autenticate")

            self.username, self.password = auth_token[:2]
        
        force = self.field_data['Force']
        force = int(force)
        log_debug(1, "Username", self.username, "Force", force)
        
        if use_session:
            self.org_id, self.force = rhnPackageUpload.authenticate_session(session_token,
                force=force, null_org=self.null_org)
        else:
            # We don't push to any channels
            self.org_id, self.force = rhnPackageUpload.authenticate(self.username,
                self.password, force=force, null_org=self.null_org)

        nevra = [self.package_name, "", self.package_version, 
            self.package_release, self.package_arch]

        return apache.OK
Exemplo n.º 19
0
    def load(self, dir, interface_signature='rpcClasses'):
        # The key we use for caching
        root_dir = "/usr/share/rhn"
        key = (dir, root_dir, interface_signature)

        if self._imports.has_key(key):
            return self._imports[key]

        dirname = "%s/%s" % (root_dir, dir)

        # We need to import things
        if root_dir is not None and root_dir not in sys.path:
            sys.path.append(root_dir)

        fromcomps = dir.split('/')
        _imports = {}
        
        # Keep track of the modules we've already tried to load, to avoid loading
        # them twice
        modules = []
        # Load each module (that is not internal - i.e. doesn't start with _)
        for module in os.listdir(dirname):
            log_debug(5, "Attempting to load module %s from %s %s" % (
                module, '.'.join(fromcomps), dirname))
            if module[0] in ('_', '.'):
                # We consider it 'internal' and we don't load it
                log_debug(6, "Ignoring module %s" % module)
                continue

            # Importing files or directories with . in them is broken, so keep
            # only the first part
            module = module.split('.', 1)[0]
            if module in modules:
                log_debug(6, "Already tried to load Module %s" % (module, ))
                continue

            # Add it to the list, so we don't load it again
            modules.append(module)


            # We use fromclause to build the full module path
            fromclause = '.'.join(fromcomps + [module])

            # Try to import the module
            try:
                m = __import__(fromclause, {}, {}, [module])
            except ImportError, e:
                log_error("Error importing %s: %s" % (module, e))
                log_debug(6, "Details: sys.path: %s" % (sys.path, ))
                continue

            if not hasattr(m, interface_signature):
                # The module does not support our API
                log_error("Module %s doesn't support our API" % (module, ))
                continue
            log_debug(5, "Module %s loaded" % (module, ))
            
            _imports[module] = getattr(m, interface_signature)
Exemplo n.º 20
0
def solve_dependencies(server_id, deps, version):
    """ The unchanged version of solve_dependencies. 
        IN: 
           server_id := id info of the server
           deps := list of filenames that are needed by the caller
           version := version of the client

        OUT:
           Dictionary with key values being the filnames in deps and the values being a list of lists of package info.
           Example :=  {'filename1'    :   [['name', 'version', 'release', 'epoch'], 
                                            ['name2', 'version2', 'release2', 'epoch2']]}    
    """
    # first, uniquify deps
    deplist = []
    for dep in deps:
        if dep not in deplist:
            deplist.append(dep)

    # SQL statement.  It is a union of 3 statements:
    #  - Lookup by package name
    #  - Lookup by provides
    #  - Lookup by file name

    statement = "%s UNION ALL %s UNION ALL %s" % (
        __packages_sql, __provides_sql, __files_sql)
    h = rhnSQL.prepare(statement)

    # prepare return value
    packages = {}
    # Iterate through the dependency problems
    for dep in deplist:
        dict = {}
        h.execute(server_id = server_id, dep = dep)
        rs = h.fetchall_dict() or []
        if not rs: # test shortcut
            log_error("Unable to solve dependency", server_id, dep)
            packages[dep] = []
            continue

        for p in rs:
            if p['epoch'] == None:
                p['epoch'] = ""
            entry = []
            map(lambda f, e = entry, p = p: e.append(p[f]),
                ['name', 'version', 'release', 'epoch'])
            if dict.has_key(entry[0]) and dict[entry[0]][1] < p['preference']:
                # Already have it with a lower preference
                continue
            # The first time we see this package.
            dict[entry[0]] = (entry, p['preference'])

        packages[dep] = _avoid_compat_packages(dict)

    # v2 clients are done
    if version > 1:
        return packages
    else:
        return _v2packages_to_v1list(packages, deplist)
Exemplo n.º 21
0
    def _send_package_stream(self, package, channel):
        log_debug(3, package, channel)
        path, dummy = self.get_package_path_by_filename(package, channel)

        log_debug(3, "Package path", path)
        if not os.path.exists(path):
            log_error("Missing package (satellite dumper): %s" % path)
            raise rhnFault(3007, "Unable to retrieve package %s" % package)
        return self._send_stream(path)
Exemplo n.º 22
0
 def __check_Int_String(name, value, package = package):
     if type(value) not in (StringType, IntType):
         log_error("Field %s (%s)=`%s' in %s does not pass type checks" % (
             name, type(value), str(value), str(package)))
         raise rhnFault(30, _("Invalid value for %s in package tuple: "
                              "%s (%s)") % (name, value, type(value)))
     value = str(value)
     if not len(value):
         log_error("Field %s has an EMPTY value in %s" % (value, package))
     return value
Exemplo n.º 23
0
    def add_hardware(self, hardware):
        log_debug(4, hardware)
        if not hardware:
            return -1
        if type(hardware) == type({}):
            hardware = UserDictCase(hardware)
        if not isinstance(hardware, UserDictCase):
            log_error("argument type is not  hash: %s" % hardware)
            raise TypeError, "This function requires a hash as an argument"
        # validation is important
        hw_class = hardware.get("class")
        if hw_class is None:
            return -1
        hw_class = string.lower(hw_class)

        class_type = None
        
        if hw_class in ["video", "audio", "audio_hd", "usb", "other", "hd", "floppy",
                        "mouse", "modem", "network", "cdrom", "scsi",
                        "unspec", "scanner", "tape", "capture", "raid",
                        "socket", "keyboard", "printer", "firewire", "ide"]:
            class_type = HardwareDevice
        elif hw_class == "cpu":
            class_type = CPUDevice
        elif hw_class == "netinfo":
            class_type = NetworkInformation
        elif hw_class == "memory":
            class_type = MemoryInformation
        elif hw_class == "dmi":
            class_type = DMIInformation
        elif hw_class == "installinfo":
            class_type = InstallInformation
        elif hw_class == "netinterfaces":
            class_type = NetIfaceInformation
        else:
            log_error("UNKNOWN CLASS TYPE `%s'" % hw_class)
            # Same trick: try-except and raise the exception so that Traceback
            # can send the e-mail
            try:
                raise KeyError, "Unknwon class type `%s' for hardware '%s'" % (
                    hw_class, hardware)
            except:
                Traceback(mail=1)
                return

        # create the new device
        new_dev = class_type(hardware)
        
        if self.__hardware.has_key(class_type):
            _l = self.__hardware[class_type]
        else:
            _l = self.__hardware[class_type] = []
        _l.append(new_dev)
        self.__changed = 1
        return 0
Exemplo n.º 24
0
def search(server_id, username = None):
    log_debug(3, server_id, username)
    s = Server(None)
    if not s.reload(server_id) == 0:
        log_error("Reloading server id %d failed" % server_id)
        # we can't say that the server is not really found
        raise rhnFault(20)
    # now that it is reloaded, fix up the s.user field
    if username:
        s.user = rhnUser.search(username)
    return s
Exemplo n.º 25
0
def check_package_file(rel_path, logpkg, raisepkg):
    if rel_path is None:
        log_error("Package path null for package id", logpkg)
        raise rhnFault(17, _("Invalid RPM package %s requested") % raisepkg)
    filePath = "%s/%s" % (CFG.MOUNT_POINT, rel_path)
    if not os.access(filePath, os.R_OK):
        # Package not found on the filesystem
        log_error("Package not found", filePath)
        raise rhnFault(17, _("Package not found"))

    return filePath
Exemplo n.º 26
0
def _process_diffs(server_id, action_id, diffs):
    _disable_old_diffs(server_id)
    for file_path, diff in diffs.items():
        action_config_revision_id = _lookup_action_revision_id(server_id, 
            action_id, file_path)
        if action_config_revision_id is None:
            log_error(
                "Missing config file for action id %s, server id %s, path %s"
                % (server_id, action_id, file_path))
            continue
        _add_result(action_config_revision_id, diff)
Exemplo n.º 27
0
 def certificate(self):
     """ convert to XML """
     dump = self.attrs
     dump["checksum"] = self.__checksum
     dump["fields"] = self.__fields
     try:
         x = xmlrpclib.dumps((dump,))
     except TypeError, e:
         log_error("Could not marshall certificate for %s" % dump)
         e.args = e.args + (dump,) # Carry on the information for the exception reporting
         raise
Exemplo n.º 28
0
 def __validate_checksum(self, secret):
     """ compute the current checksum against a secret and check it against
         the current checksum
     """
     csum = self.compute_checksum(secret)
     if not csum == self.__checksum:
         # fail, current checksum does not match
         log_error("Checksum check failed: %s != %s" % (csum, self.__checksum),
                   "fields = %s" % str(self.__fields), "attrs = %s" % str(self.attrs))
         return 0
     return 1
Exemplo n.º 29
0
def _mark_dep_failures(server_id, action_id, data):
    if not data:
        log_debug(4, "Nothing to do")
        return
    failed_deps = data.get('failed_deps')
    if not failed_deps:
        log_debug(4, "No failed deps")
        return

    if not isinstance(failed_deps, ListType):
        # Not the right format
        log_error("action_extra_data.packages.remove: server %s, action %s: "
            "wrong type %s" % (server_id, action_id, type(failed_deps)))
        return

    inserts = {}
    for f in ( 'server_id', 'action_id', 
            'name', 'version', 'release', 'epoch',
            'needs_name', 'needs_version', 'ignore_null',
            'flags', 'suggested', 'sense'):
        inserts[f] = []
    

    for failed_dep in failed_deps:
        try:
            pkg, needs_pkg, flags, suggested, sense = _check_dep(server_id,
                action_id, failed_dep)
        except InvalidDep:
            continue

        inserts['server_id'].append(server_id)
        inserts['action_id'].append(action_id)
        inserts['name'] .append(pkg[0])
        inserts['version'].append(pkg[1])
        inserts['release'].append(pkg[2])
        inserts['epoch'].append(None)
 
        inserts['needs_name'].append(needs_pkg[0])
        inserts['needs_version'].append(needs_pkg[1])

        inserts['flags'].append(flags)
        inserts['suggested'].append(suggested)
        inserts['ignore_null'].append(1)
        inserts['sense'].append(sense)
        
    h = rhnSQL.prepare(_query_delete_dep_failures)
    rowcount = h.execute(server_id=server_id, action_id=action_id)
    log_debug(5, "Removed old rows", rowcount)

    h = rhnSQL.prepare(_query_insert_dep_failures)

    rowcount = h.execute_bulk(inserts)
    log_debug(5, "Inserted rows", rowcount)
Exemplo n.º 30
0
    def _get_method_params(self):
        # Returns the method name and params for this call

        # Split the request into parts
        array = string.split(self.req.path_info, '/')
        if len(array) < 4:
            log_error("Invalid URI for GET request", self.req.path_info)
            raise rhnFault(21, _("Invalid URI %s" % self.req.path_info))

        self.channel, method = (array[2], array[3])
        params = tuple(array[4:])
        return method, params