Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
ThriftMethodMetadata { public Method getMethod() { return method; } ThriftMethodMetadata(Method method, ThriftCatalog catalog); String getName(); ThriftType getReturnType(); List<ThriftFieldMetadata> getParameters(); Set<ThriftHeaderParameter> getHeaderParameters(); Map<Short, ExceptionInfo> getExceptions(); Method getMethod(); boolean getOneway(); boolean isIdempotent(); List<String> getDocumentation(); boolean isAsync(); @Override boolean equals(Object o); @Override int hashCode(); }
@Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "ThriftMethod .* parameter 1 must not be annotated with both @ThriftField and @ThriftHeader") public void invalidHeaderAndFieldParameter() { Method validHeaderWithInferredFieldIds = getMethod("invalidHeaderAndFieldParameter", boolean.class, String.class); new ThriftMethodMetadata(validHeaderWithInferredFieldIds, THRIFT_CATALOG); } @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "ThriftMethod .* parameter 1 annotated with @ThriftHeader must be a String") public void invalidHeaderType() { Method validHeaderWithInferredFieldIds = getMethod("invalidHeaderType", boolean.class, int.class); new ThriftMethodMetadata(validHeaderWithInferredFieldIds, THRIFT_CATALOG); }
DriftServer { public ServerTransport getServerTransport() { return serverTransport; } @Inject DriftServer( ServerTransportFactory serverTransportFactory, ThriftCodecManager codecManager, MethodInvocationStatsFactory methodInvocationStatsFactory, Set<DriftService> services, Set<MethodInvocationFilter> filters); ServerTransport getServerTransport(); @PostConstruct void start(); @PreDestroy void shutdown(); }
@Test public void testGuiceServer() { ResultsSupplier resultsSupplier = new ResultsSupplier(); TestService testService = new TestService(resultsSupplier); TestingServerTransportFactory serverTransportFactory = new TestingServerTransportFactory(); TestingMethodInvocationStatsFactory statsFactory = new TestingMethodInvocationStatsFactory(); Bootstrap app = new Bootstrap( binder -> binder.bind(TestService.class).toInstance(testService), binder -> driftServerBinder(binder).bindService(TestService.class), binder -> binder.bind(ServerTransportFactory.class).toInstance(serverTransportFactory), binder -> newOptionalBinder(binder, MethodInvocationStatsFactory.class) .setBinding() .toInstance(statsFactory)); LifeCycleManager lifeCycleManager = null; try { Injector injector = app .strictConfig() .doNotInitializeLogging() .initialize(); lifeCycleManager = injector.getInstance(LifeCycleManager.class); assertEquals(serverTransportFactory.getServerTransport().getState(), State.RUNNING); testServer(resultsSupplier, testService, statsFactory, serverTransportFactory.getServerTransport()); } catch (Exception e) { throw new RuntimeException(e); } finally { if (lifeCycleManager != null) { try { lifeCycleManager.stop(); } catch (Exception ignored) { } } } assertEquals(serverTransportFactory.getServerTransport().getState(), State.SHUTDOWN); } @Test public void testGuiceServerFilter() { ResultsSupplier resultsSupplier = new ResultsSupplier(); PassThroughFilter passThroughFilter = new PassThroughFilter(); ShortCircuitFilter shortCircuitFilter = new ShortCircuitFilter(resultsSupplier); TestService testService = new TestService(() -> Futures.immediateFailedFuture(new Exception("Should not be called"))); TestingServerTransportFactory serverTransportFactory = new TestingServerTransportFactory(); TestingMethodInvocationStatsFactory statsFactory = new TestingMethodInvocationStatsFactory(); Bootstrap app = new Bootstrap( binder -> binder.bind(TestService.class).toInstance(testService), binder -> driftServerBinder(binder).bindService(TestService.class), binder -> driftServerBinder(binder).bindFilter(passThroughFilter), binder -> driftServerBinder(binder).bindFilter(shortCircuitFilter), binder -> binder.bind(ServerTransportFactory.class).toInstance(serverTransportFactory), binder -> newOptionalBinder(binder, MethodInvocationStatsFactory.class) .setBinding() .toInstance(statsFactory)); LifeCycleManager lifeCycleManager = null; try { Injector injector = app .strictConfig() .doNotInitializeLogging() .initialize(); lifeCycleManager = injector.getInstance(LifeCycleManager.class); assertEquals(serverTransportFactory.getServerTransport().getState(), State.RUNNING); testServer(resultsSupplier, combineTestingInvocationTarget(passThroughFilter, shortCircuitFilter), statsFactory, serverTransportFactory.getServerTransport()); } catch (Exception e) { throw new RuntimeException(e); } finally { if (lifeCycleManager != null) { try { lifeCycleManager.stop(); } catch (Exception ignored) { } } } assertEquals(serverTransportFactory.getServerTransport().getState(), State.SHUTDOWN); }
ThriftFramedDecoder extends ByteToMessageDecoder { @Override protected void decode(ChannelHandlerContext context, ByteBuf buffer, List<Object> output) { decode(buffer).ifPresent(output::add); } ThriftFramedDecoder(FrameInfoDecoder frameInfoDecoder, int maxFrameSizeInBytes); }
@Test public void testBelowLimit() { byte[] first = new byte[] {1, 2, 3, 4, 5}; byte[] second = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; byte[] third = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; try (TestingPooledByteBufAllocator allocator = new TestingPooledByteBufAllocator()) { ByteBuf buffer = allocator.buffer(1024); writeLengthPrefixedFrame(buffer, first); writeLengthPrefixedFrame(buffer, second); writeLengthPrefixedFrame(buffer, third); ThriftFramedDecoder decoder = createDecoder(third.length); ByteBuf decodedFirst = decode(decoder, buffer); assertNotNull(decodedFirst); assertContentEquals(decodedFirst, first); decodedFirst.release(); ByteBuf decodedSecond = decode(decoder, buffer); assertNotNull(decodedSecond); assertContentEquals(decodedSecond, second); decodedSecond.release(); ByteBuf decodedThird = decode(decoder, buffer); assertNotNull(decodedThird); assertContentEquals(decodedThird, third); decodedThird.release(); buffer.release(); } } @Test public void testChunked() { byte[] first = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; byte[] second = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; byte[] third = new byte[] {5, 4, 3}; try (TestingPooledByteBufAllocator allocator = new TestingPooledByteBufAllocator()) { ByteBuf buffer = allocator.buffer(1024); ThriftFramedDecoder decoder = createDecoder(second.length); ByteBuf decoded = decode(decoder, buffer); assertNull(decoded); buffer.writeByte(0xAB); decoded = decode(decoder, buffer); assertNull(decoded); assertEquals(buffer.readerIndex(), 0); assertEquals(buffer.writerIndex(), 1); buffer.writerIndex(0); buffer.writeInt(first.length); decoded = decode(decoder, buffer); assertNull(decoded); assertEquals(buffer.readerIndex(), 0); assertEquals(buffer.writerIndex(), Integer.BYTES); buffer.writeBytes(first, 0, 5); decoded = decode(decoder, buffer); assertNull(decoded); assertEquals(buffer.readerIndex(), 0); assertEquals(buffer.writerIndex(), Integer.BYTES + 5); buffer.writeBytes(first, 5, first.length - 5); decoded = decode(decoder, buffer); assertNotNull(decoded); assertContentEquals(decoded, first); decoded.release(); writeLengthPrefixedFrame(buffer, second); buffer.writeInt(third.length); buffer.writeBytes(third, 0, 1); decoded = decode(decoder, buffer); assertNotNull(decoded); assertContentEquals(decoded, second); decoded.release(); decoded = decode(decoder, buffer); assertNull(decoded); buffer.writeBytes(third, 1, third.length - 1); decoded = decode(decoder, buffer); assertNotNull(decoded); assertContentEquals(decoded, third); decoded.release(); assertEquals(buffer.readerIndex(), buffer.writerIndex()); buffer.release(); } } @Test public void testBeyondLimit() throws Exception { try (TestingPooledByteBufAllocator allocator = new TestingPooledByteBufAllocator()) { byte[] small = new byte[] {5, 4, 3}; byte[] firstLargeFrame = createTestFrame(allocator, "first_method", 1, CALL); byte[] secondLargeFrame = createTestFrame(allocator, "second_method", 2, ONEWAY); byte[] invalidLargeFrame = createInvalidFrame(); FrameInfo firstFrameInfo = new FrameInfo("first_method", CALL, 1, FRAMED, BINARY, true); FrameInfo secondFrameInfo = new FrameInfo("second_method", ONEWAY, 2, FRAMED, BINARY, true); ByteBuf buffer = allocator.buffer(1024); ThriftFramedDecoder decoder = createDecoder(firstLargeFrame.length - 5); writeLengthPrefixedFrame(buffer, small); ByteBuf decoded = decode(decoder, buffer); assertNotNull(decoded); assertContentEquals(decoded, small); decoded.release(); writeLengthPrefixedFrame(buffer, firstLargeFrame); writeLengthPrefixedFrame(buffer, small); try { decode(decoder, buffer); fail("failure expected"); } catch (RuntimeException e) { assertThat(e).isInstanceOf(FrameTooLargeException.class) .hasFieldOrPropertyWithValue("frameInfo", Optional.of(firstFrameInfo)); } assertEquals(buffer.readableBytes(), Integer.BYTES + small.length); decoded = decode(decoder, buffer); assertNotNull(decoded); assertContentEquals(decoded, small); decoded.release(); buffer.writeInt(secondLargeFrame.length); decoded = decode(decoder, buffer); assertNull(decoded); buffer.writeBytes(secondLargeFrame, 0, 1); decoded = decode(decoder, buffer); assertNull(decoded); buffer.writeBytes(secondLargeFrame, 1, 2); decoded = decode(decoder, buffer); assertNull(decoded); buffer.writeBytes(secondLargeFrame, 3, secondLargeFrame.length - 3); buffer.writeInt(firstLargeFrame.length); buffer.writeBytes(firstLargeFrame, 0, 5); try { decode(decoder, buffer); fail("failure expected"); } catch (RuntimeException e) { assertThat(e).isInstanceOf(FrameTooLargeException.class) .hasFieldOrPropertyWithValue("frameInfo", Optional.of(secondFrameInfo)); } assertEquals(buffer.readableBytes(), Integer.BYTES + 5); decoded = decode(decoder, buffer); assertNull(decoded); buffer.writeBytes(firstLargeFrame, 5, firstLargeFrame.length - 5); try { decode(decoder, buffer); fail("failure expected"); } catch (RuntimeException e) { assertThat(e).isInstanceOf(FrameTooLargeException.class) .hasFieldOrPropertyWithValue("frameInfo", Optional.of(firstFrameInfo)); } assertEquals(buffer.readableBytes(), 0); writeLengthPrefixedFrame(buffer, invalidLargeFrame); writeLengthPrefixedFrame(buffer, small); try { decode(decoder, buffer); fail("failure expected"); } catch (RuntimeException e) { assertThat(e).isInstanceOf(FrameTooLargeException.class) .hasFieldOrPropertyWithValue("frameInfo", Optional.empty()); } assertEquals(buffer.readableBytes(), Integer.BYTES + small.length); decoded = decode(decoder, buffer); assertNotNull(decoded); assertContentEquals(decoded, small); decoded.release(); buffer.writeInt(invalidLargeFrame.length); buffer.writeBytes(invalidLargeFrame, 0, invalidLargeFrame.length / 2); decoded = decode(decoder, buffer); assertNull(decoded); buffer.writeBytes(invalidLargeFrame, invalidLargeFrame.length / 2, invalidLargeFrame.length - invalidLargeFrame.length / 2); try { decode(decoder, buffer); fail("failure expected"); } catch (RuntimeException e) { assertThat(e).isInstanceOf(FrameTooLargeException.class) .hasFieldOrPropertyWithValue("frameInfo", Optional.empty()); } assertEquals(buffer.readableBytes(), 0); buffer.release(); } }
SimpleAddressSelectorBinder implements AddressSelectorBinder { public static AddressSelectorBinder simpleAddressSelector() { return new SimpleAddressSelectorBinder(Optional.empty()); } private SimpleAddressSelectorBinder(Optional<List<HostAndPort>> defaultAddresses); static AddressSelectorBinder simpleAddressSelector(); static AddressSelectorBinder simpleAddressSelector(HostAndPort defaultAddress); static AddressSelectorBinder simpleAddressSelector(List<HostAndPort> defaultAddresses); @Override void bind(Binder binder, Annotation annotation, String prefix); }
@Test public void testNoDefaults() throws Exception { List<HostAndPort> addresses = ImmutableList.of(HostAndPort.fromParts("example.com", 1), HostAndPort.fromParts("example.com", 2)); Map<String, String> properties = ImmutableMap.of("testService" + ".thrift.client.addresses", "example.com:1,example.com:2"); testAddressSelector(simpleAddressSelector(), properties, addresses); } @Test public void testSingleDefault() throws Exception { HostAndPort address = HostAndPort.fromParts("example.com", 1); testAddressSelector(simpleAddressSelector(address), ImmutableMap.of(), ImmutableList.of(address)); testAddressSelector( simpleAddressSelector(address), ImmutableMap.of("testService" + ".thrift.client.addresses", "example.com:11,example.com:22"), ImmutableList.of(HostAndPort.fromParts("example.com", 11), HostAndPort.fromParts("example.com", 22))); } @Test public void testMultipleDefaults() throws Exception { List<HostAndPort> addresses = ImmutableList.of(HostAndPort.fromParts("example.com", 1), HostAndPort.fromParts("example.com", 2)); testAddressSelector(simpleAddressSelector(addresses), ImmutableMap.of(), addresses); testAddressSelector( simpleAddressSelector(addresses), ImmutableMap.of("testService" + ".thrift.client.addresses", "example.com:11,example.com:22"), ImmutableList.of(HostAndPort.fromParts("example.com", 11), HostAndPort.fromParts("example.com", 22))); }
ConnectionPool implements ConnectionManager { @Override public Future<Channel> getConnection(ConnectionParameters connectionParameters, HostAndPort address) { ConnectionKey key = new ConnectionKey(connectionParameters, address); while (true) { synchronized (this) { if (closed) { return group.next().newFailedFuture(new TTransportException("Connection pool is closed")); } Future<Channel> future; try { future = cachedConnections.get(key, () -> createConnection(key)); } catch (ExecutionException e) { throw new RuntimeException(e); } if (!future.isDone()) { return future; } Channel channel = future.getNow(); if (channel != null && channel.isOpen()) { return future; } cachedConnections.asMap().remove(key, future); } } } ConnectionPool(ConnectionManager connectionFactory, EventLoopGroup group, int maxSize, Duration idleTimeout); @Override Future<Channel> getConnection(ConnectionParameters connectionParameters, HostAndPort address); @Override void returnConnection(Channel connection); @Override synchronized void close(); }
@Test public void testPooling() { try (ConnectionPool pool = new ConnectionPool(new TestingConnectionManager(), new DefaultEventLoopGroup(), 10, new Duration(1, MINUTES))) { HostAndPort address1 = HostAndPort.fromParts("localhost", 1234); HostAndPort address2 = HostAndPort.fromParts("localhost", 4567); Channel channel1 = futureGet(pool.getConnection(PARAMETERS, address1)); Channel channel2 = futureGet(pool.getConnection(PARAMETERS, address1)); assertSame(channel1, channel2); Channel channel3 = futureGet(pool.getConnection(PARAMETERS, address2)); assertNotSame(channel1, channel3); Channel channel4 = futureGet(pool.getConnection(PARAMETERS, address1)); assertSame(channel1, channel4); } }
DriftNettyMethodInvoker implements MethodInvoker { @Override public ListenableFuture<Object> invoke(InvokeRequest request) { try { return MoreFutures.addTimeout( InvocationResponseFuture.createInvocationResponseFuture(request, connectionParameters, connectionManager), () -> { String message = "Invocation response future did not complete after " + invokeTimeout; log.error(message); throw new RequestTimeoutException(message); }, invokeTimeout, delayService); } catch (Exception e) { return immediateFailedFuture(e); } } DriftNettyMethodInvoker(ConnectionParameters connectionParameters, ConnectionManager connectionManager, ScheduledExecutorService delayService); @VisibleForTesting DriftNettyMethodInvoker( ConnectionParameters connectionParameters, ConnectionManager connectionManager, ScheduledExecutorService delayService, Duration invocationTimeoutGracePeriod); @Override ListenableFuture<Object> invoke(InvokeRequest request); @Override ListenableFuture<?> delay(Duration duration); }
@Test public void testTimeout() throws Exception { ScheduledExecutorService executor = newSingleThreadScheduledExecutor(daemonThreadsNamed("test-timeout")); DriftNettyMethodInvoker invoker = new DriftNettyMethodInvoker( new ConnectionParameters( FRAMED, BINARY, new DataSize(16, Unit.MEGABYTE), new Duration(11, MILLISECONDS), new Duration(13, MILLISECONDS), Optional.empty(), Optional.empty()), new HangingConnectionManager(), executor, new Duration(17, MILLISECONDS)); ListenableFuture<Object> response = invoker.invoke(new InvokeRequest( new MethodMetadata( "test", ImmutableList.of(), (ThriftCodec<Object>) (Object) new VoidThriftCodec(), ImmutableMap.of(), ImmutableMap.of(), false, true), () -> HostAndPort.fromParts("localhost", 1234), ImmutableMap.of(), ImmutableList.of())); try { response.get(); fail("expected exception"); } catch (ExecutionException e) { assertInstanceOf(e.getCause(), io.airlift.drift.TException.class); assertEquals(e.getCause().getMessage(), "Invocation response future did not complete after 41.00ms"); } finally { executor.shutdown(); } }
DriftServerConfig { @Config("thrift.server.stats.enabled") public DriftServerConfig setStatsEnabled(boolean statsEnabled) { this.statsEnabled = statsEnabled; return this; } boolean isStatsEnabled(); @Config("thrift.server.stats.enabled") DriftServerConfig setStatsEnabled(boolean statsEnabled); }
@Test public void testDefaults() { assertRecordedDefaults(recordDefaults(DriftServerConfig.class) .setStatsEnabled(true)); } @Test public void testExplicitPropertyMappings() { Map<String, String> properties = new ImmutableMap.Builder<String, String>() .put("thrift.server.stats.enabled", "false") .build(); DriftServerConfig expected = new DriftServerConfig() .setStatsEnabled(false); assertFullMapping(properties, expected); }
GenericJDBCConfigurationStore extends AbstractJDBCConfigurationStore implements MessageStoreProvider { @Override public void onDelete(final ConfiguredObject<?> parent) { assertState(CLOSED); ConnectionProvider connectionProvider = JdbcUtils.createConnectionProvider(parent, LOGGER); try { try (Connection conn = connectionProvider.getConnection()) { conn.setAutoCommit(true); onDelete(conn); } catch (SQLException e) { getLogger().error("Exception while deleting store tables", e); } } finally { try { connectionProvider.close(); } catch (SQLException e) { LOGGER.warn("Unable to close connection provider ", e); } } } GenericJDBCConfigurationStore(final Class<? extends ConfiguredObject> rootClass); @Override void init(ConfiguredObject<?> parent); @Override void upgradeStoreStructure(); @Override Connection getConnection(); @Override void closeConfigurationStore(); @Override void onDelete(final ConfiguredObject<?> parent); @Override String getSqlBigIntType(); @Override MessageStore getMessageStore(); PreferenceStore getPreferenceStore(); }
@Test public void testOnDelete() throws Exception { try (Connection connection = openConnection()) { GenericJDBCConfigurationStore store = (GenericJDBCConfigurationStore) getConfigurationStore(); Collection<String> expectedTables = Arrays.asList(store.getConfiguredObjectHierarchyTableName(), store.getConfiguredObjectsTableName()); assertTablesExistence(expectedTables, getTableNames(connection), true); store.closeConfigurationStore(); assertTablesExistence(expectedTables, getTableNames(connection), true); store.onDelete(getVirtualHostNode()); assertTablesExistence(expectedTables, getTableNames(connection), false); } }
EnvHomeRegistry { public synchronized void registerHome(final File home) throws StoreException { if (home == null) { throw new IllegalArgumentException("home parameter cannot be null"); } String canonicalForm = getCanonicalForm(home); if (_canonicalNames.contains(canonicalForm)) { throw new IllegalArgumentException("JE Home " + home + " is already in use"); } _canonicalNames.add(canonicalForm); } EnvHomeRegistry(); static final EnvHomeRegistry getInstance(); synchronized void registerHome(final File home); synchronized void deregisterHome(final File home); }
@Test public void testDuplicateEnvHomeRejected() throws Exception { File home = new File(UnitTestBase.TMP_FOLDER, getTestName()); _ehr.registerHome(home); try { _ehr.registerHome(home); fail("Exception not thrown"); } catch (IllegalArgumentException iae) { } } @Test public void testUniqueEnvHomesAllowed() throws Exception { File home1 = new File(UnitTestBase.TMP_FOLDER, getTestName() + "1"); File home2 = new File(UnitTestBase.TMP_FOLDER, getTestName() + "2"); _ehr.registerHome(home1); _ehr.registerHome(home2); }
StandardEnvironmentFacade implements EnvironmentFacade { @Override public void close() { try { _committer.stop(); closeSequences(); closeDatabases(); } finally { try { closeEnvironment(); } finally { EnvHomeRegistry.getInstance().deregisterHome(_environmentPath); } } } StandardEnvironmentFacade(StandardEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(com.sleepycat.je.Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(long cacheSize); @Override void flushLogFailed(final RuntimeException e); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String,Map<String,Object>> getEnvironmentStatistics(boolean reset); @Override Map<String,Object> getDatabaseStatistics(String database, boolean reset); @Override void deleteDatabase(final String databaseName); @Override Map<String, Object> getTransactionStatistics(boolean reset); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); @Override RuntimeException handleDatabaseException(String contextMessage, RuntimeException e); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void closeDatabase(final String name); }
@Test public void testSecondEnvironmentFacadeUsingSamePathRejected() throws Exception { EnvironmentFacade ef = createEnvironmentFacade(); assertNotNull("Environment should not be null", ef); try { createEnvironmentFacade(); fail("Exception not thrown"); } catch (IllegalArgumentException iae) { } ef.close(); EnvironmentFacade ef2 = createEnvironmentFacade(); assertNotNull("Environment should not be null", ef2); } @Test public void testClose() throws Exception { EnvironmentFacade ef = createEnvironmentFacade(); ef.close(); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { @Override public void close() { if (_state.compareAndSet(State.OPENING, State.CLOSING) || _state.compareAndSet(State.OPEN, State.CLOSING) || _state.compareAndSet(State.RESTARTING, State.CLOSING) ) { try { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Closing replicated environment facade for " + _prettyGroupNodeName + " current state is " + _state.get()); } long timeout = Math.max(_executorShutdownTimeout, _envSetupTimeoutMillis); shutdownAndAwaitExecutorService(_environmentJobExecutor, timeout, TimeUnit.MILLISECONDS); shutdownAndAwaitExecutorService(_groupChangeExecutor, _executorShutdownTimeout, TimeUnit.MILLISECONDS); shutdownAndAwaitExecutorService(_stateChangeExecutor, _executorShutdownTimeout, TimeUnit.MILLISECONDS); try { if (_coalescingCommiter != null) { _coalescingCommiter.stop(); } closeSequences(); closeDatabases(); } finally { try { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Closing replicated environment"); } closeEnvironment(); } finally { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Deregistering environment home " + _environmentDirectory); } EnvHomeRegistry.getInstance().deregisterHome(_environmentDirectory); } } } finally { _state.compareAndSet(State.CLOSING, State.CLOSED); } } } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testClose() throws Exception { ReplicatedEnvironmentFacade ef = createMaster(); ef.close(); assertEquals("Unexpected state after close", ReplicatedEnvironmentFacade.State.CLOSED, ef.getFacadeState()); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public String getGroupName() { return (String)_configuration.getGroupName(); } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testGetGroupName() throws Exception { assertEquals("Unexpected group name", TEST_GROUP_NAME, createMaster().getGroupName()); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public String getNodeName() { return _configuration.getName(); } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testGetNodeName() throws Exception { assertEquals("Unexpected group name", TEST_NODE_NAME, createMaster().getNodeName()); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public long getLastKnownReplicationTransactionId() { if (_state.get() == State.OPEN) { try { VLSNRange range = RepInternal.getRepImpl(getEnvironment()).getVLSNIndex().getRange(); VLSN lastTxnEnd = range.getLastTxnEnd(); return lastTxnEnd.getSequence(); } catch (RuntimeException e) { throw handleDatabaseException("Exception on getting last known replication transaction id", e); } } else { return -1L; } } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testLastKnownReplicationTransactionId() throws Exception { ReplicatedEnvironmentFacade master = createMaster(); long lastKnownReplicationTransactionId = master.getLastKnownReplicationTransactionId(); assertTrue("Unexpected LastKnownReplicationTransactionId " + lastKnownReplicationTransactionId, lastKnownReplicationTransactionId > 0); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public String getHostPort() { return (String)_configuration.getHostPort(); } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testGetNodeHostPort() throws Exception { assertEquals("Unexpected node host port", TEST_NODE_HOST_PORT, createMaster().getHostPort()); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public String getHelperHostPort() { return (String)_configuration.getHelperHostPort(); } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testGetHelperHostPort() throws Exception { assertEquals("Unexpected node helper host port", TEST_NODE_HELPER_HOST_PORT, createMaster().getHelperHostPort()); }
CompositeFilter extends Filter<ILoggingEvent> { public void addLogInclusionRule(LogBackLogInclusionRule logInclusionRule) { Filter<ILoggingEvent> f = logInclusionRule.asFilter(); f.setName(logInclusionRule.getName()); _filterList.add(f); } void addLogInclusionRule(LogBackLogInclusionRule logInclusionRule); void removeLogInclusionRule(LogBackLogInclusionRule logInclusionRule); @Override FilterReply decide(ILoggingEvent event); long getErrorCount(); long getWarnCount(); }
@Test public void testAddLogInclusionRule() { CompositeFilter compositeFilter = new CompositeFilter(); LogBackLogInclusionRule rule = createRule(FilterReply.ACCEPT, "accept"); compositeFilter.addLogInclusionRule(rule); verify(rule.asFilter()).setName("accept"); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy) { if (_messageStoreDurability == null || localTransactionSynchronizationPolicy != _messageStoreDurability.getLocalSync() || remoteTransactionSynchronizationPolicy != _messageStoreDurability.getReplicaSync() || replicaAcknowledgmentPolicy != _messageStoreDurability.getReplicaAck()) { _messageStoreDurability = new Durability(localTransactionSynchronizationPolicy, remoteTransactionSynchronizationPolicy, replicaAcknowledgmentPolicy); if (_coalescingCommiter != null) { _coalescingCommiter.stop(); _coalescingCommiter = null; } if (localTransactionSynchronizationPolicy == LOCAL_TRANSACTION_SYNCHRONIZATION_POLICY) { localTransactionSynchronizationPolicy = SyncPolicy.NO_SYNC; _coalescingCommiter = new CoalescingCommiter(_configuration.getGroupName(), this); _coalescingCommiter.start(); } _realMessageStoreDurability = new Durability(localTransactionSynchronizationPolicy, remoteTransactionSynchronizationPolicy, replicaAcknowledgmentPolicy); } } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testSetMessageStoreDurability() throws Exception { ReplicatedEnvironmentFacade master = createMaster(); assertEquals("Unexpected message store durability", new Durability(Durability.SyncPolicy.NO_SYNC, Durability.SyncPolicy.NO_SYNC, Durability.ReplicaAckPolicy.SIMPLE_MAJORITY), master.getRealMessageStoreDurability()); assertEquals("Unexpected durability", TEST_DURABILITY, master.getMessageStoreDurability()); assertTrue("Unexpected coalescing sync", master.isCoalescingSync()); master.setMessageStoreDurability(Durability.SyncPolicy.WRITE_NO_SYNC, Durability.SyncPolicy.SYNC, Durability.ReplicaAckPolicy.ALL); assertEquals("Unexpected message store durability", new Durability(Durability.SyncPolicy.WRITE_NO_SYNC, Durability.SyncPolicy.SYNC, Durability.ReplicaAckPolicy.ALL), master.getRealMessageStoreDurability()); assertFalse("Coalescing sync committer is still running", master.isCoalescingSync()); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public String getNodeState() { if (_state.get() != State.OPEN) { return ReplicatedEnvironment.State.UNKNOWN.name(); } try { ReplicatedEnvironment.State state = getEnvironment().getState(); return state.toString(); } catch (RuntimeException e) { throw handleDatabaseException("Cannot get environment state", e); } } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testGetNodeState() throws Exception { assertEquals("Unexpected state", State.MASTER.name(), createMaster().getNodeState()); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public int getNumberOfElectableGroupMembers() { try { return getEnvironment().getGroup().getElectableNodes().size(); } catch(RuntimeException e) { throw handleDatabaseException("Exception on getting number of electable group members", e); } } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testReplicationGroupListenerHearsAboutExistingRemoteReplicationNodes() throws Exception { ReplicatedEnvironmentFacade master = createMaster(); String nodeName2 = TEST_NODE_NAME + "_2"; String host = "localhost"; int port = _portHelper.getNextAvailable(); String node2NodeHostPort = host + ":" + port; final AtomicInteger invocationCount = new AtomicInteger(); final CountDownLatch nodeRecoveryLatch = new CountDownLatch(1); ReplicationGroupListener listener = new NoopReplicationGroupListener() { @Override public void onReplicationNodeRecovered(ReplicationNode node) { nodeRecoveryLatch.countDown(); invocationCount.incrementAndGet(); } }; createReplica(nodeName2, node2NodeHostPort, listener); assertEquals("Unexpected number of nodes", (long) 2, (long) master.getNumberOfElectableGroupMembers()); assertTrue("Listener not fired within timeout", nodeRecoveryLatch.await(_timeout, TimeUnit.SECONDS)); assertEquals("Unexpected number of listener invocations", (long) 1, (long) invocationCount.get()); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public void removeNodeFromGroup(final String nodeName) { try { createReplicationGroupAdmin().removeMember(nodeName); } catch (MasterStateException e) { throw new IllegalStateTransitionException(String.format("Node '%s' cannot be deleted when role is a master", nodeName)); } catch (MemberNotFoundException e) { throw new IllegalArgumentException(String.format("Node '%s' is not a member of the group", nodeName), e); } catch (RuntimeException e) { throw handleDatabaseException("Exception on node removal from group", e); } } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testRemoveNodeFromGroup() throws Exception { TestStateChangeListener stateChangeListener = new TestStateChangeListener(); ReplicatedEnvironmentFacade environmentFacade = addNode(TEST_NODE_NAME, TEST_NODE_HOST_PORT, true, stateChangeListener, new NoopReplicationGroupListener()); assertTrue("Environment was not created", stateChangeListener.awaitForStateChange(State.MASTER, _timeout, TimeUnit.SECONDS)); String node2Name = TEST_NODE_NAME + "_2"; String node2NodeHostPort = "localhost:" + _portHelper.getNextAvailable(); ReplicatedEnvironmentFacade ref2 = createReplica(node2Name, node2NodeHostPort, new NoopReplicationGroupListener()); assertEquals("Unexpected group members count", (long) 2, (long) environmentFacade.getNumberOfElectableGroupMembers()); ref2.close(); environmentFacade.removeNodeFromGroup(node2Name); assertEquals("Unexpected group members count", (long) 1, (long) environmentFacade.getNumberOfElectableGroupMembers()); }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { @Override public Transaction beginTransaction(TransactionConfig transactionConfig) { return getEnvironment().beginTransaction(null, transactionConfig); } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testBeginTransaction() throws Exception { ReplicatedEnvironmentFacade facade = createMaster(); Transaction txn = null; try { TransactionConfig transactionConfig = new TransactionConfig(); transactionConfig.setDurability(facade.getRealMessageStoreDurability()); txn = facade.beginTransaction(transactionConfig); assertNotNull("Transaction is not created", txn); txn.commit(); txn = null; } finally { if (txn != null) { txn.abort(); } } }
ReplicatedEnvironmentFacade implements EnvironmentFacade, StateChangeListener { public void setPermittedNodes(Collection<String> permittedNodes) { if (LOGGER.isDebugEnabled()) { LOGGER.debug(_prettyGroupNodeName + " permitted nodes set to " + permittedNodes); } _permittedNodes.clear(); if (permittedNodes != null) { _permittedNodes.addAll(permittedNodes); registerAppStateMonitorIfPermittedNodesSpecified(_permittedNodes); ReplicationGroupListener listener = _replicationGroupListener.get(); int count = 0; for(ReplicationNode node: _remoteReplicationNodes.values()) { if (!isNodePermitted(node)) { onIntruder(listener, node); } count++; } if (LOGGER.isDebugEnabled()) { LOGGER.debug(_prettyGroupNodeName + " checked " + count + " node(s)"); } } } ReplicatedEnvironmentFacade(ReplicatedEnvironmentConfiguration configuration); @Override Transaction beginTransaction(TransactionConfig transactionConfig); @Override void commit(final Transaction tx, boolean syncCommit); @Override ListenableFuture<X> commitAsync(final Transaction tx, final X val); @Override void close(); @Override RuntimeException handleDatabaseException(String contextMessage, final RuntimeException dbe); @Override Database openDatabase(String name, DatabaseConfig databaseConfig); @Override Database clearDatabase(Transaction txn, String databaseName, DatabaseConfig databaseConfig); @Override void closeDatabase(final String databaseName); @Override Sequence openSequence(final Database database, final DatabaseEntry sequenceKey, final SequenceConfig sequenceConfig); @Override void stateChange(final StateChangeEvent stateChangeEvent); @Override long getTotalLogSize(); @Override void reduceSizeOnDisk(); @Override void flushLog(); @Override void setCacheSize(final long cacheSize); @Override void updateMutableConfig(final ConfiguredObject<?> object); @Override int cleanLog(); @Override void checkpoint(final boolean force); @Override Map<String, Map<String, Object>> getEnvironmentStatistics(final boolean reset); @Override Map<String, Object> getTransactionStatistics(final boolean reset); @Override Map<String,Object> getDatabaseStatistics(final String database, final boolean reset); @Override void deleteDatabase(final String databaseName); @Override void flushLogFailed(final RuntimeException e); Set<ReplicationNode> getNodes(); String getGroupName(); String getNodeName(); String getHostPort(); String getHelperHostPort(); Durability getMessageStoreDurability(); boolean isCoalescingSync(); String getNodeState(); boolean isDesignatedPrimary(); Future<Void> reapplyDesignatedPrimary(); Future<Void> reapplyPriority(); Future<Void> reapplyElectableGroupSizeOverride(); Future<Void> transferMasterToSelfAsynchronously(); Future<Void> transferMasterAsynchronously(final String nodeName); void removeNodeFromGroup(final String nodeName); long getJoinTime(); long getLastKnownReplicationTransactionId(); @Override void upgradeIfNecessary(ConfiguredObject<?> parent); State getFacadeState(); void setStateChangeListener(StateChangeListener stateChangeListener); int getNumberOfElectableGroupMembers(); boolean isMaster(); void setReplicationGroupListener(ReplicationGroupListener replicationGroupListener); void setMessageStoreDurability(SyncPolicy localTransactionSynchronizationPolicy, SyncPolicy remoteTransactionSynchronizationPolicy, ReplicaAckPolicy replicaAcknowledgmentPolicy); void setPermittedNodes(Collection<String> permittedNodes); static Set<String> convertApplicationStateBytesToPermittedNodeList(byte[] applicationState); static Collection<String> connectToHelperNodeAndCheckPermittedHosts(final String nodeName, final String hostPort, final String groupName, final String helperNodeName, final String helperHostPort, final int dbPingSocketTimeout); static final String MASTER_TRANSFER_TIMEOUT_PROPERTY_NAME; static final String DB_PING_SOCKET_TIMEOUT_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_INTERVAL_PROPERTY_NAME; static final String REMOTE_NODE_MONITOR_TIMEOUT_PROPERTY_NAME; static final String ENVIRONMENT_RESTART_RETRY_LIMIT_PROPERTY_NAME; static final String EXECUTOR_SHUTDOWN_TIMEOUT_PROPERTY_NAME; static final ReplicaAckPolicy REPLICA_REPLICA_ACKNOWLEDGMENT_POLICY; static final String PERMITTED_NODE_LIST; }
@Test public void testSetPermittedNodes() throws Exception { ReplicatedEnvironmentFacade firstNode = createMaster(); Set<String> permittedNodes = new HashSet<String>(); permittedNodes.add("localhost:" + TEST_NODE_PORT); permittedNodes.add("localhost:" + _portHelper.getNextAvailable()); firstNode.setPermittedNodes(permittedNodes); ReplicationNodeImpl replicationNode = new ReplicationNodeImpl(TEST_NODE_NAME, TEST_NODE_HOST_PORT); NodeState nodeState = getRemoteNodeState(TEST_GROUP_NAME, replicationNode, 5000); ObjectMapper objectMapper = new ObjectMapper(); Map<String, Object> settings = objectMapper.readValue(nodeState.getAppState(), Map.class); Collection<String> appStatePermittedNodes = (Collection<String>)settings.get(PERMITTED_NODE_LIST); assertEquals("Unexpected permitted nodes", permittedNodes, new HashSet<String>(appStatePermittedNodes)); } @Test public void testIntruderNodeIsDetected() throws Exception { final CountDownLatch intruderLatch = new CountDownLatch(1); ReplicationGroupListener listener = new NoopReplicationGroupListener() { @Override public boolean onIntruderNode(ReplicationNode node) { intruderLatch.countDown(); return true; } }; ReplicatedEnvironmentFacade firstNode = createMaster(listener); int replica1Port = _portHelper.getNextAvailable(); String node1NodeHostPort = "localhost:" + replica1Port; Set<String> permittedNodes = new HashSet<String>(); permittedNodes.add("localhost:" + TEST_NODE_PORT); firstNode.setPermittedNodes(permittedNodes); String nodeName = TEST_NODE_NAME + "_1"; createIntruder(nodeName, node1NodeHostPort); assertTrue("Intruder node was not detected", intruderLatch.await(_timeout, TimeUnit.SECONDS)); }
BDBMessageStore extends AbstractBDBMessageStore { @Override public void onDelete(ConfiguredObject<?> parent) { if (isMessageStoreOpen()) { throw new IllegalStateException("Cannot delete the store as store is still open"); } FileBasedSettings fileBasedSettings = (FileBasedSettings)parent; String storePath = fileBasedSettings.getStorePath(); if (storePath != null) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Deleting store : {}", storePath); } File configFile = new File(storePath); if (!FileUtils.delete(configFile, true)) { LOGGER.info("Failed to delete the store at location : {} ", storePath); } } } BDBMessageStore(); BDBMessageStore(EnvironmentFacadeFactory environmentFacadeFactory); @Override void onDelete(ConfiguredObject<?> parent); @Override EnvironmentFacade getEnvironmentFacade(); @Override String getStoreLocation(); @Override File getStoreLocationAsFile(); }
@Test public void testOnDelete() throws Exception { String storeLocation = getStore().getStoreLocation(); File location = new File(storeLocation); assertTrue("Store does not exist at " + storeLocation, location.exists()); getStore().closeMessageStore(); assertTrue("Store does not exist at " + storeLocation, location.exists()); BDBVirtualHost mockVH = mock(BDBVirtualHost.class); String testLocation = getStore().getStoreLocation(); when(mockVH.getStorePath()).thenReturn(testLocation); getStore().onDelete(mockVH); assertFalse("Store exists at " + storeLocation, location.exists()); }
StandardEnvironmentFacadeFactory implements EnvironmentFacadeFactory { @SuppressWarnings("unchecked") @Override public EnvironmentFacade createEnvironmentFacade(final ConfiguredObject<?> parent) { final FileBasedSettings settings = (FileBasedSettings)parent; final String storeLocation = settings.getStorePath(); StandardEnvironmentConfiguration sec = new StandardEnvironmentConfiguration() { @Override public String getName() { return parent.getName(); } @Override public String getStorePath() { return storeLocation; } @Override public CacheMode getCacheMode() { return BDBUtils.getCacheMode(parent); } @Override public Map<String, String> getParameters() { return BDBUtils.getEnvironmentConfigurationParameters(parent); } @Override public <T> T getFacadeParameter(final Class<T> clazz, final String parameterName, final T defaultValue) { return BDBUtils.getContextValue(parent, clazz, parameterName, defaultValue); } @Override public <T> T getFacadeParameter(final Class<T> paremeterClass, final Type type, final String parameterName, final T defaultValue) { return BDBUtils.getContextValue(parent, paremeterClass, type, parameterName, defaultValue); } }; return new StandardEnvironmentFacade(sec); } @SuppressWarnings("unchecked") @Override EnvironmentFacade createEnvironmentFacade(final ConfiguredObject<?> parent); }
@Test public void testCreateEnvironmentFacade() { when(_parent.getName()).thenReturn(getTestName()); when(_parent.getContextKeys(any(boolean.class))).thenReturn(Collections.singleton(EnvironmentConfig.ENV_IS_TRANSACTIONAL)); when(_parent.getContextValue(String.class, EnvironmentConfig.ENV_IS_TRANSACTIONAL)).thenReturn("false"); StandardEnvironmentFacadeFactory factory = new StandardEnvironmentFacadeFactory(); EnvironmentFacade facade = factory.createEnvironmentFacade(_parent); try { facade.beginTransaction(null); fail("Context variables were not picked up on environment creation"); } catch(UnsupportedOperationException e) { } }
MessageConverter_0_8_to_1_0 extends MessageConverter_to_1_0<AMQMessage> { @Override public String getType() { return "v0-8 to v1-0"; } @Override Class<AMQMessage> getInputClass(); @Override String getType(); }
@Test public void testConvertJmsStreamMessageBody() throws Exception { final List<Object> expected = Lists.newArrayList("apple", 43, 31.42D); final byte[] messageBytes = getJmsStreamMessageBytes(expected); final String mimeType = "jms/stream-message"; doTestStreamMessage(messageBytes, mimeType, expected, JmsMessageTypeAnnotation.STREAM_MESSAGE.getType()); } @Test public void testConvertJmsStreamMessageEmptyBody() throws Exception { final List<Object> expected = Collections.emptyList(); doTestStreamMessage(null, "jms/stream-message", expected, JmsMessageTypeAnnotation.STREAM_MESSAGE.getType()); } @Test public void testConvertAmqpListMessageBody() throws Exception { final List<Object> expected = Lists.newArrayList("apple", 43, 31.42D); final byte[] messageBytes = new ListToAmqpListConverter().toMimeContent(expected); final String mimeType = "amqp/list"; doTestStreamMessage(messageBytes, mimeType, expected, JmsMessageTypeAnnotation.STREAM_MESSAGE.getType()); } @Test public void testConvertJmsMapMessageBody() throws Exception { final Map<String, Object> expected = Collections.singletonMap("key", "value"); final byte[] messageBytes = getJmsMapMessageBytes(expected); doTestMapMessage(messageBytes, "jms/map-message", expected, JmsMessageTypeAnnotation.MAP_MESSAGE.getType()); } @Test public void testConvertJmsMapMessageEmptyBody() throws Exception { final Map<String, Object> expected = Collections.emptyMap(); doTestMapMessage(null, "jms/map-message", expected, JmsMessageTypeAnnotation.MAP_MESSAGE.getType()); } @Test public void testConvertAmqpMapMessageBody() throws Exception { final Map<String, Object> expected = Collections.singletonMap("key", "value"); final byte[] messageBytes = new MapToAmqpMapConverter().toMimeContent(expected); doTestMapMessage(messageBytes, "amqp/map", expected, JmsMessageTypeAnnotation.MAP_MESSAGE.getType()); } @Test public void testConvertEmptyMessageWithoutContentType() throws Exception { doTest(null, null, AmqpValueSection.class, null, null, JmsMessageTypeAnnotation.MESSAGE.getType()); }
MessageConverter_1_0_to_v0_8 implements MessageConverter<Message_1_0, AMQMessage> { @Override public AMQMessage convert(Message_1_0 serverMsg, NamedAddressSpace addressSpace) { return new AMQMessage(convertToStoredMessage(serverMsg, addressSpace), null); } @Override Class<Message_1_0> getInputClass(); @Override Class<AMQMessage> getOutputClass(); @Override AMQMessage convert(Message_1_0 serverMsg, NamedAddressSpace addressSpace); @Override void dispose(final AMQMessage message); @Override String getType(); }
@Test public void testAmqpValueWithNullWithTextMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(TEXT_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testAmqpValueWithNullWithMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testAmqpValueWithNullWithObjectMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(OBJECT_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected mime type", "application/java-object-stream", convertedMessage.getMessageHeader().getMimeType()); assertArrayEquals("Unexpected content size", getObjectBytes(null), getBytes(content)); } @Test public void testAmqpValueWithNullWithMapMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(MAP_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected mime type", "jms/map-message", convertedMessage.getMessageHeader().getMimeType()); assertArrayEquals("Unexpected content size", new MapToJmsMapMessage().toMimeContent(Collections.emptyMap()), getBytes(content)); } @Test public void testAmqpValueWithNullWithBytesMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(BYTE_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testAmqpValueWithNullWithStreamMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(STREAM_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "jms/stream-message", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testAmqpValueWithNullWithUnknownMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(new MessageAnnotations(Collections.singletonMap(Symbol.valueOf("x-opt-jms-msg-type"), (byte) 11)), amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testAmqpValueWithNullWithContentTypeApplicationOctetStream() throws Exception { Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/octet-stream")); final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(properties, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testAmqpValueWithNullWithObjectMessageContentType() throws Exception { final Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/x-java-serialized-object")); final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(properties, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/java-object-stream", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) getObjectBytes(null).length, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testAmqpValueWithNullWithJmsMapContentType() throws Exception { final Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("jms/map-message")); final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(properties, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected mime type", "jms/map-message", convertedMessage.getMessageHeader().getMimeType()); assertArrayEquals("Unexpected content size", new MapToJmsMapMessage().toMimeContent(Collections.emptyMap()), getBytes(content)); } @Test public void testAmqpValueWithNull() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testAmqpValueWithString() throws Exception { final String expected = "testContent"; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected content", expected, new String(getBytes(content), UTF_8)); } @Test public void testAmqpValueWithStringWithTextMessageAnnotation() throws Exception { final String expected = "testContent"; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(TEXT_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected content", expected, new String(getBytes(content), UTF_8)); } @Test public void testAmqpValueWithMap() throws Exception { final Map<String, Object> originalMap = new LinkedHashMap<>(); originalMap.put("binaryEntry", new Binary(new byte[]{0x00, (byte) 0xFF})); originalMap.put("intEntry", 42); originalMap.put("nullEntry", null); final AmqpValue amqpValue = new AmqpValue(originalMap); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "jms/map-message", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); Map<String, Object> convertedMap = new JmsMapMessageToMap().toObject(getBytes(content)); assertEquals("Unexpected size", (long) originalMap.size(), (long) convertedMap.size()); assertArrayEquals("Unexpected binary entry", ((Binary) originalMap.get("binaryEntry")).getArray(), (byte[]) convertedMap.get("binaryEntry")); assertEquals("Unexpected int entry", originalMap.get("intEntry"), convertedMap.get("intEntry")); assertEquals("Unexpected null entry", originalMap.get("nullEntry"), convertedMap.get("nullEntry")); } @Test public void testAmqpValueWithMapContainingMap() throws Exception { final Map<String, Object> originalMap = Collections.singletonMap("testMap", Collections.singletonMap("innerKey", "testValue")); final AmqpValue amqpValue = new AmqpValue(originalMap); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "amqp/map", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); Map<String, Object> convertedMap = new AmqpMapToMapConverter().toObject(getBytes(content)); assertEquals("Unexpected size", (long) originalMap.size(), (long) convertedMap.size()); assertEquals("Unexpected binary entry", new HashMap((Map<String, Object>) originalMap.get("testMap")), new HashMap((Map<String, Object>) convertedMap.get("testMap"))); } @Test public void testAmqpValueWithMapContainingNonFieldTableCompliantEntries() throws Exception { final AmqpValue amqpValue = new AmqpValue(Collections.<Object, Object>singletonMap(13, 42)); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); try { _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); fail("expected exception not thrown."); } catch (MessageConversionException e) { } } @Test public void testAmqpValueWithList() throws Exception { final List<Object> originalList = new ArrayList<>(); originalList.add(new Binary(new byte[]{0x00, (byte) 0xFF})); originalList.add(42); originalList.add(null); final AmqpValue amqpValue = new AmqpValue(originalList); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "jms/stream-message", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); List<Object> convertedList = new JmsStreamMessageToList().toObject(getBytes(content)); assertEquals("Unexpected size", (long) originalList.size(), (long) convertedList.size()); assertArrayEquals("Unexpected binary item", ((Binary) originalList.get(0)).getArray(), (byte[]) convertedList.get(0)); assertEquals("Unexpected int item", originalList.get(1), convertedList.get(1)); assertEquals("Unexpected null item", originalList.get(2), convertedList.get(2)); } @Test public void testAmqpValueWithListContainingMap() throws Exception { final List<Object> originalList = Collections.singletonList(Collections.singletonMap("testKey", "testValue")); final AmqpValue amqpValue = new AmqpValue(originalList); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "amqp/list", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); List<Object> convertedList = new AmqpListToListConverter().toObject(getBytes(content)); assertEquals("Unexpected size", (long) originalList.size(), (long) convertedList.size()); assertEquals("Unexpected map item", new HashMap<String, Object>((Map) originalList.get(0)), new HashMap<String, Object>((Map) convertedList.get(0))); } @Test public void testAmqpValueWithListContainingUnsupportedType() throws Exception { final List<Object> originalList = Collections.singletonList(new Source()); final AmqpValue amqpValue = new AmqpValue(originalList); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); try { _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); fail("expected exception not thrown."); } catch (MessageConversionException e) { } } @Test public void testAmqpValueWithUnsupportedType() throws Exception { final Integer originalValue = 42; final AmqpValue amqpValue = new AmqpValue(originalValue); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); try { _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); fail("expected exception not thrown."); } catch (MessageConversionException e) { } } @Test public void testAmqpSequenceWithSimpleTypes() throws Exception { final List<Integer> expected = new ArrayList<>(); expected.add(37); expected.add(42); final AmqpSequence amqpSequence = new AmqpSequence(expected); Message_1_0 sourceMessage = createTestMessage(amqpSequence.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "jms/stream-message", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected content", expected, new JmsStreamMessageToList().toObject(getBytes(content))); } @Test public void testAmqpSequenceWithMap() throws Exception { final List<Object> originalList = Collections.singletonList(Collections.singletonMap("testKey", "testValue")); final AmqpSequence amqpSequence = new AmqpSequence(originalList); Message_1_0 sourceMessage = createTestMessage(amqpSequence.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "amqp/list", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); List<Object> convertedList = new AmqpListToListConverter().toObject(getBytes(content)); assertEquals("Unexpected size", (long) originalList.size(), (long) convertedList.size()); assertEquals("Unexpected map item", new HashMap<String, Object>((Map) originalList.get(0)), new HashMap<String, Object>((Map) convertedList.get(0))); } @Test public void testAmqpSequenceWithUnsupportedType() throws Exception { final List<Object> originalList = Collections.singletonList(new Source()); final AmqpSequence amqpSequence = new AmqpSequence(originalList); Message_1_0 sourceMessage = createTestMessage(amqpSequence.createEncodingRetainingSection()); try { _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); fail("expected exception not thrown."); } catch (MessageConversionException e) { } } @Test public void testDataWithMapMessageAnnotationAndContentTypeJmsMapMessage() throws Exception { Map<String, Object> originalMap = Collections.singletonMap("testKey", "testValue"); byte[] data = new MapToJmsMapMessage().toMimeContent(originalMap); String expectedMimeType = "jms/map-message"; final Data value = new Data(new Binary(data)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf(expectedMimeType)); Message_1_0 sourceMessage = createTestMessage(properties, MAP_MESSAGE_MESSAGE_ANNOTATION, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", expectedMimeType, convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", data, getBytes(content)); } @Test public void testDataWithMapMessageAnnotationAndContentTypeAmqpMap() throws Exception { Map<String, Object> originalMap = Collections.singletonMap("testKey", "testValue"); byte[] data = new MapToAmqpMapConverter().toMimeContent(originalMap); String expectedMimeType = "amqp/map"; final Data value = new Data(new Binary(data)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf(expectedMimeType)); Message_1_0 sourceMessage = createTestMessage(properties, MAP_MESSAGE_MESSAGE_ANNOTATION, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", expectedMimeType, convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", data, getBytes(content)); } @Test public void testDataWithStreamMessageAnnotationAndContentTypeJmsStreamMessage() throws Exception { List<Object> originalList = Collections.singletonList("testValue"); byte[] data = new ListToJmsStreamMessage().toMimeContent(originalList); String expectedMimeType = "jms/stream-message"; final Data value = new Data(new Binary(data)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf(expectedMimeType)); Message_1_0 sourceMessage = createTestMessage(properties, STREAM_MESSAGE_MESSAGE_ANNOTATION, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", expectedMimeType, convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", data, getBytes(content)); } @Test public void testDataWithStreamMessageAnnotationAndContentTypeAmqpList() throws Exception { List<Object> originalList = Collections.singletonList("testValue"); byte[] data = new ListToAmqpListConverter().toMimeContent(originalList); String expectedMimeType = "amqp/list"; final Data value = new Data(new Binary(data)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf(expectedMimeType)); Message_1_0 sourceMessage = createTestMessage(properties, STREAM_MESSAGE_MESSAGE_ANNOTATION, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", expectedMimeType, convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", data, getBytes(content)); } @Test public void testDataWithContentTypeAmqpMap() throws Exception { Map<String, Object> originalMap = Collections.singletonMap("testKey", "testValue"); byte[] bytes = new MapToAmqpMapConverter().toMimeContent(originalMap); final Data value = new Data(new Binary(bytes)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("amqp/map")); Message_1_0 sourceMessage = createTestMessage(properties, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "amqp/map", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", bytes, getBytes(content)); } @Test public void testDataWithContentTypeJmsMapMessage() throws Exception { Map<String, Object> originalMap = Collections.singletonMap("testKey", "testValue"); byte[] bytes = new MapToJmsMapMessage().toMimeContent(originalMap); final Data value = new Data(new Binary(bytes)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("jms/map-message")); Message_1_0 sourceMessage = createTestMessage(properties, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "jms/map-message", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", bytes, getBytes(content)); } @Test public void testDataWithContentTypeAmqpList() throws Exception { List<Object> originalMap = Collections.singletonList("testValue"); byte[] bytes = new ListToAmqpListConverter().toMimeContent(originalMap); final Data value = new Data(new Binary(bytes)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("amqp/list")); Message_1_0 sourceMessage = createTestMessage(properties, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "amqp/list", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", bytes, getBytes(content)); } @Test public void testDataWithContentTypeJmsStreamMessage() throws Exception { List<Object> originalMap = Collections.singletonList("testValue"); byte[] bytes = new ListToJmsStreamMessage().toMimeContent(originalMap); final Data value = new Data(new Binary(bytes)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("jms/stream-message")); Message_1_0 sourceMessage = createTestMessage(properties, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "jms/stream-message", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", bytes, getBytes(content)); } @Test public void testDataWithContentTypeJavaSerializedObject() throws Exception { final byte[] expected = getObjectBytes("helloworld".getBytes(UTF_8)); final Data value = new Data(new Binary(expected)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/x-java-serialized-object")); Message_1_0 sourceMessage = createTestMessage(properties, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/java-object-stream", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", expected, getBytes(content)); } @Test public void testDataWithContentTypeJavaObjectStream() throws Exception { final byte[] expected = getObjectBytes("helloworld".getBytes(UTF_8)); final Data value = new Data(new Binary(expected)); Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/java-object-stream")); Message_1_0 sourceMessage = createTestMessage(properties, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/java-object-stream", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", expected, getBytes(content)); } @Test public void testDataWithContentTypeOther() throws Exception { final byte[] expected = "helloworld".getBytes(UTF_8); final Data value = new Data(new Binary(expected)); final Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/bin")); Message_1_0 sourceMessage = createTestMessage(properties, value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", expected, getBytes(content)); } @Test public void testData() throws Exception { final byte[] expected = getObjectBytes("helloworld".getBytes(UTF_8)); final Data value = new Data(new Binary(expected)); final Message_1_0 sourceMessage = createTestMessage(value.createEncodingRetainingSection()); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader().getMimeType()); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertArrayEquals("Unexpected content", expected, getBytes(content)); } @Test public void testNoBodyWithMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(MESSAGE_MESSAGE_ANNOTATION, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testNoBodyWithObjectMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(OBJECT_MESSAGE_MESSAGE_ANNOTATION, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected mime type", "application/java-object-stream", convertedMessage.getMessageHeader().getMimeType()); assertArrayEquals("Unexpected content size", getObjectBytes(null), getBytes(content)); } @Test public void testNoBodyWithMapMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(MAP_MESSAGE_MESSAGE_ANNOTATION, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected mime type", "jms/map-message", convertedMessage.getMessageHeader().getMimeType()); assertArrayEquals("Unexpected content size", new MapToJmsMapMessage().toMimeContent(Collections.emptyMap()), getBytes(content)); } @Test public void testNoBodyWithBytesMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(BYTE_MESSAGE_MESSAGE_ANNOTATION, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testNoBodyWithStreamMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(STREAM_MESSAGE_MESSAGE_ANNOTATION, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "jms/stream-message", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testNoBodyWithTextMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(TEXT_MESSAGE_MESSAGE_ANNOTATION, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testNoBodyWithUnknownMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(new MessageAnnotations(Collections.singletonMap(Symbol.valueOf("x-opt-jms-msg-type"), (byte) 11)), null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testNoBody() throws Exception { final Message_1_0 sourceMessage = createTestMessage(null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testNoBodyWithContentTypeApplicationOctetStream() throws Exception { Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/octet-stream")); final Message_1_0 sourceMessage = createTestMessage(properties, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader() .getMimeType()); assertEquals("Unexpected content size", (long) 0, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testNoBodyWithObjectMessageContentType() throws Exception { final Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/x-java-serialized-object")); final Message_1_0 sourceMessage = createTestMessage(properties, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/java-object-stream", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) getObjectBytes(null).length, (long) convertedMessage.getMessageMetaData().getContentSize()); } @Test public void testNoBodyWithJmsMapContentType() throws Exception { final Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("jms/map-message")); final Message_1_0 sourceMessage = createTestMessage(properties, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); final QpidByteBuffer content = convertedMessage.getContent(0, (int) convertedMessage.getSize()); assertEquals("Unexpected mime type", "jms/map-message", convertedMessage.getMessageHeader().getMimeType()); assertArrayEquals("Unexpected content size", new MapToJmsMapMessage().toMimeContent(Collections.emptyMap()), getBytes(content)); } @Test public void testMessageAnnotationTakesPrecedenceOverContentType() throws Exception { final Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/octet-stream")); final Message_1_0 sourceMessage = createTestMessage(OBJECT_MESSAGE_MESSAGE_ANNOTATION, null); final AMQMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/java-object-stream", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content size", (long) getObjectBytes(null).length, (long) convertedMessage.getMessageMetaData().getContentSize()); }
MessageConverter_v1_0_to_Internal implements MessageConverter<Message_1_0, InternalMessage> { @Override public InternalMessage convert(Message_1_0 serverMessage, NamedAddressSpace addressSpace) { Object bodyObject = MessageConverter_from_1_0.convertBodyToObject(serverMessage); final AMQMessageHeader convertHeader = convertHeader(serverMessage, addressSpace, bodyObject); return InternalMessage.convert(serverMessage, convertHeader, bodyObject); } @Override Class<Message_1_0> getInputClass(); @Override Class<InternalMessage> getOutputClass(); @Override InternalMessage convert(Message_1_0 serverMessage, NamedAddressSpace addressSpace); @Override void dispose(final InternalMessage message); @Override String getType(); }
@Test public void testAmqpValueWithNullWithBytesMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(BYTE_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader().getMimeType()); assertNull("Unexpected content", convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithNullWithStreamMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(STREAM_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertNull("Unexpected content", convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithNullWithUnknownMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(new MessageAnnotations(Collections.singletonMap(Symbol.valueOf("x-opt-jms-msg-type"), (byte) 11)), amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertNull("Unexpected content", convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithNullWithContentType() throws Exception { Properties properties = new Properties(); final String mimeType = "foo/bar"; properties.setContentType(Symbol.valueOf(mimeType)); final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(properties, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", mimeType, convertedMessage.getMessageHeader().getMimeType()); assertNull("Unexpected content", convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithNull() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertNull("Unexpected content", convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithString() throws Exception { final String expected = "testContent"; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", expected, convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithStringWithKnownTextualContentType() throws Exception { Properties properties = new Properties(); final String mimeType = "text/foo"; properties.setContentType(Symbol.valueOf(mimeType)); final Object expected = "content"; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(properties, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", mimeType, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", expected, convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithStringWithUnknownTextualContentType() throws Exception { Properties properties = new Properties(); final String mimeType = "foo/bar"; properties.setContentType(Symbol.valueOf(mimeType)); final Object expected = "content"; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(properties, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", expected, convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithMap() throws Exception { final Map<Object, Object> originalMap = new LinkedHashMap<>(); originalMap.put("binaryEntry", new Binary(new byte[]{0x00, (byte) 0xFF})); originalMap.put("intEntry", 42); originalMap.put("uuidEntry", UUID.randomUUID()); originalMap.put("nullEntry", null); originalMap.put(43, "nonstringkey"); originalMap.put("mapEntry", Collections.singletonMap("foo", "bar")); final AmqpValue amqpValue = new AmqpValue(originalMap); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); Map<Object, Object> convertedMap = (Map<Object, Object>) convertedMessage.getMessageBody(); assertEquals("Unexpected size", (long) originalMap.size(), (long) convertedMap.size()); assertArrayEquals("Unexpected binary entry", ((Binary) originalMap.get("binaryEntry")).getArray(), (byte[]) convertedMap.get("binaryEntry")); assertEquals("Unexpected int entry", originalMap.get("intEntry"), convertedMap.get("intEntry")); assertEquals("Unexpected null entry", originalMap.get("nullEntry"), convertedMap.get("nullEntry")); assertEquals("Unexpected uuid entry", originalMap.get("uuidEntry"), convertedMap.get("uuidEntry")); assertEquals("Unexpected nonstringkey entry", originalMap.get(43), convertedMap.get(43)); assertEquals("Unexpected map entry", new HashMap((Map) originalMap.get("mapEntry")), new HashMap((Map) convertedMap.get("mapEntry"))); } @Test public void testAmqpValueWithList() throws Exception { final List<Object> originalList = new ArrayList<>(); originalList.add(new Binary(new byte[]{0x00, (byte) 0xFF})); originalList.add(42); originalList.add(null); originalList.add(Collections.singletonMap("foo", "bar")); final AmqpValue amqpValue = new AmqpValue(originalList); Message_1_0 sourceMessage = createTestMessage(amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); List<Object> convertedList = ((List<Object>) convertedMessage.getMessageBody()); assertEquals("Unexpected size", (long) originalList.size(), (long) convertedList.size()); assertArrayEquals("Unexpected binary item", ((Binary) originalList.get(0)).getArray(), (byte[]) convertedList.get(0)); assertEquals("Unexpected int item", originalList.get(1), convertedList.get(1)); assertEquals("Unexpected null item", originalList.get(2), convertedList.get(2)); assertEquals("Unexpected map item", new HashMap((Map) originalList.get(3)), new HashMap((Map) convertedList.get(3))); } @Test public void testAmqpValueWithAmqpType() throws Exception { final Date originalValue = new Date(); final AmqpValue amqpValue = new AmqpValue(originalValue); Properties properties = new Properties(); final String mimeType = "foo/bar"; properties.setContentType(Symbol.valueOf(mimeType)); Message_1_0 sourceMessage = createTestMessage(properties, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", mimeType, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", originalValue, convertedMessage.getMessageBody()); } @Test public void testAmqpSequenceWithSimpleTypes() throws Exception { final List<Object> originalList = new ArrayList<>(); originalList.add(37); originalList.add(42F); final AmqpSequence amqpSequence = new AmqpSequence(originalList); Message_1_0 sourceMessage = createTestMessage(amqpSequence.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); List<Object> convertedList = ((List<Object>) convertedMessage.getMessageBody()); assertEquals("Unexpected size", (long) originalList.size(), (long) convertedList.size()); assertEquals("Unexpected first item", originalList.get(0), convertedList.get(0)); assertEquals("Unexpected second item", originalList.get(1), convertedList.get(1)); } @Test public void testData() throws Exception { final byte[] expected = getObjectBytes("helloworld".getBytes(UTF_8)); final Data value = new Data(new Binary(expected)); final Message_1_0 sourceMessage = createTestMessage(value.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader().getMimeType()); assertArrayEquals("Unexpected content", expected, ((byte[]) convertedMessage.getMessageBody())); } @Test public void testNoBodyWithMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithObjectMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(OBJECT_MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/x-java-serialized-object", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithMapMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(MAP_MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithBytesMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(BYTE_MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/octet-stream", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithStreamMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(STREAM_MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithTextMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(TEXT_MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithTextMessageAnnotationWithKnownTextualContentType() throws Exception { final String mimeType = "text/foo"; Properties properties = new Properties(); properties.setContentType(Symbol.valueOf(mimeType)); Message_1_0 sourceMessage = createTestMessage(properties, TEXT_MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", mimeType, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithTextMessageAnnotationWithUnknownTextualContentType() throws Exception { final String mimeType = "foo/bar"; Properties properties = new Properties(); properties.setContentType(Symbol.valueOf(mimeType)); Message_1_0 sourceMessage = createTestMessage(properties, TEXT_MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithUnknownMessageAnnotation() throws Exception { Message_1_0 sourceMessage = createTestMessage(new MessageAnnotations(Collections.singletonMap(Symbol.valueOf("x-opt-jms-msg-type"), (byte) 11)), null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithUnknownMessageAnnotationWithContentType() throws Exception { final String mimeType = "foo/bar"; Properties properties = new Properties(); properties.setContentType(Symbol.valueOf(mimeType)); Message_1_0 sourceMessage = createTestMessage(properties, new MessageAnnotations(Collections.singletonMap(Symbol.valueOf("x-opt-jms-msg-type"), (byte) 11)), null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", mimeType, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBody() throws Exception { final Message_1_0 sourceMessage = createTestMessage(null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testNoBodyWithContentTypeApplicationOctetStream() throws Exception { final String mimeType = "foo/bar"; Properties properties = new Properties(); properties.setContentType(Symbol.valueOf(mimeType)); final Message_1_0 sourceMessage = createTestMessage(properties, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", mimeType, convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testMessageAnnotationTakesPrecedenceOverContentType() throws Exception { final Properties properties = new Properties(); properties.setContentType(Symbol.valueOf("application/octet-stream")); final Message_1_0 sourceMessage = createTestMessage(OBJECT_MESSAGE_MESSAGE_ANNOTATION, null); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/x-java-serialized-object", convertedMessage.getMessageHeader().getMimeType()); assertEquals("Unexpected content", null, convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithNullWithTextMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(TEXT_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertNull("Unexpected content", convertedMessage.getMessageBody()); assertEquals("Unexpected mime type", "text/plain", convertedMessage.getMessageHeader().getMimeType()); } @Test public void testAmqpValueWithNullWithMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertNull("Unexpected content", convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithNullWithObjectMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(OBJECT_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", "application/x-java-serialized-object", convertedMessage.getMessageHeader().getMimeType()); assertNull("Unexpected content", convertedMessage.getMessageBody()); } @Test public void testAmqpValueWithNullWithMapMessageAnnotation() throws Exception { final Object expected = null; final AmqpValue amqpValue = new AmqpValue(expected); Message_1_0 sourceMessage = createTestMessage(MAP_MESSAGE_MESSAGE_ANNOTATION, amqpValue.createEncodingRetainingSection()); final InternalMessage convertedMessage = _converter.convert(sourceMessage, mock(NamedAddressSpace.class)); assertEquals("Unexpected mime type", null, convertedMessage.getMessageHeader().getMimeType()); assertNull("Unexpected content", convertedMessage.getMessageBody()); }
AMQShortString implements Comparable<AMQShortString> { @Override public boolean equals(Object o) { if (o == this) { return true; } if(o instanceof AMQShortString) { return equals((AMQShortString) o); } return false; } private AMQShortString(byte[] data); static String readAMQShortStringAsString(QpidByteBuffer buffer); static AMQShortString readAMQShortString(QpidByteBuffer buffer); static AMQShortString createAMQShortString(byte[] data); static AMQShortString createAMQShortString(String string); int length(); char charAt(int index); byte[] getBytes(); void writeToBuffer(QpidByteBuffer buffer); static void writeShortString(final QpidByteBuffer buffer, final String data); @Override boolean equals(Object o); boolean equals(final AMQShortString otherString); @Override int hashCode(); @Override String toString(); @Override int compareTo(AMQShortString name); boolean contains(final byte b); static AMQShortString validValueOf(Object obj); static AMQShortString valueOf(Object obj); static AMQShortString valueOf(String obj); static String toString(AMQShortString amqShortString); static final int MAX_LENGTH; static final AMQShortString EMPTY_STRING; }
@Test public void testEquals() { assertEquals(GOODBYE, AMQShortString.createAMQShortString("Goodbye")); assertEquals(AMQShortString.createAMQShortString("A"), AMQShortString.createAMQShortString("A")); assertFalse(AMQShortString.createAMQShortString("A").equals(AMQShortString.createAMQShortString("a"))); }
AMQShortString implements Comparable<AMQShortString> { public static AMQShortString createAMQShortString(byte[] data) { if (data == null) { throw new NullPointerException("Cannot create AMQShortString with null data[]"); } final AMQShortString cached = getShortStringCache().getIfPresent(ByteBuffer.wrap(data)); return cached != null ? cached : new AMQShortString(data); } private AMQShortString(byte[] data); static String readAMQShortStringAsString(QpidByteBuffer buffer); static AMQShortString readAMQShortString(QpidByteBuffer buffer); static AMQShortString createAMQShortString(byte[] data); static AMQShortString createAMQShortString(String string); int length(); char charAt(int index); byte[] getBytes(); void writeToBuffer(QpidByteBuffer buffer); static void writeShortString(final QpidByteBuffer buffer, final String data); @Override boolean equals(Object o); boolean equals(final AMQShortString otherString); @Override int hashCode(); @Override String toString(); @Override int compareTo(AMQShortString name); boolean contains(final byte b); static AMQShortString validValueOf(Object obj); static AMQShortString valueOf(Object obj); static AMQShortString valueOf(String obj); static String toString(AMQShortString amqShortString); static final int MAX_LENGTH; static final AMQShortString EMPTY_STRING; }
@Test public void testCreateAMQShortStringStringOver255() { String test = buildString('a', 256); try { AMQShortString.createAMQShortString(test); fail("It should not be possible to create AMQShortString with length over 255"); } catch (IllegalArgumentException e) { assertEquals("Exception message differs from expected", "Cannot create AMQShortString with number of octets over 255!", e.getMessage()); } }
AMQShortString implements Comparable<AMQShortString> { static AMQShortString valueOf(Object obj, boolean truncate, boolean nullAsEmptyString) { if (obj == null) { if (nullAsEmptyString) { return EMPTY_STRING; } return null; } else { String value = String.valueOf(obj); int strLength = Math.min(value.length(), AMQShortString.MAX_LENGTH); byte[] bytes = EncodingUtils.asUTF8Bytes(value); if(truncate) { while (bytes.length > AMQShortString.MAX_LENGTH) { value = value.substring(0, strLength-- - 3) + "..."; bytes = EncodingUtils.asUTF8Bytes(value); } } return createAMQShortString(bytes); } } private AMQShortString(byte[] data); static String readAMQShortStringAsString(QpidByteBuffer buffer); static AMQShortString readAMQShortString(QpidByteBuffer buffer); static AMQShortString createAMQShortString(byte[] data); static AMQShortString createAMQShortString(String string); int length(); char charAt(int index); byte[] getBytes(); void writeToBuffer(QpidByteBuffer buffer); static void writeShortString(final QpidByteBuffer buffer, final String data); @Override boolean equals(Object o); boolean equals(final AMQShortString otherString); @Override int hashCode(); @Override String toString(); @Override int compareTo(AMQShortString name); boolean contains(final byte b); static AMQShortString validValueOf(Object obj); static AMQShortString valueOf(Object obj); static AMQShortString valueOf(String obj); static String toString(AMQShortString amqShortString); static final int MAX_LENGTH; static final AMQShortString EMPTY_STRING; }
@Test public void testValueOf() { String string = buildString('a', 255); AMQShortString shortString = AMQShortString.valueOf(string, true, true); assertEquals("Unexpected string from valueOf", string, shortString.toString()); } @Test public void testValueOfNulAsEmptyString() { AMQShortString shortString = AMQShortString.valueOf(null, true, true); assertEquals("Unexpected empty string from valueOf", AMQShortString.EMPTY_STRING, shortString); } @Test public void testValueOfNullAsNull() { AMQShortString shortString = AMQShortString.valueOf(null, true, false); assertEquals("Unexpected null string from valueOf", null, shortString); }
BasicContentHeaderProperties { public synchronized int getPropertyListSize() { if(useEncodedForm()) { return _encodedForm.remaining(); } else { int size = 0; if ((_propertyFlags & (CONTENT_TYPE_MASK)) != 0) { size += EncodingUtils.encodedShortStringLength(_contentType); } if ((_propertyFlags & ENCODING_MASK) != 0) { size += EncodingUtils.encodedShortStringLength(_encoding); } if ((_propertyFlags & HEADERS_MASK) != 0) { size += EncodingUtils.encodedFieldTableLength(_headers); } if ((_propertyFlags & DELIVERY_MODE_MASK) != 0) { size += 1; } if ((_propertyFlags & PRIORITY_MASK) != 0) { size += 1; } if ((_propertyFlags & CORRELATION_ID_MASK) != 0) { size += EncodingUtils.encodedShortStringLength(_correlationId); } if ((_propertyFlags & REPLY_TO_MASK) != 0) { size += EncodingUtils.encodedShortStringLength(_replyTo); } if ((_propertyFlags & EXPIRATION_MASK) != 0) { if (_expiration == 0L) { size += EncodingUtils.encodedShortStringLength(ZERO_STRING); } else { size += EncodingUtils.encodedShortStringLength(_expiration); } } if ((_propertyFlags & MESSAGE_ID_MASK) != 0) { size += EncodingUtils.encodedShortStringLength(_messageId); } if ((_propertyFlags & TIMESTAMP_MASK) != 0) { size += 8; } if ((_propertyFlags & TYPE_MASK) != 0) { size += EncodingUtils.encodedShortStringLength(_type); } if ((_propertyFlags & USER_ID_MASK) != 0) { size += EncodingUtils.encodedShortStringLength(_userId); } if ((_propertyFlags & APPLICATION_ID_MASK) != 0) { size += EncodingUtils.encodedShortStringLength(_appId); } if ((_propertyFlags & CLUSTER_ID_MASK) != 0) { size += EncodingUtils.encodedShortStringLength(_clusterId); } return size; } } BasicContentHeaderProperties(BasicContentHeaderProperties other); BasicContentHeaderProperties(); BasicContentHeaderProperties(QpidByteBuffer buffer, int propertyFlags, int size); synchronized int getPropertyListSize(); void setPropertyFlags(int propertyFlags); int getPropertyFlags(); synchronized long writePropertyListPayload(QpidByteBuffer buffer); synchronized long writePropertyListPayload(final ByteBufferSender sender); AMQShortString getContentType(); String getContentTypeAsString(); synchronized void setContentType(AMQShortString contentType); void setContentType(String contentType); String getEncodingAsString(); AMQShortString getEncoding(); void setEncoding(String encoding); synchronized void setEncoding(AMQShortString encoding); synchronized Object getHeader(String name); synchronized Collection<String> getHeaderNames(); synchronized boolean containsHeader(String name); synchronized Map<String, Object> getHeadersAsMap(); synchronized void setHeaders(FieldTable headers); byte getDeliveryMode(); synchronized void setDeliveryMode(byte deliveryMode); byte getPriority(); synchronized void setPriority(byte priority); AMQShortString getCorrelationId(); String getCorrelationIdAsString(); void setCorrelationId(String correlationId); synchronized void setCorrelationId(AMQShortString correlationId); String getReplyToAsString(); AMQShortString getReplyTo(); void setReplyTo(String replyTo); synchronized void setReplyTo(AMQShortString replyTo); long getExpiration(); synchronized void setExpiration(long expiration); boolean hasExpiration(); AMQShortString getMessageId(); String getMessageIdAsString(); void setMessageId(String messageId); synchronized void setMessageId(AMQShortString messageId); long getTimestamp(); synchronized void setTimestamp(long timestamp); boolean hasTimestamp(); String getTypeAsString(); AMQShortString getType(); void setType(String type); synchronized void setType(AMQShortString type); String getUserIdAsString(); AMQShortString getUserId(); void setUserId(String userId); synchronized void setUserId(AMQShortString userId); String getAppIdAsString(); AMQShortString getAppId(); void setAppId(String appId); synchronized void setAppId(AMQShortString appId); String getClusterIdAsString(); AMQShortString getClusterId(); void setClusterId(String clusterId); synchronized void setClusterId(AMQShortString clusterId); @Override String toString(); synchronized void dispose(); synchronized void clearEncodedForm(); synchronized void validate(); boolean checkValid(); static final byte NON_PERSISTENT; static final byte PERSISTENT; }
@Test public void testGetPropertyListSize() { int expectedSize = EncodingUtils.encodedIntegerLength(); expectedSize += EncodingUtils.encodedShortStringLength("TestInt"); expectedSize += 1 + EncodingUtils.encodedIntegerLength(); expectedSize += EncodingUtils.encodedShortStringLength("TestString"); expectedSize += 1 + EncodingUtils.encodedLongStringLength(_testString); int size = _testProperties.getPropertyListSize(); assertEquals((long) expectedSize, (long) size); }
BasicContentHeaderProperties { public synchronized void dispose() { nullEncodedForm(); if (_headers != null) { _headers.dispose(); } } BasicContentHeaderProperties(BasicContentHeaderProperties other); BasicContentHeaderProperties(); BasicContentHeaderProperties(QpidByteBuffer buffer, int propertyFlags, int size); synchronized int getPropertyListSize(); void setPropertyFlags(int propertyFlags); int getPropertyFlags(); synchronized long writePropertyListPayload(QpidByteBuffer buffer); synchronized long writePropertyListPayload(final ByteBufferSender sender); AMQShortString getContentType(); String getContentTypeAsString(); synchronized void setContentType(AMQShortString contentType); void setContentType(String contentType); String getEncodingAsString(); AMQShortString getEncoding(); void setEncoding(String encoding); synchronized void setEncoding(AMQShortString encoding); synchronized Object getHeader(String name); synchronized Collection<String> getHeaderNames(); synchronized boolean containsHeader(String name); synchronized Map<String, Object> getHeadersAsMap(); synchronized void setHeaders(FieldTable headers); byte getDeliveryMode(); synchronized void setDeliveryMode(byte deliveryMode); byte getPriority(); synchronized void setPriority(byte priority); AMQShortString getCorrelationId(); String getCorrelationIdAsString(); void setCorrelationId(String correlationId); synchronized void setCorrelationId(AMQShortString correlationId); String getReplyToAsString(); AMQShortString getReplyTo(); void setReplyTo(String replyTo); synchronized void setReplyTo(AMQShortString replyTo); long getExpiration(); synchronized void setExpiration(long expiration); boolean hasExpiration(); AMQShortString getMessageId(); String getMessageIdAsString(); void setMessageId(String messageId); synchronized void setMessageId(AMQShortString messageId); long getTimestamp(); synchronized void setTimestamp(long timestamp); boolean hasTimestamp(); String getTypeAsString(); AMQShortString getType(); void setType(String type); synchronized void setType(AMQShortString type); String getUserIdAsString(); AMQShortString getUserId(); void setUserId(String userId); synchronized void setUserId(AMQShortString userId); String getAppIdAsString(); AMQShortString getAppId(); void setAppId(String appId); synchronized void setAppId(AMQShortString appId); String getClusterIdAsString(); AMQShortString getClusterId(); void setClusterId(String clusterId); synchronized void setClusterId(AMQShortString clusterId); @Override String toString(); synchronized void dispose(); synchronized void clearEncodedForm(); synchronized void validate(); boolean checkValid(); static final byte NON_PERSISTENT; static final byte PERSISTENT; }
@Test public void testPopulatePropertiesFromBuffer() throws Exception { QpidByteBuffer buf = QpidByteBuffer.wrap(new byte[300]); _testProperties.dispose(); _testProperties = new BasicContentHeaderProperties(buf, 99, 99); }
BasicContentHeaderProperties { synchronized void reallocate() { if (_encodedForm != null) { _encodedForm = QpidByteBuffer.reallocateIfNecessary(_encodedForm); if (_headers != null) { _headers.dispose(); _headers = null; } rebuildHeadersIfHeadersMaskIsSet(); } } BasicContentHeaderProperties(BasicContentHeaderProperties other); BasicContentHeaderProperties(); BasicContentHeaderProperties(QpidByteBuffer buffer, int propertyFlags, int size); synchronized int getPropertyListSize(); void setPropertyFlags(int propertyFlags); int getPropertyFlags(); synchronized long writePropertyListPayload(QpidByteBuffer buffer); synchronized long writePropertyListPayload(final ByteBufferSender sender); AMQShortString getContentType(); String getContentTypeAsString(); synchronized void setContentType(AMQShortString contentType); void setContentType(String contentType); String getEncodingAsString(); AMQShortString getEncoding(); void setEncoding(String encoding); synchronized void setEncoding(AMQShortString encoding); synchronized Object getHeader(String name); synchronized Collection<String> getHeaderNames(); synchronized boolean containsHeader(String name); synchronized Map<String, Object> getHeadersAsMap(); synchronized void setHeaders(FieldTable headers); byte getDeliveryMode(); synchronized void setDeliveryMode(byte deliveryMode); byte getPriority(); synchronized void setPriority(byte priority); AMQShortString getCorrelationId(); String getCorrelationIdAsString(); void setCorrelationId(String correlationId); synchronized void setCorrelationId(AMQShortString correlationId); String getReplyToAsString(); AMQShortString getReplyTo(); void setReplyTo(String replyTo); synchronized void setReplyTo(AMQShortString replyTo); long getExpiration(); synchronized void setExpiration(long expiration); boolean hasExpiration(); AMQShortString getMessageId(); String getMessageIdAsString(); void setMessageId(String messageId); synchronized void setMessageId(AMQShortString messageId); long getTimestamp(); synchronized void setTimestamp(long timestamp); boolean hasTimestamp(); String getTypeAsString(); AMQShortString getType(); void setType(String type); synchronized void setType(AMQShortString type); String getUserIdAsString(); AMQShortString getUserId(); void setUserId(String userId); synchronized void setUserId(AMQShortString userId); String getAppIdAsString(); AMQShortString getAppId(); void setAppId(String appId); synchronized void setAppId(AMQShortString appId); String getClusterIdAsString(); AMQShortString getClusterId(); void setClusterId(String clusterId); synchronized void setClusterId(AMQShortString clusterId); @Override String toString(); synchronized void dispose(); synchronized void clearEncodedForm(); synchronized void validate(); boolean checkValid(); static final byte NON_PERSISTENT; static final byte PERSISTENT; }
@Test public void testReallocate() throws Exception { try { QpidByteBuffer.deinitialisePool(); QpidByteBuffer.initialisePool(BUFFER_SIZE, POOL_SIZE, SPARSITY_FRACTION); try (QpidByteBuffer buffer = QpidByteBuffer.allocateDirect(BUFFER_SIZE)) { _testProperties.setContentType("text/plain"); _testProperties.setUserId("test"); final Map<String, Object> headers = _testProperties.getHeadersAsMap(); final int propertyListSize = _testProperties.getPropertyListSize(); final int flags = _testProperties.getPropertyFlags(); final int pos = BUFFER_SIZE - propertyListSize * 2; buffer.position(pos); try (QpidByteBuffer propertiesBuffer = buffer.view(0, propertyListSize)) { _testProperties.writePropertyListPayload(propertiesBuffer); propertiesBuffer.flip(); BasicContentHeaderProperties testProperties = new BasicContentHeaderProperties(propertiesBuffer, flags, propertyListSize); final Map<String, Object> headersBeforeReallocation = testProperties.getHeadersAsMap(); assertEquals("Unexpected headers", headers, headersBeforeReallocation); buffer.dispose(); assertTrue("Properties buffer should be sparse", propertiesBuffer.isSparse()); testProperties.reallocate(); final Map<String, Object> headersAfterReallocation = testProperties.getHeadersAsMap(); assertEquals("Unexpected headers after re-allocation", headers, headersAfterReallocation); } } } finally { QpidByteBuffer.deinitialisePool(); } }
EncodingUtils { public static long readLongAsShortString(QpidByteBuffer buffer) throws AMQFrameDecodingException { short length = buffer.getUnsignedByte(); short pos = 0; if (length == 0) { return 0L; } byte digit = buffer.get(); boolean isNegative; long result = 0; if (digit == (byte) '-') { isNegative = true; pos++; digit = buffer.get(); } else { isNegative = false; } result = toNumber(digit); pos++; while (pos < length) { pos++; digit = buffer.get(); result = (result << 3) + (result << 1); result += toNumber(digit); } return isNegative ? -result : result; } private EncodingUtils(); static int encodedShortStringLength(String s); static int encodedShortStringLength(long l); static int encodedShortStringLength(AMQShortString s); static int encodedLongStringLength(String s); static int encodedLongstrLength(byte[] bytes); static int encodedFieldTableLength(FieldTable table); static void writeLongAsShortString(QpidByteBuffer buffer, long l); static void writeShortStringBytes(QpidByteBuffer buffer, AMQShortString s); static void writeShortStringBytes(QpidByteBuffer buffer, String s); static void writeLongStringBytes(QpidByteBuffer buffer, String s); static int unsignedIntegerLength(); static void writeFieldTableBytes(QpidByteBuffer buffer, FieldTable table); static void writeLongstr(QpidByteBuffer buffer, byte[] data); static FieldTable readFieldTable(QpidByteBuffer input); static void skipFieldTable(QpidByteBuffer buffer); static String readLongString(QpidByteBuffer buffer); static void skipLongString(final QpidByteBuffer buffer); static byte[] readLongstr(QpidByteBuffer buffer); static void writeBoolean(QpidByteBuffer buffer, boolean aBoolean); static int encodedBooleanLength(); static int encodedByteLength(); static int encodedShortLength(); static int encodedIntegerLength(); static int encodedLongLength(); static int encodedFloatLength(); static int encodedDoubleLength(); static byte[] readBytes(QpidByteBuffer buffer); static void writeBytes(QpidByteBuffer buffer, byte[] data); static int encodedCharLength(); static long readLongAsShortString(QpidByteBuffer buffer); static byte[] asUTF8Bytes(CharSequence string); static int getUTF8Length(CharSequence string); }
@Test public void testReadLongAsShortStringWhenDigitsAreSpecified() throws Exception { _buffer.putUnsignedByte((short)3); _buffer.put((byte)'9'); _buffer.put((byte)'2'); _buffer.put((byte)'0'); _buffer.flip(); assertEquals("Unexpected result", 920L, EncodingUtils.readLongAsShortString(_buffer)); } @Test public void testReadLongAsShortStringWhenNonDigitCharacterIsSpecified() throws Exception { _buffer.putUnsignedByte((short)2); _buffer.put((byte)'1'); _buffer.put((byte)'a'); _buffer.flip(); try { EncodingUtils.readLongAsShortString(_buffer); fail("Exception is expected"); } catch(AMQFrameDecodingException e) { } }
AMQMessageMutator implements ServerMessageMutator<AMQMessage> { @Override public void setPriority(final byte priority) { _basicContentHeaderProperties.setPriority(priority); } AMQMessageMutator(final AMQMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override AMQMessage create(); }
@Test public void setPriority() { _messageMutator.setPriority((byte) (TEST_PRIORITY + 1)); assertThat(_messageMutator.getPriority(), is(equalTo((byte) (TEST_PRIORITY + 1)))); }
AMQMessageMutator implements ServerMessageMutator<AMQMessage> { @Override public byte getPriority() { return _basicContentHeaderProperties.getPriority(); } AMQMessageMutator(final AMQMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override AMQMessage create(); }
@Test public void getPriority() { assertThat((int) _messageMutator.getPriority(), is(equalTo((int) TEST_PRIORITY))); }
AMQMessageMutator implements ServerMessageMutator<AMQMessage> { @Override public AMQMessage create() { final long contentSize = _message.getSize(); final QpidByteBuffer content = _message.getContent(); final ContentHeaderBody contentHeader = new ContentHeaderBody(_basicContentHeaderProperties, contentSize); final MessageMetaData messageMetaData = new MessageMetaData(_message.getMessagePublishInfo(), contentHeader, _message.getArrivalTime()); final MessageHandle<MessageMetaData> handle = _messageStore.addMessage(messageMetaData); if (content != null) { handle.addContent(content); } return new AMQMessage(handle.allContentAdded(), _message.getConnectionReference()); } AMQMessageMutator(final AMQMessage message, final MessageStore messageStore); @Override void setPriority(final byte priority); @Override byte getPriority(); @Override AMQMessage create(); }
@Test public void create() { _messageMutator.setPriority((byte) (TEST_PRIORITY + 1)); AMQMessage newMessage = _messageMutator.create(); assertThat(newMessage.getMessageHeader().getPriority(), is(equalTo((byte) (TEST_PRIORITY + 1)))); assertThat(newMessage.getMessageHeader().getMimeType(), is(equalTo(TEST_CONTENT_TYPE))); assertThat(newMessage.getMessageHeader().getHeader(TEST_HEADER_NAME), is(equalTo(TEST_HEADER_VALUE))); QpidByteBuffer content = newMessage.getContent(); final byte[] bytes = new byte[content.remaining()]; content.copyTo(bytes); assertThat(new String(bytes, UTF_8), is(equalTo(TEST_CONTENT))); }
FieldTable { public long getEncodedSize() { return _fieldTableSupport.getEncodedSize(); } FieldTable(QpidByteBuffer input, int len); FieldTable(QpidByteBuffer buffer); FieldTable(Map<String, Object> properties); FieldTable(FieldTableSupport fieldTableSupport); @Override String toString(); void writeToBuffer(QpidByteBuffer buffer); byte[] getDataAsBytes(); long getEncodedSize(); static Map<String, Object> convertToMap(final FieldTable fieldTable); void dispose(); int size(); boolean isEmpty(); boolean containsKey(String key); Set<String> keys(); Object get(String key); @Override boolean equals(final Object o); @Override int hashCode(); static FieldTable convertToFieldTable(Map<String, Object> map); static FieldTable convertToDecodedFieldTable(final FieldTable fieldTable); void validate(); }
@Test public void testEncodingSize() { Map<String, Object> result = new LinkedHashMap<>(); int size = 0; result.put("boolean", true); size += 1 + EncodingUtils.encodedShortStringLength("boolean") + EncodingUtils.encodedBooleanLength(); result.put("byte", Byte.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("byte") + EncodingUtils.encodedByteLength(); byte[] _bytes = { 99, 98, 97, 96, 95 }; result.put("bytes", _bytes); size += 1 + EncodingUtils.encodedShortStringLength("bytes") + 4 + _bytes.length; result.put("char", 'c'); size += 1 + EncodingUtils.encodedShortStringLength("char") + EncodingUtils.encodedCharLength(); result.put("double", Double.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("double") + EncodingUtils.encodedDoubleLength(); result.put("float", Float.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("float") + EncodingUtils.encodedFloatLength(); result.put("int", Integer.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("int") + EncodingUtils.encodedIntegerLength(); result.put("long", Long.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("long") + EncodingUtils.encodedLongLength(); result.put("short", Short.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("short") + EncodingUtils.encodedShortLength(); result.put("result", "Hello"); size += 1 + EncodingUtils.encodedShortStringLength("result") + EncodingUtils.encodedLongStringLength("Hello"); result.put("object-bool", true); size += 1 + EncodingUtils.encodedShortStringLength("object-bool") + EncodingUtils.encodedBooleanLength(); result.put("object-byte", Byte.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("object-byte") + EncodingUtils.encodedByteLength(); result.put("object-bytes", _bytes); size += 1 + EncodingUtils.encodedShortStringLength("object-bytes") + 4 + _bytes.length; result.put("object-char", 'c'); size += 1 + EncodingUtils.encodedShortStringLength("object-char") + EncodingUtils.encodedCharLength(); result.put("object-double", Double.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("object-double") + EncodingUtils.encodedDoubleLength(); result.put("object-float", Float.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("object-float") + EncodingUtils.encodedFloatLength(); result.put("object-int", Integer.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("object-int") + EncodingUtils.encodedIntegerLength(); result.put("object-long", Long.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("object-long") + EncodingUtils.encodedLongLength(); result.put("object-short", Short.MAX_VALUE); size += 1 + EncodingUtils.encodedShortStringLength("object-short") + EncodingUtils.encodedShortLength(); assertEquals(size, FieldTableFactory.createFieldTable(result).getEncodedSize()); }
FieldTable { @Override public String toString() { return _fieldTableSupport.toString(); } FieldTable(QpidByteBuffer input, int len); FieldTable(QpidByteBuffer buffer); FieldTable(Map<String, Object> properties); FieldTable(FieldTableSupport fieldTableSupport); @Override String toString(); void writeToBuffer(QpidByteBuffer buffer); byte[] getDataAsBytes(); long getEncodedSize(); static Map<String, Object> convertToMap(final FieldTable fieldTable); void dispose(); int size(); boolean isEmpty(); boolean containsKey(String key); Set<String> keys(); Object get(String key); @Override boolean equals(final Object o); @Override int hashCode(); static FieldTable convertToFieldTable(Map<String, Object> map); static FieldTable convertToDecodedFieldTable(final FieldTable fieldTable); void validate(); }
@Test public void testCheckPropertyNameHasMaxLength() { StringBuilder longPropertyName = new StringBuilder(129); for (int i = 0; i < 129; i++) { longPropertyName.append("x"); } boolean strictAMQP = FieldTable._strictAMQP; try { FieldTable._strictAMQP = true; new FieldTable(Collections.singletonMap(longPropertyName.toString(), "String")); fail("property name must be < 128 characters"); } catch (IllegalArgumentException iae) { } finally { FieldTable._strictAMQP = strictAMQP; } }
FieldTable { public void validate() { _fieldTableSupport.validate(); } FieldTable(QpidByteBuffer input, int len); FieldTable(QpidByteBuffer buffer); FieldTable(Map<String, Object> properties); FieldTable(FieldTableSupport fieldTableSupport); @Override String toString(); void writeToBuffer(QpidByteBuffer buffer); byte[] getDataAsBytes(); long getEncodedSize(); static Map<String, Object> convertToMap(final FieldTable fieldTable); void dispose(); int size(); boolean isEmpty(); boolean containsKey(String key); Set<String> keys(); Object get(String key); @Override boolean equals(final Object o); @Override int hashCode(); static FieldTable convertToFieldTable(Map<String, Object> map); static FieldTable convertToDecodedFieldTable(final FieldTable fieldTable); void validate(); }
@Test public void testValidateMalformedFieldTable() { final FieldTable fieldTable = buildMalformedFieldTable(); try { fieldTable.validate(); fail("Exception is expected"); } catch (RuntimeException e) { } }
AMQChannel extends AbstractAMQPSession<AMQChannel, ConsumerTarget_0_8> implements AsyncAutoCommitTransaction.FutureRecorder, ServerChannelMethodProcessor, EventLoggerProvider, CreditRestorer, org.apache.qpid.server.util.Deletable<AMQChannel> { @Override public void receiveExchangeDelete(final AMQShortString exchangeStr, final boolean ifUnused, final boolean nowait) { if(LOGGER.isDebugEnabled()) { LOGGER.debug("RECV[" + _channelId + "] ExchangeDelete[" +" exchange: " + exchangeStr + " ifUnused: " + ifUnused + " nowait: " + nowait + " ]"); } NamedAddressSpace virtualHost = _connection.getAddressSpace(); sync(); if (isDefaultExchange(exchangeStr)) { _connection.sendConnectionClose(ErrorCodes.NOT_ALLOWED, "Default Exchange cannot be deleted", getChannelId()); } else { final String exchangeName = exchangeStr.toString(); final Exchange<?> exchange = getExchange(exchangeName); if (exchange == null) { closeChannel(ErrorCodes.NOT_FOUND, "No such exchange: '" + exchangeStr + "'"); } else { if (ifUnused && exchange.hasBindings()) { closeChannel(ErrorCodes.IN_USE, "Exchange has bindings"); } else { try { exchange.delete(); if (!nowait) { ExchangeDeleteOkBody responseBody = _connection.getMethodRegistry().createExchangeDeleteOkBody(); _connection.writeFrame(responseBody.generateFrame(getChannelId())); } } catch (MessageDestinationIsAlternateException e) { closeChannel(ErrorCodes.NOT_ALLOWED, "Exchange in use as an alternate binding destination"); } catch (RequiredExchangeException e) { closeChannel(ErrorCodes.NOT_ALLOWED, "Exchange '" + exchangeStr + "' cannot be deleted"); } catch (AccessControlException e) { _connection.sendConnectionClose(ErrorCodes.ACCESS_REFUSED, e.getMessage(), getChannelId()); } } } } } AMQChannel(AMQPConnection_0_8 connection, int channelId, final MessageStore messageStore); AccessControlContext getAccessControllerContext(); void receivedComplete(); long getNextDeliveryTag(); @Override void close(); void close(int cause, String message); void addUnacknowledgedMessage(MessageInstance entry, long deliveryTag, MessageInstanceConsumer consumer, final boolean usesCredit); @Override String toString(); @Override boolean isClosing(); AMQPConnection_0_8<?> getConnection(); ClientDeliveryMethod getClientDeliveryMethod(); Subject getSubject(); boolean isChannelFlow(); @Override synchronized void block(); @Override synchronized void unblock(); @Override synchronized void block(Queue<?> queue); @Override synchronized void unblock(Queue<?> queue); @Override void transportStateChanged(); @Override Object getConnectionReference(); @Override int getUnacknowledgedMessageCount(); @Override boolean getBlocking(); NamedAddressSpace getAddressSpace(); @Override void recordFuture(final ListenableFuture<Void> future, final ServerTransaction.Action action); @Override long getTransactionStartTimeLong(); @Override long getTransactionUpdateTimeLong(); @Override void receiveAccessRequest(final AMQShortString realm, final boolean exclusive, final boolean passive, final boolean active, final boolean write, final boolean read); @Override void receiveBasicAck(final long deliveryTag, final boolean multiple); @Override void receiveBasicCancel(final AMQShortString consumerTag, final boolean nowait); @Override void receiveBasicConsume(final AMQShortString queue, final AMQShortString consumerTag, final boolean noLocal, final boolean noAck, final boolean exclusive, final boolean nowait, final FieldTable arguments); @Override void receiveBasicGet(final AMQShortString queueName, final boolean noAck); @Override void receiveBasicPublish(final AMQShortString exchangeName, final AMQShortString routingKey, final boolean mandatory, final boolean immediate); @Override void receiveBasicQos(final long prefetchSize, final int prefetchCount, final boolean global); @Override void receiveBasicRecover(final boolean requeue, final boolean sync); @Override void receiveBasicReject(final long deliveryTag, final boolean requeue); @Override void receiveChannelClose(final int replyCode, final AMQShortString replyText, final int classId, final int methodId); @Override void receiveChannelCloseOk(); @Override void receiveMessageContent(final QpidByteBuffer data); @Override void receiveMessageHeader(final BasicContentHeaderProperties properties, final long bodySize); @Override boolean ignoreAllButCloseOk(); @Override void receiveBasicNack(final long deliveryTag, final boolean multiple, final boolean requeue); @Override void receiveChannelFlow(final boolean active); @Override void receiveChannelFlowOk(final boolean active); @Override void receiveExchangeBound(final AMQShortString exchangeName, final AMQShortString routingKey, final AMQShortString queueName); @Override void receiveExchangeDeclare(final AMQShortString exchangeName, final AMQShortString type, final boolean passive, final boolean durable, final boolean autoDelete, final boolean internal, final boolean nowait, final FieldTable arguments); @Override void receiveExchangeDelete(final AMQShortString exchangeStr, final boolean ifUnused, final boolean nowait); @Override void receiveQueueBind(final AMQShortString queueName, final AMQShortString exchange, AMQShortString bindingKey, final boolean nowait, final FieldTable argumentsTable); @Override void receiveQueueDeclare(final AMQShortString queueStr, final boolean passive, final boolean durable, final boolean exclusive, final boolean autoDelete, final boolean nowait, final FieldTable arguments); @Override void receiveQueueDelete(final AMQShortString queueName, final boolean ifUnused, final boolean ifEmpty, final boolean nowait); @Override void receiveQueuePurge(final AMQShortString queueName, final boolean nowait); @Override void receiveQueueUnbind(final AMQShortString queueName, final AMQShortString exchange, final AMQShortString bindingKey, final FieldTable arguments); @Override void receiveTxSelect(); @Override void receiveTxCommit(); @Override void receiveTxRollback(); @Override void receiveConfirmSelect(final boolean nowait); @Override void restoreCredit(final ConsumerTarget target, final int count, final long size); void dispose(); static final int DEFAULT_PREFETCH; }
@Test public void testReceiveExchangeDeleteWhenIfUsedIsSetAndExchangeHasBindings() throws Exception { String testExchangeName = getTestName(); Exchange<?> exchange = mock(Exchange.class); when(exchange.hasBindings()).thenReturn(true); doReturn(exchange).when(_virtualHost).getAttainedMessageDestination(eq(testExchangeName), anyBoolean()); AMQChannel channel = new AMQChannel(_amqConnection, 1, _messageStore); channel.receiveExchangeDelete(AMQShortString.valueOf(testExchangeName), true, false); verify(_amqConnection).closeChannelAndWriteFrame(eq(channel), eq(ErrorCodes.IN_USE), eq("Exchange has bindings")); } @Test public void testReceiveExchangeDeleteWhenIfUsedIsSetAndExchangeHasNoBinding() throws Exception { Exchange<?> exchange = mock(Exchange.class); when(exchange.hasBindings()).thenReturn(false); doReturn(exchange).when(_virtualHost).getAttainedMessageDestination(eq(getTestName()), anyBoolean()); AMQChannel channel = new AMQChannel(_amqConnection, 1, _messageStore); channel.receiveExchangeDelete(AMQShortString.valueOf(getTestName()), true, false); verify(exchange).delete(); }
QpidException extends Exception { @Override public String toString() { return getClass().getName() + ": " + getMessage(); } QpidException(String msg); QpidException(String msg, Throwable cause); @Override String toString(); QpidException cloneForCurrentThread(); @Override QpidException clone(); }
@Test public void testGetMessageAsString() { StringBuilder sb = new StringBuilder(); for (int i = 0; i < 25; i++) { sb.append("message [" + i + "]"); } AMQException e = new AMQException(ErrorCodes.INTERNAL_ERROR, sb.toString(), null); AMQShortString message = AMQShortString.validValueOf(e.getMessage()); assertEquals(sb.substring(0, AMQShortString.MAX_LENGTH - 3) + "...", message.toString()); }
HttpManagement extends AbstractPluginAdapter<HttpManagement> implements HttpManagementConfiguration<HttpManagement>, PortManager { @Override public int getSessionTimeout() { return _sessionTimeout; } @ManagedObjectFactoryConstructor HttpManagement(Map<String, Object> attributes, Broker broker); @Override int getSessionTimeout(); @Override String getCorsAllowOrigins(); @Override Set<String> getCorsAllowMethods(); @Override String getCorsAllowHeaders(); @Override boolean getCorsAllowCredentials(); @Override int getBoundPort(final HttpPort httpPort); @Override int getNumberOfAcceptors(HttpPort httpPort); @Override int getNumberOfSelectors(HttpPort httpPort); @Override SSLContext getSSLContext(final HttpPort httpPort); @Override boolean updateSSLContext(final HttpPort httpPort); @Override boolean isHttpsSaslAuthenticationEnabled(); @Override boolean isHttpSaslAuthenticationEnabled(); @Override boolean isHttpsBasicAuthenticationEnabled(); @Override boolean isHttpBasicAuthenticationEnabled(); @Override boolean isCompressResponses(); @Override AuthenticationProvider getAuthenticationProvider(HttpServletRequest request); @SuppressWarnings("unused") static Set<String> getAllAvailableCorsMethodCombinations(); @Override HttpPort<?> getPort(final HttpServletRequest request); @Override long getSaslExchangeExpiry(); static final int DEFAULT_TIMEOUT_IN_SECONDS; static final String TIME_OUT; static final String HTTP_BASIC_AUTHENTICATION_ENABLED; static final String HTTPS_BASIC_AUTHENTICATION_ENABLED; static final String HTTP_SASL_AUTHENTICATION_ENABLED; static final String HTTPS_SASL_AUTHENTICATION_ENABLED; static final String PLUGIN_TYPE; static final String DEFAULT_LOGOUT_URL; static final String DEFAULT_LOGIN_URL; @ManagedAttributeField public String _corsAllowOrigins; @ManagedAttributeField public Set<String> _corsAllowMethods; @ManagedAttributeField public String _corsAllowHeaders; @ManagedAttributeField public boolean _corsAllowCredentials; }
@Test public void testGetSessionTimeout() { assertEquals("Unexpected session timeout", 10000l, (long) _management.getSessionTimeout()); }
HttpManagement extends AbstractPluginAdapter<HttpManagement> implements HttpManagementConfiguration<HttpManagement>, PortManager { @Override public boolean isHttpsSaslAuthenticationEnabled() { return _httpsSaslAuthenticationEnabled; } @ManagedObjectFactoryConstructor HttpManagement(Map<String, Object> attributes, Broker broker); @Override int getSessionTimeout(); @Override String getCorsAllowOrigins(); @Override Set<String> getCorsAllowMethods(); @Override String getCorsAllowHeaders(); @Override boolean getCorsAllowCredentials(); @Override int getBoundPort(final HttpPort httpPort); @Override int getNumberOfAcceptors(HttpPort httpPort); @Override int getNumberOfSelectors(HttpPort httpPort); @Override SSLContext getSSLContext(final HttpPort httpPort); @Override boolean updateSSLContext(final HttpPort httpPort); @Override boolean isHttpsSaslAuthenticationEnabled(); @Override boolean isHttpSaslAuthenticationEnabled(); @Override boolean isHttpsBasicAuthenticationEnabled(); @Override boolean isHttpBasicAuthenticationEnabled(); @Override boolean isCompressResponses(); @Override AuthenticationProvider getAuthenticationProvider(HttpServletRequest request); @SuppressWarnings("unused") static Set<String> getAllAvailableCorsMethodCombinations(); @Override HttpPort<?> getPort(final HttpServletRequest request); @Override long getSaslExchangeExpiry(); static final int DEFAULT_TIMEOUT_IN_SECONDS; static final String TIME_OUT; static final String HTTP_BASIC_AUTHENTICATION_ENABLED; static final String HTTPS_BASIC_AUTHENTICATION_ENABLED; static final String HTTP_SASL_AUTHENTICATION_ENABLED; static final String HTTPS_SASL_AUTHENTICATION_ENABLED; static final String PLUGIN_TYPE; static final String DEFAULT_LOGOUT_URL; static final String DEFAULT_LOGIN_URL; @ManagedAttributeField public String _corsAllowOrigins; @ManagedAttributeField public Set<String> _corsAllowMethods; @ManagedAttributeField public String _corsAllowHeaders; @ManagedAttributeField public boolean _corsAllowCredentials; }
@Test public void testIsHttpsSaslAuthenticationEnabled() { assertEquals("Unexpected value for the https sasl enabled attribute", true, _management.isHttpsSaslAuthenticationEnabled()); }
HttpManagement extends AbstractPluginAdapter<HttpManagement> implements HttpManagementConfiguration<HttpManagement>, PortManager { @Override public boolean isHttpSaslAuthenticationEnabled() { return _httpSaslAuthenticationEnabled; } @ManagedObjectFactoryConstructor HttpManagement(Map<String, Object> attributes, Broker broker); @Override int getSessionTimeout(); @Override String getCorsAllowOrigins(); @Override Set<String> getCorsAllowMethods(); @Override String getCorsAllowHeaders(); @Override boolean getCorsAllowCredentials(); @Override int getBoundPort(final HttpPort httpPort); @Override int getNumberOfAcceptors(HttpPort httpPort); @Override int getNumberOfSelectors(HttpPort httpPort); @Override SSLContext getSSLContext(final HttpPort httpPort); @Override boolean updateSSLContext(final HttpPort httpPort); @Override boolean isHttpsSaslAuthenticationEnabled(); @Override boolean isHttpSaslAuthenticationEnabled(); @Override boolean isHttpsBasicAuthenticationEnabled(); @Override boolean isHttpBasicAuthenticationEnabled(); @Override boolean isCompressResponses(); @Override AuthenticationProvider getAuthenticationProvider(HttpServletRequest request); @SuppressWarnings("unused") static Set<String> getAllAvailableCorsMethodCombinations(); @Override HttpPort<?> getPort(final HttpServletRequest request); @Override long getSaslExchangeExpiry(); static final int DEFAULT_TIMEOUT_IN_SECONDS; static final String TIME_OUT; static final String HTTP_BASIC_AUTHENTICATION_ENABLED; static final String HTTPS_BASIC_AUTHENTICATION_ENABLED; static final String HTTP_SASL_AUTHENTICATION_ENABLED; static final String HTTPS_SASL_AUTHENTICATION_ENABLED; static final String PLUGIN_TYPE; static final String DEFAULT_LOGOUT_URL; static final String DEFAULT_LOGIN_URL; @ManagedAttributeField public String _corsAllowOrigins; @ManagedAttributeField public Set<String> _corsAllowMethods; @ManagedAttributeField public String _corsAllowHeaders; @ManagedAttributeField public boolean _corsAllowCredentials; }
@Test public void testIsHttpSaslAuthenticationEnabled() { assertEquals("Unexpected value for the http sasl enabled attribute", false, _management.isHttpSaslAuthenticationEnabled()); }
HttpManagement extends AbstractPluginAdapter<HttpManagement> implements HttpManagementConfiguration<HttpManagement>, PortManager { @Override public boolean isHttpsBasicAuthenticationEnabled() { return _httpsBasicAuthenticationEnabled; } @ManagedObjectFactoryConstructor HttpManagement(Map<String, Object> attributes, Broker broker); @Override int getSessionTimeout(); @Override String getCorsAllowOrigins(); @Override Set<String> getCorsAllowMethods(); @Override String getCorsAllowHeaders(); @Override boolean getCorsAllowCredentials(); @Override int getBoundPort(final HttpPort httpPort); @Override int getNumberOfAcceptors(HttpPort httpPort); @Override int getNumberOfSelectors(HttpPort httpPort); @Override SSLContext getSSLContext(final HttpPort httpPort); @Override boolean updateSSLContext(final HttpPort httpPort); @Override boolean isHttpsSaslAuthenticationEnabled(); @Override boolean isHttpSaslAuthenticationEnabled(); @Override boolean isHttpsBasicAuthenticationEnabled(); @Override boolean isHttpBasicAuthenticationEnabled(); @Override boolean isCompressResponses(); @Override AuthenticationProvider getAuthenticationProvider(HttpServletRequest request); @SuppressWarnings("unused") static Set<String> getAllAvailableCorsMethodCombinations(); @Override HttpPort<?> getPort(final HttpServletRequest request); @Override long getSaslExchangeExpiry(); static final int DEFAULT_TIMEOUT_IN_SECONDS; static final String TIME_OUT; static final String HTTP_BASIC_AUTHENTICATION_ENABLED; static final String HTTPS_BASIC_AUTHENTICATION_ENABLED; static final String HTTP_SASL_AUTHENTICATION_ENABLED; static final String HTTPS_SASL_AUTHENTICATION_ENABLED; static final String PLUGIN_TYPE; static final String DEFAULT_LOGOUT_URL; static final String DEFAULT_LOGIN_URL; @ManagedAttributeField public String _corsAllowOrigins; @ManagedAttributeField public Set<String> _corsAllowMethods; @ManagedAttributeField public String _corsAllowHeaders; @ManagedAttributeField public boolean _corsAllowCredentials; }
@Test public void testIsHttpsBasicAuthenticationEnabled() { assertEquals("Unexpected value for the https basic authentication enabled attribute", true, _management.isHttpsBasicAuthenticationEnabled()); }
HttpManagement extends AbstractPluginAdapter<HttpManagement> implements HttpManagementConfiguration<HttpManagement>, PortManager { @Override public boolean isHttpBasicAuthenticationEnabled() { return _httpBasicAuthenticationEnabled; } @ManagedObjectFactoryConstructor HttpManagement(Map<String, Object> attributes, Broker broker); @Override int getSessionTimeout(); @Override String getCorsAllowOrigins(); @Override Set<String> getCorsAllowMethods(); @Override String getCorsAllowHeaders(); @Override boolean getCorsAllowCredentials(); @Override int getBoundPort(final HttpPort httpPort); @Override int getNumberOfAcceptors(HttpPort httpPort); @Override int getNumberOfSelectors(HttpPort httpPort); @Override SSLContext getSSLContext(final HttpPort httpPort); @Override boolean updateSSLContext(final HttpPort httpPort); @Override boolean isHttpsSaslAuthenticationEnabled(); @Override boolean isHttpSaslAuthenticationEnabled(); @Override boolean isHttpsBasicAuthenticationEnabled(); @Override boolean isHttpBasicAuthenticationEnabled(); @Override boolean isCompressResponses(); @Override AuthenticationProvider getAuthenticationProvider(HttpServletRequest request); @SuppressWarnings("unused") static Set<String> getAllAvailableCorsMethodCombinations(); @Override HttpPort<?> getPort(final HttpServletRequest request); @Override long getSaslExchangeExpiry(); static final int DEFAULT_TIMEOUT_IN_SECONDS; static final String TIME_OUT; static final String HTTP_BASIC_AUTHENTICATION_ENABLED; static final String HTTPS_BASIC_AUTHENTICATION_ENABLED; static final String HTTP_SASL_AUTHENTICATION_ENABLED; static final String HTTPS_SASL_AUTHENTICATION_ENABLED; static final String PLUGIN_TYPE; static final String DEFAULT_LOGOUT_URL; static final String DEFAULT_LOGIN_URL; @ManagedAttributeField public String _corsAllowOrigins; @ManagedAttributeField public Set<String> _corsAllowMethods; @ManagedAttributeField public String _corsAllowHeaders; @ManagedAttributeField public boolean _corsAllowCredentials; }
@Test public void testIsHttpBasicAuthenticationEnabled() { assertEquals("Unexpected value for the http basic authentication enabled attribute", false, _management.isHttpBasicAuthenticationEnabled()); }
LoginLogoutReporter implements HttpSessionBindingListener { @Override public void valueBound(HttpSessionBindingEvent arg0) { reportLogin(); } LoginLogoutReporter(Subject subject, EventLoggerProvider eventLoggerProvider); @Override void valueBound(HttpSessionBindingEvent arg0); @Override void valueUnbound(HttpSessionBindingEvent arg0); EventLogger getEventLogger(); }
@Test public void testLoginLogged() { _loginLogoutReport.valueBound(null); verify(_logger).message(isLogMessageWithMessage("MNG-1007 : Open : User mockusername")); }
LoginLogoutReporter implements HttpSessionBindingListener { @Override public void valueUnbound(HttpSessionBindingEvent arg0) { reportLogout(); } LoginLogoutReporter(Subject subject, EventLoggerProvider eventLoggerProvider); @Override void valueBound(HttpSessionBindingEvent arg0); @Override void valueUnbound(HttpSessionBindingEvent arg0); EventLogger getEventLogger(); }
@Test public void testLogoutLogged() { _loginLogoutReport.valueUnbound(null); verify(_logger).message(isLogMessageWithMessage("MNG-1008 : Close : User mockusername")); }
HttpManagementUtil { public static String ensureFilenameIsRfc2183(final String requestedFilename) { return requestedFilename.replaceAll("[\\P{InBasic_Latin}\\\\:/\\p{Cntrl}]", ""); } static String getRequestSpecificAttributeName(String name, HttpServletRequest request); static HttpPort<?> getPort(final HttpServletRequest request); static Broker<?> getBroker(ServletContext servletContext); static HttpManagementConfiguration getManagementConfiguration(ServletContext servletContext); static Subject getAuthorisedSubject(HttpServletRequest request); static Subject createServletConnectionSubject(final HttpServletRequest request, Subject original); static void assertManagementAccess(final Broker<?> broker, Subject subject); static void saveAuthorisedSubject(HttpServletRequest request, Subject subject); static Subject tryToAuthenticate(HttpServletRequest request, HttpManagementConfiguration managementConfig); static OutputStream getOutputStream(final HttpServletRequest request, final HttpServletResponse response); static OutputStream getOutputStream(final HttpServletRequest request, final HttpServletResponse response, HttpManagementConfiguration managementConfiguration); static boolean isCompressingAccepted(final HttpServletRequest request, final HttpManagementConfiguration managementConfiguration); static String ensureFilenameIsRfc2183(final String requestedFilename); static List<String> getPathInfoElements(final String servletPath, final String pathInfo); static String getRequestURL(HttpServletRequest httpRequest); static String getRequestPrincipals(HttpServletRequest httpRequest); static void invalidateSession(HttpSession session); static Object getSessionAttribute(String attributeName, HttpSession session, HttpServletRequest request); static void setSessionAttribute(String attributeName, Object attributeValue, HttpSession session, HttpServletRequest request); static void removeAttribute(final String attributeName, final HttpSession session, final HttpServletRequest request); static void createServletConnectionSubjectAssertManagementAccessAndSave(final Broker broker, final HttpServletRequest request, final Subject original); static final String ATTR_BROKER; static final String ATTR_MANAGEMENT_CONFIGURATION; static final String ACCEPT_ENCODING_HEADER; static final String CONTENT_ENCODING_HEADER; static final String GZIP_CONTENT_ENCODING; }
@Test public void testEnsureFilenameIsRfc2183() { assertEquals("Unexpected conversion", "aBC8-d.json", HttpManagementUtil.ensureFilenameIsRfc2183("aBC8-d.json\n\r\t:/\\")); }
CSVFormat { public <T extends Collection<?>> void printRecord(final Appendable out, final T record) throws IOException { boolean newRecord = true; for (Object item : record) { print(out, item, newRecord); newRecord = false; } println(out); } CSVFormat(); private CSVFormat(final char delimiter, final Character quoteCharacter, final String recordSeparator); void printRecord(final Appendable out, final T record); void printRecords(final Appendable out, final C records); void println(final Appendable out); void print(final Appendable out, final Object value, final boolean newRecord); void printComments(final Appendable out, final String... comments); }
@Test public void testPrintRecord() throws Exception { CSVFormat csvFormat = new CSVFormat(); final StringWriter out = new StringWriter(); csvFormat.printRecord(out, Arrays.asList("test", 1, true, "\"quoted\" test")); assertEquals("Unexpected format", String.format("%s,%d,%b,%s%s", "test", 1, true, "\"\"\"quoted\"\" test\"", "\r\n"), out.toString()); }
CSVFormat { public <C extends Collection<? extends Collection<?>>> void printRecords(final Appendable out, final C records) throws IOException { for (Collection<?> record : records) { printRecord(out, record); } } CSVFormat(); private CSVFormat(final char delimiter, final Character quoteCharacter, final String recordSeparator); void printRecord(final Appendable out, final T record); void printRecords(final Appendable out, final C records); void println(final Appendable out); void print(final Appendable out, final Object value, final boolean newRecord); void printComments(final Appendable out, final String... comments); }
@Test public void testPrintRecords() throws Exception { CSVFormat csvFormat = new CSVFormat(); final StringWriter out = new StringWriter(); csvFormat.printRecords(out, Arrays.asList(Arrays.asList("test", 1, true, "\"quoted\" test"), Arrays.asList("delimeter,test", 1.0f, false, "quote\" in the middle"))); assertEquals("Unexpected format", String.format("%s,%d,%b,%s%s%s,%s,%b,%s%s", "test", 1, true, "\"\"\"quoted\"\" test\"", "\r\n", "\"delimeter,test\"", "1.0", false, "\"quote\"\" in the middle\"", "\r\n"), out.toString()); }
CSVFormat { public void println(final Appendable out) throws IOException { if (_recordSeparator != null) { out.append(_recordSeparator); } } CSVFormat(); private CSVFormat(final char delimiter, final Character quoteCharacter, final String recordSeparator); void printRecord(final Appendable out, final T record); void printRecords(final Appendable out, final C records); void println(final Appendable out); void print(final Appendable out, final Object value, final boolean newRecord); void printComments(final Appendable out, final String... comments); }
@Test public void testPrintln() throws Exception { CSVFormat csvFormat = new CSVFormat(); final StringWriter out = new StringWriter(); csvFormat.println(out); assertEquals("Unexpected new line", "\r\n", out.toString()); }
CSVFormat { public void print(final Appendable out, final Object value, final boolean newRecord) throws IOException { CharSequence charSequence; if (value == null) { charSequence = EMPTY; } else if (value instanceof CharSequence) { charSequence = (CharSequence) value; } else if (value instanceof Date || value instanceof Calendar) { final Date time = value instanceof Calendar ? ((Calendar) value).getTime() : (Date) value; charSequence = DATE_TIME_FORMATTER.format(time.toInstant().atZone(ZoneId.systemDefault())); } else { charSequence = value.toString(); } this.print(out, value, charSequence, 0, charSequence.length(), newRecord); } CSVFormat(); private CSVFormat(final char delimiter, final Character quoteCharacter, final String recordSeparator); void printRecord(final Appendable out, final T record); void printRecords(final Appendable out, final C records); void println(final Appendable out); void print(final Appendable out, final Object value, final boolean newRecord); void printComments(final Appendable out, final String... comments); }
@Test public void testPrint() throws Exception { CSVFormat csvFormat = new CSVFormat(); final StringWriter out = new StringWriter(); csvFormat.print(out, "test", true); csvFormat.print(out, 1, false); csvFormat.print(out, true, false); csvFormat.print(out, "\"quoted\" test", false); assertEquals("Unexpected format ", String.format("%s,%d,%b,%s", "test", 1, true, "\"\"\"quoted\"\" test\""), out.toString()); } @Test public void testDate() throws Exception { Date date = new Date(); SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); CSVFormat csvFormat = new CSVFormat(); final StringWriter out = new StringWriter(); csvFormat.print(out, date, true); assertEquals("Unexpected format ", simpleDateFormat.format(date), out.toString()); }
CSVFormat { public void printComments(final Appendable out, final String... comments) throws IOException { for (String comment: comments) { out.append(COMMENT).append(SP).append(comment); println(out); } } CSVFormat(); private CSVFormat(final char delimiter, final Character quoteCharacter, final String recordSeparator); void printRecord(final Appendable out, final T record); void printRecords(final Appendable out, final C records); void println(final Appendable out); void print(final Appendable out, final Object value, final boolean newRecord); void printComments(final Appendable out, final String... comments); }
@Test public void testPrintComments() throws Exception { CSVFormat csvFormat = new CSVFormat(); final StringWriter out = new StringWriter(); csvFormat.printComments(out, "comment1", "comment2"); assertEquals("Unexpected format of comments", String.format("# %s%s# %s%s", "comment1", "\r\n", "comment2", "\r\n"), out.toString()); }
TlsOrPlainConnectionFactory extends AbstractConnectionFactory { @Override public PlainOrTlsConnection newConnection(final Connector connector, final EndPoint realEndPoint) { final MarkableEndPoint endPoint = new MarkableEndPoint(realEndPoint); final PlainOrTlsConnection plainOrTlsConnection = new PlainOrTlsConnection(connector, endPoint); endPoint.setConnection(plainOrTlsConnection); return plainOrTlsConnection; } TlsOrPlainConnectionFactory(@Name("sslContextFactory") final SslContextFactory factory, @Name("nextProtocol") final String nextProtocol); @Override PlainOrTlsConnection newConnection(final Connector connector, final EndPoint realEndPoint); @Override String toString(); }
@Test public void testOnFillableForTLS() throws Exception { AtomicBoolean firstPart = new AtomicBoolean(true); Answer<Object> answer = (InvocationOnMock invocation) -> { ByteBuffer dst = (ByteBuffer) invocation.getArguments()[0]; if (firstPart.get()) { firstPart.set(false); return writeBytes(dst, (byte) 22, (byte) 3, (byte) 1); } return writeBytes(dst, (byte) 0, (byte) 0, (byte) 1); }; when(_endPoint.fill(any(ByteBuffer.class))).thenAnswer(answer); TlsOrPlainConnectionFactory.PlainOrTlsConnection connection = _factory.newConnection(_connector, _endPoint); connection.onFillable(); verify(_endPoint).fillInterested(any(Callback.class)); connection.onFillable(); verify(_actualConnection).onOpen(); verify(_sslContextFactory).newSSLEngine(any()); ByteBuffer buffer = BufferUtil.allocate(4); int result = connection.getEndPoint().fill(buffer); assertEquals((long) 4, (long) result); assertTrue(Arrays.equals(new byte[]{(byte) 22, (byte) 3, (byte) 1, (byte) 0}, buffer.array())); buffer = BufferUtil.allocate(2); result = connection.getEndPoint().fill(buffer); assertEquals((long) 2, (long) result); assertTrue(Arrays.equals(new byte[]{(byte) 0, (byte) 1}, buffer.array())); verify(_endPoint, times(3)).fill(any()); } @Test public void testOnFillableForPlain() throws Exception { AtomicBoolean firstPart = new AtomicBoolean(true); Answer<Object> answer = (InvocationOnMock invocation) -> { ByteBuffer dst = (ByteBuffer) invocation.getArguments()[0]; if (firstPart.get()) { firstPart.set(false); return writeBytes(dst, "HTTP 1".getBytes()); } return writeBytes(dst, ".1\n\n".getBytes()); }; when(_endPoint.fill(any(ByteBuffer.class))).thenAnswer(answer); TlsOrPlainConnectionFactory.PlainOrTlsConnection connection = _factory.newConnection(_connector, _endPoint); connection.onFillable(); verify(_actualConnection).onOpen(); verify(_sslContextFactory, times(0)).newSSLEngine(any()); verify(_endPoint).fill(any()); ByteBuffer buffer = BufferUtil.allocate(4); int result = connection.getEndPoint().fill(buffer); assertEquals((long) 4, (long) result); assertEquals("HTTP", new String(buffer.array())); buffer = BufferUtil.allocate(6); result = connection.getEndPoint().fill(buffer); assertEquals((long) 6, (long) result); assertEquals(" 1.1\n\n", new String(buffer.array())); verify(_endPoint, times(2)).fill(any()); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public Collection<String> getAttributeNames() { return _nextVersionLegacyConfiguredObject.getAttributeNames(); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getAttributeNames() { final Collection<String> attributeNames = Arrays.asList("foo", "bar", "test"); when(_nextVersionLegacyConfiguredObject.getAttributeNames()).thenReturn(attributeNames); Collection<String> names = _object.getAttributeNames(); assertThat(names, is(equalTo(attributeNames))); verify(_nextVersionLegacyConfiguredObject).getAttributeNames(); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public Object getAttribute(final String name) { return convertLegacyConfiguredObjectIfRequired(_nextVersionLegacyConfiguredObject.getAttribute(name)); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getAttribute() { final String attributeName = "name"; final String attributeValue = "test"; when(_nextVersionLegacyConfiguredObject.getAttribute(attributeName)).thenReturn(attributeValue); final Object value = _object.getAttribute(attributeName); assertThat(value, is(equalTo(attributeValue))); verify(_nextVersionLegacyConfiguredObject).getAttribute(attributeName); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public Object getActualAttribute(final String name) { return _nextVersionLegacyConfiguredObject.getActualAttribute(name); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getActualAttribute() { final String attributeName = "name"; final String attributeValue = "test"; when(_nextVersionLegacyConfiguredObject.getActualAttribute(attributeName)).thenReturn(attributeValue); final Object value = _object.getActualAttribute(attributeName); assertThat(value, is(equalTo(attributeValue))); verify(_nextVersionLegacyConfiguredObject).getActualAttribute(attributeName); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public Collection<LegacyConfiguredObject> getChildren(final String category) { final Collection<LegacyConfiguredObject> children = _nextVersionLegacyConfiguredObject.getChildren(category); if (children != null) { return children.stream().map(_managementController::convertFromNextVersion).collect(Collectors.toSet()); } return Collections.emptySet(); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getChildren() { final String childrenCategory = "testChildrenCategory"; final LegacyConfiguredObject child = mock(LegacyConfiguredObject.class); final Collection<LegacyConfiguredObject> children = Collections.singleton(child); when(_nextVersionLegacyConfiguredObject.getChildren(childrenCategory)).thenReturn(children); final LegacyConfiguredObject converted = mock(LegacyConfiguredObject.class); when(_managementController.convertFromNextVersion(child)).thenReturn(converted); final Collection<LegacyConfiguredObject> value = _object.getChildren(childrenCategory); assertThat(value.size(), is(equalTo(1))); final LegacyConfiguredObject convertedChild = value.iterator().next(); assertThat(convertedChild, is(equalTo(converted))); verify(_nextVersionLegacyConfiguredObject).getChildren(childrenCategory); verify(_managementController).convertFromNextVersion(child); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public String getCategory() { return _category; } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getCategory() { assertThat(_object.getCategory(), is(equalTo(CATEGORY))); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure) { ManagementResponse result = _nextVersionLegacyConfiguredObject.invoke(operation, parameters, isSecure); return convertLegacyConfiguredObjectIfRequired(result); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void invoke() { final String operationName = "testOperation"; final Map<String, Object> operationArguments = Collections.singletonMap("arg", "argValue"); final String operationResult = "testOperationResult"; final ControllerManagementResponse managementResponse = new ControllerManagementResponse( ResponseType.DATA, operationResult); when(_nextVersionLegacyConfiguredObject.invoke(operationName, operationArguments, true)).thenReturn(managementResponse); final ManagementResponse result = _object.invoke(operationName, operationArguments, true); assertThat(result, is(notNullValue())); assertThat(result.getResponseCode(), is(equalTo(200))); assertThat(result.getBody(), is(equalTo(operationResult))); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public LegacyConfiguredObject getNextVersionConfiguredObject() { return _nextVersionLegacyConfiguredObject; } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getNextVersionConfiguredObject() { assertThat(_object.getNextVersionConfiguredObject(), is(equalTo(_nextVersionLegacyConfiguredObject))); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public LegacyConfiguredObject getParent(final String category) { LegacyConfiguredObject parent = _nextVersionLegacyConfiguredObject.getParent(category); return _managementController.convertFromNextVersion(parent); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getParent() { final String parentCategory = "testParentCategory"; final LegacyConfiguredObject nextVersionParent = mock(LegacyConfiguredObject.class); final LegacyConfiguredObject nextVersionParentConverted = mock(LegacyConfiguredObject.class); when(_nextVersionLegacyConfiguredObject.getParent(parentCategory)).thenReturn(nextVersionParent); when(_managementController.convertFromNextVersion(nextVersionParent)).thenReturn( nextVersionParentConverted); final LegacyConfiguredObject parent = _object.getParent(parentCategory); assertThat(parent, is(equalTo(nextVersionParentConverted))); verify(_nextVersionLegacyConfiguredObject).getParent(parentCategory); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public boolean isSecureAttribute(final String name) { return _nextVersionLegacyConfiguredObject.isSecureAttribute(name); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void isSecureAttribute() { final String attributeName = "testAttribute"; when(_nextVersionLegacyConfiguredObject.isSecureAttribute(attributeName)).thenReturn(true); assertThat(_object.isSecureAttribute(attributeName), is(equalTo(true))); verify(_nextVersionLegacyConfiguredObject).isSecureAttribute(attributeName); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public boolean isOversizedAttribute(final String name) { return _nextVersionLegacyConfiguredObject.isOversizedAttribute(name); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void isOversizedAttribute() { final String attributeName = "testAttribute"; when(_nextVersionLegacyConfiguredObject.isOversizedAttribute(attributeName)).thenReturn(true); assertThat(_object.isOversizedAttribute(attributeName), is(equalTo(true))); verify(_nextVersionLegacyConfiguredObject).isOversizedAttribute(attributeName); }
GenericJDBCConfigurationStore extends AbstractJDBCConfigurationStore implements MessageStoreProvider { @Override public void upgradeStoreStructure() throws StoreException { upgradeIfNecessary(_parent); } GenericJDBCConfigurationStore(final Class<? extends ConfiguredObject> rootClass); @Override void init(ConfiguredObject<?> parent); @Override void upgradeStoreStructure(); @Override Connection getConnection(); @Override void closeConfigurationStore(); @Override void onDelete(final ConfiguredObject<?> parent); @Override String getSqlBigIntType(); @Override MessageStore getMessageStore(); PreferenceStore getPreferenceStore(); }
@Test public void testUpgradeStoreStructure() throws Exception { GenericJDBCConfigurationStore store = (GenericJDBCConfigurationStore) getConfigurationStore(); store.closeConfigurationStore(); store.onDelete(getVirtualHostNode()); GenericJDBCConfigurationStore store2 = (GenericJDBCConfigurationStore) createConfigStore(); UUID hostId = UUID.randomUUID(); UUID queueId = UUID.randomUUID(); try (Connection connection = openConnection()) { assertTablesExistence(Arrays.asList("QPID_CONFIGURED_OBJECTS", "QPID_CONFIGURED_OBJECT_HIERARCHY"), getTableNames(connection), false); try (Statement stmt = connection.createStatement()) { stmt.execute("CREATE TABLE QPID_CONFIGURED_OBJECTS ( id VARCHAR(36) not null," + " object_type varchar(255), attributes blob, PRIMARY KEY (id))"); stmt.execute("CREATE TABLE QPID_CONFIGURED_OBJECT_HIERARCHY ( child_id VARCHAR(36) not null," + " parent_type varchar(255), parent_id VARCHAR(36), PRIMARY KEY (child_id, parent_type))"); } try (PreparedStatement insertStmt = connection.prepareStatement( "INSERT INTO QPID_CONFIGURED_OBJECTS ( id, object_type, attributes) VALUES (?,?,?)")) { insertStmt.setString(1, hostId.toString()); insertStmt.setString(2, "VirtualHost"); final byte[] attributesAsBytes = "{\"name\":\"testHost\"}".getBytes(StandardCharsets.UTF_8); try (ByteArrayInputStream bis = new ByteArrayInputStream(attributesAsBytes)) { insertStmt.setBinaryStream(3, bis, attributesAsBytes.length); } insertStmt.execute(); } try (PreparedStatement insertStmt = connection.prepareStatement( "INSERT INTO QPID_CONFIGURED_OBJECTS ( id, object_type, attributes) VALUES (?,?,?)")) { insertStmt.setString(1, queueId.toString()); insertStmt.setString(2, "Queue"); final byte[] attributesAsBytes = "{\"name\":\"testQueue\"}".getBytes(StandardCharsets.UTF_8); try (ByteArrayInputStream bis = new ByteArrayInputStream(attributesAsBytes)) { insertStmt.setBinaryStream(3, bis, attributesAsBytes.length); } insertStmt.execute(); } try (PreparedStatement insertStmt = connection.prepareStatement( "INSERT INTO QPID_CONFIGURED_OBJECT_HIERARCHY " + " ( child_id, parent_type, parent_id) VALUES (?,?,?)")) { insertStmt.setString(1, queueId.toString()); insertStmt.setString(2, "VirtualHost"); insertStmt.setString(3, hostId.toString()); insertStmt.execute(); } } store2.init(getVirtualHostNode()); store2.upgradeStoreStructure(); try (Connection connection = openConnection()) { try { assertTablesExistence(Arrays.asList("QPID_CONFIGURED_OBJECTS", "QPID_CONFIGURED_OBJECT_HIERARCHY"), getTableNames(connection), false); assertTablesExistence(Collections.singletonList("QPID_CFG_VERSION"), getTableNames(connection), true); } finally { JdbcUtils.dropTables(connection, store2.getLogger(), Arrays.asList("QPID_CONFIGURED_OBJECTS", "QPID_CONFIGURED_OBJECT_HIERARCHY")); } } ConfiguredObjectRecordHandler handler = mock(ConfiguredObjectRecordHandler.class); store2.openConfigurationStore(handler); verify(handler).handle(matchesRecord(hostId, "VirtualHost", map("name", "testHost"))); verify(handler).handle(matchesRecord(queueId, "Queue", map("name", "testQueue"), Collections.singletonMap("VirtualHost", hostId))); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public String getContextValue(final String contextKey) { return _nextVersionLegacyConfiguredObject.getContextValue(contextKey); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getContextValue() { final String contextName = "testContext"; final String contextValue = "testValue"; when(_nextVersionLegacyConfiguredObject.getContextValue(contextName)).thenReturn(contextValue); assertThat(_object.getContextValue(contextName), is(equalTo(contextValue))); verify(_nextVersionLegacyConfiguredObject).getContextValue(contextName); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { @Override public Map<String, Object> getStatistics() { return _nextVersionLegacyConfiguredObject.getStatistics(); } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getStatistics() { Map<String, Object> stats = Collections.singletonMap("testStat", "statValue"); when(_nextVersionLegacyConfiguredObject.getStatistics()).thenReturn(stats); assertThat(_object.getStatistics(), is(equalTo(stats))); verify(_nextVersionLegacyConfiguredObject).getStatistics(); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { public LegacyManagementController getManagementController() { return _managementController; } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getManagementController() { assertThat(_object.getManagementController(), is(equalTo(_managementController))); }
GenericLegacyConfiguredObject implements LegacyConfiguredObject { protected LegacyConfiguredObject getNextVersionLegacyConfiguredObject() { return _nextVersionLegacyConfiguredObject; } GenericLegacyConfiguredObject(final LegacyManagementController managementController, final LegacyConfiguredObject nextVersionLegacyConfiguredObject, final String category); @Override Collection<String> getAttributeNames(); @Override Object getAttribute(final String name); @Override Object getActualAttribute(final String name); @Override Collection<LegacyConfiguredObject> getChildren(final String category); @Override String getCategory(); @Override ManagementResponse invoke(final String operation, final Map<String, Object> parameters, final boolean isSecure); @Override LegacyConfiguredObject getNextVersionConfiguredObject(); @Override LegacyConfiguredObject getParent(final String category); @Override boolean isSecureAttribute(final String name); @Override boolean isOversizedAttribute(final String name); @Override String getContextValue(final String contextKey); @Override Map<String, Object> getStatistics(); @Override boolean equals(final Object o); @Override int hashCode(); LegacyManagementController getManagementController(); }
@Test public void getNextVersionLegacyConfiguredObject() { assertThat(_object.getNextVersionConfiguredObject(), is(equalTo(_nextVersionLegacyConfiguredObject))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public String getVersion() { return _modelVersion; } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getVersion() { assertThat(_controller.getVersion(), is(equalTo(TEST_VERSION))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public Collection<String> getCategories() { return Collections.unmodifiableCollection(_categoryNames.values()); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getCategories() { Collection<String> categories = _controller.getCategories(); Set<String> expected = new HashSet<>(Arrays.asList(TEST_CATEGORY, TEST_CATEGORY_2)); assertThat(new HashSet<>(categories), is(equalTo(expected))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public String getCategoryMapping(final String category) { return String.format("/api/v%s/%s/", getVersion(), category.toLowerCase()); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getCategoryMapping() { assertThat(_controller.getCategoryMapping(TEST_CATEGORY), is(equalTo( String.format("/api/v%s/%s/", TEST_VERSION, TEST_CATEGORY.toLowerCase())))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public String getCategory(final ConfiguredObject<?> managedObject) { return _nextVersionManagementController.getCategory(managedObject); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getCategory() { final ConfiguredObject<?> managementObject = mock(ConfiguredObject.class); when(_nextVersionManagementController.getCategory(managementObject)).thenReturn(TEST_CATEGORY); String category = _controller.getCategory(managementObject); assertThat(category, is(equalTo(TEST_CATEGORY))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName) { return getCategoryHierarchy(getCategory(root), categoryName); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getCategoryHierarchy() { when(_nextVersionManagementController.getCategory(_root)).thenReturn(TEST_CATEGORY); final List<String> hierarchy = _controller.getCategoryHierarchy(_root, TEST_CATEGORY_2); final Set<String> expected = Collections.singleton(TEST_CATEGORY_2); assertThat(new HashSet<>(hierarchy), is(equalTo(expected))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public ManagementController getNextVersionManagementController() { return _nextVersionManagementController; } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getNextVersionManagementController() { assertThat(_controller.getNextVersionManagementController(), is(equalTo(_nextVersionManagementController))); } @Test public void getNextVersionLegacyConfiguredObjectConverter() { assertThat(_controller.getNextVersionManagementController(), is(equalTo(_nextVersionManagementController))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost) throws ManagementException { return getCategoryController(category).createOrUpdate(root, path, attributes, isPost); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void createOrUpdate() { final List<String> path = Collections.singletonList("test"); final Map<String, Object> attributes = Collections.singletonMap("name", "test"); final LegacyConfiguredObject object = mock(LegacyConfiguredObject.class); when(_categoryController2.createOrUpdate(_root, path, attributes, false)).thenReturn(object); final LegacyConfiguredObject result = _controller.createOrUpdate(_root, TEST_CATEGORY_2, path, attributes, false); assertThat(result, is(equalTo(object))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters) throws ManagementException { return getCategoryController(category).get(root, path, convertQueryParameters(parameters)); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void get() { final List<String> path = Collections.singletonList("test"); final LegacyConfiguredObject object = mock(LegacyConfiguredObject.class); final Map<String, List<String>> parameters = Collections.singletonMap("name", Collections.singletonList("test")); when(_categoryController2.get(_root, path, parameters)).thenReturn(object); final Object result = _controller.get(_root, TEST_CATEGORY_2, path, parameters); assertThat(result, is(equalTo(object))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters) throws ManagementException { return getCategoryController(category).delete(root, path, convertQueryParameters(parameters)); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void delete() { final List<String> path = Collections.singletonList("test"); final Map<String, List<String>> parameters = Collections.singletonMap("name", Collections.singletonList("test")); _controller.delete(_root, TEST_CATEGORY_2, path, parameters); verify(_categoryController2).delete(_root, path, parameters); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel) throws ManagementException { return getCategoryController(category).invoke(root, path, operation, parameters, isPost, isSecureOrAllowedOnInsecureChannel); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void invoke() { final List<String> path = Collections.singletonList("test"); final Map<String, Object> parameters = Collections.singletonMap("name", "test"); final Object operationResult = mock(Object.class); final String operationName = "testOperation"; final ManagementResponse managementResponse = new ControllerManagementResponse(ResponseType.DATA, operationResult); when(_categoryController2.invoke(_root, path, operationName, parameters, true, true)).thenReturn( managementResponse); final ManagementResponse result = _controller.invoke(_root, TEST_CATEGORY_2, path, operationName, parameters, true, true); assertThat(result, is(notNullValue())); assertThat(result.getResponseCode(), is(equalTo(200))); assertThat(result.getBody(), is(equalTo(operationResult))); verify(_categoryController2).invoke(_root, path, operationName, parameters, true, true); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters) throws ManagementException { return getCategoryController(category).getPreferences(root, path, convertQueryParameters(parameters)); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getPreferences() { final List<String> path = Arrays.asList("test", "preferences"); final Map<String, List<String>> parameters = Collections.singletonMap("name", Collections.singletonList("test")); final Object prefs = mock(Object.class); when(_categoryController2.getPreferences(_root, path, parameters)).thenReturn(prefs); final Object preferences = _controller.getPreferences(_root, TEST_CATEGORY_2, path, parameters); assertThat(preferences, is(equalTo(prefs))); verify(_categoryController2).getPreferences(_root, path, parameters); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost) throws ManagementException { getCategoryController(category).setPreferences(root, path, preferences, parameters, isPost); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void setPreferences() { final List<String> path = Arrays.asList("test", "preferences"); final Map<String, List<String>> parameters = Collections.singletonMap("name", Collections.singletonList("test")); final Object prefs = mock(Object.class); _controller.setPreferences(_root, TEST_CATEGORY_2, path, prefs, parameters, true); verify(_categoryController2).setPreferences(_root, path, prefs, parameters, true); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters) throws ManagementException { return getCategoryController(category).deletePreferences(root, path, convertQueryParameters(parameters)); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void deletePreferences() { final List<String> path = Arrays.asList("test", "preferences"); final Map<String, List<String>> parameters = Collections.singletonMap("name", Collections.singletonList("test")); _controller.deletePreferences(_root, TEST_CATEGORY_2, path, parameters); verify(_categoryController2).deletePreferences(_root, path, parameters); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public CategoryController getCategoryController(final String category) { CategoryController converter = _categoryConverters.get(category.toLowerCase()); if (converter == null) { throw createInternalServerErrorManagementException(String.format("Converter for type '%s' cannot be found ", category)); } return converter; } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getCategoryController() { assertThat(_controller.getCategoryController(TEST_CATEGORY_2), is(equalTo(_categoryController2))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public Set<TypeController> getTypeControllersByCategory(final String name) { Set<TypeController> typeControllers = _typeControllers.get(name.toLowerCase()); if (typeControllers == null) { return Collections.emptySet(); } return Collections.unmodifiableSet(typeControllers); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getTypeControllersByCategory() { final Set<TypeController> typeControllers = _controller.getTypeControllersByCategory(TEST_CATEGORY); assertThat(typeControllers, is(equalTo(Collections.singleton(_typeController)))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public Collection<String> getChildrenCategories(String category) { List<String> children = _children.get(_categoryNames.get(category.toLowerCase())); if (children == null) { return Collections.emptyList(); } return Collections.unmodifiableList(children); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getChildrenCategories() { final Collection<String> childrenCategories = _controller.getChildrenCategories(TEST_CATEGORY); assertThat(new HashSet<>(childrenCategories), is(equalTo(Collections.singleton(TEST_CATEGORY_2)))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override public Collection<String> getParentTypes(final String category) { return _parents.get(category); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getParentTypes() { final Collection<String> childrenCategories = _controller.getParentTypes(TEST_CATEGORY_2); assertThat(new HashSet<>(childrenCategories), is(equalTo(Collections.singleton(TEST_CATEGORY)))); }
AbstractLegacyConfiguredObjectController extends AbstractManagementController implements LegacyManagementController { @Override protected RequestType getRequestType(final ManagementRequest managementRequest) throws ManagementException { final List<String> path = managementRequest.getPath(); final String category = managementRequest.getCategory(); if (category == null) { throw createNotFoundManagementException(String.format("Category is not found for path '%s%s'", getCategoryMapping(category), buildPath(path))); } final List<String> hierarchy = getCategoryHierarchy(managementRequest.getRoot(), category); return getManagementRequestType(managementRequest.getMethod(), category, path, hierarchy); } AbstractLegacyConfiguredObjectController(final String modelVersion, final ManagementController nextVersionManagementController); @Override String getVersion(); @Override Collection<String> getCategories(); @Override String getCategoryMapping(final String category); @Override String getCategory(final ConfiguredObject<?> managedObject); @Override List<String> getCategoryHierarchy(final ConfiguredObject<?> root, final String categoryName); @Override ManagementController getNextVersionManagementController(); @Override LegacyConfiguredObject createOrUpdate(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, Object> attributes, final boolean isPost); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override int delete(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override ManagementResponse invoke(final ConfiguredObject<?> root, final String category, final List<String> path, final String operation, final Map<String, Object> parameters, final boolean isPost, final boolean isSecureOrAllowedOnInsecureChannel); @Override Object getPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override void setPreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Object preferences, final Map<String, List<String>> parameters, final boolean isPost); @Override int deletePreferences(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override CategoryController getCategoryController(final String category); @Override Set<TypeController> getTypeControllersByCategory(final String name); @Override List<String> getCategoryHierarchy(final String rootCategory, final String categoryName); @Override Collection<String> getChildrenCategories(String category); @Override Collection<String> getParentTypes(final String category); void initialize(); @Override LegacyConfiguredObject convertFromNextVersion(final LegacyConfiguredObject nextVersionObject); }
@Test public void getRequestType() { final Map<String, List<String>> parameters = Collections.singletonMap("name", Collections.singletonList("test")); final ManagementRequest managementRequest = mock(ManagementRequest.class); doReturn(_root).when(managementRequest).getRoot(); when(managementRequest.getMethod()).thenReturn("GET"); when(managementRequest.getParameters()).thenReturn(parameters); when(managementRequest.getPath()).thenReturn(Collections.singletonList("test")); when(managementRequest.getCategory()).thenReturn(TEST_CATEGORY_2); when(_controller.getCategory(_root)).thenReturn(TEST_CATEGORY); final RequestType requestType = _controller.getRequestType(managementRequest); assertThat(requestType, is(equalTo(RequestType.MODEL_OBJECT))); }
LegacyManagementController extends AbstractLegacyConfiguredObjectController { @Override public Map<String, List<String>> convertQueryParameters(final Map<String, List<String>> requestParameters) { Map<String, List<String>> params = requestParameters .entrySet() .stream() .filter(e -> !INCLUDE_SYS_CONTEXT_PARAM.equals(e.getKey()) && !INHERITED_ACTUALS_PARAM.equals(e.getKey())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); Map<String, List<String>> parameters = new HashMap<>(params); boolean excludeInheritedContext = isInheritedContextExcluded(params); parameters.put(EXCLUDE_INHERITED_CONTEXT_PARAM, Collections.singletonList(String.valueOf(excludeInheritedContext))); if (!parameters.containsKey(DEPTH_PARAM)) { parameters.put(DEPTH_PARAM, Collections.singletonList("1")); } return parameters; } LegacyManagementController(final ManagementController nextVersionManagementController); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override Map<String, List<String>> convertQueryParameters(final Map<String, List<String>> requestParameters); @Override Object formatConfiguredObject(final Object content, final Map<String, List<String>> parameters, final boolean isSecureOrAllowedOnInsecureChannel); }
@Test public void convertQueryParameters() { final Map<String, List<String>> parameters = Collections.singletonMap("actuals", Collections.singletonList("true")); final Map<String, List<String>> converted = _controller.convertQueryParameters(parameters); assertThat(converted, is(notNullValue())); assertThat(converted.get("excludeInheritedContext"), is(equalTo(Collections.singletonList("true")))); }
LegacyManagementController extends AbstractLegacyConfiguredObjectController { @Override public Object formatConfiguredObject(final Object content, final Map<String, List<String>> parameters, final boolean isSecureOrAllowedOnInsecureChannel) { final int depth = getIntParameterFromRequest(parameters, DEPTH_PARAM, DEFAULT_DEPTH); final int oversizeThreshold = getIntParameterFromRequest(parameters, OVERSIZE_PARAM, DEFAULT_OVERSIZE); final boolean actuals = Boolean.parseBoolean(getParameter(ACTUALS_PARAM, parameters)); final boolean excludeInheritedContext = isInheritedContextExcluded(parameters); if (content instanceof LegacyConfiguredObject) { LegacyConfiguredObject legacyConfiguredObjectObject = (LegacyConfiguredObject) content; return convertManageableToMap( legacyConfiguredObjectObject, depth, actuals, oversizeThreshold, excludeInheritedContext); } else if (content instanceof Collection) { return ((Collection<?>) content).stream() .filter(o -> o instanceof LegacyConfiguredObject) .map(LegacyConfiguredObject.class::cast) .map(o -> convertManageableToMap( o, depth, actuals, oversizeThreshold, excludeInheritedContext)) .collect(Collectors.toSet()); } return content; } LegacyManagementController(final ManagementController nextVersionManagementController); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override Map<String, List<String>> convertQueryParameters(final Map<String, List<String>> requestParameters); @Override Object formatConfiguredObject(final Object content, final Map<String, List<String>> parameters, final boolean isSecureOrAllowedOnInsecureChannel); }
@Test public void formatConfiguredObject() { final String objectName = "test-object"; final String hostName = "test-vhn"; final Map<String, List<String>> parameters = Collections.emptyMap(); final LegacyConfiguredObject object = mock(LegacyConfiguredObject.class); final LegacyConfiguredObject vhn = mock(LegacyConfiguredObject.class); when(object.getAttributeNames()).thenReturn(Arrays.asList(LegacyConfiguredObject.NAME, LegacyConfiguredObject.TYPE)); when(object.getAttribute(LegacyConfiguredObject.NAME)).thenReturn(objectName); when(object.getAttribute(LegacyConfiguredObject.TYPE)).thenReturn("Broker"); when(object.getCategory()).thenReturn("Broker"); when(object.getChildren("VirtualHostNode")).thenReturn(Collections.singletonList(vhn)); when(vhn.getAttributeNames()).thenReturn(Arrays.asList(LegacyConfiguredObject.NAME, LegacyConfiguredObject.TYPE)); when(vhn.getAttribute(LegacyConfiguredObject.NAME)).thenReturn(hostName); when(vhn.getAttribute(LegacyConfiguredObject.TYPE)).thenReturn("VirtualHostNode"); when(vhn.getCategory()).thenReturn("VirtualHostNode"); Object data = _controller.formatConfiguredObject(object, parameters, true); assertThat(data, is(instanceOf(Map.class))); Map<?, ?> formatted = (Map<?, ?>) data; assertThat(formatted.get(LegacyConfiguredObject.NAME), is(equalTo(objectName))); assertThat(formatted.get(LegacyConfiguredObject.TYPE), is(equalTo("Broker"))); Object vhns = formatted.get("virtualhostnodes"); assertThat(vhns, is(instanceOf(Collection.class))); Collection<?> nodes = (Collection<?>)vhns; assertThat(nodes.size(), is(equalTo(1))); Object node = nodes.iterator().next(); assertThat(node, is(instanceOf(Map.class))); Map<?, ?> formattedNode = (Map<?, ?>) node; assertThat(formattedNode.get(LegacyConfiguredObject.NAME), is(equalTo(hostName))); assertThat(formattedNode.get(LegacyConfiguredObject.TYPE), is(equalTo("VirtualHostNode"))); }
LegacyManagementController extends AbstractLegacyConfiguredObjectController { @Override public Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters) throws ManagementException { Object result = super.get(root, category, path, convertQueryParameters(parameters)); if (result instanceof LegacyConfiguredObject) { return Collections.singletonList(result); } return result; } LegacyManagementController(final ManagementController nextVersionManagementController); @Override Object get(final ConfiguredObject<?> root, final String category, final List<String> path, final Map<String, List<String>> parameters); @Override Map<String, List<String>> convertQueryParameters(final Map<String, List<String>> requestParameters); @Override Object formatConfiguredObject(final Object content, final Map<String, List<String>> parameters, final boolean isSecureOrAllowedOnInsecureChannel); }
@Test public void get() { final List<String> path = Collections.emptyList(); final LegacyConfiguredObject object = mock(LegacyConfiguredObject.class); final Map<String, List<String>> parameters = Collections.emptyMap(); final ConfiguredObject<?> root = mock(ConfiguredObject.class); when(_nextVersionManagementController.get(eq(root), eq(BrokerController.TYPE), eq(path), any())).thenReturn(object); final Object result = _controller.get(root, BrokerController.TYPE, path, parameters); assertThat(result, is(instanceOf(Collection.class))); Collection data = (Collection) result; assertThat(data.size(), is(equalTo(1))); Object obj = data.iterator().next(); assertThat(obj, is(instanceOf(LegacyConfiguredObject.class))); assertThat(((LegacyConfiguredObject)obj).getCategory(), is(equalTo(BrokerController.TYPE))); }
PortController extends LegacyCategoryController { @Override protected LegacyConfiguredObject convertNextVersionLegacyConfiguredObject(final LegacyConfiguredObject object) { return new LegacyPort(getManagementController(), object); } PortController(final LegacyManagementController legacyManagementController, final Set<TypeController> typeControllers); @Override Map<String, Object> convertAttributesToNextVersion(final ConfiguredObject<?> root, final List<String> path, final Map<String, Object> attributes); static final String TYPE; }
@Test public void convertNextVersionLegacyConfiguredObject() { final LegacyConfiguredObject nextVersionPort = mock(LegacyConfiguredObject.class); when(nextVersionPort.getAttribute(LegacyConfiguredObject.NAME)).thenReturn("test"); when(nextVersionPort.getAttribute(LegacyConfiguredObject.TYPE)).thenReturn("HTTP"); Map<String, String> context = new HashMap<>(); context.put("qpid.port.http.acceptBacklog", "2000"); when(nextVersionPort.getAttribute(LegacyConfiguredObject.CONTEXT)).thenReturn(context); final LegacyConfiguredObject converted = _portController.convertNextVersionLegacyConfiguredObject(nextVersionPort); assertThat(converted, is(notNullValue())); assertThat(converted.getCategory(), is(equalTo(PortController.TYPE))); assertThat(converted.getAttribute(LegacyConfiguredObject.NAME), is(equalTo("test"))); assertThat(converted.getAttribute(LegacyConfiguredObject.TYPE), is(equalTo("HTTP"))); Object contextObject = converted.getAttribute(LegacyConfiguredObject.CONTEXT); assertThat(contextObject, is(instanceOf(Map.class))); Map<?,?> convertedContext = (Map<?,?>)contextObject; assertThat(convertedContext.get("port.http.maximumQueuedRequests"), is(equalTo("2000"))); }
PortController extends LegacyCategoryController { @Override public Map<String, Object> convertAttributesToNextVersion(final ConfiguredObject<?> root, final List<String> path, final Map<String, Object> attributes) { Map<String, Object> portAttributes = attributes; if ("HTTP".equals(portAttributes.get("type")) && portAttributes.containsKey("context")) { @SuppressWarnings("unchecked") Map<String, String> context = (Map<String, String>) portAttributes.get("context"); if (context.containsKey("port.http.additionalInternalThreads") || context.containsKey("port.http.maximumQueuedRequests")) { Map<String, Object> updatedAttributes = new LinkedHashMap<>(portAttributes); updatedAttributes.put("context", convertContextToNextVersion(context)); portAttributes = updatedAttributes; } } return portAttributes; } PortController(final LegacyManagementController legacyManagementController, final Set<TypeController> typeControllers); @Override Map<String, Object> convertAttributesToNextVersion(final ConfiguredObject<?> root, final List<String> path, final Map<String, Object> attributes); static final String TYPE; }
@Test public void convertAttributesToNextVersion() { Map<String, Object> attributes = new HashMap<>(); attributes.put(LegacyConfiguredObject.NAME, "test"); attributes.put(LegacyConfiguredObject.TYPE, "HTTP"); Map<String, String> context = new HashMap<>(); context.put("port.http.maximumQueuedRequests", "2000"); context.put("port.http.additionalInternalThreads", "10"); attributes.put(LegacyConfiguredObject.CONTEXT, context); final ConfiguredObject<?> root = mock(ConfiguredObject.class); final List<String> path = Collections.emptyList(); final Map<String, Object> converted = _portController.convertAttributesToNextVersion(root, path, attributes); assertThat(converted, is(instanceOf(Map.class))); assertThat(converted.get(LegacyConfiguredObject.NAME), is(equalTo("test"))); assertThat(converted.get(LegacyConfiguredObject.TYPE), is(equalTo("HTTP"))); Object contextObject = converted.get(LegacyConfiguredObject.CONTEXT); assertThat(converted, is(instanceOf(Map.class))); Map<?,?> convertedContext = (Map<?,?>)contextObject; assertThat(convertedContext.get("qpid.port.http.acceptBacklog"), is(equalTo("2000"))); assertThat(convertedContext.containsKey("port.http.additionalInternalThreads"), is(equalTo(false))); }
SessionController extends LegacyCategoryController { @Override protected LegacyConfiguredObject convertNextVersionLegacyConfiguredObject(final LegacyConfiguredObject object) { return new LegacySession(getManagementController(), object); } SessionController(final LegacyManagementController legacyManagementController, final Set<TypeController> typeControllers); static final String TYPE; }
@Test public void convertNextVersionLegacyConfiguredObject() { final UUID sessionID = UUID.randomUUID(); final LegacyConfiguredObject nextVersionSession = mock(LegacyConfiguredObject.class); final LegacyConfiguredObject nextVersionConsumer = mock(LegacyConfiguredObject.class); when(nextVersionSession.getCategory()).thenReturn(SessionController.TYPE); when(nextVersionSession.getAttribute(LegacyConfiguredObject.ID)).thenReturn(sessionID); final ManagementResponse operationResult = new ControllerManagementResponse(ResponseType.MODEL_OBJECT, Collections.singletonList( nextVersionConsumer)); when(nextVersionSession.invoke(eq("getConsumers"), eq(Collections.emptyMap()), eq(true))).thenReturn( operationResult); final LegacyConfiguredObject convertedConsumer = mock(LegacyConfiguredObject.class); when(_legacyManagementController.convertFromNextVersion(nextVersionConsumer)).thenReturn(convertedConsumer); final LegacyConfiguredObject convertedSession = _sessionController.convertNextVersionLegacyConfiguredObject(nextVersionSession); assertThat(convertedSession.getAttribute(LegacyConfiguredObject.ID), is(equalTo(sessionID))); final Collection<LegacyConfiguredObject> consumers = convertedSession.getChildren(ConsumerController.TYPE); assertThat(consumers, is(notNullValue())); assertThat(consumers.size(), is(equalTo(1))); assertThat(consumers.iterator().next(), is(equalTo(convertedConsumer))); }
ExchangeController extends DestinationController { @Override protected LegacyConfiguredObject convertNextVersionLegacyConfiguredObject(final LegacyConfiguredObject object) { return new LegacyExchange(getManagementController(), object); } ExchangeController(final LegacyManagementController legacyManagementController, final Set<TypeController> typeControllers); static final String TYPE; }
@Test public void convertNextVersionLegacyConfiguredObject() { final ExchangeController exchangeController = new ExchangeController(_legacyManagementController, Collections.emptySet()); final String exchangeName = "testExchange"; final String alternateExchangeName = "altExchange"; final String queueName = "testQueue"; final String bindingKey = "testBindingKey"; final LegacyConfiguredObject nextVersionExchange = mock(LegacyConfiguredObject.class); final AlternateBinding alternateBinding = mock(AlternateBinding.class); final Binding nextVersionBinding = mock(Binding.class); final LegacyConfiguredObject nextVersionAlternateExchange = mock(LegacyConfiguredObject.class); final LegacyConfiguredObject nextVersionVirtualHost = mock(LegacyConfiguredObject.class); final LegacyConfiguredObject queue = mock(LegacyConfiguredObject.class); when(alternateBinding.getDestination()).thenReturn(alternateExchangeName); when(nextVersionExchange.getCategory()).thenReturn(ExchangeController.TYPE); when(nextVersionExchange.getAttribute("alternateBinding")).thenReturn(alternateBinding); when(nextVersionExchange.getAttribute(AbstractConfiguredObject.NAME)).thenReturn(exchangeName); when(nextVersionExchange.getAttribute("bindings")).thenReturn(Collections.singletonList(nextVersionBinding)); when(nextVersionExchange.getParent(VirtualHostController.TYPE)).thenReturn(nextVersionVirtualHost); when(nextVersionBinding.getDestination()).thenReturn(queueName); when(nextVersionBinding.getBindingKey()).thenReturn(bindingKey); when(nextVersionAlternateExchange.getCategory()).thenReturn(ExchangeController.TYPE); when(nextVersionAlternateExchange.getAttribute(LegacyConfiguredObject.NAME)).thenReturn(alternateExchangeName); when(nextVersionVirtualHost.getChildren(ExchangeController.TYPE)).thenReturn(Arrays.asList(nextVersionExchange, nextVersionAlternateExchange)); when(nextVersionVirtualHost.getChildren(QueueController.TYPE)).thenReturn(Collections.singletonList(queue)); final LegacyConfiguredObject convertedExchange = mock(LegacyConfiguredObject.class); final LegacyConfiguredObject convertedAltExchange = mock(LegacyConfiguredObject.class); final LegacyConfiguredObject convertedQueue = mock(LegacyConfiguredObject.class); when(_legacyManagementController.convertFromNextVersion(nextVersionExchange)).thenReturn(convertedExchange); when(_legacyManagementController.convertFromNextVersion(nextVersionAlternateExchange)).thenReturn(convertedAltExchange); when(_legacyManagementController.convertFromNextVersion(queue)).thenReturn(convertedQueue); final LegacyConfiguredObject destination = exchangeController.convertFromNextVersion(nextVersionExchange); assertThat(destination.getAttribute("alternateExchange"), is(equalTo(convertedAltExchange))); final Collection<LegacyConfiguredObject> children = destination.getChildren(BindingController.TYPE); assertThat(children.size(), is(equalTo(1))); final LegacyConfiguredObject o = children.iterator().next(); assertThat(o.getCategory(), is(equalTo(BindingController.TYPE))); assertThat(o.getAttribute(AbstractConfiguredObject.NAME), is(equalTo(bindingKey))); assertThat(o.getAttribute("queue"), is(equalTo(convertedQueue))); assertThat(o.getAttribute("exchange"), is(equalTo(convertedExchange))); }
DestinationController extends LegacyCategoryController { @Override @SuppressWarnings("unchecked") public Map<String, Object> convertAttributesToNextVersion(final ConfiguredObject<?> root, final List<String> path, final Map<String, Object> attributes) { if (attributes.containsKey(LegacyDestination.ALTERNATE_EXCHANGE)) { final Map<String, Object> converted = new LinkedHashMap<>(attributes); final String alternateExchange = (String) converted.remove(LegacyDestination.ALTERNATE_EXCHANGE); final LegacyConfiguredObject exchange = findExchange(root, path, object -> alternateExchange.equals(object.getAttribute(LegacyConfiguredObject.ID)) || alternateExchange.equals(object.getAttribute(LegacyConfiguredObject.NAME))); if (exchange != null) { converted.put(ALTERNATE_BINDING, Collections.singletonMap("destination", exchange.getAttribute(LegacyConfiguredObject.NAME))); } else { throw createBadRequestManagementException(String.format("Cannot find alternate exchange '%s'", alternateExchange)); } return converted; } return attributes; } DestinationController(final LegacyManagementController legacyManagementController, final String name, final String[] parentCategories, final String defaultType, final Set<TypeController> typeControllers); @Override @SuppressWarnings("unchecked") Map<String, Object> convertAttributesToNextVersion(final ConfiguredObject<?> root, final List<String> path, final Map<String, Object> attributes); }
@Test public void convertAttributesToNextVersion() { final String alternateExchangeName = "alternate"; final String queueName = "test"; final Map<String, Object> attributes = new HashMap<>(); attributes.put("alternateExchange", alternateExchangeName); attributes.put(LegacyConfiguredObject.NAME, queueName); final DestinationController controller = new DestinationController(_legacyVersionManagementController, "Queue", new String[]{"VirtualHost"}, null, Collections.emptySet()); assertThat(controller.getCategory(), is(equalTo("Queue"))); assertThat(controller.getParentCategories(), is(equalTo(new String[]{"VirtualHost"}))); final ConfiguredObject root = mock(ConfiguredObject.class); final List<String> exchangePath = Arrays.asList("vhn", "vh"); final LegacyConfiguredObject exchange = mock(LegacyConfiguredObject.class); when(exchange.getAttribute(LegacyConfiguredObject.NAME)).thenReturn(alternateExchangeName); when(exchange.getCategory()).thenReturn(ExchangeController.TYPE); final Collection<LegacyConfiguredObject> exchanges = Collections.singletonList(exchange); when(_nextVersionManagementController.get(eq(root), eq(ExchangeController.TYPE), eq(exchangePath), eq(Collections.emptyMap()))).thenReturn(exchanges); final Collection<String> hierarchy = Arrays.asList("virtualhostnode", "virtualhost", "exchange"); when(_nextVersionManagementController.getCategoryHierarchy(eq(root), eq(ExchangeController.TYPE))).thenReturn(hierarchy); final List<String> path = Arrays.asList("vhn", "vh", queueName); final Map<String, Object> converted = controller.convertAttributesToNextVersion(root, path, attributes); assertThat(converted.size(), is(equalTo(2))); assertThat(converted.get(LegacyConfiguredObject.NAME), is(equalTo(queueName))); final Object alternateBinding = converted.get("alternateBinding"); assertThat(alternateBinding, is(notNullValue())); assertThat(alternateBinding, is(instanceOf(Map.class))); final Map<?, ?> alternateDestination = (Map<?, ?>) alternateBinding; assertThat(alternateDestination.get("destination"), is(equalTo(alternateExchangeName))); assertThat(alternateDestination.get("attributes"), is(equalTo(null))); }
LegacyCategoryControllerFactory implements CategoryControllerFactory { @Override public CategoryController createController(final String type, final LegacyManagementController legacyManagementController) { switch (type) { case CATEGORY_ACCESS_CONTROL_PROVIDER: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_BROKER: return new BrokerController(legacyManagementController, legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_BROKER_LOGGER: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_BROKER_LOG_INCLUSION_RULE: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER_LOGGER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_AUTHENTICATION_PROVIDER: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_USER: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_AUTHENTICATION_PROVIDER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_PORT: return new PortController(legacyManagementController, legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_VIRTUAL_HOST_ALIAS: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_VIRTUAL_HOST_ALIAS}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_PLUGIN: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_TRUST_STORE: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_KEY_STORE: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_GROUP_PROVIDER: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_GROUP: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_GROUP_PROVIDER}, null, legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_GROUP_MEMBER: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_GROUP}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_VIRTUAL_HOST_NODE: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_BROKER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_REMOTE_REPLICATION_NODE: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_VIRTUAL_HOST_NODE}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_VIRTUAL_HOST: return new VirtualHostController(legacyManagementController, legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_VIRTUAL_HOST_LOGGER: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_VIRTUAL_HOST}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_VIRTUAL_HOST_LOG_INCLUSION_RULE: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_VIRTUAL_HOST_LOGGER}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_VIRTUAL_HOST_ACCESS_CONTROL_PROVIDER: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_VIRTUAL_HOST}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_EXCHANGE: return new ExchangeController(legacyManagementController, legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_QUEUE: return new QueueController(legacyManagementController, legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_BINDING: return new BindingController(legacyManagementController ); case CATEGORY_CONNECTION: return new LegacyCategoryController(legacyManagementController, type, new String[]{CATEGORY_PORT, CATEGORY_VIRTUAL_HOST}, DEFAULT_TYPES.get(type), legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_SESSION: return new SessionController(legacyManagementController, legacyManagementController.getTypeControllersByCategory(type)); case CATEGORY_CONSUMER: return new ConsumerController(legacyManagementController ); default: throw new IllegalArgumentException(String.format("Unsupported category '%s'", type)); } } @Override CategoryController createController(final String type, final LegacyManagementController legacyManagementController); @Override Set<String> getSupportedCategories(); @Override String getModelVersion(); @Override String getType(); }
@Test public void createController() { LegacyCategoryControllerFactory.SUPPORTED_CATEGORIES.forEach(category -> { final CategoryController controller = _factory.createController(category, _nextVersionManagementController); assertThat(controller.getCategory(), is(equalTo(category))); }); }
LegacyCategoryControllerFactory implements CategoryControllerFactory { @Override public Set<String> getSupportedCategories() { return SUPPORTED_CATEGORIES; } @Override CategoryController createController(final String type, final LegacyManagementController legacyManagementController); @Override Set<String> getSupportedCategories(); @Override String getModelVersion(); @Override String getType(); }
@Test public void getSupportedCategories() { assertThat(_factory.getSupportedCategories(), is(equalTo(LegacyCategoryControllerFactory.SUPPORTED_CATEGORIES))); }