Esempio n. 1
0
    def __init__(self, configfile=None):
        db.configure_db()

        self.tunnel_key = db_api_v2.TunnelKey(
            cfg.CONF.OVS.tunnel_key_min, cfg.CONF.OVS.tunnel_key_max)
        ofp_con_host = cfg.CONF.OVS.openflow_controller
        ofp_api_host = cfg.CONF.OVS.openflow_rest_api

        if ofp_con_host is None or ofp_api_host is None:
            raise q_exc.Invalid(_('Invalid configuration. check ryu.ini'))

        hosts = [(ofp_con_host, ofp_service_type.CONTROLLER),
                 (ofp_api_host, ofp_service_type.REST_API)]
        db_api_v2.set_ofp_servers(hosts)

        self.client = client.OFPClient(ofp_api_host)
        self.tun_client = client.TunnelClient(ofp_api_host)
        self.iface_client = client.QuantumIfaceClient(ofp_api_host)
        for nw_id in rest_nw_id.RESERVED_NETWORK_IDS:
            if nw_id != rest_nw_id.NW_ID_UNKNOWN:
                self.client.update_network(nw_id)
        self._setup_rpc()

        # register known all network list on startup
        self._create_all_tenant_network()
Esempio n. 2
0
    def __init__(self):
        LOG.info(_('QuantumPluginPLUMgrid Status: Starting Plugin'))

        # PLUMgrid NOS configuration
        nos_plumgrid = cfg.CONF.PLUMgridNOS.nos_server
        nos_port = cfg.CONF.PLUMgridNOS.nos_server_port
        timeout = cfg.CONF.PLUMgridNOS.servertimeout
        self.topology_name = cfg.CONF.PLUMgridNOS.topologyname
        self.snippets = plumgrid_nos_snippets.DataNOSPLUMgrid()

        # TODO: (Edgar) These are placeholders for next PLUMgrid release
        nos_username = cfg.CONF.PLUMgridNOS.username
        nos_password = cfg.CONF.PLUMgridNOS.password
        self.rest_conn = rest_connection.RestConnection(nos_plumgrid,
                                                        nos_port, timeout)
        if self.rest_conn is None:
            raise SystemExit(_('QuantumPluginPLUMgrid Status: '
                               'Aborting Plugin'))

        else:
            # Plugin DB initialization
            db.configure_db()

            # PLUMgrid NOS info validation
            LOG.info(_('QuantumPluginPLUMgrid NOS: %s'), nos_plumgrid)
            if not nos_plumgrid:
                raise SystemExit(_('QuantumPluginPLUMgrid Status: '
                                   'NOS value is missing in config file'))

            LOG.debug(_('QuantumPluginPLUMgrid Status: Quantum server with '
                        'PLUMgrid Plugin has started'))
Esempio n. 3
0
    def __init__(self, configfile=None):
        if configfile is None:
            if os.path.exists(CONF_FILE):
                configfile = CONF_FILE
            else:
                configfile = find_config(os.path.abspath(
                    os.path.dirname(__file__)))
        if configfile is None:
            raise Exception("Configuration file \"%s\" doesn't exist" %
                            (configfile))
        LOG.debug("Using configuration file: %s" % configfile)
        conf = config.parse(configfile)
        options = {"sql_connection": conf.DATABASE.sql_connection}
        reconnect_interval = conf.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        self.vmap = VlanMap()
        # Populate the map with anything that is already present in the
        # database
        vlans = ovs_db.get_vlans()
        for x in vlans:
            vlan_id, network_id = x
            LOG.debug("Adding already populated vlan %s -> %s" %
                      (vlan_id, network_id))
            self.vmap.already_used(vlan_id, network_id)
Esempio n. 4
0
 def __init__(self):
     # NOTE(jkoelker) This is an incomlete implementation. Subclasses
     #                must override __init__ and setup the database
     #                and not call into this class's __init__.
     #                This connection is setup as memory for the tests.
     sql_connection = "sqlite:///:memory:"
     db.configure_db({"sql_connection": sql_connection, "base": models_v2.model_base.BASEV2})
Esempio n. 5
0
    def __init__(self, configfile=None):
        options = {"sql_connection": cfg.CONF.DATABASE.sql_connection}
        options.update({"base": models_v2.model_base.BASEV2})
        reconnect_interval = cfg.CONF.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        self.tunnel_key = db_api_v2.TunnelKey(cfg.CONF.OVS.tunnel_key_min, cfg.CONF.OVS.tunnel_key_max)
        ofp_con_host = cfg.CONF.OVS.openflow_controller
        ofp_api_host = cfg.CONF.OVS.openflow_rest_api

        if ofp_con_host is None or ofp_api_host is None:
            raise q_exc.Invalid(_("invalid configuration. check ryu.ini"))

        hosts = [(ofp_con_host, ofp_service_type.CONTROLLER), (ofp_api_host, ofp_service_type.REST_API)]
        db_api_v2.set_ofp_servers(hosts)

        self.client = client.OFPClient(ofp_api_host)
        self.tun_client = client.TunnelClient(ofp_api_host)
        self.iface_client = client.QuantumIfaceClient(ofp_api_host)
        for nw_id in rest_nw_id.RESERVED_NETWORK_IDS:
            if nw_id != rest_nw_id.NW_ID_UNKNOWN:
                self.client.update_network(nw_id)
        self._setup_rpc()

        # register known all network list on startup
        self._create_all_tenant_network()
Esempio n. 6
0
    def setUp(self):
        super(QuarkIpamBaseTest, self).setUp()

        cfg.CONF.set_override("sql_connection", "sqlite://", "DATABASE")
        quantum_db_api.configure_db()
        models.BASEV2.metadata.create_all(quantum_db_api._ENGINE)
        self.ipam = quark.ipam.QuarkIpam()
    def __init__(self):
        """Initialize the segmentation manager.

        Checks which device plugins are configured, and load the inventories
        those device plugins for which the inventory is configured.
        """
        conf.CiscoConfigOptions()

        for key in conf.CISCO_PLUGINS.keys():
            plugin_obj = conf.CISCO_PLUGINS[key]
            self._plugins[key] = importutils.import_object(plugin_obj)
            LOG.debug(_("Loaded device plugin %s\n"),
                      conf.CISCO_PLUGINS[key])

        if ((const.VSWITCH_PLUGIN in self._plugins) and
            hasattr(self._plugins[const.VSWITCH_PLUGIN],
                    "supported_extension_aliases")):
            self.supported_extension_aliases.extend(
                self._plugins[const.VSWITCH_PLUGIN].
                supported_extension_aliases)

        # At this point, all the database models should have been loaded. It's
        # possible that configure_db() may have been called by one of the
        # plugins loaded in above. Otherwise, this call is to make sure that
        # the database is initialized
        db_api.configure_db()

        # Initialize credential store after database initialization
        cred.Store.initialize()
        LOG.debug(_("%(module)s.%(name)s init done"),
                  {'module': __name__,
                   'name': self.__class__.__name__})
def initialize():
    options = {"sql_connection": "%s" % cfg.CONF.DATABASE.sql_connection}
    options.update({"sql_max_retries": cfg.CONF.DATABASE.sql_max_retries})
    options.update({"reconnect_interval":cfg.CONF.DATABASE.reconnect_interval})
    options.update({"base": HW_BASE})
    options.update({"sql_dbpool_enable":cfg.CONF.DATABASE.sql_dbpool_enable})
    db.configure_db(options)
Esempio n. 9
0
    def setUp(self):
        super(MetaQuantumPluginV2Test, self).setUp()
        db._ENGINE = None
        db._MAKER = None
        self.fake_tenant_id = uuidutils.generate_uuid()
        self.context = context.get_admin_context()

        db.configure_db()

        setup_metaplugin_conf()

        self.mox = mox.Mox()
        self.stubs = stubout.StubOutForTesting()
        args = ['--config-file', etcdir('quantum.conf.test')]
        self.client_cls_p = mock.patch('quantumclient.v2_0.client.Client')
        client_cls = self.client_cls_p.start()
        self.client_inst = mock.Mock()
        client_cls.return_value = self.client_inst
        self.client_inst.create_network.return_value = \
            {'id': 'fake_id'}
        self.client_inst.create_port.return_value = \
            {'id': 'fake_id'}
        self.client_inst.create_subnet.return_value = \
            {'id': 'fake_id'}
        self.client_inst.update_network.return_value = \
            {'id': 'fake_id'}
        self.client_inst.update_port.return_value = \
            {'id': 'fake_id'}
        self.client_inst.update_subnet.return_value = \
            {'id': 'fake_id'}
        self.client_inst.delete_network.return_value = True
        self.client_inst.delete_port.return_value = True
        self.client_inst.delete_subnet.return_value = True
        self.plugin = MetaPluginV2(configfile=None)
Esempio n. 10
0
    def __init__(self, configfile=None):
        config = ConfigParser.ConfigParser()
        if configfile is None:
            if os.path.exists(CONF_FILE):
                configfile = CONF_FILE
            else:
                configfile = find_config(os.path.abspath(
                        os.path.dirname(__file__)))
        if configfile is None:
            raise Exception("Configuration file \"%s\" doesn't exist" %
              (configfile))
        LOG.debug("Using configuration file: %s" % configfile)
        config.read(configfile)
        LOG.debug("Config: %s" % config)

        options = {"sql_connection": config.get("DATABASE", "sql_connection")}
        db.configure_db(options)

        self.vmap = VlanMap()
        # Populate the map with anything that is already present in the
        # database
        vlans = ovs_db.get_vlans()
        for x in vlans:
            vlan_id, network_id = x
            # LOG.debug("Adding already populated vlan %s -> %s"
            #                                   % (vlan_id, network_id))
            self.vmap.set_vlan(vlan_id, network_id)
Esempio n. 11
0
def initialize():
    options = {"sql_connection": "%s" % cfg.CONF.DATABASE.sql_connection}
    options.update({"sql_max_retries": cfg.CONF.DATABASE.sql_max_retries})
    options.update({"reconnect_interval":
                   cfg.CONF.DATABASE.reconnect_interval})
    options.update({"base": models_v2.model_base.BASEV2})
    db.configure_db(options)
Esempio n. 12
0
    def setUp(self):
        super(VPNTestCase, self).setUp()
        plugin = ("quantum.tests.unit.test_vpn.VPNTestPlugin")

        # point config file to: quantum/tests/etc/quantum.conf.test
        args = ['--config-file', test_api_v2.etcdir('quantum.conf.test')]
        config.parse(args=args)

        #just stubbing core plugin with VPN plugin
        cfg.CONF.set_override('core_plugin', plugin)
        cfg.CONF.set_override('service_plugins', [plugin])
        self.addCleanup(cfg.CONF.reset)

        # Ensure 'stale' patched copies of the plugin are never returned
        quantum.manager.QuantumManager._instance = None

        # Ensure the database is reset between tests
        db._ENGINE = None
        db._MAKER = None
        db.configure_db()
        # Ensure existing ExtensionManager is not used

        ext_mgr = extensions.PluginAwareExtensionManager(
            extensions_path,
            {constants.VPN: VPNTestPlugin()}
        )
        extensions.PluginAwareExtensionManager._instance = ext_mgr
        router.APIRouter()

        app = config.load_paste_app('extensions_test_app')
        self._api = extensions.ExtensionMiddleware(app, ext_mgr=ext_mgr)

        self._tenant_id = "8c70909f-b081-452d-872b-df48e6c355d1"
        self._subnet_id = "0c798ed8-33ba-11e2-8b28-000c291c4d14"
Esempio n. 13
0
    def __init__(self):

        # Read config values
        midonet_conf = cfg.CONF.MIDONET
        midonet_uri = midonet_conf.midonet_uri
        admin_user = midonet_conf.username
        admin_pass = midonet_conf.password
        admin_project_id = midonet_conf.project_id
        provider_router_id = midonet_conf.provider_router_id
        metadata_router_id = midonet_conf.metadata_router_id
        mode = midonet_conf.mode

        self.mido_api = api.MidonetApi(midonet_uri, admin_user,
                                       admin_pass,
                                       project_id=admin_project_id)
        self.client = midonet_lib.MidoClient(self.mido_api)

        if provider_router_id and metadata_router_id:
            # get MidoNet provider router and metadata router
            self.provider_router = self.client.get_router(provider_router_id)
            self.metadata_router = self.client.get_router(metadata_router_id)

        elif not provider_router_id or not metadata_router_id:
            if mode == 'dev':
                msg = _('No provider router and metadata device ids found. '
                        'But skipping because running in dev env.')
                LOG.debug(msg)
            else:
                msg = _('provider_router_id and metadata_router_id '
                        'should be configured in the plugin config file')
                LOG.exception(msg)
                raise MidonetPluginException(msg=msg)

        db.configure_db()
Esempio n. 14
0
    def setUp(self):
        config = utils.get_config()
        options = {"sql_connection": config.get("DATABASE", "sql_connection")}
        db.configure_db(options)

        self.config = config
        self.mox = mox.Mox()
        self.stubs = stubout.StubOutForTesting()
Esempio n. 15
0
    def __init__(self, loglevel=None):
        if loglevel:
            logging.basicConfig(level=loglevel)
            nvplib.LOG.setLevel(loglevel)
            NvpApiClient.LOG.setLevel(loglevel)

        self.db_opts, self.nvp_opts, self.clusters_opts = parse_config()
        self.clusters = []
        for c_opts in self.clusters_opts:
            # Password is guaranteed to be the same across all controllers
            # in the same NVP cluster.
            cluster = NVPCluster(c_opts["name"])
            for controller_connection in c_opts["nvp_controller_connection"]:
                args = controller_connection.split(":")
                try:
                    args.extend([c_opts["default_tz_uuid"], c_opts["nvp_cluster_uuid"], c_opts["nova_zone_id"]])
                    cluster.add_controller(*args)
                except Exception:
                    LOG.exception(
                        "Invalid connection parameters for " "controller %s in cluster %s",
                        controller_connection,
                        c_opts["name"],
                    )
                    raise

            api_providers = [(x["ip"], x["port"], True) for x in cluster.controllers]
            cluster.api_client = NvpApiClient.NVPApiHelper(
                api_providers,
                cluster.user,
                cluster.password,
                request_timeout=cluster.request_timeout,
                http_timeout=cluster.http_timeout,
                retries=cluster.retries,
                redirects=cluster.redirects,
                failover_time=self.nvp_opts["failover_time"],
                concurrent_connections=self.nvp_opts["concurrent_connections"],
            )

            # TODO(salvatore-orlando): do login at first request,
            # not when plugin, is instantiated
            cluster.api_client.login()

            # TODO(pjb): What if the cluster isn't reachable this
            # instant?  It isn't good to fall back to invalid cluster
            # strings.
            # Default for future-versions
            self.clusters.append(cluster)

        # Connect and configure ovs_quantum db
        options = {
            "sql_connection": self.db_opts["sql_connection"],
            "sql_max_retries": self.db_opts["sql_max_retries"],
            "reconnect_interval": self.db_opts["reconnect_interval"],
            "base": models_v2.model_base.BASEV2,
        }
        db.configure_db(options)
        self.setup_rpc()
Esempio n. 16
0
    def setUp(self):
        config = utils.get_config()
        options = {"sql_connection": config.get("DATABASE", "sql_connection")}
        options.update({'base': models_v2.model_base.BASEV2})
        db.configure_db(options)

        self.config = config
        self.mox = mox.Mox()
        self.stubs = stubout.StubOutForTesting()
Esempio n. 17
0
 def test_warn_when_no_connection(self):
     with mock.patch.object(db, 'register_models') as mock_register:
         mock_register.return_value = False
         with mock.patch.object(db.LOG, 'warn') as mock_log:
             mock_log.return_value = False
             db.configure_db()
             self.assertEqual(mock_log.call_count, 1)
             args = mock_log.call_args
             self.assertNotEqual(args.find('sql_connection'), -1)
Esempio n. 18
0
 def new_nexus_init(self):
     self._client = importutils.import_object(NEXUS_DRIVER)
     self._nexus_ip = NEXUS_IP_ADDRESS
     self._nexus_username = NEXUS_USERNAME
     self._nexus_password = NEXUS_PASSWORD
     self._nexus_ports = NEXUS_PORTS
     self._nexus_ssh_port = NEXUS_SSH_PORT
     self.credentials = {self._nexus_ip: {"username": self._nexus_username, "password": self._nexus_password}}
     db.configure_db()
Esempio n. 19
0
def initialize(base=None):
    global L2_MODEL
    options = {"sql_connection": "%s" % CONF.DATABASE.sql_connection}
    options.update({"reconnect_interval": CONF.DATABASE.reconnect_interval})
    if base:
        options.update({"base": base})
        L2_MODEL = l2network_models_v2
    db.configure_db(options)
    create_vlanids()
Esempio n. 20
0
def initialize():
    options = {"sql_connection": "%s" % config.DATABASE.sql_connection,
               "sql_max_retries": config.DATABASE.sql_max_retries,
               "reconnect_interval": config.DATABASE.reconnect_interval,
               "base": model_base.BASEV2,
               "sql_min_pool_size": config.CONF.DATABASE.sql_min_pool_size,
               "sql_max_pool_size": config.CONF.DATABASE.sql_max_pool_size,
               "sql_idle_timeout": config.CONF.DATABASE.sql_idle_timeout,
               "sql_dbpool_enable": config.CONF.DATABASE.sql_dbpool_enable}
    db.configure_db(options)
Esempio n. 21
0
 def __init__(self, configfile=None):
     db.configure_db()
     self.quantum = client.Client(
         username=cfg.CONF.PROXY.admin_user,
         password=cfg.CONF.PROXY.admin_password,
         tenant_name=cfg.CONF.PROXY.admin_tenant_name,
         auth_url=cfg.CONF.PROXY.auth_url,
         auth_strategy=cfg.CONF.PROXY.auth_strategy,
         auth_region=cfg.CONF.PROXY.auth_region,
     )
Esempio n. 22
0
def initialize(base=None):
    global L2_MODEL
    options = {"sql_connection": "%s" % cfg.CONF.DATABASE.sql_connection}
    options.update({"sql_max_retries": cfg.CONF.DATABASE.sql_max_retries})
    options.update({"reconnect_interval":
                   cfg.CONF.DATABASE.reconnect_interval})
    if base:
        options.update({"base": base})
    db.configure_db(options)
    create_vlanids()
Esempio n. 23
0
    def __init__(self, configfile=None):
        conf = config.parse(CONF_FILE)
        options = {"sql_connection": conf.DATABASE.sql_connection}
        options.update({'base': models_v2.model_base.BASEV2})
        reconnect_interval = conf.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        self.vmap = VlanMap(conf.OVS.vlan_min, conf.OVS.vlan_max)
        self.vmap.populate_already_used(ovs_db_v2.get_vlans())
Esempio n. 24
0
    def __init__(self, configfile=None):
        conf = config.parse(CONF_FILE)
        options = {"sql_connection": conf.DATABASE.sql_connection}
        reconnect_interval = conf.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        self.vmap = VlanMap(conf.OVS.vlan_min, conf.OVS.vlan_max)
        # Populate the map with anything that is already present in the
        # database
        self.vmap.populate_already_used(ovs_db.get_vlans())
Esempio n. 25
0
    def __init__(self, configfile=None):
        options = {"sql_connection": cfg.CONF.DATABASE.sql_connection}
        sql_max_retries = cfg.CONF.DATABASE.sql_max_retries
        options.update({"sql_max_retries": sql_max_retries})
        reconnect_interval = cfg.CONF.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        self.vmap = VlanMap(cfg.CONF.OVS.vlan_min, cfg.CONF.OVS.vlan_max)
        # Populate the map with anything that is already present in the
        # database
        self.vmap.populate_already_used(ovs_db.get_vlans())
Esempio n. 26
0
    def __init__(self, configfile=None):
        self.enable_tunneling = cfg.CONF.OVS.enable_tunneling
        options = {"sql_connection": cfg.CONF.DATABASE.sql_connection}
        options.update({'base': models_v2.model_base.BASEV2})
        sql_max_retries = cfg.CONF.DATABASE.sql_max_retries
        options.update({"sql_max_retries": sql_max_retries})
        reconnect_interval = cfg.CONF.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        self.vmap = VlanMap(cfg.CONF.OVS.vlan_min, cfg.CONF.OVS.vlan_max)
        self.vmap.populate_already_used(ovs_db_v2.get_vlans())
Esempio n. 27
0
    def __init__(self, conf_file, mod_file, configfile=None):
        super(OVSQuantumPluginBase, self).__init__()
        options = {"sql_connection": cfg.CONF.DATABASE.sql_connection}
        sql_max_retries = cfg.CONF.DATABASE.sql_max_retries
        options.update({"sql_max_retries": sql_max_retries})
        reconnect_interval = cfg.CONF.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        self.conf = cfg.CONF
        # Subclass must set self.driver to its own OVSQuantumPluginDriverBase
        self.driver = None
Esempio n. 28
0
    def setUp(self):
        options = {"sql_connection": "sqlite:///:memory:"}
        options.update({"base": models_v2.model_base.BASEV2})
        reconnect_interval = cfg.CONF.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        self.hosts = [
            (cfg.CONF.OVS.openflow_controller, ofp_service_type.CONTROLLER),
            (cfg.CONF.OVS.openflow_rest_api, ofp_service_type.REST_API),
        ]
        db_api_v2.set_ofp_servers(self.hosts)
Esempio n. 29
0
    def __init__(self, configfile=None):
        self.enable_tunneling = cfg.CONF.OVS.enable_tunneling
        options = {"sql_connection": cfg.CONF.DATABASE.sql_connection}
        options.update({'base': models_v2.model_base.BASEV2})
        sql_max_retries = cfg.CONF.DATABASE.sql_max_retries
        options.update({"sql_max_retries": sql_max_retries})
        reconnect_interval = cfg.CONF.DATABASE.reconnect_interval
        options.update({"reconnect_interval": reconnect_interval})
        db.configure_db(options)

        # update the vlan_id table based on current configuration
        ovs_db_v2.update_vlan_id_pool()
Esempio n. 30
0
    def __init__(self, configfile=None):
        LOG.debug(_("Start initializing metaplugin"))
        self.supported_extension_aliases = cfg.CONF.META.supported_extension_aliases.split(",")
        self.supported_extension_aliases += ["flavor", "router"]

        # Ignore config option overapping
        def _is_opt_registered(opts, opt):
            if opt.dest in opts:
                return True
            else:
                return False

        cfg._is_opt_registered = _is_opt_registered

        # Keep existing tables if multiple plugin use same table name.
        db.model_base.QuantumBase.__table_args__ = {"keep_existing": True}

        self.plugins = {}

        plugin_list = [plugin_set.split(":") for plugin_set in cfg.CONF.META.plugin_list.split(",")]
        for flavor, plugin_provider in plugin_list:
            self.plugins[flavor] = self._load_plugin(plugin_provider)
            # Needed to clear _ENGINE for each plugin
            db._ENGINE = None

        self.l3_plugins = {}
        l3_plugin_list = [plugin_set.split(":") for plugin_set in cfg.CONF.META.l3_plugin_list.split(",")]
        for flavor, plugin_provider in l3_plugin_list:
            if flavor in self.plugins:
                self.l3_plugins[flavor] = self.plugins[flavor]
            else:
                # For l3 only plugin
                self.l3_plugins[flavor] = self._load_plugin(plugin_provider)
                db._ENGINE = None

        self.default_flavor = cfg.CONF.META.default_flavor
        if not self.default_flavor in self.plugins:
            raise exc.Invalid(_("default_flavor %s is not plugin list") % self.default_flavor)

        self.default_l3_flavor = cfg.CONF.META.default_l3_flavor
        if not self.default_l3_flavor in self.l3_plugins:
            raise exc.Invalid(_("default_l3_flavor %s is not plugin list") % self.default_l3_flavor)

        db.configure_db()

        self.extension_map = {}
        if not cfg.CONF.META.extension_map == "":
            extension_list = [method_set.split(":") for method_set in cfg.CONF.META.extension_map.split(",")]
            for method_name, flavor in extension_list:
                self.extension_map[method_name] = flavor

        self.default_flavor = cfg.CONF.META.default_flavor