def monitor_thread_pool(self, thread_info=None, condition=None):
     global launchd_threads_info
     if thread_info is None:
         thread_info = launchd_threads_info
     if condition is None:
         condition = self._condition
     while True:
         condition.acquire()
         for each_thread in iter(thread_info.keys()):
             if 'result' in thread_info[each_thread].keys():
                 LOG.debug(_("Worker Thread # for VNF configuration Ending"), thread_info[each_thread])
                 LOG.debug(_("%s"), thread_info)
                 #print "Result:  "+str(thread_info[each_thread]['result'])+'\n'
                 ## TODO(padmaja, anirudh): The return value to be standardized, 
                 #                          to enable support crosss language drivers.
                 status = 'ERROR' if 'Error' in str(thread_info[each_thread]['result']) else 'COMPLETE' 
                 self.vplugin_rpc.send_ack(self.ctx,
                                            thread_info[each_thread]['vnfd'],
                                            thread_info[each_thread]['vdu'],
                                            thread_info[each_thread]['vm_name'],
                                            status,
                                            self.nsd_id)
                 if thread_info[each_thread]['thread_obj'].isAlive():
                     thread_info[each_thread]['thread_obj'].kill()
                 del(thread_info[each_thread])
         condition.wait()
         condition.release()

        def _inner():
            if initial_delay:
                greenthread.sleep(initial_delay)

            try:
                while self._running:
                    start = timeutils.utcnow()
                    self.f(*self.args, **self.kw)
                    end = timeutils.utcnow()
                    if not self._running:
                        break
                    delay = interval - timeutils.delta_seconds(start, end)
                    if delay <= 0:
                        LOG.warn(_('task run outlasted interval by %s sec') %
                                 -delay)
                    greenthread.sleep(delay if delay > 0 else 0)
            except LoopingCallDone as e:
                self.stop()
                done.send(e.retvalue)
            except Exception:
                LOG.exception(_('in fixed duration looping call'))
                done.send_exception(*sys.exc_info())
                return
            else:
                done.send(True)

 def monitor_thread_pool(self, thread_info=None, condition=None):
     global launchd_threads_info
     if thread_info is None:
         thread_info = launchd_threads_info
     if condition is None:
         condition = self._condition
     while True:
         condition.acquire()
         for each_thread in iter(thread_info.keys()):
             if 'result' in thread_info[each_thread].keys():
                 LOG.debug(_("Worker Thread # for VNF configuration Ending"), thread_info[each_thread])
                 LOG.debug(_("%s"), thread_info)
                 status = 'ERROR' if 'ERROR' in str(thread_info[each_thread]['result']) else 'COMPLETE' 
                 self.vplugin_rpc.send_ack(self.ctx,
                                            thread_info[each_thread]['vnfd'],
                                            thread_info[each_thread]['vdu'],
                                            thread_info[each_thread]['vm_name'],
                                            status,
                                            self.nsd_id, self.ns_config)
                 if status == "COMPLETE":
                     self.drv_conf[thread_info[each_thread]['vdu']]['COMPLETE'].append(thread_info[each_thread]['vm_name'])
                 if thread_info[each_thread]['thread_obj'].isAlive():
                     thread_info[each_thread]['thread_obj'].kill()
                 del(thread_info[each_thread])
         condition.wait()
         condition.release()

 def inner(*args, **kwargs):
     try:
         with lock(name, lock_file_prefix, external, lock_path):
             LOG.debug(_('Got semaphore / lock "%(function)s"'),
                       {'function': f.__name__})
             return f(*args, **kwargs)
     finally:
         LOG.debug(_('Semaphore / lock released "%(function)s"'),
                   {'function': f.__name__})

 def _configure_service(self, vdu, instance, mgmt_ip, configuration_event):
     status = "ERROR"
     try:
         #vdu['_drv_obj'].configure_service(instance)
         LOG.debug(_("Configuration of VNF being carried out on VDU:%s with IP:%s"), vdu, mgmt_ip)
         status = vdu['_drv_obj'].push_configuration(instance, mgmt_ip, configuration_event)
     except exceptions.DriverException or Exception:
         LOG.exception(_("Configuration of VNF Failed!!"))
     finally:
         return status

    def configure_service(self, *args, **kwargs):
         """configure the service """
         self._check_connection()
         conf_dict = {"private_ip": self.localip , "public_ip": self.localip , "chronos_ip": self.localip, "homer_ip": self.localip , "service_name": "homer"}
         confstr = templates.homer_settings.format(**conf_dict)
         conf_dict1 = {"service_homer": "cassandra"}
         confstr1 = templates.homer_service.format(**conf_dict1)
         configuration_done = False
         while not configuration_done:
             try:
                 with manager.connect(host=self.mgmtip, username=self.username, password=self.password, port=830, hostkey_verify=False) as m:
                     print "VM is UP"
                     LOG.debug(_("VM is UP"))
                     configuration_done = True
                     c = m.get_config(source='running').data_xml
                     LOG.debug(_("config %s"), c)
                     #c1 = m.edit_config(target='candidate', config=confstr1)
                     #m.commit()
                     c2 = m.edit_config(target='candidate', config=confstr)
                     m.commit(confirmed=False, timeout=300)
             except Exception as e:
                 LOG.debug(_("VM is DOWN %s"), e)
                 LOG.debug(_("VM is DOWN"))
                 print e
                 print "VM is down"
                 time.sleep(5)      
             

         """
         with manager.connect(host=self.mgmtip, username=self.username, password=self.password, port=830, hostkey_verify=False) as m:
             c = m.get_config(source='running').data_xml
             #c1 = m.edit_config(target='candidate', config=confstr1)
             #m.commit()
             c2 = m.edit_config(target='candidate', config=confstr)
             m.commit()
         """


         """
         with manager.connect(host=self.mgmtip, port=830, username=self.username, password=self.password, hostkey_verify=False) as m:
         #m = manager.connect(self.mgmtip, port=830, username=self.username, password=self.password,hostkey_verify=False)
             try:
                 print(m)
                 print("in try")
                 c = m.get_config(source='running').data_xml
                 print c
                 c1 = m.edit_config(target='candidate', config=confstr)
                 print c1
             finally:
                 print("in final")
             m.commit()
             #m.close_session()
         """

         """

 def _invoke_driver_thread(self, vdu, instance, vdu_name):
     global launchd_threads_info
     LOG.debug(_("Configuration of the remote VNF %s being intiated"), instance)
     _thr_id = str(uuid.generate_uuid()).split('-')[1]   
     try:
        driver_thread = ImplThread(self._configure_service, self._condition, vdu, instance, _id = _thr_id)
        self._condition.acquire()
        launchd_threads_info[_thr_id] = {'vm_name': instance, 'thread_obj': driver_thread, 'vnfd': vdu['_vnfd'], 'vdu':vdu_name}
        self._condition.release()
        driver_thread.start()
     except RuntimeError:
        LOG.warning(_("Configuration by the Driver Failed!"))

    def __init__(self, conf):
        LOG.debug(_("Bono __init__"))
        LOG.debug(_(conf))
        self.__ncport = "830"
        self.retries = 10
        self.homerip = "0.0.0.0"
        self.hsip = "0.0.0.0"
        self.sproutip = "0.0.0.0"

        self.parse(conf)
        try:
            self.__uname = "user="+self.username
            self.__pswd = "password="+self.password
        except KeyError:
            raise

 def _report_state(self):
     try:
         self.agent_state.get('configurations').update(
             self.cache.get_state())
         ctx = context.get_admin_context_without_session()
         self.state_rpc.report_state(ctx, self.agent_state, self.use_call)
     except AttributeError:
         # This means the server does not support report_state
         LOG.warn(_("VNF server does not support state report."
                    " State report for this agent will be disabled."))
         self.heartbeat.stop()
         return
     except Exception:
         LOG.exception(_("Failed reporting state!"))
         return

def bool_from_string(subject, strict=False, default=False):
    """Interpret a string as a boolean.

    A case-insensitive match is performed such that strings matching 't',
    'true', 'on', 'y', 'yes', or '1' are considered True and, when
    `strict=False`, anything else returns the value specified by 'default'.

    Useful for JSON-decoded stuff and config file parsing.

    If `strict=True`, unrecognized values, including None, will raise a
    ValueError which is useful when parsing values passed in from an API call.
    Strings yielding False are 'f', 'false', 'off', 'n', 'no', or '0'.
    """
    if not isinstance(subject, six.string_types):
        subject = six.text_type(subject)

    lowered = subject.strip().lower()

    if lowered in TRUE_STRINGS:
        return True
    elif lowered in FALSE_STRINGS:
        return False
    elif strict:
        acceptable = ', '.join(
            "'%s'" % s for s in sorted(TRUE_STRINGS + FALSE_STRINGS))
        msg = _("Unrecognized value '%(val)s', acceptable values are:"
                " %(acceptable)s") % {'val': subject,
                                      'acceptable': acceptable}
        raise ValueError(msg)
    else:
        return default

def main(manager='vnfmanager.vnf_manager.VNFMgrWithStateReport'):

    # placebo func to replace the server/__init__ with project startup. 
    # pool of threads needed to spawn worker threads for RPC.
    # Default action for project's startup, explictly maintainly a pool
    # for manager as it cannot inherit the vnfsvc's thread pool.
    pool = eventlet.GreenPool()
    pool.waitall()

    conf_params = read_sys_args(sys.argv)
    _register_opts(cfg.CONF)
    common_config.init(sys.argv[1:])
    uuid = conf_params['uuid']
    config.setup_logging(cfg.CONF)
    LOG.warn(_("UUID: %s"), uuid)
    vnfm_conf_dir = conf_params['vnfm_conf_dir'].split("/")
    vnfm_conf_dir[-2] = uuid
    vnfm_conf_dir = "/".join(vnfm_conf_dir)
    vnfm_conf_path = vnfm_conf_dir+uuid+'.yaml'
    load_vnfm_conf(vnfm_conf_path)
    server = vnfsvc_service.Service.create(
                binary='vnf-manager',
                topic=topics.set_topic_name(uuid, prefix=topics.VNF_MANAGER),
                report_interval=60, manager=manager)
    service.launch(server).wait()

def execute(cmd, root_helper=None, process_input=None, addl_env=None,
            check_exit_code=True, return_stderr=False):
    try:
        obj, cmd = create_process(cmd, root_helper=root_helper,
                                  addl_env=addl_env)
        _stdout, _stderr = (process_input and
                            obj.communicate(process_input) or
                            obj.communicate())
        obj.stdin.close()
        m = _("\nCommand: %(cmd)s\nExit code: %(code)s\nStdout: %(stdout)r\n"
              "Stderr: %(stderr)r") % {'cmd': cmd, 'code': obj.returncode,
                                       'stdout': _stdout, 'stderr': _stderr}
        if obj.returncode:
            LOG.error(m)
            if check_exit_code:
                raise RuntimeError(m)
        else:
            LOG.debug(m)
    finally:
        # NOTE(termie): this appears to be necessary to let the subprocess
        #               call clean something up in between calls, without
        #               it two execute calls in a row hangs the second one
        greenthread.sleep(0)

    return return_stderr and (_stdout, _stderr) or _stdout

    def deprecated(self, msg, *args, **kwargs):
        """Call this method when a deprecated feature is used.

        If the system is configured for fatal deprecations then the message
        is logged at the 'critical' level and :class:`DeprecatedConfig` will
        be raised.

        Otherwise, the message will be logged (once) at the 'warn' level.

        :raises: :class:`DeprecatedConfig` if the system is configured for
                 fatal deprecations.

        """
        stdmsg = _("Deprecated: %s") % msg
        if CONF.fatal_deprecations:
            self.critical(stdmsg, *args, **kwargs)
            raise DeprecatedConfig(msg=stdmsg)

        # Using a list because a tuple with dict can't be stored in a set.
        sent_args = self._deprecated_messages_sent.setdefault(msg, list())

        if args in sent_args:
            # Already logged this message, so don't log it again.
            return

        sent_args.append(args)
        self.warn(stdmsg, *args, **kwargs)

 def _configure_vdu(self, vdu_name, method, arguments ,scale=False, update=False):    ## ARGS ADDED BY ANIRUDH
     status = ""
     for instance in range(0,len(self.drv_conf[vdu_name]['_instances'])):
         instance_name = self.drv_conf[vdu_name]['_instances'][instance]
         if instance_name not in self.drv_conf[vdu_name]['COMPLETE'] or update:
             try:
                 if not self.drv_conf[vdu_name]['_driver']:
                     status = 'COMPLETE'
                     self.vplugin_rpc.send_ack(self.ctx, self.drv_conf[vdu_name]['_vnfd'],
                                           vdu_name,
                                           instance_name,
                                           #self.drv_conf[vdu_name]['_mgmt_ips'][instance_name],
                                           status,
                                           self.nsd_id, self.ns_config)
                     self.drv_conf[vdu_name][status].append(instance_name)
                 else:
                     self._invoke_driver_thread(self.drv_conf[vdu_name],
                                            instance_name,
                                            vdu_name,
                                            self.drv_conf[vdu_name]['_mgmt_ips'][instance_name],
                                            method,
                                            arguments,
                                            scale)
                     status = 'COMPLETE'
             except Exception:
                 status = 'ERROR'
                 LOG.warn(_("Configuration Failed for VNF %s"), instance_name)
                 self.vplugin_rpc.send_ack(self.ctx,
                                           self.drv_conf[vdu_name]['_vnfd'],
                                           vdu_name,
                                       instance_name,
                                       status,
                                       self.nsd_id, self.ns_config)
     return status

    def parse(self,cfg):
        for i in range(0, len(cfg['Ims'])):
            regex = re.compile('^(vBono)\_\d*$')
            #if(cfg['Ims'][i]['name']=="vBono"):
            if re.search(regex, cfg['Ims'][i]['name']):
                LOG.debug(_("CONDITION*********************************SATISFIED"))
                self.username=cfg['Ims'][i]['vm_details']['image_details']['username']
                self.password=cfg['Ims'][i]['vm_details']['image_details']['password']
                #self.pkt_in_ips_key = cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips'].keys()[0]
                self.localip=cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips']['ims-'+cfg['Ims'][i]['name']]
                self.publicip=cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips']['ims-'+cfg['Ims'][i]['name']]
                self.mgmtip=cfg['Ims'][i]['vm_details']['network_interfaces']['management-interface']['ips']['ims-'+cfg['Ims'][i]['name']]
         
                     
            if(cfg['Ims'][i]['name']=="vSprout"):
                self.pkt_in_ips_key = cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips'].keys()[0]
                self.sproutip=cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips'][self.pkt_in_ips_key]

            if(cfg['Ims'][i]['name']=="vHomer"):
                self.pkt_in_ips_key = cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips'].keys()[0]
                self.homerip=cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips'][self.pkt_in_ips_key]

            if(cfg['Ims'][i]['name']=="vHS"):
                self.pkt_in_ips_key = cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips'].keys()[0]
                self.hsip=cfg['Ims'][i]['vm_details']['network_interfaces']['pkt-in']['ips'][self.pkt_in_ips_key]

 def __exit__(self, exc_type, exc_val, exc_tb):
     try:
         self.unlock()
         self.lockfile.close()
     except IOError:
         LOG.exception(_("Could not release the acquired lock `%s`"),
                       self.fname)

 def _configure_service(self, vdu, instance, mgmt_ip, method, arguments):
     status = "ERROR"
     try:
         #return vdu['_drv_obj'].configure_service(instance)
         #vdu['_drv_obj'].configure_service(instance)
         LOG.debug(_("Configuration of VNF being carried out on VDU:%s with IP:%s"), vdu, mgmt_ip)
         configurator = getattr(vdu['_drv_obj'], method)
         #status = vdu['_drv_obj'].push_configuration(instance, mgmt_ip, method, arguments)
         drv_args = dict({'conf': arguments, 'mgmt-ip': mgmt_ip})
         #arguments.fromkeys(('conf', 'mgmt-ip'), [arguments, mgmt_ip]) 
         #arguments.update({'mgmt-ip': mgmt_ip})
         status = configurator(**drv_args)
     except exceptions.DriverException or Exception:
         LOG.exception(_("Configuration of VNF Failed!!"))
     finally:
         return status

def initialize_if_enabled():
    backdoor_locals = {
        'exit': _dont_use_this,      # So we don't exit the entire process
        'quit': _dont_use_this,      # So we don't exit the entire process
        'fo': _find_objects,
        'pgt': _print_greenthreads,
        'pnt': _print_nativethreads,
    }

    if CONF.backdoor_port is None:
        return None

    start_port, end_port = _parse_port_range(str(CONF.backdoor_port))

    # NOTE(johannes): The standard sys.displayhook will print the value of
    # the last expression and set it to __builtin__._, which overwrites
    # the __builtin__._ that gettext sets. Let's switch to using pprint
    # since it won't interact poorly with gettext, and it's easier to
    # read the output too.
    def displayhook(val):
        if val is not None:
            pprint.pprint(val)
    sys.displayhook = displayhook

    sock = _listen('localhost', start_port, end_port, eventlet.listen)

    # In the case of backdoor port being zero, a port number is assigned by
    # listen().  In any case, pull the port number out here.
    port = sock.getsockname()[1]
    LOG.info(_('Eventlet backdoor listening on %(port)s for process %(pid)d') %
             {'port': port, 'pid': os.getpid()})
    eventlet.spawn_n(eventlet.backdoor.backdoor_server, sock,
                     locals=backdoor_locals)
    return port

 def _populate_vnfd_drivers(self, drv_conf):
     vnfd_drv_cls_path = drv_conf['_driver']
     try:
         drv_conf['_drv_obj'] = importutils.import_object(vnfd_drv_cls_path,
                                                          self.ns_config)
     except Exception:
         LOG.warn(_("%s driver not Loaded"), vnfd_drv_cls_path)
         raise

def setup_logging(conf):
    """Sets up the logging options for a log with supplied name.

    :param conf: a cfg.ConfOpts object
    """
    product_name = "vnfsvc"
    logging.setup(product_name)
    LOG.info(_("Logging enabled!"))