def __init__(self, name=None):
     self._name = name or config.get(
         'containers', 'network_name')
     self._gw = config.get('containers', 'network_gateway')
     self._nic = config.get('containers', 'network_interface')
     self._subnet = config.get('containers', 'network_subnet')
     self._mask = config.getint('containers', 'network_mask')
     self._existing = False

 def _loadBindingJsonRpc(self):
     from BindingJsonRpc import BindingJsonRpc
     from Bridge import DynamicBridge
     ip = config.get('addresses', 'management_ip')
     port = config.getint('addresses', 'json_port')
     truststore_path = None
     if config.getboolean('vars', 'ssl'):
         truststore_path = config.get('vars', 'trust_store_path')
     conf = [('tcp', {"ip": ip, "port": port})]
     self.bindings['json'] = BindingJsonRpc(DynamicBridge(), conf,
                                            truststore_path)

 def _createSSLContext(self):
     sslctx = None
     if config.getboolean('vars', 'ssl'):
         truststore_path = config.get('vars', 'trust_store_path')
         key_file = os.path.join(truststore_path, 'keys', 'vdsmkey.pem')
         cert_file = os.path.join(truststore_path, 'certs', 'vdsmcert.pem')
         ca_cert = os.path.join(truststore_path, 'certs', 'cacert.pem')
         protocol = config.get('vars', 'ssl_protocol')
         sslctx = SSLContext(cert_file, key_file, ca_cert=ca_cert,
                             protocol=protocol)
     return sslctx

 def _prepareBindings(self):
     self.bindings = {}
     xmlrpc_params = {
         'ip': config.get('addresses', 'management_ip'),
         'port': config.get('addresses', 'management_port'),
         'ssl': config.getboolean('vars', 'ssl'),
         'vds_responsiveness_timeout':
             config.getint('vars', 'vds_responsiveness_timeout'),
         'trust_store_path': config.get('vars', 'trust_store_path'),
         'default_bridge': config.get("vars", "default_bridge"), }
     self.bindings['xmlrpc'] = BindingXMLRPC(self, self.log, xmlrpc_params)

 def start(self):
     if _JSONRPC_ENABLED:
         requestQueues = config.get('addresses', 'request_queues')
         requestQueue = requestQueues.split(",")[0]
         self.vdscli = jsonrpcvdscli.connect(requestQueue, xml_compat=False)
     else:
         self.vdscli = vdscli.connect()
     self.netinfo = self._get_netinfo()
     if config.get('vars', 'net_persistence') == 'unified':
         self.config = RunningConfig()
     else:
         self.config = None

 def _loadBindingXMLRPC(self):
     from BindingXMLRPC import BindingXMLRPC
     ip = config.get('addresses', 'management_ip')
     xmlrpc_port = config.get('addresses', 'management_port')
     use_ssl = config.getboolean('vars', 'ssl')
     resp_timeout = config.getint('vars', 'vds_responsiveness_timeout')
     truststore_path = config.get('vars', 'trust_store_path')
     default_bridge = config.get("vars", "default_bridge")
     self.bindings['xmlrpc'] = BindingXMLRPC(self, self.log, ip,
                                             xmlrpc_port, use_ssl,
                                             resp_timeout, truststore_path,
                                             default_bridge)

def start():
    """ Starts application wide CPU profiling """
    global _profiler
    if is_enabled():
        with _lock:
            if _profiler:
                raise UsageError('CPU profiler is already running')
            _profiler = Profiler(
                config.get('devel', 'cpu_profile_filename'),
                format=config.get('devel', 'cpu_profile_format'),
                clock=config.get('devel', 'cpu_profile_clock'),
                builtins=config.getboolean('devel', 'cpu_profile_builtins'),
                threads=True)
            _profiler.start()

 def __init__(self, net_info, inRollback=False):
     is_unipersistence = config.get('vars', 'net_persistence') == 'unified'
     super(Ifcfg, self).__init__(ConfigWriter(),
                                 net_info,
                                 is_unipersistence,
                                 inRollback)
     self.runningConfig = RunningConfig()

 def start(self):
     self.vdscli = vdscli.connect()
     self.netinfo = self._get_netinfo()
     if config.get("vars", "net_persistence") == "unified":
         self.config = RunningConfig()
     else:
         self.config = None

 def _send_notification(self, message):
     try:
         self.bindings['jsonrpc'].reactor.server.send(
             message, config.get('addresses', 'event_queue'))
     except KeyError:
         self.log.warning("Attempt to send an event when jsonrpc binding"
                          " not available")

    def _setupVdsConnection(self):
        if self.hibernating:
            return

        hostPort = vdscli.cannonizeHostPort(
            self._dst,
            config.getint('addresses', 'management_port'))
        self.remoteHost, port = hostPort.rsplit(':', 1)

        try:
            client = self._createClient(port)
            requestQueues = config.get('addresses', 'request_queues')
            requestQueue = requestQueues.split(",")[0]
            self._destServer = jsonrpcvdscli.connect(requestQueue, client)
            self.log.debug('Initiating connection with destination')
            self._destServer.ping()

        except (JsonRpcBindingsError, JsonRpcNoResponseError):
            if config.getboolean('vars', 'ssl'):
                self._destServer = vdscli.connect(
                    hostPort,
                    useSSL=True,
                    TransportClass=kaxmlrpclib.TcpkeepSafeTransport)
            else:
                self._destServer = kaxmlrpclib.Server('http://' + hostPort)

        self.log.debug('Destination server is: ' + hostPort)

 def __init__(self, vm, dst='', dstparams='',
              mode=MODE_REMOTE, method=METHOD_ONLINE,
              tunneled=False, dstqemu='', abortOnError=False,
              compressed=False, autoConverge=False, **kwargs):
     self.log = vm.log
     self._vm = vm
     self._dst = dst
     self._mode = mode
     if method != METHOD_ONLINE:
         self.log.warning(
             'migration method %s is deprecated, forced to "online"',
             method)
     self._dstparams = dstparams
     self._machineParams = {}
     self._tunneled = utils.tobool(tunneled)
     self._abortOnError = utils.tobool(abortOnError)
     self._dstqemu = dstqemu
     self._downtime = kwargs.get('downtime') or \
         config.get('vars', 'migration_downtime')
     self._autoConverge = autoConverge
     self._compressed = compressed
     self.status = {
         'status': {
             'code': 0,
             'message': 'Migration in progress'}}
     self._progress = 0
     threading.Thread.__init__(self)
     self._preparingMigrationEvt = True
     self._migrationCanceledEvt = False
     self._monitorThread = None

    def _setupVdsConnection(self):
        if self.hibernating:
            return

        # FIXME: The port will depend on the binding being used.
        # This assumes xmlrpc
        hostPort = vdscli.cannonizeHostPort(
            self._dst,
            config.get('addresses', 'management_port'))
        self.remoteHost, _ = hostPort.rsplit(':', 1)

        if config.getboolean('vars', 'ssl'):
            self.destServer = vdscli.connect(
                hostPort,
                useSSL=True,
                TransportClass=kaxmlrpclib.TcpkeepSafeTransport)
        else:
            self.destServer = kaxmlrpclib.Server('http://' + hostPort)
        self.log.debug('Destination server is: ' + hostPort)
        try:
            self.log.debug('Initiating connection with destination')
            status = self.destServer.getVmStats(self._vm.id)
            if not status['status']['code']:
                self.log.error("Machine already exists on the destination")
                self.status = errCode['exist']
        except Exception:
            self.log.error("Error initiating connection", exc_info=True)
            self.status = errCode['noConPeer']

 def __init__(self, configApplier):
     self.configApplier = configApplier
     self._libvirtAdded = set()
     self.unifiedPersistence = \
         config.get('vars', 'persistence') == 'unified'
     if self.unifiedPersistence:
         self.runningConfig = RunningConfig()

    def wrapped(*args, **kwargs):
        if not config.get('vars', 'net_persistence') == 'unified':
            return func(*args, **kwargs)

        # Get args and kwargs in a single dictionary
        attrs = kwargs.copy()
        attrs.update(dict(zip(spec.args, args)))

        isolatedCommand = attrs.get('configurator') is None
        # Detect if we are running an isolated command, i.e., a command that is
        # not called as part of composed API operation like setupNetworks or
        # editNetwork, but rather as its own API verb. This is necessary in
        # order to maintain behavior of the addNetwork and delNetwork API verbs
        if isolatedCommand:
            attrs['configurator'] = configurator = ConfiguratorClass()
            configurator.begin()
        else:
            configurator = attrs['configurator']

        ret = func(**attrs)

        nics = attrs.pop('nics', None)
        # Bond config handled in configurator so that operations only touching
        # bonds don't need special casing and the logic of this remains simpler
        if not attrs.get('bonding'):
            if nics:
                attrs['nic'], = nics

        if func.__name__ == 'delNetwork':
            configurator.runningConfig.removeNetwork(attrs.pop('network'))
        else:
            configurator.runningConfig.setNetwork(attrs.pop('network'), attrs)
        if isolatedCommand:  # Commit the no-rollback transaction.
            configurator.commit()
        return ret

    def __init__(self, vm, dst='', dstparams='',
                 mode=MODE_REMOTE, method=METHOD_ONLINE,
                 tunneled=False, dstqemu='', abortOnError=False,
                 consoleAddress=None, compressed=False,
                 autoConverge=False, **kwargs):
        self.log = vm.log
        self._vm = vm
        self._dst = dst
        self._mode = mode
        if method != METHOD_ONLINE:
            self.log.warning(
                'migration method %s is deprecated, forced to "online"',
                method)
        self._dstparams = dstparams
        self._machineParams = {}
        self._tunneled = utils.tobool(tunneled)
        self._abortOnError = utils.tobool(abortOnError)
        self._consoleAddress = consoleAddress
        self._dstqemu = dstqemu
        self._downtime = kwargs.get('downtime') or \
            config.get('vars', 'migration_downtime')
        self._maxBandwidth = int(
            kwargs.get('maxBandwidth') or
            config.getint('vars', 'migration_max_bandwidth')
        )
        self._autoConverge = autoConverge
        self._compressed = compressed
        self.status = {
            'status': {
                'code': 0,
                'message': 'Migration in progress'}}
        self._progress = 0
        threading.Thread.__init__(self)
        self._preparingMigrationEvt = True
        self._migrationCanceledEvt = False
        self._monitorThread = None
        self._destServer = None

        progress_timeout = config.getint('vars', 'migration_progress_timeout')

        self._convergence_schedule = {
            'init': [],
            'stalling': [
                {
                    'limit': progress_timeout,
                    'action': {
                        'name': CONVERGENCE_SCHEDULE_SET_ABORT,
                        'params': []
                    }
                }
            ]
        }

        self._use_convergence_schedule = False
        if 'convergenceSchedule' in kwargs:
            self._convergence_schedule = kwargs.get('convergenceSchedule')
            self._use_convergence_schedule = True

        self.log.debug('convergence schedule set to: %s',
                       str(self._convergence_schedule))

 def __init__(self, inRollback=False):
     self.unifiedPersistence = \
         config.get('vars', 'net_persistence') == 'unified'
     super(Ifcfg, self).__init__(ConfigWriter(self.unifiedPersistence),
                                 inRollback)
     if self.unifiedPersistence:
         self.runningConfig = RunningConfig()

 def _backup(self, filename):
     self._atomicBackup(filename)
     if config.get('vars', 'net_persistence') != 'unified':
         self._persistentBackup(filename)
     elif not self._ownedIfcfg(filename):
         # Backup non-VDSM network devices (BZ#1188251)
         self._persistentBackup(filename)

 def __init__(self, hostID, poolID, monitorInterval=2):
     self._hostID = str(hostID)
     self._poolID = str(poolID)
     self._monitorInterval = monitorInterval
     self._spmStorageDir = config.get('irs', 'repository')
     self._queue = Queue.Queue(-1)
     #  *** IMPORTANT NOTE: The SPM's inbox is the HSMs' outbox and vice
     #                      versa *** #
     self._inbox = os.path.join(self._spmStorageDir, self._poolID,
                                "mastersd", sd.DOMAIN_META_DATA, "outbox")
     if not os.path.exists(self._inbox):
         self.log.error("HSM_Mailbox create failed - inbox %s does not "
                        "exist" % repr(self._inbox))
         raise RuntimeError("HSM_Mailbox create failed - inbox %s does not "
                            "exist" % repr(self._inbox))
     self._outbox = os.path.join(self._spmStorageDir, self._poolID,
                                 "mastersd", sd.DOMAIN_META_DATA, "inbox")
     if not os.path.exists(self._outbox):
         self.log.error("HSM_Mailbox create failed - outbox %s does not "
                        "exist" % repr(self._outbox))
         raise RuntimeError("HSM_Mailbox create failed - outbox %s does "
                            "not exist" % repr(self._outbox))
     self._mailman = HSM_MailMonitor(self._inbox, self._outbox, hostID,
                                     self._queue, monitorInterval)
     self.log.debug('HSM_MailboxMonitor created for pool %s' % self._poolID)

 def _loadBindingJsonRpc(self):
     from BindingJsonRpc import BindingJsonRpc
     from Bridge import DynamicBridge
     ip = config.get('addresses', 'management_ip')
     port = config.getint('addresses', 'json_port')
     conf = [('tcp', {"ip": ip, "port": port})]
     self.bindings['json'] = BindingJsonRpc(DynamicBridge(), conf)