def testConfigRuntimeStore(self):
        "Verify that values Config['value'] are set for runtime only and not saved"
        cfg = config.initUp2dateConfig(test_up2date)
        cfg['blippy12345'] = "wantafreehat?"
        cfg.save()
        # cfg is a fairly persistent singleton, blow it awy to get a new referece
        del config.cfg

        cfg2 = config.initUp2dateConfig(test_up2date)
        # if this returns a value, it means we saved the config file...
        assert cfg2['blippy12345'] == None

    def __init__(self):
        UserDict.UserDict.__init__(self)
        self.missingCaps = {}
        #self.populate()
#        self.validate()
        self.neededCaps = neededCaps
        self.cfg = config.initUp2dateConfig()

    def _read_rhn_proxy_settings(self):
        if not rhn_config:
            return
        # Read and store rhn-setup's proxy settings, as they have been set
        # on the prior screen (which is owned by rhn-setup)
        up2date_cfg = rhn_config.initUp2dateConfig()
        cfg = rhsm.config.initConfig()

        if up2date_cfg["enableProxy"]:
            proxy = up2date_cfg["httpProxy"]
            if proxy:
                # Remove any URI scheme provided
                proxy = remove_scheme(proxy)
                try:
                    host, port = proxy.split(":")
                    cfg.set("server", "proxy_hostname", host)
                    cfg.set("server", "proxy_port", port)
                except ValueError:
                    cfg.set("server", "proxy_hostname", proxy)
                    cfg.set("server", "proxy_port", rhsm.config.DEFAULT_PROXY_PORT)
            if up2date_cfg["enableProxyAuth"]:
                cfg.set("server", "proxy_user", up2date_cfg["proxyUser"])
                cfg.set("server", "proxy_password", up2date_cfg["proxyPassword"])
        else:
            cfg.set("server", "proxy_hostname", "")
            cfg.set("server", "proxy_port", "")
            cfg.set("server", "proxy_user", "")
            cfg.set("server", "proxy_password", "")

        cfg.save()
        self.backend.cp_provider.set_connection_info()

    def setUp(self):
        self.__setupData()
        import testutils

        testutils.setupConfig("8.0-workstation-i386-1")
        self.cfg = config.initUp2dateConfig(test_up2date)
        self.origversion = self.cfg["versionOverride"]

 def get_up2date_config(self):
     if self._up2date_config is None:
         self._up2date_config = initUp2dateConfig()
     if not hasattr(self._up2date_config, '__getitem__'):
         # Old interface
         self._up2date_config = OldUp2dateConfig(self._up2date_config)
     return self._up2date_config

    def _read_rhn_proxy_settings(self):
        # Read and store rhn-setup's proxy settings, as they have been set
        # on the prior screen (which is owned by rhn-setup)
        up2date_cfg = config.initUp2dateConfig()
        cfg = rhsm.config.initConfig()

        if up2date_cfg['enableProxy']:
            proxy = up2date_cfg['httpProxy']
            if proxy:
                # Remove any URI scheme provided
                proxy = remove_scheme(proxy)
                try:
                    host, port = proxy.split(':')
                    cfg.set('server', 'proxy_hostname', host)
                    cfg.set('server', 'proxy_port', port)
                except ValueError:
                    cfg.set('server', 'proxy_hostname', proxy)
                    cfg.set('server', 'proxy_port',
                            rhsm.config.DEFAULT_PROXY_PORT)
            if up2date_cfg['enableProxyAuth']:
                cfg.set('server', 'proxy_user', up2date_cfg['proxyUser'])
                cfg.set('server', 'proxy_password',
                        up2date_cfg['proxyPassword'])
        else:
            cfg.set('server', 'proxy_hostname', '')
            cfg.set('server', 'proxy_port', '')
            cfg.set('server', 'proxy_user', '')
            cfg.set('server', 'proxy_password', '')

        cfg.save()
        self.backend.cp_provider.set_connection_info()

    def apply(self, interface, testing=False):
        if testing:
            return RESULT_SUCCESS

        up2DateConfig = config.initUp2dateConfig()
        up2DateConfig.save()
        return RESULT_SUCCESS

def getChannels(force=None, label_whitelist=None, timeout=None):
    """ return rhnChannelList containing list of channel we are subscribed to """
    cfg = config.initUp2dateConfig()
    global selected_channels
    if not selected_channels and not force:
        selected_channels = rhnChannelList()
        s = rhnserver.RhnServer(timeout=timeout)

        if not up2dateAuth.getSystemId():
            raise up2dateErrors.NoSystemIdError(_("Unable to Locate SystemId"))

        up2dateChannels = s.up2date.listChannels(up2dateAuth.getSystemId())

        for chan in up2dateChannels:
            if label_whitelist and not chan['label'] in label_whitelist:
                continue

            channel = rhnChannel(type = 'up2date', url = config.getServerlURL())
            for key in chan.keys():
                if key == "last_modified":
                    channel['version'] = chan['last_modified']
                else:
                    channel[key] = chan[key]
            selected_channels.addChannel(channel)

    if len(selected_channels.list) == 0:
        raise up2dateErrors.NoChannelsError(_("This system may not be updated until it is associated with a channel."))

    return selected_channels

    def __init__(self):
        self.cfg = config.initUp2dateConfig()
        self.xmlrpcServerUrl = self.cfg["serverURL"]
        refreshServerList = 0
	if self.cfg["useNoSSLForPackages"]:
            self.httpServerUrls = self.cfg["noSSLServerURL"]
            refreshServerList = 1
	else:
	    self.httpServerUrls = self.cfg["serverURL"]

        if type(self.httpServerUrls) == type(""):
            self.httpServerUrls = [self.httpServerUrls]

        self.serverList = rpcServer.initServerList(self.httpServerUrls)
        # if the list of servers for packages and stuff is different,
        # refresh
        if refreshServerList:
            self.serverList.resetServerList(self.httpServerUrls)

        self.proxyUrl = None
        self.proxyUser = None
        self.proxyPassword = None
        
        if self.cfg["enableProxy"] and up2dateUtils.getProxySetting():
            self.proxyUrl = up2dateUtils.getProxySetting()
            if self.cfg["enableProxyAuth"]:
                if self.cfg["proxyUser"] and self.cfg["proxyPassword"]:
                    self.proxyPassword = self.cfg["proxyPassword"]
                    self.proxyUser = self.cfg["proxyUser"]

 def _rpc_call(self, function_name, params):
     get_server_obj = self.login()
     # Try a couple of times
     cfg = config.initUp2dateConfig()
     for i in range(cfg["networkRetries"]):
         try:
             ret = apply(getattr(get_server_obj, function_name), params)
         except rpclib.ProtocolError, e:
             # We have two codes to check: the HTTP error code, and the
             # combination (failtCode, faultString) encoded in the headers
             # of the request.
             http_error_code = e.errcode
             fault_code, fault_string = rpclib.reportError(e.headers)
             if http_error_code == 401 and fault_code == -34:
                 # Login token expired
                 get_server_obj = self.login(force=1)
                 continue
             if http_error_code == 404 and fault_code == -17:
                 # File not found
                 self.extinctErrorYN = 1
                 return None
             log(-1, "ERROR: http error code :%s; fault code: %s; %s" % (http_error_code, fault_code, fault_string))
             # XXX
             raise
         else:
             return ret

    def __init__(self, options):
        self.rhncfg = initUp2dateConfig()
        self.rhsmcfg = config.Config(initConfig())

        # Sometimes we need to send up the entire contents of the system id file
        # which is referred to in Satellite 5 nomenclature as a "certificate"
        # although it is not an X509 certificate.
        try:
            self.system_id_contents = open(self.rhncfg["systemIdPath"], 'r').read()
        except IOError:
            system_exit(os.EX_IOERR, _("Could not read legacy system id at %s") % self.rhncfg["systemIdPath"])

        self.system_id = self.get_system_id(self.system_id_contents)

        self.proxy_host = None
        self.proxy_port = None
        self.proxy_user = None
        self.proxy_pass = None

        self.cp = None
        self.db = ProductDatabase()

        self.consumer_id = None

        self.options = options
        self.is_hosted = is_hosted()

 def _rpc_call(self, function_name, params):
     get_server_obj = self.login()
     # Try a couple of times
     fault_count = 0
     expired_token = 0
     cfg = config.initUp2dateConfig()
     while fault_count - expired_token < cfg['networkRetries']:
         try:
             ret = getattr(get_server_obj, function_name)(*params)
         except rpclib.xmlrpclib.ProtocolError:
             e = sys.exc_info()[1]
             # We have two codes to check: the HTTP error code, and the
             # combination (failtCode, faultString) encoded in the headers
             # of the request.
             http_error_code = e.errcode
             fault_code, fault_string = rpclib.reportError(e.headers)
             fault_count += 1
             if http_error_code == 401 and fault_code == -34:
                 # Login token expired
                 get_server_obj = self.login(force=1)
                 # allow exactly one respin for expired token
                 expired_token = 1
                 continue
             if http_error_code == 404 and fault_code == -17:
                 # File not found
                 self.extinctErrorYN = 1
                 return None
             log(-1, 'ERROR: http error code :%s; fault code: %s; %s' %
                 (http_error_code, fault_code, fault_string))
             # XXX
             raise
         else:
             return ret
     raise Exception("Failed after multiple attempts!")

def get_config():
    """send back a cross platform structure containing cfg info"""
    global _config
    if not _config:
        _config = config.initUp2dateConfig()
        
    return _config

    def _openSocketStream(self, method, params):
        """Wraps the gzipstream.GzipStream instantiation in a test block so we
           can open normally if stream is not gzipped."""

        stream = None
        retryYN = 0
        wait = 0.33
        lastErrorMsg = ''
        cfg = config.initUp2dateConfig()
        for i in range(cfg['networkRetries']):
            server = self.getServer(retryYN)
            if server is None:
                log2(-1, 2, 'ERROR: server unable to initialize, attempt %s' % i, stream=sys.stderr)
                retryYN = 1
                time.sleep(wait)
                continue
            func = getattr(server, method)
            try:
                stream = func(*params)
                return stream
            except rpclib.xmlrpclib.ProtocolError, e:
                p = tuple(['<the systemid>'] + list(params[1:]))
                lastErrorMsg = 'ERROR: server.%s%s: %s' % (method, p, e)
                log2(-1, 2, lastErrorMsg, stream=sys.stderr)
                retryYN = 1
                time.sleep(wait)
                # do not reraise this exception!
            except (KeyboardInterrupt, SystemExit):
                raise

 def __init__(self, proxyHost=None,
              loginInfo=None, cacheObject=None,
              register=None):
     self.cfg = config.initUp2dateConfig()
     rpmSource.PackageSource.__init__(self, cacheObject = cacheObject)
     self._loginInfo=loginInfo
     self.headerCache = cacheObject
     self.pkglists = {}

    def apply(self, interface, testing=False):
        if testing:
            return RESULT_SUCCESS

        up2DateConfig = config.initUp2dateConfig()
        up2DateConfig.save()
        interface.moveToPage(pageNum = len(interface.moduleList))
        return RESULT_JUMP

    def rhn_username(self):
        try:
            cfg = config.initUp2dateConfig()

            return rpclib.xmlrpclib.loads(up2dateAuth.getSystemId())[0][0]['username']
        except:
            # ignore any exception and return an empty username
            return ""

def getVersion():
    '''
    Returns the version of redhat-release rpm
    '''
    cfg = config.initUp2dateConfig()
    if cfg["versionOverride"]:
        return str(cfg["versionOverride"])
    os_release, version, release = _getOSVersionAndRelease()
    return version

    def setUp(self):

        self.defaultServer = testConfig.brokenServer500error
        import testutils
        testutils.setupConfig("fc1-at-pepsi")

        # cant import config until we put the right stuff in place
        self.cfg = config.initUp2dateConfig(test_up2date)
        self.cfg['serverURL'] = self.defaultServer

def _init():
    cfg = config.initUp2dateConfig()
    cfg_dict = dict(cfg.items())
    server_url = config.getServerlURL()
    cfg_dict['proto'], cfg_dict['server_name'] = utils.parse_url(server_url[0], scheme="https")[:2]
    if len(server_url) > 1:
        cfg_dict['server_list'] = server_url
    local_config.init('rhncfg-client', defaults=cfg_dict)
    set_debug_level(int(local_config.get('debug_level') or 0))
    set_logfile("/var/log/rhncfg-actions")