How to use

getProtocol

method

in

pl.edu.icm.synat.api.services.registry.model.ConnectionDescriptor

/**
 * Create new list of ConnectionDescriptor for those protocols which exists in both: given service list and acceptable protocols.
 */
private List<ConnectionDescriptor> limitServiceLocations(final List<ConnectionDescriptor> serviceLocations,
    final Collection<String> acceptableProtocols) {
  
  final List<ConnectionDescriptor> limitedConnections = new ArrayList<ConnectionDescriptor>();
  
  for (String protocol : acceptableProtocols) {
    for (final ConnectionDescriptor connectionDescriptor : serviceLocations) {
      if (protocol.equals(connectionDescriptor.getProtocol())) {
        limitedConnections.add(connectionDescriptor);
      }
    }
  }
  return limitedConnections;
}

private ConnectionDescriptorProto transformConnectionDesc(final ConnectionDescriptor connectionDescriptor) {
  pl.edu.icm.synat.api.services.registry.model.protobuf.ServicesModel.ConnectionDescriptorProto.Builder builder;
  builder = ConnectionDescriptorProto.newBuilder();
  builder.addAllFeatures(transformMap(connectionDescriptor.getProtocolFeatures()));
  if (connectionDescriptor.getLocation() != null) {
    builder.setLocation(connectionDescriptor.getLocation().toString());
  }
  builder.setProtocol(connectionDescriptor.getProtocol());
  return builder.build();
}

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 boolean haveCommonElement(final Collection<String> acceptableProtocols, final ServiceDescriptor descriptor, final String clientName, final String containerName) {
  for (final ConnectionDescriptor connectionDescriptor : descriptor.getServiceLocations()) {
    final String protocol = connectionDescriptor.getProtocol();
    if (acceptableProtocols.contains(protocol)) {
      if (ServiceRegistryConstants.SERVICE_PROTOCOL_LOCAL.equals(protocol)) {
        if (clientName != null && clientName.equals(containerName)) {
          return true;
        }
      } else {
        return true;
      }
    }
  }
  return false;
}

private ConnectionDescriptor findLocation(ServiceManagerDescriptor managerDescriptor) {
  List<ConnectionDescriptor> locations = managerDescriptor.getServiceLocations();
  for (ConnectionDescriptor connectionDescriptor : locations) {
    String protocol = connectionDescriptor.getProtocol();
    if ("jmx".equals(protocol)) {
      return connectionDescriptor;
    }
  }
  
  throw new GeneralServiceException("Unable to find jmx connectionDescriptor in manager descriptor {}", managerDescriptor);
}

@RequestMapping(value="/containers/add", method=RequestMethod.POST)
public String addContainer(final Model model, @ModelAttribute("containerDescriptor") ServiceDescriptor containerDescriptor, BindingResult result) {
  
  containerDescriptorValidator.validate(containerDescriptor, result);
  if (result.hasErrors()) {
    model.addAttribute("availableServiceProtocols", ServiceRegistryConstants.ALL_KNOWN_SERVICE_PROTOCOLS);
    return "console.platform.container.add";
  }
  ListIterator<ConnectionDescriptor> it = containerDescriptor.getServiceLocations().listIterator();
  while (it.hasNext()) {
    ConnectionDescriptor conn = it.next();
    if (conn.getLocation() == null || conn.getProtocol() == null) {
      it.remove();
    }
  }
  registryManager.addContainer(containerDescriptor);
  return UrlBasedViewResolver.REDIRECT_URL_PREFIX + "/containers";
}

@Override
public void addNewConnectionDeploymentResult(final String serviceId,
    final InternalConnectionDeploymentResult connectionDeploymentResult) {
  
  final String protocol = connectionDeploymentResult.getConnectionDescriptor().getProtocol();
  
  final ServiceInfo sericeInfo = getOrThrowServiceInfo(serviceId);
  sericeInfo.exportedProtocols.put(protocol , connectionDeploymentResult);
  sericeInfo.serviceDescriptor.getServiceLocations().add(connectionDeploymentResult.getConnectionDescriptor());
}

  private void processManagerDescriptor(ServiceManagerDescriptor managerDescriptor) throws MalformedURLException, URISyntaxException {
    for (ConnectionDescriptor descriptor : managerDescriptor.getServiceLocations()) {
      if ("jmx".equals(descriptor.getProtocol())) {
        URI oldLocationUri = descriptor.getLocation();
        URI newLocationUri = processJmxURI(oldLocationUri);
        descriptor.setLocation(newLocationUri);
      } else {
        descriptor.setLocation(
            new URIBuilder(descriptor.getLocation()).setPort(descriptor.getLocation().getPort() + portShift).build());
      }
    }
  }
}

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;
}

public void waitForServiceInRegistry(final ServiceDescriptor serviceDescriptor) {
  final ServiceRegistry serviceRegistry = getServiceRegistry();
  List<ConnectionDescriptor> locations = serviceDescriptor.getServiceLocations();
  if (locations == null || locations.isEmpty()) {
    return;
  }
  final String[] protocols = new String[locations.size()];
  int i = 0;
  for (ConnectionDescriptor connection : locations) {
    String protocol = connection.getProtocol();
    protocols[i++] = protocol;
  }
  try {
    await().pollDelay(1, TimeUnit.SECONDS).atMost(20, TimeUnit.SECONDS).pollInterval(1, TimeUnit.SECONDS).until(new Callable<Boolean>() {
      @Override
      public Boolean call() {
        String serviceId = serviceDescriptor.getServiceId();
        String version = serviceDescriptor.getVersion();
        final ServiceDescriptor descriptor = serviceRegistry.lookupService(serviceId, version, "", protocols);
        return descriptor != null;
      }
    });
  } catch (Exception e) {
    logger.warn("Exception while waiting for service be visible by registry", e);
  }
}

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;
}