private void waitForExecution(final Object result) throws ExecutionException, InterruptedException { if(result instanceof Future) { ((Future) result).get(); } else { LOGGER.warn("Service["+serviceDescription.getType()+"] implementation of "+unit+" does not provide feedback about triggered operation! Just continue without feedback..."); } }
private synchronized void updateFieldsToKeep() { if(serviceTempus == ServiceTempus.UNKNOWN) { return; } fieldsToKeep.clear(); Set<ServiceType> serviceTypeSet = new HashSet<>(); for (ServiceDescription serviceDescription : unitTemplate.getServiceDescriptionList()) { if (!serviceTypeSet.contains(serviceDescription.getType())) { serviceTypeSet.add(serviceDescription.getType()); fieldsToKeep.add(Services.getServiceFieldName(serviceDescription.getType(), serviceTempus)); } } }
public static boolean verifyServiceCompatibility(final UnitConfig unitConfig, final ServiceType serviceType) { return unitConfig.getServiceConfigList().stream().anyMatch((serviceConfig) -> (serviceConfig.getServiceDescription().getType() == serviceType)); }
public ConnectionItemEntry(final UnitConfig connectionUnitConfig, final ServiceDescription serviceDescription) throws org.openbase.jul.exception.InstantiationException, InterruptedException { super(connectionUnitConfig, null); try { this.itemId = generateItemId(connectionUnitConfig, serviceDescription.getType()); this.icon = ""; this.commandType = getDefaultCommand(serviceDescription.getType()); this.label = connectionUnitConfig.getLabel(); this.itemHardwareConfig = "rsb=\"" + LOCATION_RSB_BINDING_CONFIG + ":" + connectionUnitConfig.getId() + "\""; groups.add(ItemIdGenerator.generateUnitGroupID(UnitType.CONNECTION)); groups.add(ItemIdGenerator.generateUnitGroupID(connectionUnitConfig.getPlacementConfig().getLocationId())); calculateGaps(); } catch (CouldNotPerformException ex) { throw new org.openbase.jul.exception.InstantiationException(this, ex); } }
private static boolean hasPowerStateService(UnitConfig config) throws InterruptedException { for (ServiceConfig sc : config.getServiceConfigList()) { ServiceTemplate.ServiceType type; try { type = getUnitRegistry().getServiceTemplateById(sc.getServiceDescription().getServiceTemplateId()).getType(); } catch (CouldNotPerformException ex) { type = sc.getServiceDescription().getType(); } if (ServiceTemplate.ServiceType.POWER_STATE_SERVICE == type && ServiceTemplate.ServicePattern.OPERATION == sc.getServiceDescription().getPattern()) { return true; } } return false; }
private boolean unitConfigContainsServiceDescription(UnitConfig.Builder unitConfig, ServiceDescription serviceDescription) { return unitConfig.getServiceConfigList().stream().map((serviceConfig) -> serviceConfig.getServiceDescription()).anyMatch((description) -> (description.getType() == serviceDescription.getType() && description.getPattern() == serviceDescription.getPattern())); }
/** * Method returns a set of all currently available service types of this unit instance. * * @return a set of {@code ServiceTypes}. * @throws NotAvailableException is thrown if the service types can not be detected. */ public Set<ServiceType> getAvailableServiceTypes() throws NotAvailableException { // todo: move this method to the unit interface or at least to the MultiUnitServiceFusion interface shared by the location and group units. final Set<ServiceType> serviceTypeList = new HashSet<>(); for (final ServiceDescription serviceDescription : getTemplate(true).getServiceDescriptionList()) { serviceTypeList.add(serviceDescription.getType()); } return serviceTypeList; }
public static Method detectServiceMethod(final ServiceDescription description, final ServiceTempus serviceTempus, final Class instanceClass, final Class... argumentClasses) throws CouldNotPerformException { return detectServiceMethod(description.getType(), description.getPattern(), serviceTempus, instanceClass, argumentClasses); }
private boolean serviceDescriptionListContainsDescription(List<ServiceDescription> serviceDescriptionList, ServiceDescription serviceDescription) { return serviceDescriptionList.stream().anyMatch((description) -> (description.getType() == serviceDescription.getType() && description.getPattern() == serviceDescription.getPattern())); }
@Override default public Set<ServiceTemplateType.ServiceTemplate.ServiceType> getSupportedServiceTypes() throws NotAvailableException, InterruptedException { final Set<ServiceTemplateType.ServiceTemplate.ServiceType> serviceTypeSet = new HashSet<>(); try { for (final ServiceDescription serviceDescription : getConfig().getUnitGroupConfig().getServiceDescriptionList()) { serviceTypeSet.add(serviceDescription.getType()); } } catch (CouldNotPerformException ex) { throw new NotAvailableException("SupportedServiceTypes", new CouldNotPerformException("Could not generate supported service type list!", ex)); } return serviceTypeSet; } }
@Override public List<ServiceConfigType.ServiceConfig> getServiceConfigs(final ServiceTemplateType.ServiceTemplate.ServiceType serviceType) throws CouldNotPerformException { validateData(); List<ServiceConfigType.ServiceConfig> serviceConfigs = new ArrayList<>(); for (UnitConfig unitConfig : getUnitConfigs()) { for (ServiceConfigType.ServiceConfig serviceConfig : unitConfig.getServiceConfigList()) { if (serviceConfig.getServiceDescription().getType() == serviceType) { serviceConfigs.add(serviceConfig); } } } return serviceConfigs; }
private boolean unitHasServiceAsOperationService(UnitConfig unitConfig, ServiceType serviceType) { return unitConfig.getServiceConfigList().stream().anyMatch((tmpServiceConfig) -> (tmpServiceConfig.getServiceDescription().getType() == serviceType && tmpServiceConfig.getServiceDescription().getPattern() == ServiceTemplate.ServicePattern.OPERATION)); } }
@Override default Set<ServiceType> getSupportedServiceTypes() throws NotAvailableException, InterruptedException { final Set<ServiceTemplate.ServiceType> serviceTypeSet = new HashSet<>(); try { for (final ServiceConfig serviceConfig : getConfig().getServiceConfigList()) { serviceTypeSet.add(serviceConfig.getServiceDescription().getType()); } } catch (CouldNotPerformException ex) { throw new NotAvailableException("SupportedServiceTypes", new CouldNotPerformException("Could not generate supported service type list!", ex)); } return serviceTypeSet; }
private static List<UnitTemplateConfig> getUnitTemplateConfigs(List<UnitTemplate.UnitType> unitTypes) throws CouldNotPerformException { List<UnitTemplateConfig> unitTemplateConfigs = new ArrayList<>(); for (UnitTemplate.UnitType type : unitTypes) { Set<ServiceTemplateConfig> serviceTemplateConfigs = new HashSet<>(); for (ServiceDescription serviceDescription : MockUnitTemplate.getTemplate(type).getServiceDescriptionList()) { serviceTemplateConfigs.add(ServiceTemplateConfig.newBuilder().setServiceType(serviceDescription.getType()).build()); } UnitTemplateConfig config = UnitTemplateConfig.newBuilder().setType(type).addAllServiceTemplateConfig(serviceTemplateConfigs).build(); unitTemplateConfigs.add(config); } return unitTemplateConfigs; }
default long getLatestTransactionId() throws CouldNotPerformException { long latestTransactionId = -1; for (ServiceDescription serviceDescription : getUnitTemplate().getServiceDescriptionList()) { if (serviceDescription.getPattern() != ServicePattern.OPERATION) { continue; } latestTransactionId = Math.max(latestTransactionId, getTransactionIdByServiceType(serviceDescription.getType())); } if (latestTransactionId == -1) { throw new NotAvailableException("transaction id"); } return latestTransactionId; }
private ServiceConfig loadServiceConfig() throws CouldNotPerformException { for (final ServiceConfig serviceConfig : ((Unit<?>) unit).getConfig().getServiceConfigList()) { if (serviceConfig.getServiceDescription().getType().equals(serviceType)) { return serviceConfig; } } throw new CouldNotPerformException("Could not detect service config! Service[" + serviceType.name() + "] is not configured in Unit[" + ((Unit) unit).getId() + "]!"); }
private boolean hasOperationServiceForType(ServiceType serviceType) throws NotAvailableException { for (ServiceDescription serviceDescription : getUnitTemplate().getServiceDescriptionList()) { if (serviceDescription.getType() == serviceType && serviceDescription.getPattern() == OPERATION) { return true; } } return false; }
private boolean checkAlreadyAvailableThrougOtherComponents(final UnitConfig unitConfig, final ServiceConfig serviceConfig) { // skip if function is already available through other components if (unitConfig.getType() == UnitType.COLORABLE_LIGHT && serviceConfig.getServiceDescription().getType() == ServiceType.BRIGHTNESS_STATE_SERVICE) { return true; } return false; }
public String getServiceName() { for (ServiceConfig serviceConfig : serviceConfigs) { if (serviceConfig != null) { return serviceConfig.getServiceDescription().getType().name(); } } return "---"; }
private void setRequestedState() throws CouldNotPerformException { try (ClosableDataBuilder dataBuilder = unit.getDataBuilder(this)) { // set the responsible action for the service attribute Message.Builder serviceStateBuilder = serviceAttribute.toBuilder(); Descriptors.FieldDescriptor fieldDescriptor = ProtoBufFieldProcessor.getFieldDescriptor(serviceStateBuilder, Service.RESPONSIBLE_ACTION_FIELD_NAME); serviceStateBuilder.setField(fieldDescriptor, actionDescriptionBuilder.build()); // set the updated service attribute as requested state in the unit data builder Services.invokeServiceMethod(serviceDescription.getType(), serviceDescription.getPattern(), ServiceTempus.REQUESTED, dataBuilder.getInternalBuilder(), serviceStateBuilder); } }