Inspect a service

        Args:
            service_id: ID or name of the service

        Returns:
            a dict with info about a service
15718
async def inspect(self, service_id: str) -> Mapping[str, Any]:
        

        response = await self.docker._query_json(
            "services/{service_id}".format(service_id=service_id), method="GET"
        )
        return response
892211
def get_requests_request_id(self, request_id):
        
        route_values = {}
        if request_id is not None:
            route_values['requestId'] = self._serialize.url('request_id', request_id, 'str')
        response = self._send(http_method='GET',
                              location_id='ebc09fe3-1b20-4667-abc5-f2b60fe8de52',
                              version='5.0-preview.1',
                              route_values=route_values)
        return self._deserialize('Request', response)
810530
def GetServiceObj(self,servicename):
        """"""
        for sobj in self.services:
            if sobj.GetName().lower()==servicename.lower():
                return sobj

        return None
1118632
def service(self, *args, **kwargs):
        
        return self._client.service(*args, scope=self.id, **kwargs)
907393
def services(self):
        
        if self._services is None:
            self._services = ServiceList(self)
        return self._services
1193071
def get_service_details(self, service_id):
		""""""
		content = self._fetch("/service/%s/details" % service_id)
		return FastlyService(self, content)
822450
def call_service(self, service_id, action):
        
        result = self.vera_request(id='action', serviceId=service_id,
                                   action=action)
        logger.debug("call_service: "
                  "result of vera_request with id %s: %s", service_id,
                  result.text)
        return result
862442
def get_rtr_name(self, router_id):
        
        try:
            body = {}
            router = self.neutronclient.show_router(router_id, body=body)
            return router.get('router').get('name')
        except Exception as exc:
            LOG.error("Failed to show router interface %(id)s "
                      "Exc %(exc)s", {'id': router_id, 'exc': str(exc)})
563348
def _retrieve_info(self, request):
        
        info = _metadata.get_service_account_info(
            request,
            service_account=self._service_account_email)

        self._service_account_email = info['email']
        self._scopes = info['scopes']
1327320
def get_service_name(self, service_id: str) -> str:
        
        # Raise an exception if we are not a manager
        if not self._manager:
            raise RuntimeError('Only the Swarm manager node can retrieve all'
                               ' the services details.')

        service = self._client.services.get(service_id)
        return service.name
281336
def service(self):
        """"""
        if not self._service:
            self._service = self._client.service(id=self.service_id)
        return self._service
575275
def get_current_service_state(self, service_id: str):
        """"""
        state = self._get_service_state(service_id)
        return state.current_state
347532
def snapshot_details(service_id, snapshot_id)
      return unless service_id && snapshot_id
      res = client.hget(redis_key(service_id), snapshot_id)
      raise ServiceError.new(ServiceError::NOT_FOUND, "snapshot #{snapshot_id}") unless res
      Yajl::Parser.parse(res)
    end
438275
def get_instance_guid(self, service_name):
        
        summary = self.space.get_space_summary()
        for service in summary['services']:
            if service['name'] == service_name:
                return service['guid']

        raise ValueError("No service with name '%s' found." % (service_name))
645149
def list(self, service_name, **params):
        
        result = self._invoke_call(service_name, 'list', **params)
        if result is not None:
            return result.get(service_name, list())
        return list()
228491
async def inspect(self, *, node_id: str) -> Mapping[str, Any]:
        

        response = await self.docker._query_json(
            "nodes/{node_id}".format(node_id=node_id), method="GET"
        )
        return response
1176477
function getServiceNames(serviceUuid, uuid) {
    if (servicesLookup[serviceUuid]) {
      var serviceName = servicesLookup[serviceUuid].name;
      var characteristicName = servicesLookup[serviceUuid].characteristics[uuid].name;      
    }

    var info = serviceUuid;
    if (serviceName) { info += ' (' + serviceName + ')' };
    info +=' -> ' + uuid;
    if (characteristicName) { info += ' (' + characteristicName +' )' }

    return info;
}