Examples with RegisterResponseMetadataEntry com.linkedin.databus2.core.container.request.RegisterResponseMetadataEntry used on opensource projects

Example 6 with RegisterResponseMetadataEntry

use of com.linkedin.databus2.core.container.request.RegisterResponseMetadataEntry in project databus by linkedin.

the class TestRelayCommandsLocal method testRegisterV4CommandHappyPath.

@Test
public void testRegisterV4CommandHappyPath() throws Exception {
    LOG.debug("\n\nstarting testRegisterV4CommandHappyPath()\n");
    // /register?protocolVersion=4
    HttpRequest httpRequest = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/register?sources=4002&" + DatabusHttpHeaders.PROTOCOL_VERSION_PARAM + "=4");
    SimpleTestHttpClient httpClient = SimpleTestHttpClient.createLocal(TimeoutPolicy.ALL_TIMEOUTS);
    SimpleHttpResponseHandler respHandler = httpClient.sendRequest(_serverAddress, httpRequest);
    assertTrue("failed to get a response", respHandler.awaitResponseUninterruptedly(1, TimeUnit.SECONDS));
    HttpResponse respObj = respHandler.getResponse();
    assertNull("/register v4 returned unexpected error: " + respObj.getHeader(DatabusHttpHeaders.DATABUS_ERROR_CLASS_HEADER), respObj.getHeader(DatabusHttpHeaders.DATABUS_ERROR_CLASS_HEADER));
    String registerResponseProtocolVersionStr = respObj.getHeader(DatabusHttpHeaders.DBUS_CLIENT_RELAY_PROTOCOL_VERSION_HDR);
    assertNotNull("/register protocol-version response header not present", registerResponseProtocolVersionStr);
    assertEquals("client-relay protocol response version mismatch", "4", registerResponseProtocolVersionStr);
    byte[] respBytes = respHandler.getReceivedBytes();
    if (LOG.isDebugEnabled()) {
        LOG.debug("/register response: " + new String(respBytes));
    }
    ByteArrayInputStream in = new ByteArrayInputStream(respBytes);
    ObjectMapper objMapper = new ObjectMapper();
    Map<String, List<Object>> resMap = objMapper.readValue(in, new TypeReference<Map<String, List<Object>>>() {
    });
    assertNotNull("no result", resMap);
    List<Object> sourceSchemasObjectsList = resMap.get(RegisterResponseEntry.SOURCE_SCHEMAS_KEY);
    assertNotNull("missing required sourceSchemas key in response", sourceSchemasObjectsList);
    assertEquals("expected one source schema", 1, sourceSchemasObjectsList.size());
    // ObjectMapper encodes plain Object as LinkedHashMap with (apparently) String keys and
    // either String or Integer values (currently).  We must construct RegisterResponseEntry
    // manually.
    assertTrue("sourceSchemas deserialization error: 'Object' type = " + sourceSchemasObjectsList.get(0).getClass().getName() + ", not LinkedHashMap", sourceSchemasObjectsList.get(0) instanceof LinkedHashMap);
    // just obj
    @SuppressWarnings("unchecked") LinkedHashMap<String, Object> obj = (LinkedHashMap<String, Object>) sourceSchemasObjectsList.get(0);
    assertTrue("sourceSchemas deserialization error: missing \"id\" key", obj.containsKey("id"));
    assertTrue("sourceSchemas deserialization error: missing \"version\" key", obj.containsKey("version"));
    assertTrue("sourceSchemas deserialization error: missing \"schema\" key", obj.containsKey("schema"));
    assertTrue("obj.get(\"id\") type = " + obj.get("id").getClass().getName() + ", not Integer", obj.get("id") instanceof Integer);
    assertTrue("obj.get(\"version\") type = " + obj.get("version").getClass().getName() + ", not Integer", obj.get("version") instanceof Integer);
    RegisterResponseEntry rre = new RegisterResponseEntry((Integer) obj.get("id"), ((Integer) obj.get("version")).shortValue(), (String) obj.get("schema"));
    assertEquals("unexpected source id", 4002, rre.getId());
    Schema resSchema = Schema.parse(rre.getSchema());
    assertEquals("unexpected source-schema name for source id 4002", "test4.source2_v1", resSchema.getFullName());
    // There's no guarantee of a metadataSchemas entry in general, but we pre-stuffed our
    // VersionedSchemaSetBackedRegistryService with one in the test's constructor, so we
    // expect the relay to hand it back to us.  Or else.
    /* disabled for now since simplistic relay implementation has been disabled; reenable/update/modify as part of DDSDBUS-2093/2096 (TODO)
    List<Object> metadataSchemasObjectsList = resMap.get(RegisterResponseMetadataEntry.METADATA_SCHEMAS_KEY);
    assertNotNull("missing expected metadataSchemas key in response", metadataSchemasObjectsList);
    assertEquals("expected one metadata schema", 1, metadataSchemasObjectsList.size());

    // As above, we must construct RegisterResponseMetadataEntry manually.
    assertTrue("metadataSchemas deserialization error: 'Object' type = " +
               metadataSchemasObjectsList.get(0).getClass().getName() + ", not LinkedHashMap",
               metadataSchemasObjectsList.get(0) instanceof LinkedHashMap);
    @SuppressWarnings("unchecked") // just obj2
    LinkedHashMap<String, Object> obj2 = (LinkedHashMap<String, Object>)metadataSchemasObjectsList.get(0);
    assertTrue("metadataSchemas deserialization error: missing \"version\" key", obj2.containsKey("version"));
    assertTrue("metadataSchemas deserialization error: missing \"schema\" key", obj2.containsKey("schema"));

    assertTrue("obj2.get(\"version\") type = " + obj2.get("version").getClass().getName() + ", not Integer",
               obj2.get("version") instanceof Integer);
    RegisterResponseMetadataEntry rrme = new RegisterResponseMetadataEntry(((Integer)obj2.get("version")).shortValue(),
                                                                          (String)obj2.get("schema"));
    assertEquals("unexpected metadata version", 1, rrme.getVersion());
    resSchema = Schema.parse(rrme.getSchema());
    assertEquals("unexpected metadata schema name", "test_namespace.metadata", resSchema.getFullName());
 */
    LOG.debug("\n\ndone with testRegisterV4CommandHappyPath()\n");
}

Example 7 with RegisterResponseMetadataEntry

use of com.linkedin.databus2.core.container.request.RegisterResponseMetadataEntry in project databus by linkedin.

the class TestRegisterRequestProcessor method testV4RegisterRequestProcessor.

// Test the happy path where there are 2 versions of document schema of a table and one version of metadata
// schema in the registry.
@Test
public void testV4RegisterRequestProcessor() throws Exception {
    Properties params = new Properties();
    final int protoVersion = 4;
    final int srcId1 = 101;
    final String srcName1 = "source-101";
    final String docSchema1 = "docSchema1";
    final String docSchema2 = "docSchema2";
    final String metadataSchema1 = makeMetadataSchema(1);
    final String metadataSchema2 = makeMetadataSchema(2);
    final byte[] metaSchemaDigest1 = new byte[] { 32, 33, 34, 35 };
    final byte[] metaSchemaDigest2 = new byte[] { 35, 34, 33, 32 };
    final short docSchemaV1 = 1;
    final short docSchemaV2 = 2;
    final short metaSchemaV1 = 1;
    final short metaSchemaV2 = 2;
    params.setProperty(DatabusHttpHeaders.PROTOCOL_VERSION_PARAM, Integer.toString(protoVersion));
    params.setProperty(RegisterRequestProcessor.SOURCES_PARAM, Integer.toString(srcId1));
    final StringBuilder responseStr = new StringBuilder();
    ChunkedWritableByteChannel chunkedWritableByteChannel = EasyMock.createMock(ChunkedWritableByteChannel.class);
    chunkedWritableByteChannel.addMetadata(EasyMock.eq(DatabusHttpHeaders.DBUS_CLIENT_RELAY_PROTOCOL_VERSION_HDR), EasyMock.eq(protoVersion));
    chunkedWritableByteChannel.write(EasyMock.anyObject(ByteBuffer.class));
    EasyMock.expectLastCall().andAnswer(new IAnswer<Object>() {

        @Override
        public Object answer() throws Throwable {
            Charset charset = Charset.forName("UTF-8");
            CharsetDecoder decoder = charset.newDecoder();
            responseStr.append(decoder.decode((ByteBuffer) EasyMock.getCurrentArguments()[0]));
            return responseStr.length();
        }
    });
    EasyMock.replay(chunkedWritableByteChannel);
    DatabusRequest mockReq = EasyMock.createMock(DatabusRequest.class);
    EasyMock.expect(mockReq.getParams()).andReturn(params).anyTimes();
    EasyMock.expect(mockReq.getResponseContent()).andReturn(chunkedWritableByteChannel);
    EasyMock.replay(mockReq);
    LogicalSource lsrc1 = new LogicalSource(srcId1, srcName1);
    SourceIdNameRegistry mockSrcIdReg = EasyMock.createMock(SourceIdNameRegistry.class);
    EasyMock.expect(mockSrcIdReg.getSource(srcId1)).andReturn(lsrc1).anyTimes();
    EasyMock.replay(mockSrcIdReg);
    Map<Short, String> srcSchemaVersions = new HashMap<Short, String>();
    srcSchemaVersions.put(docSchemaV1, docSchema1);
    srcSchemaVersions.put(docSchemaV2, docSchema2);
    VersionedSchemaSet metadataSchemaSet = new VersionedSchemaSet();
    metadataSchemaSet.add(SchemaRegistryService.DEFAULT_METADATA_SCHEMA_SOURCE, metaSchemaV1, new SchemaId(metaSchemaDigest1), metadataSchema1, true);
    metadataSchemaSet.add(SchemaRegistryService.DEFAULT_METADATA_SCHEMA_SOURCE, metaSchemaV2, new SchemaId(metaSchemaDigest2), metadataSchema2, true);
    SchemaRegistryService mockSchemaReg = EasyMock.createMock(SchemaRegistryService.class);
    EasyMock.expect(mockSchemaReg.fetchAllSchemaVersionsBySourceName(srcName1)).andReturn(srcSchemaVersions).anyTimes();
    EasyMock.expect(mockSchemaReg.fetchAllMetadataSchemaVersions()).andReturn(metadataSchemaSet).anyTimes();
    EasyMock.replay(mockSchemaReg);
    HttpRelay mockRelay = EasyMock.createMock(HttpRelay.class);
    EasyMock.expect(mockRelay.getHttpStatisticsCollector()).andReturn(null).anyTimes();
    EasyMock.expect(mockRelay.getSourcesIdNameRegistry()).andReturn(mockSrcIdReg).anyTimes();
    EasyMock.expect(mockRelay.getSchemaRegistryService()).andReturn(mockSchemaReg).anyTimes();
    EasyMock.replay(mockRelay);
    RegisterRequestProcessor reqProcessor = new RegisterRequestProcessor(null, mockRelay);
    reqProcessor.process(mockReq);
    // Decode
    ObjectMapper mapper = new ObjectMapper();
    HashMap<String, List<Object>> responseMap = mapper.readValue(responseStr.toString(), new TypeReference<HashMap<String, List<Object>>>() {
    });
    Map<Long, List<RegisterResponseEntry>> sourcesSchemasMap = RegisterResponseEntry.createFromResponse(responseMap, RegisterResponseEntry.SOURCE_SCHEMAS_KEY, false);
    // There should be one entry in the map, which is a  list.
    Assert.assertEquals(1, sourcesSchemasMap.size());
    Assert.assertEquals(2, sourcesSchemasMap.get(new Long(srcId1)).size());
    for (RegisterResponseEntry r : sourcesSchemasMap.get(new Long(srcId1))) {
        Assert.assertEquals(srcId1, r.getId());
        if (r.getVersion() == docSchemaV1) {
            Assert.assertEquals(docSchema1, r.getSchema());
        } else {
            Assert.assertEquals(docSchema2, r.getSchema());
        }
    }
    Map<Long, List<RegisterResponseEntry>> keysSchemasMap = RegisterResponseEntry.createFromResponse(responseMap, RegisterResponseEntry.KEY_SCHEMAS_KEY, true);
    Assert.assertNull(keysSchemasMap);
    List<RegisterResponseMetadataEntry> metadataSchemasList = RegisterResponseMetadataEntry.createFromResponse(responseMap, RegisterResponseMetadataEntry.METADATA_SCHEMAS_KEY, true);
    // The response should contain the exact string that the schema registry has.
    Assert.assertEquals(2, metadataSchemasList.size());
    for (RegisterResponseMetadataEntry r : metadataSchemasList) {
        if (r.getVersion() == 1) {
            Assert.assertEquals(metadataSchema1, r.getSchema());
            Assert.assertTrue(Arrays.equals(metaSchemaDigest1, r.getCrc32()));
        } else {
            Assert.assertEquals(metadataSchema2, r.getSchema());
            Assert.assertTrue(Arrays.equals(metaSchemaDigest2, r.getCrc32()));
        }
    }
    EasyMock.verify(mockRelay);
    EasyMock.verify(mockReq);
    EasyMock.verify(mockSchemaReg);
    EasyMock.verify(mockSrcIdReg);
}

Example 8 with RegisterResponseMetadataEntry

use of com.linkedin.databus2.core.container.request.RegisterResponseMetadataEntry in project databus by linkedin.

the class MockRemoteExceptionHandler method createRelayPullThread.

private static RelayPullThread createRelayPullThread(boolean failRelayConnection, boolean muteTransition, boolean bootstrapEnabled, boolean readLatestScnEnabled, boolean readDataThrowException, boolean readDataException, String exceptionName, int numRetriesOnFellOff, DbusKeyCompositeFilterConfig filterConfig) throws Exception {
    List<String> sources = Arrays.asList("source1");
    Properties clientProps = new Properties();
    if (bootstrapEnabled) {
        clientProps.setProperty("client.runtime.bootstrap.enabled", "true");
        clientProps.setProperty("client.runtime.bootstrap.service(1).name", "bs1");
        clientProps.setProperty("client.runtime.bootstrap.service(1).port", "10001");
        clientProps.setProperty("client.runtime.bootstrap.service(1).sources", "source1");
    } else {
        clientProps.setProperty("client.runtime.bootstrap.enabled", "false");
    }
    clientProps.setProperty("client.container.jmx.rmiEnabled", "false");
    clientProps.setProperty("client.runtime.relay(1).name", "relay1");
    clientProps.setProperty("client.runtime.relay(1).port", "10001");
    clientProps.setProperty("client.runtime.relay(1).sources", "source1");
    clientProps.setProperty("client.runtime.relay(2).name", "relay2");
    clientProps.setProperty("client.runtime.relay(2).port", "10002");
    clientProps.setProperty("client.runtime.relay(2).sources", "source1");
    clientProps.setProperty("client.runtime.relay(3).name", "relay3");
    clientProps.setProperty("client.runtime.relay(3).port", "10003");
    clientProps.setProperty("client.runtime.relay(3).sources", "source1");
    if (readLatestScnEnabled)
        clientProps.setProperty("client.enableReadLatestOnRelayFallOff", "true");
    clientProps.setProperty("client.connectionDefaults.eventBuffer.maxSize", "100000");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.maxRetryNum", "9");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.sleepIncFactor", "1.0");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.sleepIncDelta", "1");
    clientProps.setProperty("client.connectionDefaults.pullerRetries.initSleep", "1");
    clientProps.setProperty("client.connectionDefaults.numRetriesOnFallOff", "" + numRetriesOnFellOff);
    DatabusHttpClientImpl.Config clientConfBuilder = new DatabusHttpClientImpl.Config();
    ConfigLoader<DatabusHttpClientImpl.StaticConfig> configLoader = new ConfigLoader<DatabusHttpClientImpl.StaticConfig>("client.", clientConfBuilder);
    configLoader.loadConfig(clientProps);
    DatabusHttpClientImpl.StaticConfig clientConf = clientConfBuilder.build();
    DatabusSourcesConnection.StaticConfig srcConnConf = clientConf.getConnectionDefaults();
    DatabusHttpClientImpl client = new DatabusHttpClientImpl(clientConf);
    if (bootstrapEnabled)
        client.registerDatabusBootstrapListener(new LoggingConsumer(), null, "source1");
    Assert.assertNotNull(client, "client instantiation ok");
    DatabusHttpClientImpl.RuntimeConfig clientRtConf = clientConf.getRuntime().build();
    //we keep the index of the next server we expect to see
    AtomicInteger serverIdx = new AtomicInteger(-1);
    //generate the order in which we should see the servers
    List<ServerInfo> relayOrder = new ArrayList<ServerInfo>(clientRtConf.getRelays());
    if (LOG.isInfoEnabled()) {
        StringBuilder sb = new StringBuilder();
        for (ServerInfo serverInfo : relayOrder) {
            sb.append(serverInfo.getName());
            sb.append(" ");
        }
        LOG.info("Relay order:" + sb.toString());
    }
    List<IdNamePair> sourcesResponse = new ArrayList<IdNamePair>();
    sourcesResponse.add(new IdNamePair(1L, "source1"));
    Map<Long, List<RegisterResponseEntry>> registerSourcesResponse = new HashMap<Long, List<RegisterResponseEntry>>();
    List<RegisterResponseEntry> regResponse = new ArrayList<RegisterResponseEntry>();
    regResponse.add(new RegisterResponseEntry(1L, (short) 1, SCHEMA$.toString()));
    registerSourcesResponse.put(1L, regResponse);
    ChunkedBodyReadableByteChannel channel = EasyMock.createMock(ChunkedBodyReadableByteChannel.class);
    if (!readDataException) {
        EasyMock.expect(channel.getMetadata(EasyMock.<String>notNull())).andReturn(null).anyTimes();
    } else {
        EasyMock.expect(channel.getMetadata(EasyMock.<String>notNull())).andReturn(exceptionName).anyTimes();
    }
    EasyMock.replay(channel);
    DbusEventBuffer dbusBuffer = EasyMock.createMock(DbusEventBuffer.class);
    EasyMock.expect(dbusBuffer.readEvents(EasyMock.<ReadableByteChannel>notNull(), EasyMock.<List<InternalDatabusEventsListener>>notNull(), EasyMock.<DbusEventsStatisticsCollector>isNull())).andReturn(1).anyTimes();
    EasyMock.expect(dbusBuffer.getSeenEndOfPeriodScn()).andReturn(1L).anyTimes();
    EasyMock.expect(dbusBuffer.getEventSerializationVersion()).andReturn(DbusEventFactory.DBUS_EVENT_V1).anyTimes();
    if (readDataThrowException) {
        EasyMock.expect(dbusBuffer.readEvents(EasyMock.<ReadableByteChannel>notNull())).andThrow(new RuntimeException("dummy")).anyTimes();
    } else {
        EasyMock.expect(dbusBuffer.readEvents(EasyMock.<ReadableByteChannel>notNull())).andReturn(1).anyTimes();
    }
    EasyMock.expect(dbusBuffer.acquireIterator(EasyMock.<String>notNull())).andReturn(null).anyTimes();
    dbusBuffer.waitForFreeSpace((int) (clientConf.getConnectionDefaults().getFreeBufferThreshold() * 100.0 / clientConf.getPullerBufferUtilizationPct()));
    EasyMock.expectLastCall().anyTimes();
    EasyMock.expect(dbusBuffer.getBufferFreeReadSpace()).andReturn(0).anyTimes();
    EasyMock.replay(dbusBuffer);
    //This guy succeeds on /sources but fails on /register  [FIXME:  it does? why?]
    Map<Long, List<RegisterResponseEntry>> registerKeysResponse = null;
    List<RegisterResponseMetadataEntry> registerMetadataResponse = null;
    MockRelayConnection mockSuccessConn = new MockRelayConnection(sourcesResponse, registerSourcesResponse, registerKeysResponse, registerMetadataResponse, channel, serverIdx, muteTransition);
    DatabusRelayConnectionFactory mockConnFactory = EasyMock.createMock("mockRelayFactory", DatabusRelayConnectionFactory.class);
    if (failRelayConnection) {
        EasyMock.expect(mockConnFactory.createRelayConnection(EasyMock.<ServerInfo>notNull(), EasyMock.<ActorMessageQueue>notNull(), EasyMock.<RemoteExceptionHandler>notNull())).andThrow(new RuntimeException("Mock Error")).anyTimes();
    } else {
        EasyMock.expect(mockConnFactory.createRelayConnection(EasyMock.<ServerInfo>notNull(), EasyMock.<ActorMessageQueue>notNull(), EasyMock.<RemoteExceptionHandler>notNull())).andReturn(mockSuccessConn).anyTimes();
    }
    List<DatabusSubscription> sourcesSubList = DatabusSubscription.createSubscriptionList(sources);
    // Mock Bootstrap Puller
    BootstrapPullThread mockBsPuller = EasyMock.createMock("bpt", BootstrapPullThread.class);
    mockBsPuller.enqueueMessage(EasyMock.notNull());
    EasyMock.expectLastCall().anyTimes();
    // Mock Relay Dispatcher
    RelayDispatcher mockDispatcher = EasyMock.createMock("rd", RelayDispatcher.class);
    mockDispatcher.enqueueMessage(EasyMock.notNull());
    EasyMock.expectLastCall().anyTimes();
    DatabusSourcesConnection sourcesConn2 = EasyMock.createMock(DatabusSourcesConnection.class);
    DatabusSourcesConnection.SourcesConnectionStatus scs = sourcesConn2.new SourcesConnectionStatus();
    EasyMock.expect(sourcesConn2.getSourcesNames()).andReturn(Arrays.asList("source1")).anyTimes();
    EasyMock.expect(sourcesConn2.getSubscriptions()).andReturn(sourcesSubList).anyTimes();
    EasyMock.expect(sourcesConn2.getConnectionConfig()).andReturn(srcConnConf).anyTimes();
    EasyMock.expect(sourcesConn2.getConnectionStatus()).andReturn(scs).anyTimes();
    EasyMock.expect(sourcesConn2.getLocalRelayCallsStatsCollector()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getInboundEventsStatsCollector()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getRelayCallsStatsCollector()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getUnifiedClientStats()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getRelayConnFactory()).andReturn(mockConnFactory).anyTimes();
    EasyMock.expect(sourcesConn2.loadPersistentCheckpoint()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getDataEventsBuffer()).andReturn(dbusBuffer).anyTimes();
    if (bootstrapEnabled)
        EasyMock.expect(sourcesConn2.isBootstrapEnabled()).andReturn(true).anyTimes();
    else
        EasyMock.expect(sourcesConn2.isBootstrapEnabled()).andReturn(false).anyTimes();
    EasyMock.expect(sourcesConn2.getBootstrapRegistrations()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getBootstrapServices()).andReturn(null).anyTimes();
    EasyMock.expect(sourcesConn2.getBootstrapPuller()).andReturn(mockBsPuller).anyTimes();
    EasyMock.expect(sourcesConn2.getRelayDispatcher()).andReturn(mockDispatcher).anyTimes();
    EasyMock.makeThreadSafe(mockConnFactory, true);
    EasyMock.makeThreadSafe(mockDispatcher, true);
    EasyMock.makeThreadSafe(mockBsPuller, true);
    EasyMock.makeThreadSafe(sourcesConn2, true);
    EasyMock.replay(mockConnFactory);
    EasyMock.replay(sourcesConn2);
    EasyMock.replay(mockDispatcher);
    EasyMock.replay(mockBsPuller);
    ConnectionStateFactory connStateFactory = new ConnectionStateFactory(sources);
    ArrayList<DbusKeyCompositeFilterConfig> filters = new ArrayList<DbusKeyCompositeFilterConfig>();
    if (filterConfig != null)
        filters.add(filterConfig);
    RelayPullThread relayPuller = new RelayPullThread("RelayPuller", sourcesConn2, dbusBuffer, connStateFactory, clientRtConf.getRelaysSet(), filters, srcConnConf.getConsumeCurrent(), srcConnConf.getReadLatestScnOnError(), srcConnConf.getPullerUtilizationPct(), // no threshold for noEventsRest set
    0, ManagementFactory.getPlatformMBeanServer(), new DbusEventV1Factory(), null);
    RemoteExceptionHandler mockRemoteExceptionHandler = new MockRemoteExceptionHandler(sourcesConn2, dbusBuffer, relayPuller);
    Field field = relayPuller.getClass().getDeclaredField("_remoteExceptionHandler");
    field.setAccessible(true);
    field.set(relayPuller, mockRemoteExceptionHandler);
    mockSuccessConn.setCallback(relayPuller);
    return relayPuller;
}

Example 9 with RegisterResponseMetadataEntry

use of com.linkedin.databus2.core.container.request.RegisterResponseMetadataEntry in project databus by linkedin.

the class StreamHttpResponseProcessor method finishResponse.

@Override
public void finishResponse() throws Exception {
    super.finishResponse();
    if (_errorHandled) {
        return;
    }
    final String registerResponseError = "/register response error: ";
    try {
        String exceptionName = RemoteExceptionHandler.getExceptionName(_decorated);
        if (null != exceptionName) {
            LOG.error(registerResponseError + RemoteExceptionHandler.getExceptionMessage(_decorated));
            _stateReuse.switchToRegisterResponseError();
        } else {
            InputStream bodyStream = Channels.newInputStream(_decorated);
            ObjectMapper mapper = new ObjectMapper();
            // either 2 or 3 would suffice here; we care only about 4
            int registerResponseVersion = 3;
            if (_registerResponseVersionHdr != null) {
                try {
                    registerResponseVersion = Integer.parseInt(_registerResponseVersionHdr);
                } catch (NumberFormatException e) {
                    throw new RuntimeException("Could not parse /register response protocol version: " + _registerResponseVersionHdr);
                }
                if (registerResponseVersion < 2 || registerResponseVersion > 4) {
                    throw new RuntimeException("Out-of-range /register response protocol version: " + _registerResponseVersionHdr);
                }
            }
            if (// DDSDBUS-2009
            registerResponseVersion == 4) {
                HashMap<String, List<Object>> responseMap = mapper.readValue(bodyStream, new TypeReference<HashMap<String, List<Object>>>() {
                });
                // Look for mandatory SOURCE_SCHEMAS_KEY.
                Map<Long, List<RegisterResponseEntry>> sourcesSchemasMap = RegisterResponseEntry.createFromResponse(responseMap, RegisterResponseEntry.SOURCE_SCHEMAS_KEY, false);
                // Look for optional KEY_SCHEMAS_KEY
                // Key schemas, if they exist, should correspond to source schemas, but it's not
                // a one-to-one mapping.  The same version of a key schema may be used for several
                // versions of a source schema, or vice versa.  (The IDs must correspond.)
                //
                // TODO (DDSDBUS-xxx):  support key schemas on the relay side, too
                Map<Long, List<RegisterResponseEntry>> keysSchemasMap = RegisterResponseEntry.createFromResponse(responseMap, RegisterResponseEntry.KEY_SCHEMAS_KEY, true);
                // Look for optional METADATA_SCHEMAS_KEY
                List<RegisterResponseMetadataEntry> metadataSchemasList = RegisterResponseMetadataEntry.createFromResponse(responseMap, RegisterResponseMetadataEntry.METADATA_SCHEMAS_KEY, true);
                _stateReuse.switchToRegisterSuccess(sourcesSchemasMap, keysSchemasMap, metadataSchemasList);
            } else // version 2 or 3
            {
                List<RegisterResponseEntry> schemasList = mapper.readValue(bodyStream, new TypeReference<List<RegisterResponseEntry>>() {
                });
                Map<Long, List<RegisterResponseEntry>> sourcesSchemasMap = RegisterResponseEntry.convertSchemaListToMap(schemasList);
                _stateReuse.switchToRegisterSuccess(sourcesSchemasMap, null, null);
            }
        }
    } catch (IOException ex) {
        LOG.error(registerResponseError, ex);
        _stateReuse.switchToRegisterResponseError();
    } catch (RuntimeException ex) {
        LOG.error(registerResponseError, ex);
        _stateReuse.switchToRegisterResponseError();
    }
    _callback.enqueueMessage(_stateReuse);
}