def svc_defs(svcs=None, op=None): """Returns service definitions for service name(s) @param svcs name or list of names of service """ from pyon.core.bootstrap import get_service_registry if not getattr(svcs, '__iter__', False) and op is not None: svcdef = get_service_registry().services[svcs] print "Service definition for: %s (version %s) operation %s" % (svcs, svcdef.version or 'ND', op) print "".join([str(o) for o in svcdef.operations if o.name == op]) return svcdef elif svcs is not None: if not getattr(svcs, '__iter__', False): svcs = (svcs,) for svcname in svcs: svcdef = get_service_registry().services[svcname] svcops = "\n ".join(sorted([o.name for o in svcdef.operations])) print "Service definition for: %s (version %s)" % (svcname, svcdef.version or 'ND') print "ops: %s" % (svcops) return svcdef else: print "List of defined services" print "------------------------" for svcname in sorted(get_service_registry().services.keys()): svcdef = get_service_registry().services[svcname] print "%s %s" % (svcname, svcdef.version) print "\nType svc_defs('name') or svc_defs(['name1','name2']) for definition" return None
def _create_service_mock(self, service_name): # set self.clients if not already set clients = Mock(name='clients') base_service = get_service_registry().get_service_base(service_name) # Save it to use in test_verify_service self.base_service = base_service self.addCleanup(delattr, self, 'base_service') dependencies = base_service.dependencies for dep_name in dependencies: dep_service = get_service_registry().get_service_base(dep_name) # Force mock service to use interface mock_service = Mock(name='clients.%s' % dep_name, spec=dep_service) setattr(clients, dep_name, mock_service) # set self.dep_name for conevenience setattr(self, dep_name, mock_service) self.addCleanup(delattr, self, dep_name) iface = list(implementedBy(dep_service))[0] names_and_methods = iface.namesAndDescriptions() for func_name, _ in names_and_methods: mock_func = mocksignature(getattr(dep_service, func_name), mock=Mock(name='clients.%s.%s' % (dep_name, func_name)), skipfirst=True) setattr(mock_service, func_name, mock_func) return clients
def _create_service_mock(self, service_name): # set self.clients if not already set clients = Mock(name='clients') base_service = get_service_registry().get_service_base(service_name) # Save it to use in test_verify_service self.base_service = base_service self.addCleanup(delattr, self, 'base_service') dependencies = base_service.dependencies for dep_name in dependencies: dep_service = get_service_registry().get_service_base(dep_name) # Force mock service to use interface mock_service = Mock(name='clients.%s' % dep_name, spec=dep_service) setattr(clients, dep_name, mock_service) # set self.dep_name for convenience setattr(self, dep_name, mock_service) self.addCleanup(delattr, self, dep_name) iface = list(implementedBy(dep_service))[0] names_and_methods = iface.namesAndDescriptions() for func_name, _ in names_and_methods: mock_func = mocksignature(getattr(dep_service, func_name), mock=Mock(name='clients.%s.%s' % (dep_name, func_name)), skipfirst=True) setattr(mock_service, func_name, mock_func) return clients
def svc_defs(svcs=None, op=None): """Returns service definitions for service name(s) @param svcs name or list of names of service """ from pyon.core.bootstrap import get_service_registry if not getattr(svcs, '__iter__', False) and op is not None: svcdef = get_service_registry().services[svcs] print "Service definition for: %s (version %s) operation %s" % ( svcs, svcdef.version or 'ND', op) print "".join([str(o) for o in svcdef.operations if o.name == op]) return svcdef elif svcs is not None: if not getattr(svcs, '__iter__', False): svcs = (svcs, ) for svcname in svcs: svcdef = get_service_registry().services[svcname] svcops = "\n ".join(sorted([o.name for o in svcdef.operations])) print "Service definition for: %s (version %s)" % ( svcname, svcdef.version or 'ND') print "ops: %s" % (svcops) return svcdef else: print "List of defined services" print "------------------------" for svcname in sorted(get_service_registry().services.keys()): svcdef = get_service_registry().services[svcname] print "%s %s" % (svcname, svcdef.version) print "\nType svc_defs('name') or svc_defs(['name1','name2']) for definition" return None
def on_start(self): rr = self.container.resource_registry name = self.CFG.get("dataset") if name: # We are looking for an external dataset! log.trace("Looking for an external dataset with name %s", name) objects, _ = rr.find_resources(RT.ExternalDataset) filtered_objs = [obj for obj in objects if obj.name == name] if (filtered_objs) == []: raise ConfigNotFound( "No appropriate ExternalDataset objects loaded") external_dataset = filtered_objs[0] instance_id = rr.read_object( subject=external_dataset._id, predicate=PRED.hasAgentInstance, object_type=RT.ExternalDatasetAgentInstance, id_only=True) dams = get_service_registry( ).services['data_acquisition_management'].client(process=self) dams.start_external_dataset_agent_instance(instance_id) client = ResourceAgentClient(external_dataset._id, process=FakeProcess()) else: name = self.CFG.get("instrument") if name: # We are looking for an instrument device! log.trace("Looking for an instrument device with name %s", name) objects, _ = rr.find_resources(RT.InstrumentDevice) filtered_objs = [obj for obj in objects if obj.name == name] if (filtered_objs) == []: raise ConfigNotFound( "No appropriate InstrumentDevice objects loaded") instrument_device = filtered_objs[0] log.trace("Found instrument device: %s", instrument_device) instance_id = rr.read_object( subject=instrument_device._id, predicate=PRED.hasAgentInstance, object_type=RT.ExternalDatasetAgentInstance, id_only=True) dams = get_service_registry( ).services['data_acquisition_management'].client(process=self) proc_id = dams.start_external_dataset_agent_instance(instance_id) client = ResourceAgentClient(instrument_device._id, process=FakeProcess()) else: raise ConfigNotFound( "Could not find dataset or instrument_device value name") log.info('Activating agent...') client.execute_agent( AgentCommand(command=ResourceAgentEvent.INITIALIZE)) client.execute_agent( AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)) client.execute_agent(AgentCommand(command=ResourceAgentEvent.RUN)) client.execute_resource(command=AgentCommand( command=DriverEvent.START_AUTOSAMPLE)) log.info('Now reading: %s', name)
def on_start(self): logger = self.CFG.get("logger") level = self.CFG.get("level") recursive = self.CFG.get("recursive", False) svc = get_service_registry().services['system_management'].client(process=self) svc.set_log_level(logger=logger, level=level, recursive=recursive)
def on_start(self): logger = self.CFG.get("logger") level = self.CFG.get("level") recursive = self.CFG.get("recursive", False) svc = get_service_registry().services['system_management'].client( process=self) svc.set_log_level(logger=logger, level=level, recursive=recursive)
def get_secure_service_def(self, service_name): """Checks whether the service indicated by given service_name exists and/or is exposed after white and black listing. Returns service registry entry. """ if self.service_whitelist: if service_name not in self.service_whitelist: raise Unauthorized("Service access not permitted") if self.service_blacklist: if service_name in self.service_blacklist: raise Unauthorized("Service access not permitted") # Retrieve service definition target_service = get_service_registry().get_service_by_name( service_name) if not target_service: raise BadRequest("The requested service (%s) is not available" % service_name) if not target_service.client: raise Inconsistent( "Cannot find a client class for the specified service: %s" % service_name) if not target_service.schema: raise Inconsistent( "Cannot find a schema for the specified service: %s" % service_name) return target_service
def on_start(self): rr = self.container.resource_registry name = self.CFG.get("dataset") if name: # We are looking for an external dataset! log.trace("Looking for an external dataset with name %s", name) objects,_ = rr.find_resources(RT.ExternalDataset) filtered_objs = [obj for obj in objects if obj.name == name] if (filtered_objs) == []: raise ConfigNotFound("No appropriate ExternalDataset objects loaded") external_dataset = filtered_objs[0] instance_id = rr.read_object(subject=external_dataset._id, predicate=PRED.hasAgentInstance, object_type=RT.ExternalDatasetAgentInstance, id_only=True) dams = get_service_registry().services['data_acquisition_management'].client(process=self) dams.start_external_dataset_agent_instance(instance_id) client = ResourceAgentClient(external_dataset._id, process=FakeProcess()) else: name = self.CFG.get("instrument") if name: # We are looking for an instrument device! log.trace("Looking for an instrument device with name %s", name) objects,_ = rr.find_resources(RT.InstrumentDevice) filtered_objs = [obj for obj in objects if obj.name == name] if (filtered_objs) == []: raise ConfigNotFound("No appropriate InstrumentDevice objects loaded") instrument_device = filtered_objs[0] log.trace("Found instrument device: %s", instrument_device) instance_id = rr.read_object(subject=instrument_device._id, predicate=PRED.hasAgentInstance, object_type=RT.ExternalDatasetAgentInstance, id_only=True) dams = get_service_registry().services['data_acquisition_management'].client(process=self) proc_id = dams.start_external_dataset_agent_instance(instance_id) client = ResourceAgentClient(instrument_device._id, process=FakeProcess()) else: raise ConfigNotFound("Could not find dataset or instrument_device value name") log.info('Activating agent...') client.execute_agent(AgentCommand(command=ResourceAgentEvent.INITIALIZE)) client.execute_agent(AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)) client.execute_agent(AgentCommand(command=ResourceAgentEvent.RUN)) client.execute_resource(command=AgentCommand(command=DriverEvent.START_AUTOSAMPLE)) log.info('Now reading: %s', name)
def _start_service(self, servicename, servicecls=None, config=None): if servicename and not servicecls: global scanned_services if not scanned_services: get_service_registry().discover_service_classes() scanned_services = True assert servicename in get_service_registry().services, "Service %s unknown" % servicename servicecls = get_service_registry().services[servicename].impl[0] assert servicecls, "Cannot start service %s" % servicename if type(servicecls) is str: mod, cls = servicecls.rsplit('.', 1) else: mod = servicecls.__module__ cls = servicecls.__name__ self.container.spawn_process(servicename, mod, cls, config)
def _register_service_definitions(self): from pyon.core.bootstrap import get_service_registry svc_list = [] for svcname, svc in get_service_registry().services.iteritems(): svc_def = ServiceDefinition(name=svcname, definition="") svc_list.append(svc_def) self._create_mult(svc_list) log.info("Created %d ServiceDefinition resources" % len(svc_list))
def _start_service(self, servicename, servicecls=None, config=None): if servicename and not servicecls: global scanned_services if not scanned_services: get_service_registry().discover_service_classes() scanned_services = True assert servicename in get_service_registry( ).services, "Service %s unknown" % servicename servicecls = get_service_registry().services[servicename].impl[0] assert servicecls, "Cannot start service %s" % servicename if type(servicecls) is str: mod, cls = servicecls.rsplit('.', 1) else: mod = servicecls.__module__ cls = servicecls.__name__ self.container.spawn_process(servicename, mod, cls, config)
def _is_policy_management_service_available(self): """ Method to verify if the Policy Management Service is running in the system. If the container cannot connect to the RR then assume it is remote container so do not try to access Policy Management Service """ policy_service = get_service_registry().is_service_available('policy_management', True) if policy_service: return True return False
def _call_target(self, target, value=None, resource_id=None, res_type=None, cmd_args=None, cmd_kwargs=None): """ Makes a call to a specified function. Function specification can be of varying type. """ try: if not target: return None match = re.match( "(func|serviceop):([\w.]+)\s*\(\s*([\w,$\s]*)\s*\)\s*(?:->\s*([\w\.]+))?\s*$", target) if match: func_type, func_name, func_args, res_path = match.groups() func = None if func_type == "func": if func_name.startswith("self."): func = getattr(self, func_name[5:]) else: func = named_any(func_name) elif func_type == "serviceop": svc_name, svc_op = func_name.split('.', 1) try: svc_client_cls = get_service_registry( ).get_service_by_name(svc_name).client except Exception as ex: log.error("No service client found for service: %s", svc_name) else: svc_client = svc_client_cls(process=self) func = getattr(svc_client, svc_op) if not func: return None args = self._get_call_args(func_args, resource_id, res_type, value, cmd_args) kwargs = {} if not cmd_kwargs else cmd_kwargs func_res = func(*args, **kwargs) log.info("Function %s result: %s", func, func_res) if res_path and isinstance(func_res, dict): func_res = get_safe(func_res, res_path, None) return func_res else: log.error("Unknown call target expression: %s", target) except Exception as ex: log.exception("_call_target exception") return None
def _is_policy_management_service_available(self): """ Method to verify if the Policy Management Service is running in the system. If the container cannot connect to the RR then assume it is remote container so do not try to access Policy Management Service """ policy_service = get_service_registry().is_service_available( 'policy_management', True) if policy_service: return True return False
def _ems_available(self): """ Returns True if the EMS is (likely) available and the auto_register CFG entry is True. @TODO: make a property """ if CFG.get_safe('container.exchange.auto_register', False) and self.use_ems: # ok now make sure it's in the directory exchange_service = get_service_registry().is_service_available('exchange_management') if exchange_service: return True return False
def _make_service_request(self, service_name=None, operation=None, id_param=None): """ Executes a secure call to a SciON service operation via messaging. """ if not service_name: if self.develop_mode: # Return a list of available services result = dict( available_services=get_service_registry().services.keys()) return result else: raise BadRequest("Service name missing") service_name = str(service_name) if not operation: if self.develop_mode: # Return a list of available operations result = dict(available_operations=[]) return result else: raise BadRequest("Service operation missing") operation = str(operation) # Apply service white list and black list for initial protection and get service client service_def = self.get_secure_service_def(service_name) target_client = service_def.client # Get service request arguments and operation parameter values request req_args = self._get_request_args() param_list = self.create_parameter_list(service_def, operation, req_args, id_param) # Validate requesting user and expiry and add governance headers ion_actor_id, expiry = self.get_governance_info_from_request(req_args) in_login_whitelist = self.in_login_whitelist("request", service_name, operation) ion_actor_id, expiry = self.validate_request( ion_actor_id, expiry, in_whitelist=in_login_whitelist) param_list["headers"] = self.build_message_headers( ion_actor_id, expiry) # Make service operation call client = target_client(process=self.process) method_call = getattr(client, operation) result = method_call(**param_list) return result
def _call_target(self, target, value=None, resource_id=None, res_type=None, cmd_args=None, cmd_kwargs=None): """ Makes a call to a specified function. Function specification can be of varying type. """ try: if not target: return None match = re.match("(func|serviceop):([\w.]+)\s*\(\s*([\w,$\s]*)\s*\)\s*(?:->\s*([\w\.]+))?\s*$", target) if match: func_type, func_name, func_args, res_path = match.groups() func = None if func_type == "func": if func_name.startswith("self."): func = getattr(self, func_name[5:]) else: func = named_any(func_name) elif func_type == "serviceop": svc_name, svc_op = func_name.split('.', 1) try: svc_client_cls = get_service_registry().get_service_by_name(svc_name).client except Exception as ex: log.error("No service client found for service: %s", svc_name) else: svc_client = svc_client_cls(process=self) func = getattr(svc_client, svc_op) if not func: return None args = self._get_call_args(func_args, resource_id, res_type, value, cmd_args) kwargs = {} if not cmd_kwargs else cmd_kwargs func_res = func(*args, **kwargs) log.info("Function %s result: %s", func, func_res) if res_path and isinstance(func_res, dict): func_res = get_safe(func_res, res_path, None) return func_res else: log.error("Unknown call target expression: %s", target) except Unauthorized as ex: # No need to log as this is not an application error, however, need to pass on the exception because # when called by the Service Gateway, the error message in the exception is required raise ex except Exception as ex: log.exception("_call_target exception") raise ex #Should to pass it back because when called by the Service Gateway, the error message in the exception is required
def _ems_available(self): """ Returns True if the EMS is (likely) available and the auto_register CFG entry is True. @TODO: make a property """ if CFG.get_safe('container.exchange.auto_register', False) and self.use_ems: # ok now make sure it's in the directory exchange_service = get_service_registry().is_service_available( 'exchange_management') if exchange_service: return True return False
def _call_target(self, target, value=None, resource_id=None, res_type=None, cmd_args=None, cmd_kwargs=None): """ Makes a call to a specified function. Function specification can be of varying type. """ try: if not target: return None match = re.match("(func|serviceop):([\w.]+)\s*\(\s*([\w,$\s]*)\s*\)\s*(?:->\s*([\w\.]+))?\s*$", target) if match: func_type, func_name, func_args, res_path = match.groups() func = None if func_type == "func": if func_name.startswith("self."): func = getattr(self, func_name[5:]) else: func = named_any(func_name) elif func_type == "serviceop": svc_name, svc_op = func_name.split(".", 1) try: svc_client_cls = get_service_registry().get_service_by_name(svc_name).client except Exception as ex: log.error("No service client found for service: %s", svc_name) else: svc_client = svc_client_cls(process=self) func = getattr(svc_client, svc_op) if not func: return None args = self._get_call_args(func_args, resource_id, res_type, value, cmd_args) kwargs = {} if not cmd_kwargs else cmd_kwargs func_res = func(*args, **kwargs) log.info("Function %s result: %s", func, func_res) if res_path and isinstance(func_res, dict): func_res = get_safe(func_res, res_path, None) return func_res else: log.error("Unknown call target expression: %s", target) except Exception as ex: log.exception("_call_target exception") return None
def get_remote_info(execution_object, method_name): """ Returns the service client and operation name """ # This is a remote method. rmi_call = method_name.split('.') # Retrieve service definition service_name = rmi_call[0] operation = rmi_call[1] if service_name == 'resource_registry': service_client = execution_object._rr else: target_service = get_service_registry().get_service_by_name(service_name) service_client = target_service.client(node=execution_object.service_provider.container.instance.node, process=execution_object.service_provider) return service_client, operation
def on_start(self): name = self.CFG.get("dataset") rr = self.container.resource_registry objects,_ = rr.find_resources(RT.ExternalDataset) filtered_objs = [obj for obj in objects if obj.name == name] external_dataset = filtered_objs[0] instance_id = rr.read_object(subject=external_dataset._id, predicate=PRED.hasAgentInstance, object_type=RT.ExternalDatasetAgentInstance, id_only=True) dams = get_service_registry().services['data_acquisition_management'].client(process=self) dams.start_external_dataset_agent_instance(instance_id) # OLD METHOD of starting agent, now this code has been implemented and tested in DAMS #obj,_ = rr.find_objects(subject=external_dataset._id, predicate=PRED.hasAgentInstance, object_type=RT.ExternalDatasetAgentInstance) #agent_instance = obj[0] #obj,_ = rr.find_objects(object_type=RT.ExternalDatasetAgent, predicate=PRED.hasAgentDefinition, subject=agent_instance._id) #agent = obj[0] #stream_definition_id = agent_instance.dataset_driver_config['dh_cfg']['stream_def'] #stream_definition = rr.read(stream_definition_id) #data_producer_id = agent_instance.dataset_driver_config['dh_cfg']['data_producer_id'] #data_producer = rr.read(data_producer_id) #subject="", predicate="", object_type="", assoc="", id_only=False) #data_product = rr.read_object(object_type=RT.DataProduct, predicate=PRED.hasOutputProduct, subject=external_dataset._id) #ids,_ = rr.find_objects(data_product._id, PRED.hasStream, RT.Stream, id_only=True) #stream_id = ids[0] #route = pubsub.read_stream_route(stream_id) #agent_instance.dataset_agent_config['driver_config']['dh_cfg']['stream_id'] = stream_id #agent_instance.dataset_agent_config['driver_config']['stream_id'] = stream_id #agent_instance.dataset_agent_config['driver_config']['dh_cfg']['stream_route'] = route # #log.info('launching agent process: %s.%s', agent.handler_module, agent.handler_class) #self.container.spawn_process(name=agent_instance.name, # module=agent.handler_module, cls=agent.handler_class, # config=agent_instance.dataset_agent_config) # # should i wait for process (above) to start # before launching client (below)? # log.info('activating agent...') client = ResourceAgentClient(external_dataset._id, process=FakeProcess()) client.execute_agent(AgentCommand(command=ResourceAgentEvent.INITIALIZE)) client.execute_agent(AgentCommand(command=ResourceAgentEvent.GO_ACTIVE)) client.execute_agent(AgentCommand(command=ResourceAgentEvent.RUN)) client.execute_resource(command=AgentCommand(command=DriverEvent.START_AUTOSAMPLE)) log.info('now reading external dataset: %s', name)
def _make_service_request(self, service_name=None, operation=None, id_param=None): """ Executes a secure call to a SciON service operation via messaging. """ if not service_name: if self.develop_mode: # Return a list of available services result = dict(available_services=get_service_registry().services.keys()) return result else: raise BadRequest("Service name missing") service_name = str(service_name) if not operation: if self.develop_mode: # Return a list of available operations result = dict(available_operations=[]) return result else: raise BadRequest("Service operation missing") operation = str(operation) # Apply service white list and black list for initial protection and get service client service_def = self.get_secure_service_def(service_name) target_client = service_def.client # Get service request arguments and operation parameter values request req_args = self._get_request_args() param_list = self.create_parameter_list(service_def, operation, req_args, id_param) # Validate requesting user and expiry and add governance headers ion_actor_id, expiry = self.get_governance_info_from_request(req_args) in_login_whitelist = self.in_login_whitelist("request", service_name, operation) ion_actor_id, expiry = self.validate_request(ion_actor_id, expiry, in_whitelist=in_login_whitelist) param_list["headers"] = self.build_message_headers(ion_actor_id, expiry) # Make service operation call client = target_client(process=self.process) method_call = getattr(client, operation) result = method_call(**param_list) return result
def _gen_paths(self, service_name): paths = {} sr = get_service_registry() if service_name == ALL_SERVICES: for svc_name in sorted(sr.services_by_name): if svc_name in self.config.get("exclude_services", []): continue svc_schema = sr.services[svc_name].schema # For operations for op_name in svc_schema["op_list"]: self._add_service_op_entries(paths, svc_name, op_name, svc_schema) else: svc_def = sr.services.get(service_name, None) if svc_def: svc_schema = svc_def.schema for op_name in svc_schema["op_list"]: self._add_service_op_entries(paths, service_name, op_name, svc_schema) return paths
def execute_method(self, resource_id, method_name, **kwargs): try: #First look to see if this is a remote method if method_name.find('.') > 0: #This is a remote method. rmi_call = method_name.split('.') #Retrieve service definition service_name = rmi_call[0] operation = rmi_call[1] if service_name == 'resource_registry': service_client = self._rr else: target_service = get_service_registry( ).get_service_by_name(service_name) service_client = target_service.client( node=self.service_provider.container.instance.node, process=self.service_provider) methodToCall = getattr(service_client, operation) param_list = [resource_id] ret = methodToCall(*param_list, **kwargs) return ret else: #For local methods, first look for the method in the current class func = getattr(self, method_name, None) if func: return func(resource_id, **kwargs) else: #Next look to see if the method exists in the service provider process func = getattr(self.service_provider, method_name, None) if func: return func(resource_id, **kwargs) return None except Exception, e: log.error('Error executing method %s for resource id %s: %s' % (method_name, resource_id, str(e))) return None
def get_remote_info(execution_object, method_name): """ Returns the service client and operation name """ # This is a remote method. rmi_call = method_name.split('.') # Retrieve service definition service_name = rmi_call[0] operation = rmi_call[1] if service_name == 'resource_registry': service_client = execution_object._rr else: target_service = get_service_registry().get_service_by_name( service_name) service_client = target_service.client( node=execution_object.service_provider.container.instance.node, process=execution_object.service_provider) return service_client, operation
def execute_method(self, resource_id, method_name, **kwargs): try: #First look to see if this is a remote method if method_name.find('.') > 0: #This is a remote method. rmi_call = method_name.split('.') #Retrieve service definition service_name = rmi_call[0] operation = rmi_call[1] if service_name == 'resource_registry': service_client = self._rr else: target_service = get_service_registry().get_service_by_name(service_name) service_client = target_service.client(node=self.service_provider.container.instance.node, process=self.service_provider) methodToCall = getattr(service_client, operation) param_list = [resource_id] param_dict = self._get_method_arguments(service_client, operation, **kwargs) ret = methodToCall(*param_list, **param_dict ) return ret else: #For local methods, first look for the method in the current class func = getattr(self, method_name, None) if func: param_dict = self._get_method_arguments(self,method_name, **kwargs) return func(resource_id, **param_dict) else: #Next look to see if the method exists in the service provider process func = getattr(self.service_provider, method_name, None) if func: param_dict = self._get_method_arguments(self.service_provider,method_name, **kwargs) return func(resource_id, **param_dict) return None except Exception, e: log.error('Error executing method %s for resource id %s: %s' % (method_name, resource_id, str(e))) return None
def _get_service_queue(self, request): """ """ id = request.resource_id svc_name = request.svc_name svc_queue = None if id: svc_queue = self._service_command_queues.get(id, None) if not svc_queue: if id == 'fake_id': svc_queue = ServiceCommandQueue(id, None, self._result_complete) svc_queue.start() self._service_command_queues[id] = svc_queue else: try: res_client = ResourceAgentClient(id, process=self) except NotFound: res_client = None else: # Create and return a new queue with this client. svc_queue = ServiceCommandQueue( id, res_client, self._result_complete) svc_queue.start() self._service_command_queues[id] = svc_queue elif svc_name: svc_queue = self._service_command_queues.get(svc_name, None) if not svc_queue: svc_cls = get_service_registry().get_service_by_name(svc_name) if svc_cls: svc_client_cls = svc_cls.client svc_client = svc_client_cls(process=self) svc_queue = ServiceCommandQueue(svc_name, svc_client, self._result_complete) svc_queue.start() self._service_command_queues[svc_name] = svc_queue return svc_queue
def get_secure_service_def(self, service_name): """Checks whether the service indicated by given service_name exists and/or is exposed after white and black listing. Returns service registry entry. """ if self.service_whitelist: if service_name not in self.service_whitelist: raise Unauthorized("Service access not permitted") if self.service_blacklist: if service_name in self.service_blacklist: raise Unauthorized("Service access not permitted") # Retrieve service definition target_service = get_service_registry().get_service_by_name(service_name) if not target_service: raise BadRequest("The requested service (%s) is not available" % service_name) if not target_service.client: raise Inconsistent("Cannot find a client class for the specified service: %s" % service_name) if not target_service.schema: raise Inconsistent("Cannot find a schema for the specified service: %s" % service_name) return target_service
def _gen_tags(self, service_name): tags = [] sr = get_service_registry() if service_name == ALL_SERVICES: for svc_name in sorted(sr.services_by_name): if svc_name in self.config.get("exclude_services", []): continue svc_schema = sr.services[svc_name].schema tag_entry = dict(name=svc_name, description=svc_schema["description"]) if self.config.get("externalDocs", {}): tag_entry["externalDocs"] = self.config["externalDocs"] tags.append(tag_entry) else: svc_def = sr.services.get(service_name, None) if svc_def: svc_schema = svc_def.schema tag_entry = dict(name=service_name, description=svc_schema["description"]) if self.config.get("externalDocs", {}): tag_entry["externalDocs"] = self.config["externalDocs"] tags.append(tag_entry) return tags
def _get_service_queue(self, request): """ """ id = request.resource_id svc_name = request.svc_name svc_queue = None if id: svc_queue = self._service_command_queues.get(id, None) if not svc_queue: if id == 'fake_id': svc_queue = ServiceCommandQueue(id, None, self._result_complete) svc_queue.start() self._service_command_queues[id] = svc_queue else: try: res_client = ResourceAgentClient(id, process=self) except NotFound: res_client = None else: # Create and return a new queue with this client. svc_queue = ServiceCommandQueue(id, res_client, self._result_complete) svc_queue.start() self._service_command_queues[id] = svc_queue elif svc_name: svc_queue = self._service_command_queues.get(svc_name, None) if not svc_queue: svc_cls = get_service_registry().get_service_by_name(svc_name) if svc_cls: svc_client_cls = svc_cls.client svc_client = svc_client_cls(process=self) svc_queue = ServiceCommandQueue(svc_name, svc_client, self._result_complete) svc_queue.start() self._service_command_queues[svc_name] = svc_queue return svc_queue
def _start_dependencies(self): """ Starts the services declared in the class or instance variable "service_dependencies" """ self.clients = DotDict() svc_deps = getattr(self, "service_dependencies", {}) log.debug("Starting service dependencies. Number=%s" % len(svc_deps)) if not svc_deps: return for svc in svc_deps: config = None if type(svc) in (tuple, list): config = svc[1] svc = svc[0] # Start the service self._start_service(svc, config=config) # Create a client clcls = get_service_registry().services[svc].simple_client self.clients[svc] = clcls(name=svc, node=self.container.node) log.debug("Service dependencies started")
def process_gateway_request(service_name, operation): try: if not service_name: raise BadRequest("Target service name not found in the URL") #Retrieve service definition from pyon.core.bootstrap import get_service_registry # MM: Note: service_registry can do more now target_service = get_service_registry().get_service_by_name(service_name) if not target_service: raise BadRequest("The requested service (%s) is not available" % service_name) if operation == '': raise BadRequest("Service operation not specified in the URL") #Find the concrete client class for making the RPC calls. if not target_service.client: raise Inconsistent("Cannot find a client class for the specified service: %s" % service_name ) target_client = target_service.client #Retrieve json data from HTTP Post payload json_params = None if request.method == "POST": payload = request.form['payload'] #debug only #payload = '{"serviceRequest": { "serviceName": "resource_registry", "serviceOp": "find_resources", "params": { "restype": "BankAccount", "lcstate": "", "name": "", "id_only": false } } }' json_params = json.loads(payload) if not json_params.has_key('serviceRequest'): raise Inconsistent("The JSON request is missing the 'serviceRequest' key in the request") if not json_params['serviceRequest'].has_key('serviceName'): raise Inconsistent("The JSON request is missing the 'serviceName' key in the request") if not json_params['serviceRequest'].has_key('serviceOp'): raise Inconsistent("The JSON request is missing the 'serviceOp' key in the request") if json_params['serviceRequest']['serviceName'] != target_service.name: raise Inconsistent("Target service name in the JSON request (%s) does not match service name in URL (%s)" % (str(json_params['serviceRequest']['serviceName']), target_service.name ) ) if json_params['serviceRequest']['serviceOp'] != operation: raise Inconsistent("Target service operation in the JSON request (%s) does not match service name in URL (%s)" % ( str(json_params['serviceRequest']['serviceOp']), operation ) ) param_list = create_parameter_list('serviceRequest', service_name, target_client,operation, json_params) #Validate requesting user and expiry and add governance headers ion_actor_id, expiry = get_governance_info_from_request('serviceRequest', json_params) ion_actor_id, expiry = validate_request(ion_actor_id, expiry) param_list['headers'] = build_message_headers(ion_actor_id, expiry) client = target_client(node=Container.instance.node, process=service_gateway_instance) methodToCall = getattr(client, operation) result = methodToCall(**param_list) return gateway_json_response(result) except Exception, e: return build_error_response(e)
def _get_service_client(self, service): return get_service_registry().services[service].client(process=self.process)
def on_start(self): svc = get_service_registry().services['system_management'].client(process=self) svc.perform_action(predicate=AllContainers(), action=ClearStatistics())
def process_gateway_request(service_name, operation): try: if not service_name: raise BadRequest("Target service name not found in the URL") #Ensure there is no unicode service_name = str(service_name) operation = str(operation) #Retrieve service definition from pyon.core.bootstrap import get_service_registry # MM: Note: service_registry can do more now target_service = get_service_registry().get_service_by_name( service_name) if not target_service: raise BadRequest("The requested service (%s) is not available" % service_name) if operation == '': raise BadRequest("Service operation not specified in the URL") #Find the concrete client class for making the RPC calls. if not target_service.client: raise Inconsistent( "Cannot find a client class for the specified service: %s" % service_name) target_client = target_service.client #Retrieve json data from HTTP Post payload json_params = None if request.method == "POST": payload = request.form['payload'] #debug only #payload = '{"serviceRequest": { "serviceName": "resource_registry", "serviceOp": "find_resources", "params": { "restype": "BankAccount", "lcstate": "", "name": "", "id_only": false } } }' json_params = simplejson.loads(str(payload)) if not json_params.has_key('serviceRequest'): raise Inconsistent( "The JSON request is missing the 'serviceRequest' key in the request" ) if not json_params['serviceRequest'].has_key('serviceName'): raise Inconsistent( "The JSON request is missing the 'serviceName' key in the request" ) if not json_params['serviceRequest'].has_key('serviceOp'): raise Inconsistent( "The JSON request is missing the 'serviceOp' key in the request" ) if json_params['serviceRequest'][ 'serviceName'] != target_service.name: raise Inconsistent( "Target service name in the JSON request (%s) does not match service name in URL (%s)" % (str(json_params['serviceRequest']['serviceName']), target_service.name)) if json_params['serviceRequest']['serviceOp'] != operation: raise Inconsistent( "Target service operation in the JSON request (%s) does not match service name in URL (%s)" % (str(json_params['serviceRequest']['serviceOp']), operation)) param_list = create_parameter_list('serviceRequest', service_name, target_client, operation, json_params) #Validate requesting user and expiry and add governance headers ion_actor_id, expiry = get_governance_info_from_request( 'serviceRequest', json_params) ion_actor_id, expiry = validate_request(ion_actor_id, expiry) param_list['headers'] = build_message_headers(ion_actor_id, expiry) client = target_client(node=Container.instance.node, process=service_gateway_instance) methodToCall = getattr(client, operation) result = methodToCall(**param_list) return gateway_json_response(result) except Exception, e: return build_error_response(e)