@Override public EndpointSpecificConfigurationDto toDto() { EndpointSpecificConfigurationDto dto = new EndpointSpecificConfigurationDto(); dto.setEndpointKeyHash(this.getEndpointKeyHash()); dto.setConfiguration(this.getConfiguration()); dto.setConfigurationSchemaVersion(this.getConfigurationVersion()); dto.setVersion(this.getVersion()); return dto; }
/** * All-args constructor. */ public MongoEndpointSpecificConfiguration(EndpointSpecificConfigurationDto dto) { this.endpointKeyHash = dto.getEndpointKeyHash(); this.configurationVersion = dto.getConfigurationSchemaVersion(); this.configuration = dto.getConfiguration(); this.version = dto.getVersion(); generateId(); }
private void validateEndpointSpecificConfiguration(EndpointSpecificConfigurationDto configurationDto, String appId) { validateString(configurationDto.getConfiguration(), "Endpoint specific configuration body is required"); int configurationVersion = configurationDto.getConfigurationSchemaVersion(); String configurationBody = configurationDto.getConfiguration(); configurationBody = configurationService.normalizeAccordingToOverrideConfigurationSchema(appId, configurationVersion, configurationBody); configurationDto.setConfiguration(configurationBody); }
@Override public EndpointSpecificConfigurationDto save(EndpointSpecificConfigurationDto configurationDto) { EndpointProfileDto profileDto = getEndpointProfileDto(configurationDto.getEndpointKeyHash()); if (configurationDto.getConfigurationSchemaVersion() == null) { configurationDto.setConfigurationSchemaVersion(profileDto.getConfigurationVersion()); } validateEndpointSpecificConfiguration(configurationDto, profileDto.getApplicationId()); return endpointSpecificConfigurationDao.save(configurationDto).toDto(); }
@Override public EndpointSpecificConfiguration save(EndpointSpecificConfigurationDto dto) { LOG.debug("Saving endpoint specific configuration {}", dto); CassandraEndpointSpecificConfiguration configuration = findByEndpointKeyHashAndConfigurationVersion(dto.getEndpointKeyHash(), dto.getConfigurationSchemaVersion()); if (configuration != null) { dto.setVersion(configuration.getVersion()); } configuration = save(new CassandraEndpointSpecificConfiguration(dto)); if (LOG.isTraceEnabled()) { LOG.trace("Saved: {}", configuration); } else { LOG.debug("Saved: {}", configuration != null); } return configuration; }
protected EndpointSpecificConfigurationDto generateEpsConfigurationDto(byte[] endpointKeyHash, Integer configurationVersion, String configuration, Long version) { EndpointSpecificConfigurationDto dto = new EndpointSpecificConfigurationDto(endpointKeyHash, configurationVersion, configuration, version); return endpointSpecificConfigurationDao.save(dto).toDto(); } }
@Test public void testShouldFindActiveConfigurationByEndpointKeyHash() { EndpointSpecificConfigurationDto dto = new EndpointSpecificConfigurationDto(); dto.setConfigurationSchemaVersion(CONF_VERSION); when(endpointServiceMock.findEndpointProfileByKeyHash(KEY)).thenReturn(generateProfile()); when(daoMock.findByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION)).thenReturn(configuration); when(configuration.toDto()).thenReturn(dto); Assert.assertTrue(SERVICE.findActiveConfigurationByEndpointKeyHash(KEY).isPresent()); verify(endpointServiceMock).findEndpointProfileByKeyHash(KEY); verify(daoMock).findByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION); }
private void sendEndpointConfigurationRefreshMessage(EndpointSpecificConfigurationDto configuration) { byte[] endpointKeyHashBytes = configuration.getEndpointKeyHash(); EndpointProfileDto endpointProfile = endpointService.findEndpointProfileByKeyHash(endpointKeyHashBytes); if (!configuration.getConfigurationSchemaVersion().equals(endpointProfile.getConfigurationVersion())) { return; } checkNeighbors(); String endpointKeyHash = Base64Util.encode(configuration.getEndpointKeyHash()); ApplicationDto appDto = applicationService.findAppById(endpointProfile.getApplicationId()); OperationsNodeInfo server = resolve(endpointKeyHash); if (server != null) { ThriftEndpointConfigurationRefreshMessage msg = new ThriftEndpointConfigurationRefreshMessage(); msg.setAddress(new ThriftEntityAddress(appDto.getTenantId(), appDto.getApplicationToken(), ThriftClusterEntityType.ENDPOINT, ByteBuffer.wrap(endpointKeyHashBytes))); msg.setActorClassifier(ThriftActorClassifier.GLOBAL); if (LOG.isTraceEnabled()) { LOG.trace("Sending message {} to [{}]", msg, Neighbors.getServerId(server.getConnectionInfo())); } neighbors.sendMessage(server.getConnectionInfo(), OperationsServiceMsg.fromEndpointConfigurationRefresh(msg)); } else { LOG.warn("Can't find server for endpoint [{}]", endpointKeyHash); } }
@Override public Optional<EndpointSpecificConfigurationDto> deleteActiveConfigurationByEndpointKeyHash(byte[] endpointKeyHash) { Optional<EndpointSpecificConfigurationDto> configuration = findActiveConfigurationByEndpointKeyHash(endpointKeyHash); if (configuration.isPresent()) { int confSchemaVersion = configuration.get().getConfigurationSchemaVersion(); endpointSpecificConfigurationDao.removeByEndpointKeyHashAndConfigurationVersion(endpointKeyHash, confSchemaVersion); } return configuration; }
@Override public byte[] fetchEndpointSpecificConfigurationHash(EndpointProfileDto profile) { Optional<EndpointSpecificConfigurationDto> configuration = endpointSpecificConfigurationService.findActiveConfigurationByEndpointProfile(profile); return configuration.filter(conf -> conf.getConfiguration() != null) .map(dto -> EndpointObjectHash.fromString(dto.getConfiguration()).getData()).orElse(null); }
@Override public EndpointSpecificConfigurationDto editEndpointSpecificConfiguration(EndpointSpecificConfigurationDto configuration) throws KaaAdminServiceException { checkAuthority(KaaAuthorityDto.TENANT_DEVELOPER, KaaAuthorityDto.TENANT_USER); try { checkEndpointProfile(configuration.getEndpointKeyHash()); return controlService.editEndpointSpecificConfiguration(configuration); } catch (Exception ex) { throw Utils.handleException(ex); } }
@Override public EndpointSpecificConfiguration save(EndpointSpecificConfigurationDto dto) { LOG.debug("Saving endpoint specific configuration {}", dto); MongoEndpointSpecificConfiguration configuration = (MongoEndpointSpecificConfiguration) findByEndpointKeyHashAndConfigurationVersion(dto.getEndpointKeyHash(), dto.getConfigurationSchemaVersion()); if (configuration != null) { dto.setVersion(configuration.getVersion()); } configuration = save(new MongoEndpointSpecificConfiguration(dto)); if (LOG.isTraceEnabled()) { LOG.trace("Saved: {}", configuration); } else { LOG.debug("Saved: {}", configuration != null); } return configuration; }
/** * Constructs an endpoint specific configuration with the information provided and * saves it to the database. * * @param endpointKeyHash The endpoint key hash * @param configurationVersion The endpoint configuration version * @param configuration The configuration body * @param version The endpoint specific configuration version * @return saved endpoint specific configuration */ protected EndpointSpecificConfigurationDto generateEndpointSpecificConfigurationDto(byte[] endpointKeyHash, Integer configurationVersion, String configuration, Long version) { EndpointSpecificConfigurationDto dto = new EndpointSpecificConfigurationDto(endpointKeyHash, configurationVersion, configuration, version); return endpointSpecificConfigurationDao.save(dto).toDto(); } }
@Test public void testShouldDeleteActiveConfigurationByEndpointKeyHash() { when(endpointServiceMock.findEndpointProfileByKeyHash(KEY)).thenReturn(generateProfile()); when(daoMock.findByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION)).thenReturn(configuration); when(configuration.toDto()).thenReturn(configurationDto); when(configurationDto.getConfigurationSchemaVersion()).thenReturn(CONF_VERSION); Assert.assertTrue(SERVICE.deleteActiveConfigurationByEndpointKeyHash(KEY).isPresent()); verify(endpointServiceMock).findEndpointProfileByKeyHash(KEY); verify(daoMock).findByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION); verify(daoMock).removeByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION); }
mergedConfiguration = mergeConfiguration(endpointId, epsConfig.getConfiguration(), latestConfigurationSchema, mergedConfiguration);
@Override public EndpointSpecificConfigurationDto toDto() { EndpointSpecificConfigurationDto dto = new EndpointSpecificConfigurationDto(); dto.setEndpointKeyHash(getBytes(this.getEndpointKeyHash())); dto.setConfiguration(this.getConfiguration()); dto.setConfigurationSchemaVersion(this.getConfigurationVersion()); dto.setVersion(this.getVersion()); return dto; }
/** * Create new instance of <code>CassandraEndpointSpecificConfiguration</code>. * * @param dto is data transfer object contain data that * assign on fields of new instance */ public CassandraEndpointSpecificConfiguration(EndpointSpecificConfigurationDto dto) { this.endpointKeyHash = getByteBuffer(dto.getEndpointKeyHash()); this.configurationVersion = dto.getConfigurationSchemaVersion(); this.configuration = dto.getConfiguration(); this.version = dto.getVersion(); }
@Test public void testShouldActiveConfigurationByEndpointProfile() { when(daoMock.findByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION)).thenReturn(configuration); when(configuration.toDto()).thenReturn(new EndpointSpecificConfigurationDto()); Assert.assertTrue(SERVICE.findActiveConfigurationByEndpointProfile(generateProfile()).isPresent()); verify(daoMock).findByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION); }
@Test public void testShouldDeleteByEndpointKeyHashAndConfSchemaVersion() { EndpointProfileDto profile = generateProfile(); profile.setConfigurationVersion(0); when(endpointServiceMock.findEndpointProfileByKeyHash(KEY)).thenReturn(profile); when(daoMock.findByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION)).thenReturn(configuration); when(configuration.toDto()).thenReturn(configurationDto); when(configurationServiceMock.findConfSchemaByAppIdAndVersion(APP_ID, CONF_VERSION)).thenReturn(new ConfigurationSchemaDto()); when(configurationDto.getConfigurationSchemaVersion()).thenReturn(CONF_VERSION); Assert.assertTrue(SERVICE.deleteByEndpointKeyHashAndConfSchemaVersion(KEY, CONF_VERSION).isPresent()); verify(endpointServiceMock).findEndpointProfileByKeyHash(KEY); verify(daoMock).findByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION); verify(daoMock).removeByEndpointKeyHashAndConfigurationVersion(KEY, CONF_VERSION); verify(configurationServiceMock).findConfSchemaByAppIdAndVersion(APP_ID, CONF_VERSION); }
@Test public void testShouldSaveWithActiveConfigSchemaVersion() { EndpointSpecificConfigurationDto dto = new EndpointSpecificConfigurationDto(); dto.setConfigurationSchemaVersion(null); dto.setEndpointKeyHash(KEY); dto.setConfiguration(CONFIG_BODY); when(endpointServiceMock.findEndpointProfileByKeyHash(KEY)).thenReturn(generateProfile()); when(configurationServiceMock.normalizeAccordingToOverrideConfigurationSchema(APP_ID, CONF_VERSION, CONFIG_BODY)).thenReturn("valid body"); when(daoMock.save(dto)).thenReturn(configuration); when(configuration.toDto()).thenReturn(new EndpointSpecificConfigurationDto()); Assert.assertTrue(SERVICE.save(dto) != null); verify(configurationServiceMock).normalizeAccordingToOverrideConfigurationSchema(APP_ID, CONF_VERSION, CONFIG_BODY); verify(endpointServiceMock).findEndpointProfileByKeyHash(KEY); verify(daoMock).save(dto); }