@Override public void markAsInactive(final ServiceDescriptor serviceDescriptor) { logger.info("Registry {} is down.", serviceDescriptor.getServiceId()); descriptorsBlackList.add(serviceDescriptor); registryDescriptors.remove(serviceDescriptor); }
@Override public void markAsActive(final ServiceDescriptor serviceDescriptor) { logger.info("Registry {} is alive.", serviceDescriptor.getServiceId()); descriptorsBlackList.remove(serviceDescriptor); registryDescriptors.add(serviceDescriptor); }
@Override public void removeContainerFromList(String containerName) { Iterator<ServiceDescriptor> iterator = serviceContainerDescriptions.iterator(); while (iterator.hasNext()) { ServiceDescriptor descriptor = iterator.next(); String candidateName = descriptor.getServiceId(); if (candidateName.equals(containerName)) { iterator.remove(); return; } } throw new IllegalStateException("Container ["+containerName+"] not found"); }
/** * Create global identifier for service. */ private String generateGlobalServiceId(final ServiceDescriptor serviceDescriptor, final String containerName) { final String serviceId = serviceDescriptor.getServiceId(); final String globalServiceId = ServiceIdUtil.globalIdByServiceIdAndContainerName(serviceId, containerName); return globalServiceId; }
@RequestMapping(value = "/statistics/services/last", method = RequestMethod.GET) public String servicesLastStatisticsHandler(Model model) { List<StatisticData> servicesStatistics = new ArrayList<StatisticData>(); for (ServiceDescriptor container : registryManager.findAllContainers()) { ContainerManager containerManager = serviceManagerHelper.findContainerManagerByContainerName(container.getServiceId()); ServiceStatistic[] servicesStatisticsSummary = containerManager.readLastStatisticSummary(); servicesStatistics.addAll(convertServicesStatisticsDataForContainer(servicesStatisticsSummary, container.getServiceId())); } model.addAttribute("statistics", servicesStatistics); model.addAttribute("statisticsType", "last"); return "statistics.services.last"; }
@RequestMapping(value = { "/statistics/services", "/statistics/services/global" }, method = RequestMethod.GET) public String servicesGlobalStatisticsHandler(Model model) { List<StatisticData> servicesStatistics = new ArrayList<StatisticData>(); for (ServiceDescriptor container : registryManager.findAllContainers()) { try { ContainerManager containerManager = serviceManagerHelper.findContainerManagerByContainerName(container.getServiceId()); ServiceStatistic[] servicesStatisticsSummary = containerManager.readGlobalStatisticSummary(); servicesStatistics.addAll(convertServicesStatisticsDataForContainer(servicesStatisticsSummary, container.getServiceId())); } catch (Exception e) { logger.warn("Exception while retrieving statistics", e); } } model.addAttribute("statistics", servicesStatistics); model.addAttribute("statisticsType", "global"); return "statistics.services.global"; }
@Override protected void onResourceLoaded(ServiceDescriptorList descriptorList) { logger.trace("Registry list has {} elements", descriptorList.getServiceDescriptors().size()); modifiableHolder.removeAllDescriptors(); for (final ServiceDescriptor descriptor : descriptorList.getServiceDescriptors()) { modifiableHolder.addNewDescriptor(descriptor); logger.trace("new descriptor {} added to registry list.", descriptor.getServiceId()); } }
@Override public Boolean call() { String serviceId = serviceDescriptor.getServiceId(); String version = serviceDescriptor.getVersion(); final ServiceDescriptor descriptor = serviceRegistry.lookupService(serviceId, version, "", protocols); return descriptor != null; } });
@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 static void printServicesDeploymentDetails(ServiceManagerHelper serviceManagerHelper, List<ServiceInformation> services, ContainerManager containerManager) { for (ServiceInformation serviceInformation : services) { String serviceId = serviceInformation.getDescriptor().getServiceId(); ServiceDeployment serviceDeployment = containerManager.getServiceDeploymentByServiceId(serviceId); logger.info("ServiceDeployment for {}:{}", serviceId, serviceDeployment); ServiceDefinition serviceDefinition = containerManager.getServiceDefinitionByServiceId(serviceId); logger.info("ServiceDefinition for {}:{}", serviceId, serviceDefinition); logger.info("ServiceManagers for {}:{}", serviceId, serviceInformation.getManagerDescriptors()); printManagersDetails(serviceInformation, serviceManagerHelper); } }
private ContainerDetails transformToContainerDetails(final ServiceDescriptor containerDescriptor) { ContainerDetails containerDetails = new ContainerDetails(); containerDetails.setName(containerDescriptor.getServiceId()); List<String> locations = new ArrayList<String>(); List<ConnectionDescriptor> serviceLocations = containerDescriptor.getServiceLocations(); if (serviceLocations != null) { for (ConnectionDescriptor connectionDescriptor : serviceLocations) { locations.add(connectionDescriptor.getLocation().toString()); } } containerDetails.setAddress(locations); return containerDetails; }
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; }
ContainerStatisticData statisticData = new ContainerStatisticData(); statisticData.setContainerName(container.getServiceId()); try { AttributeDetails loadAttribute = platformManagmentService.getServiceManagerAttribute(container.getServiceId(), STATISTIC_CONTAINER_MANAGER_TYPE, STATISTIC_CONTAINER_LOAD_ATTRIBUTE); AttributeDetails freeAttribute = platformManagmentService.getServiceManagerAttribute(container.getServiceId(), STATISTIC_CONTAINER_MANAGER_TYPE, STATISTIC_CONTAINER_FREE_MEMORY_ATTRIBUTE); AttributeDetails totalAttribute = platformManagmentService.getServiceManagerAttribute(container.getServiceId(), STATISTIC_CONTAINER_MANAGER_TYPE, STATISTIC_CONTAINER_TOTAL_MEMORY_ATTRIBUTE);
public void waitForServiceInRegistry(final String serviceId) { List<ServiceInformation> serviceInformations = getServiceContainer().getContainerInformation().getServiceInformations(); for (ServiceInformation serviceInformation : serviceInformations) { ServiceDescriptor serviceDescriptor = serviceInformation.getDescriptor(); if (serviceDescriptor.getServiceId().equals(serviceId)) { waitForServiceInRegistry(serviceDescriptor); } } }
@Override public void destroy() throws Exception { final List<ServiceDescriptor> allServiceDescriptors = getAllServiceDescriptor(); Comparator<ServiceDescriptor> comparator = new DestroyOrderComparator(); Collections.sort(allServiceDescriptors, comparator); for (final ServiceDescriptor descriptor : allServiceDescriptors) { String serviceId = descriptor.getServiceId(); if(deployedServicesData.isServiceDeployed(serviceId)){ SpringContextServiceReference reference = deployedServicesData.getServiceReferenceById(serviceId); reference.destroy(); } } }
public void undeployAllNonLocalServices() { ServiceContainer serviceContainer = getServiceContainer(); List<ServiceInformation> services = serviceContainer.getContainerInformation().getServiceInformations(); if (services != null) { for (ServiceInformation serviceInformation : services) { getContainerManager().undeployService(serviceInformation.getDescriptor().getServiceId()); } } }
public static void main(String[] args) { DropResourceClient dropResourceClient = new DropResourceClient(); ContainerManager containerManager = dropResourceClient.getContainerManager(); ServiceContainer serviceContainer = dropResourceClient.getServiceContainer(); List<ServiceInformation> serviceInformations = serviceContainer.getContainerInformation().getServiceInformations(); if (serviceInformations != null) { for (ServiceInformation serviceInformation : serviceInformations) { ServiceDescriptor serviceDescriptor = serviceInformation.getDescriptor(); String serviceId = serviceDescriptor.getServiceId(); logger.info("Droping resource for {}", serviceId); try { containerManager.manageResource(serviceId, ResourceAction.INITIALIZE); containerManager.manageResource(serviceId, ResourceAction.DROP); } catch (Exception e) { logger.error("Error while dropping resource [{}] ", serviceId, e); } } } } }
/** * 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; }
@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(); }
/** * 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; }