/** * Create new ServiceDescriptor based on given as a parameter and limit serviceLocations and generate service globalId * @param candidate * @param queryCriteria * @return */ private ServiceDescriptor modifyServiceDescriptor(final ServiceCandidate candidate, final QueryCriteria queryCriteria) { final ServiceDescriptor origDescriptor = candidate.getServiceInformation().getDescriptor(); final Collection<String> acceptableProtocols = queryCriteria.getAcceptableProtocols(); final ServiceDescriptor modifiedDescriptor = new ServiceDescriptor(); modifiedDescriptor.setServiceId(origDescriptor.getServiceId()); modifiedDescriptor.setType(origDescriptor.getType()); modifiedDescriptor.setVersion(origDescriptor.getVersion()); modifiedDescriptor.setFeatures(origDescriptor.getFeatures()); modifiedDescriptor.setGlobalId(origDescriptor.getGlobalId()); modifiedDescriptor.setServiceLocations(limitServiceLocations(origDescriptor.getServiceLocations(), acceptableProtocols)); modifiedDescriptor.setServicePriority(origDescriptor.getServicePriority()); return modifiedDescriptor; }
@RequestMapping(value="/containers/add", method=RequestMethod.GET) public String addContainerInit(final Model model) throws URISyntaxException { ServiceDescriptor containerDescriptor = new ServiceDescriptor(); containerDescriptor.setType("container"); containerDescriptor.setVersion("1.0.0"); model.addAttribute("containerDescriptor", containerDescriptor); model.addAttribute("availableServiceProtocols", ServiceRegistryConstants.ALL_KNOWN_SERVICE_PROTOCOLS); return "console.platform.container.add"; }
@Override public Boolean call() { String serviceId = serviceDescriptor.getServiceId(); String version = serviceDescriptor.getVersion(); final ServiceDescriptor descriptor = serviceRegistry.lookupService(serviceId, version, "", protocols); return descriptor != null; } });
@Override public ServiceDescriptorProto convertFrom(final ServiceDescriptor serviceDescriptor) { if (serviceDescriptor == null) { return null; } Builder builder = ServiceDescriptorProto.newBuilder(); Collection<Feature> features = transformMap(serviceDescriptor.getFeatures()); builder.addAllFeatures(features); if (serviceDescriptor.getGlobalId() != null) { builder.setGlobalId(serviceDescriptor.getGlobalId()); } builder.setServiceId(serviceDescriptor.getServiceId()); builder.setType(serviceDescriptor.getType()); builder.setVersion(serviceDescriptor.getVersion()); List<ConnectionDescriptor> locations = serviceDescriptor.getServiceLocations(); for (ConnectionDescriptor connectionDescriptor : locations) { ConnectionDescriptorProto connectionDescProto; connectionDescProto = transformConnectionDesc(connectionDescriptor); builder.addLocations(connectionDescProto); } return builder.build(); }
@Override public void markAsInactive(final ServiceDescriptor serviceDescriptor) { logger.info("Registry {} is down.", serviceDescriptor.getServiceId()); descriptorsBlackList.add(serviceDescriptor); registryDescriptors.remove(serviceDescriptor); }
/** * Match connector based on supported protocols. First connection * description for which connector exists will be used. */ @Override public <T> ServiceProxy<T> createConnector(final ServiceDescriptor descriptor, final Class<T> localInterface) { if (descriptor == null) { logger.warn("unable to create connection to service as descriptor is null. "); return null; } final List<ConnectionDescriptor> serviceLocations = descriptor.getServiceLocations(); if (logger.isTraceEnabled()) { logger.trace("checking connections for {}.", descriptor); } if (serviceLocations != null) { for (final ConnectionDescriptor connectionDescriptor : serviceLocations) { for (final ServiceProxyFactory proxyFactory : serviceProxyFactories) { ServiceProxy<T> serviceProxy; serviceProxy = findAndCreateServiceProxy(descriptor, localInterface, connectionDescriptor, proxyFactory); if (serviceProxy != null) { return serviceProxy; } } } } throw new IllegalStateException("It's not possible to find proper connector for service" + descriptor.getServiceId()); }
/** * Checks if given service meet query criteria. * @param serviceGlobalIds * @param containerName */ private boolean checkConditions(final Collection<String> serviceGlobalIds, final ServiceInformation serviceInformation, final QueryCriteria queryCriteria, final String containerName) { final String candidateGlobalId = serviceInformation.getDescriptor().getGlobalId(); final String candidateServiceId = serviceInformation.getDescriptor().getServiceId(); final ServiceState candidateState = serviceInformation.getState(); final boolean correctService = (serviceGlobalIds.contains(candidateGlobalId) || candidateServiceId.equals(queryCriteria.getServiceId())); final boolean alive = candidateState == ServiceState.STARTED; if (correctService && alive) { final Collection<String> acceptableProtocols = queryCriteria.getAcceptableProtocols(); final VersionComparingResult comparingResult = serviceVersionComparator.compareVersions(queryCriteria.getVersion(), serviceInformation.getDescriptor().getVersion()); final boolean correctVersion = comparingResult.isCompatible(); if (correctVersion && haveCommonElement(acceptableProtocols, serviceInformation.getDescriptor(), queryCriteria.getClientName(), containerName)) { return true; } } return false; }
private ConnectionDescriptor getJmsDescriptor(final ServiceDescriptor serviceDescriptor) { final List<ConnectionDescriptor> serviceLocations = serviceDescriptor.getServiceLocations(); for (final ConnectionDescriptor connectionDescriptor : serviceLocations) { if (ServiceRegistryConstants.SERVICE_PROTOCOL_JMS.equals(connectionDescriptor.getProtocol())) { return connectionDescriptor; } } logger.warn("Jms descriptor not found in {}", serviceDescriptor); throw new IllegalStateException("Jms descriptor not found"); }
private ServiceDescriptorList createContainerListObject() { List<ServiceDescriptor> serviceDescriptors = new ArrayList<ServiceDescriptor>(); ServiceDescriptorList descriptorList = new ServiceDescriptorList(); descriptorList.setServiceDescriptors(serviceDescriptors); ServiceDescriptor serviceDescriptor = new ServiceDescriptor(); serviceDescriptors.add(serviceDescriptor); String containerNameToUse; if (containerName == null) { containerNameToUse = "TestContainer"; } else { containerNameToUse = containerName; } serviceDescriptor.setServiceId(containerNameToUse); URI uri = URI.create("rmi://127.0.0.1:"+rmiPort+"/platform-serviceContainer"); ConnectionDescriptor connectionDescriptor= new ConnectionDescriptor(uri, ServiceRegistryConstants.SERVICE_PROTOCOL_RMI, Collections.emptyMap()); serviceDescriptor.setServiceLocations(Collections.singletonList(connectionDescriptor)); return descriptorList; }
@RequestMapping(value="/services/{serviceGlobalId:.+}/edit") public String editService(final Model model, @PathVariable final String serviceGlobalId) { // TODO work on efficiency String containerId = null; String serviceId = null; List<ServiceDescriptor> containers = registryManager.findAllContainers(); for (ServiceDescriptor container : containers) { String cId = container.getServiceId(); List<ServiceInformation> serviceList = registryManager.findAllServicesForContainer(cId); if (serviceList != null) { for (ServiceInformation serviceInformation :serviceList) { if (serviceInformation.getDescriptor().getGlobalId().equals(serviceGlobalId)) { serviceId = serviceInformation.getDescriptor().getServiceId(); containerId = cId; } } } } return UrlBasedViewResolver.REDIRECT_URL_PREFIX + "/containers/" + containerId + "/services/" + serviceId + "/edit"; }
private <T> ServiceProxy<T> findAndCreateServiceProxy(final ServiceDescriptor descriptor, final Class<T> localInterface, final ConnectionDescriptor connectionDescriptor, final ServiceProxyFactory proxyFactory) { final String[] supportedProtocols = proxyFactory.getProtocols(); for (final String proxyProtocol : supportedProtocols) { if (proxyProtocol.equals(connectionDescriptor.getProtocol())) { final String serviceId = descriptor.getServiceId(); if (proxyFactory.isApplicable(connectionDescriptor, localInterface, serviceId)) { if (logger.isTraceEnabled()) { logger.trace("connection will be created by {} using protocol {} ", proxyFactory, proxyProtocol); } return proxyFactory.buildProxy(connectionDescriptor, localInterface, serviceId, descriptor.getFeatures()); } } } return null; }
/** * Creates service descriptor for new service. */ private ServiceDescriptor createServiceDescriptor(final LocalService service, final ServiceDeployment serviceDeployment) { final ServiceDescriptor serviceDescriptor = new ServiceDescriptor(service); serviceDescriptor.setServicePriority(serviceDeployment.getServicePriority()); String bundleId = serviceDeployment.getBundleId(); String serviceDefinitionId = serviceDeployment.getServiceDefinitionId(); SpringContextServiceFactory serviceFactory = serviceFactoryContext.getServiceFactory(bundleId, serviceDefinitionId); if (serviceFactory == null) { throw new ServiceCreationException("Service of definition id '{}' and bundle id '{}' not found in bundle context.", serviceDefinitionId, bundleId); } ServiceDefinition serviceDefinition = serviceFactory.getServiceDefinition(); if (serviceDefinition.isStateful()) { serviceDescriptor.getFeatures().put("stateful", "true"); } deployedServicesData.setServiceDescriptor(service.getServiceId(), serviceDescriptor); return serviceDescriptor; }
private Map<String, List<String>> buildServiceOptionMap(List<String> serviceTypes) { Map<String, List<String>> serviceOptionMap = new HashMap<String, List<String>>(); for (String serviceType : serviceTypes) { serviceOptionMap.put(serviceType, new LinkedList<String>()); } for (ServiceInformation serviceInformation : registryManager.findAllServices()) { if (serviceTypes.contains(serviceInformation.getDescriptor().getType())) { serviceOptionMap.get(serviceInformation.getDescriptor().getType()).add( serviceInformation.getDescriptor().getGlobalId()); } } return serviceOptionMap; }
@SuppressWarnings("unchecked") @Override @ManagedOperation(description="List of all managers for given service") public List<ServiceManagerDescriptor> findServiceManagerDescriptorById(final String serviceGlobalId) { final Collection<String> containersName = context.getAllContainersName(); for (final String containerName : containersName) { final List<ServiceInformation> servicesForContainer = context.getAllServicesForContainer(containerName); for (ServiceInformation serviceInformation : servicesForContainer) { String globalId = serviceInformation.getDescriptor().getGlobalId(); if (globalId != null && globalId.equals(serviceGlobalId)) { return Arrays.asList(serviceInformation.getManagerDescriptors()); } } } return Collections.EMPTY_LIST; }
/** * return service with given list of acceptable protocols */ @Override public <T extends Service> ServiceProxy<T> getService(final String sid, final Class<T> serviceInterface, final String[] protocols) { final String version = getLocalServiceInterfaceVersion(serviceInterface); final ServiceDescriptor descriptor = serviceRegistry.lookupService(sid, version, getContainerName(), protocols); if (descriptor != null) { validateVersion(version, descriptor.getVersion()); } return connectorManager.createConnector(descriptor, serviceInterface); }
@Override public void setServiceDescriptor(final String serviceId, final ServiceDescriptor serviceDescriptor) { serviceDescriptor.setServiceLocations(new ArrayList<ConnectionDescriptor>()); getOrCreateServiceInfo(serviceId).serviceDescriptor = serviceDescriptor; }
private void exportServices(final ServiceDeployment serviceDeployment, final LocalService service, final Class<? extends Service> serviceInterface, final ServiceDescriptor serviceDescriptor) { final Map<String, String> serviceFeatures = Collections.unmodifiableMap(serviceDescriptor.getFeatures()); serviceExportManager.exportAllProtocols(service, serviceInterface, serviceDeployment.getServiceAccesses(), serviceFeatures); }
@Override public int compare(ServiceDescriptor o1, ServiceDescriptor o2) { if (o1 == null) { return Integer.MAX_VALUE; } if (o2 == null) { return Integer.MIN_VALUE; } return o1.getServicePriority() - o2.getServicePriority(); } }
private ServiceDetails transformToServiceDetails(final ServiceInformation serviceInformation) { ServiceDetails serviceDetails = new ServiceDetails(); serviceDetails.setId(serviceInformation.getDescriptor().getServiceId()); serviceDetails.setGlobalId(serviceInformation.getDescriptor().getGlobalId()); serviceDetails.setStatus(serviceInformation.getState().name()); serviceDetails.setVersion(serviceInformation.getDescriptor().getVersion()); serviceDetails.setType(serviceInformation.getDescriptor().getType()); List<String> protocols = new ArrayList<String>(); List<ConnectionDescriptor> serviceLocations = serviceInformation.getDescriptor().getServiceLocations(); if (serviceLocations != null) { for (ConnectionDescriptor connectionDescriptor : serviceLocations) { protocols.add(connectionDescriptor.getProtocol()); } } serviceDetails.setProtocols(protocols); Collection<String> aliases = registryManager.findAllAliasesForService(serviceDetails.getGlobalId()); List<String> serviceDetailsAliases = new ArrayList<String>(); if (aliases != null) { for (String alias : aliases) { serviceDetailsAliases.add(alias); } } serviceDetails.setAliases(serviceDetailsAliases); serviceDetails.setManagersAvailable(ArrayUtils.isNotEmpty(serviceInformation.getManagerDescriptors())); return serviceDetails; }
@Override public void markAsActive(final ServiceDescriptor serviceDescriptor) { logger.info("Registry {} is alive.", serviceDescriptor.getServiceId()); descriptorsBlackList.remove(serviceDescriptor); registryDescriptors.add(serviceDescriptor); }