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

    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

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"])

    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

    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

    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

    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)

 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

    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)

 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

 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

    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:', self.httpProxyUsername)
        log_debug(3, 'HTTP proxy password:', "<password>")
        log_debug(3, '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."))

 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

 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")

 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

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 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

    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

    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)

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)