def _test_get_child_level(self): """ [XOS-Config] Should return a child level param """ Config.init(sample_conf) res = Config.get("nested.parameter.for") self.assertEqual(res, "testing")
def test_missing_file_exception(self): """ [XOS-Config] Raise if file not found """ with self.assertRaises(Exception) as e: Config.init("missing_conf") self.assertEqual(e.exception.message, "[XOS-Config] Config file not found at: missing_conf")
def test_invalid_format(self): """ [XOS-Config] Raise if format is not valid (we expect a dictionary) """ with self.assertRaises(Exception) as e: Config.init(invalid_format) self.assertEqual(e.exception.message, "[XOS-Config] The config format is wrong: Schema validation failed:\n - Value '['I am', 'a yaml', 'but the', 'format is not', 'correct']' is not a dict. Value path: ''.")
def setUp(self): self.sys_path_save = sys.path self.cwd_save = os.getcwd() config = os.path.join(test_path, "test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from xossynchronizer.mock_modelaccessor_build import ( build_mock_modelaccessor, ) build_mock_modelaccessor(sync_lib_dir, xos_dir, services_dir=None, service_xprotos=[]) # The test config.yaml references files in `xos-synchronizer-tests/` so make sure we're in the parent # directory of the test directory. os.chdir(os.path.join(test_path, "..")) import xossynchronizer.event_loop reload(xossynchronizer.event_loop) import xossynchronizer.backend reload(xossynchronizer.backend) from xossynchronizer.modelaccessor import model_accessor b = xossynchronizer.backend.Backend(model_accessor=model_accessor) steps_dir = Config.get("steps_dir") self.steps = b.load_sync_step_modules(steps_dir) self.synchronizer = xossynchronizer.event_loop.XOSObserver(self.steps, model_accessor)
def setUp(self): global ComputeNodePolicy, MockObjectList self.sys_path_save = sys.path config = os.path.join(test_path, "../test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor imp.reload(mock_modelaccessor) # in case nose2 loaded it in a previous test imp.reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from model_policy_compute_nodes import ComputeNodePolicy, model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # Some of the functions we call have side-effects. For example, creating a VSGServiceInstance may lead to # creation of tags. Ideally, this wouldn't happen, but it does. So make sure we reset the world. model_accessor.reset_all_object_stores() self.policy = ComputeNodePolicy self.model = Mock()
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import build_mock_modelaccessor # FIXME this is to get jenkins to pass the tests, somehow it is running tests in a different order # and apparently it is not overriding the generated model accessor build_mock_modelaccessor(sync_lib_dir, xos_dir, services_dir, []) import xossynchronizer.modelaccessor # import all class names to globals for ( k, v, ) in xossynchronizer.modelaccessor.model_accessor.all_model_classes.items(): globals()[k] = v self.log = Mock()
def test_get_default_val_for_missing_param(self): """ [XOS-Config] Should get the default value if nothing is specified """ Config.init(basic_conf) dir = Config.get("xos_dir") self.assertEqual(dir, "/opt/xos")
def test_get_config_file(self): """ [XOS-Config] Should return the config file in use """ Config.init(sample_conf) res = Config.get_config_file() self.assertEqual(res, sample_conf)
def test_get_missing_param(self): """ [XOS-Config] Should return None reading a missing param """ Config.init(sample_conf) res = Config.get("foo") self.assertEqual(res, None)
def test_yaml_not_valid(self): """ [XOS-Config] Raise if yaml is not valid """ with self.assertRaises(Exception) as e: Config.init(yaml_not_valid) self.assertEqual(e.exception.message, "[XOS-Config] The config format is wrong: Unable to load any data from source yaml file")
def test_get_child_level(self): """ [XOS-Config] Should return a child level param """ Config.init(sample_conf) res = Config.get("database.name") self.assertEqual(res, "xos")
def test_initialize_only_once(self): """ [XOS-Config] Raise if initialized twice """ with self.assertRaises(Exception) as e: Config.init(sample_conf) Config2.init(sample_conf) self.assertEqual(str(e.exception), "[XOS-Config] Module already initialized")
def test_schema_override_usage(self): """ [XOS-Config] the XOS_CONFIG_SCHEMA should be used to validate a config """ os.environ["XOS_CONFIG_SCHEMA"] = small_schema with self.assertRaises(Exception) as e: Config.init(basic_conf) self.assertEqual(e.exception.message, "[XOS-Config] The config format is wrong: Schema validation failed:\n - Key 'database' was not defined. Path: ''.") del os.environ["XOS_CONFIG_SCHEMA"]
def test_config_override(self): """ [XOS-Config] If an override is provided for the config, it should return the overridden value """ Config.init(sample_conf, "xos-config-schema.yaml", override_conf) res = Config.get("logging.level") self.assertEqual(res, "info") res = Config.get("database.password") self.assertEqual(res, "overridden_password")
def test_yaml_not_valid(self): """ [XOS-Config] Raise if yaml is not valid """ with self.assertRaises(Exception) as e: Config.init(yaml_not_valid) self.assertTrue( str(e.exception).startswith("[XOS-Config] The config format is wrong:") )
def test_get_first_level(self): """ [XOS-Config] Should return a first level param """ Config.init(sample_conf) # NOTE we are using Config2 here to be sure that the configuration is readable from any import, # not only from the one that has been used to initialize it res = Config2.get("database") self.assertEqual(res, {"name": "xos", "username": "******", "password": "******"})
def test_env_override(self): """ [XOS-Config] the XOS_CONFIG_FILE environment variable should override the config_file """ os.environ["XOS_CONFIG_FILE"] = "env.yaml" with self.assertRaises(Exception) as e: Config.init("missing_conf") self.assertEqual(e.exception.message, "[XOS-Config] Config file not found at: env.yaml") del os.environ["XOS_CONFIG_FILE"]
def test_schema_override(self): """ [XOS-Config] the XOS_CONFIG_SCHEMA environment variable should override the config_schema """ os.environ["XOS_CONFIG_SCHEMA"] = "env-schema.yaml" with self.assertRaises(Exception) as e: Config.init(basic_conf) self.assertRegexpMatches(e.exception.message, '\[XOS\-Config\] Config schema not found at: (.+)env-schema\.yaml') # self.assertEqual(e.exception.message, "[XOS-Config] Config schema not found at: env-schema.yaml") del os.environ["XOS_CONFIG_SCHEMA"]
def setUp(self): from xosconfig import Config test_path = os.path.abspath(os.path.dirname(os.path.realpath(__file__))) config = os.path.join(test_path, "test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") if USE_FAKE_STUB: sys.path.append(PARENT_DIR)
def configure_logging(verbose): global log # INITIALIZING LOGGER Config.init() cfg = Config().get("logging") if verbose: cfg["handlers"]["console"]["level"] = "DEBUG" log = create_logger(cfg)
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("vrouter", "vrouter.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from sync_routes import SyncRoutes, model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncRoutes self.sync_step.log = Mock() # mock onos-fabric onos_fabric = Mock() onos_fabric.name = "onos-fabric" onos_fabric.rest_hostname = "onos-fabric" onos_fabric.rest_port = "8181" onos_fabric.rest_username = "******" onos_fabric.rest_password = "******" onos_fabric_base = Mock() onos_fabric_base.leaf_model = onos_fabric self.fabric = Mock() self.fabric.name = "fabric" self.fabric.provider_services = [onos_fabric_base] self.vrouter = Mock() self.vrouter.name = "vrouter" self.vrouter.provider_services = [self.fabric] # create a mock VRouterStaticRoute instance self.o = Mock() self.o.id = 1 self.o.vrouter.owner = self.vrouter self.o.tologdict.return_value = {}
def test_config_extend(self): """ [XOS-Config] If an override is provided for the config, it should return the overridden value (also if not defined in the base one) """ Config.init(sample_conf, "xos-config-schema.yaml", extend_conf) res = Config.get("xos_dir") self.assertEqual(res, "/opt/xos") res = Config.get("database.password") self.assertEqual(res, "safe")
def test_get_default_val_for_missing_param(self): """ [XOS-Config] Should get the default value if nothing is specified """ Config.init(basic_conf) log = Config.get("logging") self.assertEqual(log, { "level": "info", "channels": ["file", "console"], "logstash_hostport": "cordloghost:5617", "file": "/var/log/xos.log", })
def main(): base_config_file = os.path.abspath(os.path.dirname( os.path.realpath(__file__)) + '/config.yaml') mounted_config_file = os.path.abspath(os.path.dirname( os.path.realpath(__file__)) + '/mounted_config.yaml') if os.path.isfile(mounted_config_file): Config.init(base_config_file, 'synchronizer-config-schema.yaml', mounted_config_file) else: Config.init(base_config_file, 'synchronizer-config-schema.yaml') Synchronizer().run()
def setUp(self): global VSGServiceInstancePolicy, LeastLoadedNodeScheduler, MockObjectList self.sys_path_save = sys.path sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base')) config = os.path.join(test_path, "test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor(xos_dir, services_dir, [get_models_fn("vsg", "vsg.xproto"), get_models_fn("addressmanager", "addressmanager.xproto")]) import synchronizers.new_base.modelaccessor import synchronizers.new_base.model_policies.model_policy_tenantwithcontainer import model_policy_vsgserviceinstance from model_policy_vsgserviceinstance import VSGServiceInstancePolicy, model_accessor from synchronizers.new_base.model_policies.model_policy_tenantwithcontainer import LeastLoadedNodeScheduler from mock_modelaccessor import MockObjectList # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # Some of the functions we call have side-effects. For example, creating a VSGServiceInstance may lead to creation of # tags. Ideally, this wouldn't happen, but it does. So make sure we reset the world. model_accessor.reset_all_object_stores() # attic functions that are not present in the mock model accessor VSGServiceInstance.volt = PropertyMock(return_value = None) AddressManagerServiceInstance.set_attribute = Mock() self.policy = VSGServiceInstancePolicy() self.tenant = VSGServiceInstance() self.user = User(email="*****@*****.**") self.tenant = VSGServiceInstance(id=1) self.flavor = Flavor(name="m1.small") self.npt_ctag = NetworkParameterType(name="c_tag", id=1) self.npt_stag = NetworkParameterType(name="s_tag", id=2) self.npt_neutron_port_name = NetworkParameterType(name="neutron_port_name", id=3) self.node = Node(hostname="my.node.com") self.slice = Slice(name="mysite_test1", default_flavor=self.flavor, default_isolation="vm") self.priv_template = NetworkTemplate(name="access_network", visibility="private") self.priv_network = Network(name="mysite_test1_private", template=self.priv_template) self.image = Image(name="trusty-server-multi-nic") self.deployment = Deployment(name="testdeployment") Tag.objects.item_list = []
def setUp(self): self.sys_path_save = sys.path self.cwd_save = os.getcwd() config = os.path.join(test_path, "test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from xossynchronizer.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor( sync_lib_dir, xos_dir, services_dir=None, service_xprotos=[] ) os.chdir( os.path.join(test_path, "..") ) # config references xos-synchronizer-tests/model-deps import xossynchronizer.event_loop reload(xossynchronizer.event_loop) import xossynchronizer.backend reload(xossynchronizer.backend) from xossynchronizer.modelaccessor import model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v from xossynchronizer.modelaccessor import model_accessor b = xossynchronizer.backend.Backend(model_accessor=model_accessor) steps_dir = Config.get("steps_dir") self.steps = b.load_sync_step_modules(steps_dir) self.synchronizer = xossynchronizer.event_loop.XOSObserver( self.steps, model_accessor ) try: os.remove("/tmp/sync_ports") except OSError: pass try: os.remove("/tmp/delete_ports") except OSError: pass
def main(): input_fn = sys.argv[1] result_fn = sys.argv[2] args = pickle.loads(open(input_fn).read()) Config.init(args['config_file'], 'synchronizer-config-schema.yaml') ansible_hosts = args["ansible_hosts"] ansible_config = args["ansible_config"] fqp = args["fqp"] opts = args["opts"] result = run_playbook(ansible_hosts, ansible_config, fqp, opts) open(result_fn, "w").write(pickle.dumps(result))
def setup_sync_unit_test(test_path, globals_dict, models, config_fn="test_config.yaml"): """ Perform the common steps associated with setting up a synchronizer unit test. 1) Import xosconfig.Config and set it up to test_config.yaml in the current dir 2) Build the mock modelaccessor and import it 3) Import all model accessor classes into global space Arguments: test_path - path to the test case that is being run globals_dict - a dictionary to add global models to models - a list of pairs (service_name, xproto_name) config_fn - filename of config file) Returns: Dictionary containing the following: sys_path_save: the original sys.path model_accessor: model accessor class Config: the Config object xos_dir: xos directory services_dir: services directory """ sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, config_fn) Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, models) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous testp from xossynchronizer.modelaccessor import model_accessor # modelaccessor.py will have ensure mock_modelaccessor is in sys.path from mock_modelaccessor import MockObjectList # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals_dict[k] = v return {"sys_path_save": sys_path_save, "model_accessor": model_accessor, "Config": Config, "MockObjectList": MockObjectList}
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import build_mock_modelaccessor # Can't use mock_modelaccessor_config because we're not in the xos-services directory, so do it # the long way... xos_dir = os.path.join(test_path, "../../../../xos") services_dir = os.path.join(test_path, "../../../..") service_xprotos = [os.path.join(test_path, "../models/testservice.xproto")] build_mock_modelaccessor(None, xos_dir, services_dir, service_xprotos) import xossynchronizer.modelaccessor import mock_modelaccessor imp.reload(mock_modelaccessor) # in case nose2 loaded it in a previous test imp.reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from sync_testservice_serviceinstance import SyncTestserviceServiceInstance from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncTestserviceServiceInstance # TODO: Use modelaccessor instead # create a mock instance instance self.model = Mock(name="Example", some_integer=0, sync_after_policy=False, sync_during_policy=False, policy_after_sync=False, policy_during_sync=False, update_during_sync=False, update_during_policy=False, create_duplicate=False)
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import build_mock_modelaccessor # Can't use mock_modelaccessor_config because we're not in the xos-services directory, so do it # the long way... xos_dir = os.path.join(test_path, "../../../../xos") services_dir = os.path.join(test_path, "../../../..") service_xprotos = [os.path.join(test_path, "../models/testservice.xproto")] build_mock_modelaccessor(None, xos_dir, services_dir, service_xprotos) # mock_modelaccessor_config(test_path, [("testservice", "testservice.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor imp.reload(mock_modelaccessor) # in case nose2 loaded it in a previous test imp.reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from model_policy_testservice_serviceinstance import TestserviceServiceInstancePolicy from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # Some of the functions we call have side-effects, reset the world. model_accessor.reset_all_object_stores() self.policy = TestserviceServiceInstancePolicy(self.model_accessor) self.si = Mock(sync_after_policy=False, sync_during_policy=False, policy_after_sync=False, policy_during_sync=False, update_during_sync=False, update_during_policy=False, create_duplicate=False)
def setUp(self): global mock_enumerator, event_loop self.sys_path_save = sys.path self.cwd_save = os.getcwd() config = os.path.join(test_path, "test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from xossynchronizer.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor(sync_lib_dir, xos_dir, services_dir=None, service_xprotos=[]) os.chdir(os.path.join( test_path, "..")) # config references xos-synchronizer-tests/model-deps import xossynchronizer.event_loop event_loop = xossynchronizer.event_loop reload(xossynchronizer.event_loop) import xossynchronizer.backend reload(xossynchronizer.backend) from xossynchronizer.modelaccessor import model_accessor from mock_modelaccessor import mock_enumerator # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v b = xossynchronizer.backend.Backend(model_accessor=model_accessor) steps_dir = Config.get("steps_dir") self.steps = b.load_sync_step_modules(steps_dir) self.synchronizer = xossynchronizer.event_loop.XOSObserver( self.steps, model_accessor)
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("att-workflow-driver", "att-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from onu_event import ONUEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.model_accessor = model_accessor self.log = Mock() self.event_step = ONUEventStep(model_accessor=self.model_accessor, log=self.log) self.event = Mock() self.event_dict = { 'status': 'activated', 'serial_number': 'BRCM1234', 'of_dpid': 'of:109299321', 'uni_port_id': 16 } self.event.value = json.dumps(self.event_dict) self.att = AttWorkflowDriverService(name="att-workflow-driver")
def setUp(self): self.sys_path_save = sys.path sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base')) # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from multistructlog import create_logger log = create_logger(Config().get('logging')) # END Setting up the config module from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor # build_mock_modelaccessor(xos_dir, services_dir, [get_models_fn("olt-service", "volt.xproto")]) build_mock_modelaccessor(xos_dir, services_dir, [ get_models_fn("hippie-oss", "hippie-oss.xproto"), get_models_fn("olt-service", "volt.xproto"), get_models_fn("rcord", "rcord.xproto") ]) import synchronizers.new_base.modelaccessor from auth_event import SubscriberAuthEventStep, model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.log = log self.event_step = SubscriberAuthEventStep(self.log) self.event = Mock() self.volt = Mock() self.volt.name = "vOLT" self.volt.leaf_model = Mock() self.hippie_si = HippieOSSServiceInstance() self.hippie_si.serial_number = "BRCM1234" self.hippie_si.save = Mock()
def setUp(self): self.sys_path_save = sys.path self.cwd_save = os.getcwd() sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, "synchronizers", "new_base")) sys.path.append( os.path.join(xos_dir, "synchronizers", "new_base", "tests", "steps")) config = os.path.join(test_path, "test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from synchronizers.new_base.mock_modelaccessor_build import ( build_mock_modelaccessor, ) build_mock_modelaccessor(xos_dir, services_dir=None, service_xprotos=[]) os.chdir(os.path.join(test_path, "..")) # config references tests/model-deps import event_loop reload(event_loop) import backend reload(backend) # self.policy = TenantWithContainerPolicy() # self.user = User(email="*****@*****.**") # self.tenant = Tenant(creator=self.user) # self.flavor = Flavor(name="m1.small") # model_policy_tenantwithcontainer.Instance = Instance # model_policy_tenantwithcontainer.Flavor = Flavor b = backend.Backend() steps_dir = Config.get("steps_dir") self.steps = b.load_sync_step_modules(steps_dir) self.synchronizer = event_loop.XOSObserver(self.steps)
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("olt-service", "volt.xproto"), ("vsg", "vsg.xproto"), ("rcord", "rcord.xproto"), ]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from xossynchronizer.steps.syncstep import DeferredException from sync_onu_device import SyncONUDevice, model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncONUDevice volt_service = Mock() volt_service.voltha_url = "voltha_url" volt_service.voltha_port = 1234 volt_service.voltha_user = "******" volt_service.voltha_pass = "******" self.o = Mock() self.o.device_id = "test_id" self.o.pon_port.olt_device.volt_service = volt_service
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_fabric_crossconnect_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric-crossconnect", "fabric-crossconnect.xproto"),]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from sync_fabric_crossconnect_service_instance import SyncFabricCrossconnectServiceInstance, model_accessor, \ DeferredException # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncFabricCrossconnectServiceInstance self.sync_step.log = Mock() # mock onos-fabric self.onos_fabric = Service(name = "onos-fabric", rest_hostname = "onos-fabric", rest_port = "8181", rest_username = "******", rest_password = "******") self.service = FabricCrossconnectService(name = "fcservice", provider_services = [self.onos_fabric])
def setUp(self): global DeferredException self.sys_path_save = sys.path sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base')) # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor(xos_dir, services_dir, [get_models_fn("fabric", "fabric.xproto")]) import synchronizers.new_base.modelaccessor from sync_fabric_port import SyncFabricPort, model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncFabricPort self.sync_step.log = Mock() # mock onos-fabric onos_fabric = Mock() onos_fabric.name = "onos-fabric" onos_fabric.rest_hostname = "onos-fabric" onos_fabric.rest_port = "8181" onos_fabric.rest_username = "******" onos_fabric.rest_password = "******" onos_fabric_base = Mock() onos_fabric_base.leaf_model = onos_fabric self.fabric = Mock() self.fabric.name = "fabric" self.fabric.provider_services = [onos_fabric_base]
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from xossynchronizer.modelaccessor import model_accessor from sync_onu_device import SyncONUDevice # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncONUDevice volt_service = Mock() volt_service.voltha_url = MOCK_VOLTHA_SERVER_ADDRESS volt_service.voltha_port = MOCK_VOLTHA_SERVER_PORT self.o = Mock() self.o.device_id = "test_id" self.o.pon_port.olt_device.volt_service = volt_service clear_voltha_client_cache() self.server = grpc.server(ThreadPoolExecutor(max_workers=5)) self.voltha_mock, _, _ = VolthaServerMock.start_voltha_server( self.server)
def setUp(self): global TenantWithContainerPolicy, LeastLoadedNodeScheduler, MockObjectList self.sys_path_save = sys.path self.cwd_save = os.getcwd() sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base')) sys.path.append( os.path.join(xos_dir, 'synchronizers', 'new_base', 'model_policies')) config = basic_conf = os.path.abspath( os.path.dirname(os.path.realpath(__file__)) + "/test_config.yaml") Config.clear() # in case left unclean by a previous test case Config.init(config, 'synchronizer-config-schema.yaml') from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor(xos_dir, services_dir=None, service_xprotos=[]) import model_policy_tenantwithcontainer from model_policy_tenantwithcontainer import TenantWithContainerPolicy, LeastLoadedNodeScheduler from mock_modelaccessor import MockObjectList # import all class names to globals for ( k, v ) in model_policy_tenantwithcontainer.model_accessor.all_model_classes.items( ): globals()[k] = v # TODO: Mock_model_accessor lacks save or delete methods #Instance.save = mock.Mock #Instance.delete = mock.Mock #TenantWithContainer.save = mock.Mock self.policy = TenantWithContainerPolicy() self.user = User(email="*****@*****.**") self.tenant = TenantWithContainer(creator=self.user) self.flavor = Flavor(name="m1.small")
def setUp(self): self.sys_path_save = sys.path config = os.path.join(test_path, "../test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config( test_path, [("att-workflow-driver", "att-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from model_policy_att_workflow_driver_serviceinstance import AttWorkflowDriverServiceInstancePolicy, AttHelpers self.AttHelpers = AttHelpers from mock_modelaccessor import MockObjectList # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # Some of the functions we call have side-effects. For example, creating a VSGServiceInstance may lead to creation of # tags. Ideally, this wouldn't happen, but it does. So make sure we reset the world. model_accessor.reset_all_object_stores() self.policy = AttWorkflowDriverServiceInstancePolicy( model_accessor=model_accessor) self.si = AttWorkflowDriverServiceInstance() self.si.owner = AttWorkflowDriverService() self.si.serial_number = "BRCM1234"
def setUp(self): global mock_enumerator, event_loop self.sys_path_save = sys.path self.cwd_save = os.getcwd() sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base')) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base', 'tests', 'steps')) config = os.path.join(test_path, "test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor(xos_dir, services_dir=None, service_xprotos=[]) os.chdir(os.path.join(test_path, '..')) # config references tests/model-deps import event_loop reload(event_loop) import backend reload(backend) from mock_modelaccessor import mock_enumerator from modelaccessor import model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # self.policy = TenantWithContainerPolicy() # self.user = User(email="*****@*****.**") # self.tenant = Tenant(creator=self.user) # self.flavor = Flavor(name="m1.small") # model_policy_tenantwithcontainer.Instance = Instance # model_policy_tenantwithcontainer.Flavor = Flavor b = backend.Backend() steps_dir = Config.get("steps_dir") self.steps = b.load_sync_step_modules(steps_dir) self.synchronizer = event_loop.XOSObserver(self.steps)
def setUp(self): global VOLTServiceInstancePolicy, MockObjectList self.sys_path_save = sys.path config = os.path.join(test_path, "../test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("olt-service", "volt.xproto"), ("vsg", "vsg.xproto"), ("rcord", "rcord.xproto"), ]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList from model_policy_voltserviceinstance import VOLTServiceInstancePolicy # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v # Some of the functions we call have side-effects. For example, creating a VSGServiceInstance may lead to creation of # tags. Ideally, this wouldn't happen, but it does. So make sure we reset the world. model_accessor.reset_all_object_stores() self.policy = VOLTServiceInstancePolicy( model_accessor=self.model_accessor) self.si = Mock()
def setUp(self): global DeferredException self.sys_path_save = sys.path sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base')) # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_fabric_crossconnect_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor(xos_dir, services_dir, [get_models_fn("fabric-crossconnect", "fabric-crossconnect.xproto")]) import synchronizers.new_base.modelaccessor from mock_modelaccessor import MockObjectList self.MockObjectList = MockObjectList from model_policy_fabriccrossconnectserviceinstance import FabricCrossconnectServiceInstancePolicy, \ model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.policy_step = FabricCrossconnectServiceInstancePolicy self.policy_step.log = Mock() # mock onos-fabric self.onos_fabric = Service(name = "onos-fabric", rest_hostname = "onos-fabric", rest_port = "8181", rest_username = "******", rest_password = "******") self.service = FabricCrossconnectService(name = "fcservice", provider_services = [self.onos_fabric])
def setUp(self): self.sys_path_save = sys.path sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base')) # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor(xos_dir, services_dir, [ get_models_fn("hippie-oss", "hippie-oss.xproto"), get_models_fn("olt-service", "volt.xproto"), get_models_fn("rcord", "rcord.xproto") ]) import synchronizers.new_base.modelaccessor from sync_hippie_oss_service_instance import SyncOSSServiceInstance, model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncOSSServiceInstance self.oss = Mock() self.oss.name = "oss" self.oss.id = 5367 # create a mock HippieOssServiceInstance instance self.o = Mock() self.o.serial_number = "BRCM1234" self.o.of_dpid = "of:109299321" self.o.owner.leaf_model = self.oss self.o.tologdict.return_value = {}
def setUp(self): self.sys_path_save = sys.path self.cwd_save = os.getcwd() sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, "synchronizers", "new_base")) sys.path.append( os.path.join(xos_dir, "synchronizers", "new_base", "tests", "steps") ) config = os.path.join(test_path, "test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, "synchronizer-config-schema.yaml") from synchronizers.new_base.mock_modelaccessor_build import ( build_mock_modelaccessor, ) build_mock_modelaccessor(xos_dir, services_dir=None, service_xprotos=[]) os.chdir(os.path.join(test_path, "..")) # config references tests/model-deps import event_loop reload(event_loop) import backend reload(backend) from modelaccessor import model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v b = backend.Backend() steps_dir = Config.get("steps_dir") self.steps = b.load_sync_step_modules(steps_dir) self.synchronizer = event_loop.XOSObserver(self.steps)
def setUp(self): global TenantWithContainerPolicy, LeastLoadedNodeScheduler, MockObjectList self.sys_path_save = sys.path self.cwd_save = os.getcwd() config = basic_conf = os.path.abspath( os.path.dirname(os.path.realpath(__file__)) + "/test_config.yaml" ) Config.clear() # in case left unclean by a previous test case Config.init(config, "synchronizer-config-schema.yaml") from xossynchronizer.mock_modelaccessor_build import ( build_mock_modelaccessor, ) build_mock_modelaccessor(sync_lib_dir, xos_dir, services_dir=None, service_xprotos=[]) import xossynchronizer.model_policies.model_policy_tenantwithcontainer from xossynchronizer.model_policies.model_policy_tenantwithcontainer import ( TenantWithContainerPolicy, LeastLoadedNodeScheduler, ) from mock_modelaccessor import MockObjectList # import all class names to globals for ( k, v, ) in xossynchronizer.model_policies.model_policy_tenantwithcontainer.model_accessor.all_model_classes.items(): globals()[k] = v from xossynchronizer.modelaccessor import model_accessor self.policy = TenantWithContainerPolicy(model_accessor=model_accessor) self.user = User(email="*****@*****.**") self.tenant = TenantWithContainer(creator=self.user) self.flavor = Flavor(name="m1.small")
def setUp(self): global log, steps, event_loop self.sys_path_save = sys.path self.cwd_save = os.getcwd() sys.path.append(xos_dir) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base')) sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base', 'tests', 'steps')) config = os.path.join(test_path, "test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor build_mock_modelaccessor(xos_dir, services_dir=None, service_xprotos=[]) os.chdir(os.path.join(test_path, '..')) # config references tests/model-deps import event_loop reload(event_loop) import backend reload(backend) import steps.sync_instances import steps.sync_controller_slices from modelaccessor import model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v from multistructlog import create_logger log = create_logger() b = backend.Backend() steps_dir = Config.get("steps_dir") self.steps = b.load_sync_step_modules(steps_dir) self.synchronizer = event_loop.XOSObserver(self.steps)
# you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. #!/usr/bin/env python # This imports and runs ../../xos-observer.py import importlib import os import sys from xosconfig import Config config_file = os.path.abspath( os.path.dirname(os.path.realpath(__file__)) + '/sepcservice_config.yaml') Config.init(config_file, 'synchronizer-config-schema.yaml') synchronizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../synchronizers/new_base") sys.path.append(synchronizer_path) mod = importlib.import_module("xos-synchronizer") mod.main()
# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Runs the standard XOS synchronizer import os from xossynchronizer import Synchronizer from xosconfig import Config base_config_file = os.path.abspath( os.path.dirname(os.path.realpath(__file__)) + '/config.yaml') mounted_config_file = os.path.abspath( os.path.dirname(os.path.realpath(__file__)) + '/mounted_config.yaml') if os.path.isfile(mounted_config_file): Config.init(base_config_file, 'synchronizer-config-schema.yaml', mounted_config_file) else: Config.init(base_config_file, 'synchronizer-config-schema.yaml') Synchronizer().run()
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v from sync_olt_device import SyncOLTDevice, DeferredException self.sync_step = SyncOLTDevice pon_port = Mock() pon_port.port_id = "00ff00" # create a mock ONOS Service onos = Mock() onos.name = "ONOS" onos.leaf_model.rest_hostname = "onos" onos.leaf_model.rest_port = 4321 onos.leaf_model.rest_username = "******" onos.leaf_model.rest_password = "******" # Create a mock OLTDevice o = Mock() o.volt_service.voltha_url = "voltha_url" o.volt_service.voltha_port = 1234 o.volt_service.voltha_user = "******" o.volt_service.voltha_pass = "******" o.volt_service.provider_services = [onos] o.device_type = "ponsim_olt" o.host = "172.17.0.1" o.port = "50060" o.uplink = "129" o.driver = "voltha" o.name = "Test Device" o.admin_state = "ENABLED" # feedback state o.device_id = None o.oper_status = None o.serial_number = None o.of_id = None o.id = 1 o.tologdict.return_value = {'name': "Mock VOLTServiceInstance"} o.save_changed_fields.return_value = "Saved" o.pon_ports.all.return_value = [pon_port] self.o = o self.voltha_devices_response = {"id": "123", "serial_number": "foobar"} self.tp = TechnologyProfile(technology="xgspon", profile_id=64, profile_value="{}")
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [ ("onos-service", "onos.xproto"), ]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from sync_onos_app import SyncONOSApp, DeferredException, model_accessor self.model_accessor = model_accessor # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = SyncONOSApp onos = ONOSService() onos.rest_hostname = "onos-url" onos.rest_port = "8181" onos.rest_username = "******" onos.rest_password = "******" self.onos_app = Mock(spec=[ 'id', 'name', 'app_id', 'dependencies', 'owner', 'url', 'backend_code', 'version', 'tologdict' ]) self.onos_app.id = 1 self.onos_app.name = "vrouter" self.onos_app.app_id = "org.onosproject.vrouter" self.onos_app.dependencies = "" self.onos_app.owner.leaf_model = onos self.onos_app.url = None self.onos_app.class_names = "ONOSApp" self.onos_app.tologdict.return_value = "" self.si = Mock() self.si.id = 1 self.si.leaf_model = self.onos_app self.vrouter_app_response = { "name": "org.onosproject.vrouter", "version": "1.13.1", } self.onos_app_attribute = Mock( spec=['id', 'service_instance', 'name', 'value']) self.onos_app_attribute.id = 1 self.onos_app_attribute.service_instance = self.si self.onos_app_attribute.name = "/onos/v1/network/configuration/apps/org.opencord.olt" self.onos_app_attribute.value = { "kafka": { "bootstrapServers": "cord-kafka-kafka.default.svc.cluster.local:9092" } }
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # Mock the kafka producer self.mockxoskafka = MagicMock() modules = { 'xoskafka': self.mockxoskafka, 'xoskafka.XOSKafkaProducer': self.mockxoskafka.XOSKafkaProducer, } self.module_patcher = patch.dict('sys.modules', modules) self.module_patcher.start() from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from mock_modelaccessor import MockObjectList from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor # necessary to reset XOSKafkaProducer's call_count import onos_event reload(onos_event) from onos_event import OnosPortEventStep, XOSKafkaProducer from onos_event import XOSKafkaProducer self.XOSKafkaProducer = XOSKafkaProducer # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = OnosPortEventStep self.volt_service = VOLTService(name="volt", id=1112, backend_code=1, backend_status="succeeded") self.oltdevice = OLTDevice(name="myolt", device_id="of:0000000000000001", switch_datapath_id="of:0000000000000001", switch_port="1") self.ponport = PONPort(olt_device = self.oltdevice) self.onudevice = ONUDevice(pon_port = self.ponport) self.subscriber = RCORDSubscriber(name="somesubscriber") self.voltsi = VOLTServiceInstance() # chain it all together self.oltdevice.pon_ports = MockObjectList([self.ponport]) self.ponport.onu_devices = MockObjectList([self.onudevice]) self.onudevice.volt_service_instances = MockObjectList([self.voltsi]) self.voltsi.westbound_service_instances = [self.subscriber] self.log = Mock()
def setUp(self): global dynamicbuild config = os.path.abspath( os.path.dirname(os.path.realpath(__file__)) + "/test_config.yaml" ) Config.clear() # in case left unclean by a previous test case Config.init(config) import dynamicbuild self.base_dir = tempfile.mkdtemp() self.example_xproto = """option app_label = "exampleservice"; option name = "exampleservice"; message ExampleService (Service){ option verbose_name = "Example Service"; required string service_message = 1 [help_text = "Service Message to Display", max_length = 254, null = False, db_index = False, blank = False]; } message Color (XOSBase){ option verbose_name = "Color"; required string name = 1 [help_text = "Name for this color", db_index = False, max_length = 256, null = False, blank = False]; required string html_code = 2 [help_text = "Code for this color", db_index = False, max_length = 256, null = False, blank = False]; } message ExampleServiceInstance (TenantWithContainer){ option verbose_name = "Example Service Instance"; required string tenant_message = 1 [help_text = "Tenant Message to Display", max_length = 254, null = False, db_index = False, blank = False]; optional manytoone foreground_color->Color:serviceinstance_foreground_colors = 3 [db_index = True, null = True, blank = True]; optional manytoone background_color->Color:serviceinstance_background_colors = 3 [db_index = True, null = True, blank = True]; } message EmbeddedImage (XOSBase){ option verbose_name = "Embedded Image"; required string name = 1 [help_text = "Name for this image", db_index = False, max_length = 256, null = False, blank = False]; required string url = 2 [help_text = "URL for this image", db_index = False, max_length = 256, null = False, blank = False]; optional manytoone serviceinstance->ExampleServiceInstance:embedded_images = 3 [db_index = True, null = True, blank = True]; } """ self.example_xproto_item = DynamicLoadItem( filename="exampleservice.xproto", contents=self.example_xproto ) self.example_request = DynamicLoadRequest( name="exampleservice", version="1", xprotos=[self.example_xproto_item], convenience_methods=[], ) self.example_unload_request = DynamicUnloadRequest( name="exampleservice", version="1" ) self.builder = dynamicbuild.DynamicBuilder(base_dir=self.base_dir)
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from django import VERSION as DJANGO_VERSION import os import warnings # Initializing xosconfig module from xosconfig import Config from xosconfig.config import INITIALIZED as CONFIG_INITIALIZED # this really shouldn't be called from settings.py. if not CONFIG_INITIALIZED: Config.init() GEOIP_PATH = "/usr/share/GeoIP" XOS_DIR = Config.get("xos_dir") DEBUG = True TEMPLATE_DEBUG = DEBUG # Enable CORS requests, needed to enable layered XOS CORS_ORIGIN_ALLOW_ALL = True ADMINS = ( # ('Your Name', '*****@*****.**'), ) # LOGIN_REDIRECT_URL = '/admin/core/user'
def setUp(self): global DeferredException self.sys_path_save = sys.path config = os.path.join(test_path, "../test_config.yaml") from xosconfig import Config Config.clear() Config.init(config, 'synchronizer-config-schema.yaml') from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("rcord", "rcord.xproto"), ("onos-service", "onos.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from mock_modelaccessor import MockObjectList from kubernetes_event import KubernetesPodDetailsEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.model_accessor = model_accessor self.event_step = KubernetesPodDetailsEventStep self.onos = ONOSService(name="myonos", id=1111, rest_hostname="onos-url", rest_port="8181", rest_username="******", rest_password="******", backend_code=1, backend_status="succeeded") self.fcservice = VOLTService(name="myoltservice", id=1112, backend_code=1, backend_status="succeeded", provider_services=[self.onos]) self.fcsi1 = VOLTServiceInstance(name="myfcsi1", owner=self.fcservice, backend_code=1, backend_status="succeeded") self.fcsi2 = VOLTServiceInstance(name="myfcsi2", owner=self.fcservice, backend_code=1, backend_status="succeeded") self.fcservice.service_instances = MockObjectList( [self.fcsi1, self.fcsi2]) self.log = Mock()
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"), ("vsg", "vsg.xproto"), ("rcord", "rcord.xproto"),]) import xossynchronizer.modelaccessor reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from pull_olts import OLTDevicePullStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.sync_step = OLTDevicePullStep # mock volt service self.volt_service = Mock() self.volt_service.id = "volt_service_id" self.volt_service.voltha_url = "voltha_url" self.volt_service.voltha_user = "******" self.volt_service.voltha_pass = "******" self.volt_service.voltha_port = 1234 # mock voltha responses self.devices = { "items": [ { "id": "test_id", "type": "simulated_olt", "host_and_port": "172.17.0.1:50060", "admin_state": "ENABLED", "oper_status": "ACTIVE", "serial_number": "serial_number", } ] } self.logical_devices = { "items": [ { "root_device_id": "test_id", "id": "of_id", "datapath_id": "55334486016" } ] } self.ports = { "items": [ { "label": "PON port", "port_no": 1, "type": "PON_OLT", "admin_state": "ENABLED", "oper_status": "ACTIVE" }, { "label": "NNI facing Ethernet port", "port_no": 2, "type": "ETHERNET_NNI", "admin_state": "ENABLED", "oper_status": "ACTIVE" } ] }
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto"), ("onos-service", "onos.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList from kubernetes_event import KubernetesPodDetailsEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = KubernetesPodDetailsEventStep self.onos = ONOSService(name="myonos", id=1111, rest_hostname="onos-url", rest_port="8181", rest_username="******", rest_password="******", backend_code=1, backend_status="succeeded") self.fabric_service = FabricService(name="fabric", id=1112, backend_code=1, backend_status="succeeded", provider_services=[self.onos]) self.switch = Switch(name="switch1", backend_code=1, backend_status="succeeded") self.port1 = SwitchPort(name="switch1port1", switch=self.switch, backend_code=1, backend_status="succeeded") self.port2 = SwitchPort(name="switch1port2", switch=self.switch, backend_code=1, backend_status="succeeded") self.switch.ports = MockObjectList([self.port1, self.port2]) self.log = Mock()
# Copyright 2017-present Open Networking Foundation # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os from xosconfig import Config current_dir = os.path.dirname(os.path.realpath(__file__)) config_file = os.path.join(current_dir, "test_config.yaml") config_schema = os.path.join(current_dir, "../src/xos-tosca-config-schema.yaml") Config.clear() Config.init(config_file, config_schema)
def setUp(self): global DeferredException self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "../test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config(test_path, [("onos-service", "onos.xproto"), ]) import xossynchronizer.modelaccessor import mock_modelaccessor reload(mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor self.model_accessor = model_accessor from mock_modelaccessor import MockObjectList from kubernetes_event import KubernetesPodDetailsEventStep # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.event_step = KubernetesPodDetailsEventStep self.onos = ONOSService(name="myonos", rest_hostname="onos-url", rest_port="8181", rest_username="******", rest_password="******", backend_code=1, backend_status="succeeded") self.attr = ServiceInstanceAttribute( name="foo", value="bar" ) self.mockAllAttr = Mock() self.mockAllAttr.all.return_value = [self.attr] self.app1 = ONOSApp(name="myapp1", owner=self.onos, backend_code=1, backend_status="succeeded", service_instance_attributes=self.mockAllAttr) self.app2 = ONOSApp(name="myapp2", owner=self.onos, backend_code=1, backend_status="succeeded", service_instance_attributes=self.mockAllAttr) self.onos.service_instances = MockObjectList([self.app1, self.app2]) self.log = Mock()
def setUp(self): self.sys_path_save = sys.path # Setting up the config module from xosconfig import Config config = os.path.join(test_path, "test_config.yaml") Config.clear() Config.init(config, "synchronizer-config-schema.yaml") # END Setting up the config module from multistructlog import create_logger self.log = create_logger(Config().get('logging')) from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config mock_modelaccessor_config( test_path, [("ntt-workflow-driver", "ntt-workflow-driver.xproto"), ("olt-service", "volt.xproto"), ("rcord", "rcord.xproto")]) import xossynchronizer.modelaccessor import mock_modelaccessor reload( mock_modelaccessor) # in case nose2 loaded it in a previous test reload(xossynchronizer.modelaccessor ) # in case nose2 loaded it in a previous test from xossynchronizer.modelaccessor import model_accessor from helpers import NttHelpers # import all class names to globals for (k, v) in model_accessor.all_model_classes.items(): globals()[k] = v self.helpers = NttHelpers self.model_accessor = model_accessor self._volt = VOLTService() self._volt.id = 1 self.volt = Service() self.volt.id = 1 self.volt.name = "vOLT" self.volt.leaf_model = self._volt self.pon_port = PONPort() self.pon_port.port_no = 1234 self.onu = ONUDevice() self.onu.pon_port = self.pon_port self.onu.serial_number = "BRCM1234" self.technologyProfile = TechnologyProfile() self.technologyProfile.profile_id = 64 self.technologyProfile.profile_value = '{"profile_type": "EPON","epon_attribute": {"package_type": "A"}}' self.ntt_si = NttWorkflowDriverServiceInstance( serial_number="BRCM1234", owner=self.volt, owner_id=self.volt.id, mac_address="0a0a0a", of_dpid="of:1234") self.whitelist_entry = NttWorkflowDriverWhiteListEntry( mac_address="0a0a0a", owner=self.volt, owner_id=self.volt.id, pon_port_from=1234, pon_port_to=1235, )