def _init(self, conf, **kwargs): """Set up the necessary ingredients.""" self.conf = conf self.kwargs = kwargs self.Plan = kwargs.get('plan_class') self.OrderLock = kwargs.get('order_locks') self.OrderLockHistory = kwargs.get('order_locks_history') self.RegionPlaceholders = kwargs.get('region_placeholders') self.CountryLatency = kwargs.get('country_latency') self.TriageTool = kwargs.get('triage_tool') # Set up the RPC service(s) we want to talk to. self.data_service = self.setup_rpc(conf, "data") # Set up the cei and optimizer self.cei = cei.ConstraintEngineInterface(self.data_service) # self.optimizer = optimizer.Optimizer(conf) # Set up Music access. self.music = db_backend.get_client() self.solver_owner_condition = {"solver_owner": socket.gethostname()} self.translated_status_condition = {"status": self.Plan.TRANSLATED} self.solving_status_condition = {"status": self.Plan.SOLVING} if not self.conf.solver.concurrent: self._reset_solving_status()
def plan_prepare(conf): music = db_backend.get_client() music.keyspace_create(keyspace=conf.keyspace) plan_tmp = base.create_dynamic_model(keyspace=conf.keyspace, baseclass=plan.Plan, classname="Plan") return plan_tmp
def setUp(self): # Initialize music API cfg.CONF.set_override('certificate_authority_bundle_file', '../AAF_RootCA.cer', 'music_api') music = db_backend.get_client() cfg.CONF.set_override('keyspace', 'conductor') music.keyspace_create(keyspace=cfg.CONF.keyspace) self.order_lock_svc = OrdersLockingService()
def plan_prepare(conf): cfg.CONF.set_override('certificate_authority_bundle_file', '../AAF_RootCA.cer', 'music_api') music = db_backend.get_client() music.keyspace_create(keyspace=conf.keyspace) plan_tmp = base.create_dynamic_model(keyspace=conf.keyspace, baseclass=plan.Plan, classname="Plan") return plan_tmp
def setUp(self): # Initialize music API music = db_backend.get_client() cfg.CONF.set_override('keyspace', 'conductor') music.keyspace_create(keyspace=cfg.CONF.keyspace) self.sp = SolverRequestParser() c1 = access_dist.AccessDistance(_name = 'c1', _type = 't1', _demand_list = ['d1', 'd2']) c2 = access_dist.AccessDistance(_name = 'c2', _type = 't1', _demand_list = ['d1']) self.sp.constraints = {'c1': c1, 'c2': c2} self.sp.demands = {'d1': demand.Demand('d1'), 'd2': demand.Demand('d2')}
def __init__(self, conf): self.conf = conf # Set up Music access. self.music = db_backend.get_client() self.music.keyspace_create(keyspace=conf.keyspace) # Dynamically create a plan class for the specified keyspace self.Plan = base.create_dynamic_model(keyspace=conf.keyspace, baseclass=plan.Plan, classname="Plan") self.OrderLock = base.create_dynamic_model( keyspace=conf.keyspace, baseclass=order_lock.OrderLock, classname="OrderLock") self.OrderLockHistory = base.create_dynamic_model( keyspace=conf.keyspace, baseclass=order_lock_history.OrderLockHistory, classname="OrderLockHistory") self.RegionPlaceholders = base.create_dynamic_model( keyspace=conf.keyspace, baseclass=region_placeholders.RegionPlaceholders, classname="RegionPlaceholders") self.CountryLatency = base.create_dynamic_model( keyspace=conf.keyspace, baseclass=country_latency.CountryLatency, classname="CountryLatency") self.TriageTool = base.create_dynamic_model( keyspace=conf.keyspace, baseclass=triage_tool.TriageTool, classname="TriageTool") # self.Groups = base.create_dynamic_model( # keyspace=conf.keyspace, baseclass=groups.Groups, classname="Groups") # self.GroupRules = base.create_dynamic_model( # keyspace=conf.keyspace, baseclass=group_rules.GroupRules, classname="GroupRules") # Initialize Prometheus metrics Endpoint # Solver service uses index 1 PC._init_metrics(1) if not self.Plan: raise if not self.OrderLock: raise if not self.OrderLockHistory: raise if not self.RegionPlaceholders: raise if not self.CountryLatency: raise if not self.TriageTool: raise
def getTransactionId(keyspace, plan_id): """get transaction id from a pariticular plan in MUSIC """ rows = db_backend.get_client().row_read(keyspace, "plans", "id", plan_id) if 'result' in rows: rows = rows['result'] for row_id, row_value in rows.items(): template = row_value['template'] if template: data = json.loads(template) if "transaction-id" in data: return data["transaction-id"]
def music_api(configuration): """Create or return a Music API instance""" configuration = dict(configuration) kwargs = { 'host': configuration.get('host'), 'port': configuration.get('port'), 'version': configuration.get('version'), 'replication_factor': configuration.get('replication_factor'), } api_instance = db_backend.get_client(**kwargs) # Create the keyspace if necessary # TODO(jdandrea): Use oslo.config with a [music] section # keyspace = conf.music.get('keyspace') # api_instance.create_keyspace(keyspace) return api_instance
def __init__(self, conf): self.conf = conf # Set up Music access. self.music = db_backend.get_client() self.music.keyspace_create(keyspace=conf.keyspace) # Dynamically create a plan class for the specified keyspace self.Plan = base.create_dynamic_model( keyspace=conf.keyspace, baseclass=plan.Plan, classname="Plan") self.OrderLock = base.create_dynamic_model( keyspace=conf.keyspace, baseclass=order_lock.OrderLock, classname="OrderLock") if not self.Plan: raise if not self.OrderLock: raise self.insert_healthcheck_plan()
def _init(self, conf, **kwargs): """Set up the necessary ingredients.""" self.conf = conf self.kwargs = kwargs self.Plan = kwargs.get('plan_class') self.OrderLock = kwargs.get('order_locks') # Set up the RPC service(s) we want to talk to. self.data_service = self.setup_rpc(conf, "data") # Set up Music access. self.music = db_backend.get_client() # Number of retries for reservation/release self.reservation_retries = self.conf.reservation.reserve_retries if not self.conf.reservation.concurrent: self._reset_reserving_status()
def load_into_country_letancy(self, json_data): datamap = collections.OrderedDict() group_map = collections.OrderedDict() datamap = json.loads(json_data) # for i, j in enumerate(datamap): # group_map[j['group']] = j['countries'] music = db_backend.get_client() # for row in group_map: # music.row_create() kwargs = {'keyspace': 'conductor_inam', 'table': 'country_latency', 'pk_name': 'id'} for row in enumerate(datamap): kwargs['pk_value'] = id(row) kwargs['values'] = {'country_name': row['country_name'], 'groups': row['groups']} music.row_create(**kwargs) print(group_map)
def _init(self, conf, **kwargs): self.conf = conf self.Plan = kwargs.get('plan_class') self.kwargs = kwargs self.opt_schema = load_config_file( str(self.conf.controller.opt_schema_file)) # Set up the RPC service(s) we want to talk to. self.data_service = self.setup_rpc(conf, "data") # Set up Music access. self.music = db_backend.get_client() self.translation_owner_condition = { "translation_owner": socket.gethostname() } self.template_status_condition = {"status": self.Plan.TEMPLATE} self.translating_status_condition = {"status": self.Plan.TRANSLATING} if not self.conf.controller.concurrent: self._reset_template_status()
def get_transport(conf, url=None, optional=False, cache=True): """Initialise the Music messaging layer.""" global TRANSPORTS cache_key = url or DEFAULT_URL transport = TRANSPORTS.get(cache_key) if not transport or not cache: try: # "Somebody set up us the API." ;) # Yes, we know an API is not a transport. Cognitive dissonance FTW! # TODO(jdandrea): try/except to catch problems keyspace = conf.messaging_server.keyspace transport = db_backend.get_client() transport.keyspace_create(keyspace=keyspace) except Exception: if not optional or url: # NOTE(sileht): oslo_messaging is configured but unloadable # so reraise the exception raise return None else: if cache: TRANSPORTS[cache_key] = transport return transport
def __init__(self): music = db_backend.get_client() print("Music version %s" % music.version())
def setUp(self, conf, _requests=None, _begin_time=None): self.music = db_backend.get_client() self.conf = cfg.CONF self.greedy = Greedy(self.conf) self._objective = None
def main(): """Sample usage of Music.""" service.prepare_service() CONF.set_override('debug', True, 'music_api') CONF.set_override('mock', True, 'music_api') CONF.set_override('hostnames', ['music2'], 'music_api') music = db_backend.get_client() print("Music version %s" % music.version()) # Randomize the name so that we don't step on each other. keyspace = 'NewVotingApp' + str(current_time_millis() / 100) music.keyspace_create(keyspace) # Create the table kwargs = { 'keyspace': keyspace, 'table': 'votecount', 'schema': { 'name': 'text', 'count': 'varint', 'PRIMARY KEY': '(name)' } } music.table_create(**kwargs) # Candidate data data = {'Joe': 5, 'Shankar': 7, 'Gueyoung': 8, 'Matti': 2, 'Kaustubh': 0} # Create an entry in the voting table for each candidate # and with a vote count of 0. kwargs = {'keyspace': keyspace, 'table': 'votecount', 'pk_name': 'name'} for name in data: # We only want the keys kwargs['pk_value'] = name kwargs['values'] = {'name': name, 'count': 0} music.row_create(**kwargs) # Update each candidate's count atomically. kwargs = {'keyspace': keyspace, 'table': 'votecount', 'pk_name': 'name'} for name in data: count = data[name] kwargs['pk_value'] = name kwargs['values'] = {'count': count} kwargs['atomic'] = True music.row_update(**kwargs) # Read all rows kwargs = {'keyspace': keyspace, 'table': 'votecount'} print(music.row_read(**kwargs)) # Reads all rows # Delete Joe, read Matti kwargs = {'keyspace': keyspace, 'table': 'votecount', 'pk_name': 'name'} kwargs['pk_value'] = 'Joe' music.row_delete(**kwargs) kwargs['pk_value'] = 'Matti' print(music.row_read(**kwargs)) # Read all rows again kwargs = {'keyspace': keyspace, 'table': 'votecount'} print(music.row_read(**kwargs)) # Reads all rows # Cleanup. music.keyspace_delete(keyspace)
def setUp(self, conf, _requests=None, _begin_time=None): self.music = db_backend.get_client() self.conf = cfg.CONF self.randomPick = RandomPick(self.conf)