src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
BrokerBasedLog implements DataSynchronizer<K, V> { @Override public void start() { try { producer.start(); consumer.subscribe(topicName, "*"); consumer.registerMessageListener(new MessageListenerImpl()); consumer.start(); } catch (MQClientException e) { log.error("Start error.", e); } } BrokerBasedLog(ConnectConfig connectConfig,
String topicName,
String workId,
DataSynchronizerCallback<K, V> dataSynchronizerCallback,
Converter keyConverter,
Converter valueConverter); @Override void start(); @Override void stop(); @Override void send(K key, V value); } | @Test public void testStart() throws MQClientException { brokerBasedLog.start(); verify(producer, times(1)).start(); verify(consumer, times(1)).subscribe(anyString(), anyString()); verify(consumer, times(1)).start(); } |
BrokerBasedLog implements DataSynchronizer<K, V> { @Override public void stop() { producer.shutdown(); consumer.shutdown(); } BrokerBasedLog(ConnectConfig connectConfig,
String topicName,
String workId,
DataSynchronizerCallback<K, V> dataSynchronizerCallback,
Converter keyConverter,
Converter valueConverter); @Override void start(); @Override void stop(); @Override void send(K key, V value); } | @Test public void testStop() { brokerBasedLog.stop(); verify(producer, times(1)).shutdown(); verify(consumer, times(1)).shutdown(); } |
BrokerBasedLog implements DataSynchronizer<K, V> { @Override public void send(K key, V value) { try { byte[] messageBody = encodeKeyValue(key, value); if (messageBody.length > MAX_MESSAGE_SIZE) { log.error("Message size is greater than {} bytes, key: {}, value {}", MAX_MESSAGE_SIZE, key, value); return; } producer.send(new Message(topicName, messageBody), new SendCallback() { @Override public void onSuccess(org.apache.rocketmq.client.producer.SendResult result) { log.info("Send async message OK, msgId: {},topic:{}", result.getMsgId(), topicName); } @Override public void onException(Throwable throwable) { if (null != throwable) { log.error("Send async message Failed, error: {}", throwable); } } }); } catch (Exception e) { log.error("BrokerBaseLog send async message Failed.", e); } } BrokerBasedLog(ConnectConfig connectConfig,
String topicName,
String workId,
DataSynchronizerCallback<K, V> dataSynchronizerCallback,
Converter keyConverter,
Converter valueConverter); @Override void start(); @Override void stop(); @Override void send(K key, V value); } | @Test public void testSend() throws RemotingException, MQClientException, InterruptedException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { brokerBasedLog.send(new Object(), new Object()); verify(producer, times(1)).send(any(Message.class), any(SendCallback.class)); } |
Worker { public synchronized void startConnectors(Map<String, ConnectKeyValue> connectorConfigs, ConnectController connectController) throws Exception { Set<WorkerConnector> stoppedConnector = new HashSet<>(); for (WorkerConnector workerConnector : workingConnectors) { String connectorName = workerConnector.getConnectorName(); ConnectKeyValue keyValue = connectorConfigs.get(connectorName); if (null == keyValue || 0 != keyValue.getInt(RuntimeConfigDefine.CONFIG_DELETED)) { workerConnector.stop(); log.info("Connector {} stop", workerConnector.getConnectorName()); stoppedConnector.add(workerConnector); } else if (!keyValue.equals(workerConnector.getKeyValue())) { workerConnector.reconfigure(keyValue); } } workingConnectors.removeAll(stoppedConnector); if (null == connectorConfigs || 0 == connectorConfigs.size()) { return; } Map<String, ConnectKeyValue> newConnectors = new HashMap<>(); for (String connectorName : connectorConfigs.keySet()) { boolean isNewConnector = true; for (WorkerConnector workerConnector : workingConnectors) { if (workerConnector.getConnectorName().equals(connectorName)) { isNewConnector = false; break; } } if (isNewConnector) { newConnectors.put(connectorName, connectorConfigs.get(connectorName)); } } for (String connectorName : newConnectors.keySet()) { ConnectKeyValue keyValue = newConnectors.get(connectorName); String connectorClass = keyValue.getString(RuntimeConfigDefine.CONNECTOR_CLASS); ClassLoader loader = plugin.getPluginClassLoader(connectorClass); final ClassLoader currentThreadLoader = plugin.currentThreadLoader(); Class clazz; boolean isolationFlag = false; if (loader instanceof PluginClassLoader) { clazz = ((PluginClassLoader) loader).loadClass(connectorClass, false); isolationFlag = true; } else { clazz = Class.forName(connectorClass); } final Connector connector = (Connector) clazz.getDeclaredConstructor().newInstance(); WorkerConnector workerConnector = new WorkerConnector(connectorName, connector, connectorConfigs.get(connectorName), new DefaultConnectorContext(connectorName, connectController)); if (isolationFlag) { Plugin.compareAndSwapLoaders(loader); } workerConnector.initialize(); workerConnector.start(); log.info("Connector {} start", workerConnector.getConnectorName()); Plugin.compareAndSwapLoaders(currentThreadLoader); this.workingConnectors.add(workerConnector); } } Worker(ConnectConfig connectConfig,
PositionManagementService positionManagementService, PositionManagementService offsetManagementService,
Plugin plugin); void start(); synchronized void startConnectors(Map<String, ConnectKeyValue> connectorConfigs,
ConnectController connectController); void startTasks(Map<String, List<ConnectKeyValue>> taskConfigs); void stop(); Set<WorkerConnector> getWorkingConnectors(); void setWorkingConnectors(
Set<WorkerConnector> workingConnectors); Set<Runnable> getWorkingTasks(); Set<Runnable> getErrorTasks(); Set<Runnable> getPendingTasks(); Set<Runnable> getStoppedTasks(); Set<Runnable> getStoppingTasks(); Set<Runnable> getCleanedErrorTasks(); Set<Runnable> getCleanedStoppedTasks(); void setWorkingTasks(Set<Runnable> workingTasks); void maintainConnectorState(); void maintainTaskState(); } | @Test public void testStartConnectors() throws Exception { Map<String, ConnectKeyValue> connectorConfigs = new HashMap<>(); for (int i = 1; i < 4; i++) { ConnectKeyValue connectKeyValue = new ConnectKeyValue(); connectKeyValue.getProperties().put("key1", "TEST-CONN-" + i + "1"); connectKeyValue.getProperties().put("key2", "TEST-CONN-" + i + "2"); connectKeyValue.getProperties().put(RuntimeConfigDefine.CONNECTOR_CLASS, TestConnector.class.getName()); connectorConfigs.put("TEST-CONN-" + i, connectKeyValue); } worker.startConnectors(connectorConfigs, connectController); Set<WorkerConnector> connectors = worker.getWorkingConnectors(); assertThat(connectors.size()).isEqualTo(3); for (WorkerConnector wc : connectors) { assertThat(wc.getConnectorName()).isIn("TEST-CONN-1", "TEST-CONN-2", "TEST-CONN-3"); } } |
Worker { public void startTasks(Map<String, List<ConnectKeyValue>> taskConfigs) { synchronized (latestTaskConfigs) { this.latestTaskConfigs = taskConfigs; } } Worker(ConnectConfig connectConfig,
PositionManagementService positionManagementService, PositionManagementService offsetManagementService,
Plugin plugin); void start(); synchronized void startConnectors(Map<String, ConnectKeyValue> connectorConfigs,
ConnectController connectController); void startTasks(Map<String, List<ConnectKeyValue>> taskConfigs); void stop(); Set<WorkerConnector> getWorkingConnectors(); void setWorkingConnectors(
Set<WorkerConnector> workingConnectors); Set<Runnable> getWorkingTasks(); Set<Runnable> getErrorTasks(); Set<Runnable> getPendingTasks(); Set<Runnable> getStoppedTasks(); Set<Runnable> getStoppingTasks(); Set<Runnable> getCleanedErrorTasks(); Set<Runnable> getCleanedStoppedTasks(); void setWorkingTasks(Set<Runnable> workingTasks); void maintainConnectorState(); void maintainTaskState(); } | @Test public void testStartTasks() throws Exception { Map<String, List<ConnectKeyValue>> taskConfigs = new HashMap<>(); for (int i = 1; i < 4; i++) { List<ConnectKeyValue> connectKeyValues = new ArrayList<>(); ConnectKeyValue connectKeyValue = new ConnectKeyValue(); connectKeyValue.getProperties().put("key1", "TEST-CONN-" + i + "1"); connectKeyValue.getProperties().put("key2", "TEST-CONN-" + i + "2"); connectKeyValue.getProperties().put(RuntimeConfigDefine.TASK_CLASS, TestSourceTask.class.getName()); connectKeyValue.getProperties().put(RuntimeConfigDefine.SOURCE_RECORD_CONVERTER, TestConverter.class.getName()); connectKeyValue.getProperties().put(RuntimeConfigDefine.NAMESRV_ADDR, "127.0.0.1:9876"); connectKeyValue.getProperties().put(RuntimeConfigDefine.RMQ_PRODUCER_GROUP, UUID.randomUUID().toString()); connectKeyValue.getProperties().put(RuntimeConfigDefine.OPERATION_TIMEOUT, "3000"); connectKeyValues.add(connectKeyValue); taskConfigs.put("TEST-CONN-" + i, connectKeyValues); } worker.startTasks(taskConfigs); Set<Runnable> sourceTasks = worker.getWorkingTasks(); assertThat(sourceTasks.size()).isEqualTo(3); for (Runnable runnable : sourceTasks) { WorkerSourceTask workerSourceTask = null; WorkerSinkTask workerSinkTask = null; if (runnable instanceof WorkerSourceTask) { workerSourceTask = (WorkerSourceTask) runnable; } else { workerSinkTask = (WorkerSinkTask) runnable; } String connectorName = null != workerSourceTask ? workerSourceTask.getConnectorName() : workerSinkTask.getConnectorName(); assertThat(connectorName).isIn("TEST-CONN-1", "TEST-CONN-2", "TEST-CONN-3"); } } |
WorkerConnector { public void reconfigure(ConnectKeyValue keyValue) { this.keyValue = keyValue; stop(); start(); } WorkerConnector(String connectorName, Connector connector, ConnectKeyValue keyValue, ConnectorContext context); void initialize(); void start(); void stop(); String getConnectorName(); ConnectKeyValue getKeyValue(); void reconfigure(ConnectKeyValue keyValue); Connector getConnector(); @Override String toString(); } | @Test public void testReconfigure() { ConnectKeyValue connectKeyValue = new ConnectKeyValue(); connectKeyValue.put("test2", "value2"); workerConnector.reconfigure(connectKeyValue); assertThat(workerConnector.getKeyValue().equals(connectKeyValue)).isEqualTo(true); } |
JsonConverter implements Converter { public JsonConverter() { this.clazz = null; } JsonConverter(); JsonConverter(Class clazz); void setClazz(Class clazz); @Override byte[] objectToByte(Object object); @Override Object byteToObject(byte[] bytes); } | @Test public void testJsonConverter() { Map<String, String> data = new HashMap<>(); data.put("test_key", "test_value"); JsonConverter jc = new JsonConverter(); byte[] o2b = jc.objectToByte(data); Map<String, String> b2o = (Map<String, String>) jc.byteToObject(o2b); assertThat(b2o.size()).isEqualTo(1); assertThat(b2o.keySet().size()).isEqualTo(1); assertThat(b2o.values().size()).isEqualTo(1); for (String key : b2o.keySet()) { assertThat(new String(key)).isEqualTo("test_key"); assertThat(new String(b2o.get(key))).isEqualTo("test_value"); } } |
RmqSourceReplicator extends SourceConnector { public String generateTargetTopic(String topic) { String fmt = this.replicatorConfig.getRenamePattern(); if (StringUtils.isNotEmpty(fmt)) { Map<String, String> params = new HashMap<String, String>(); params.put("topic", topic); return StrSubstitutor.replace(fmt, params); } return topic; } RmqSourceReplicator(); @Override String verifyAndSetConfig(KeyValue config); @Override void start(); void startListner(); boolean compare(Map<String, Set<TaskTopicInfo>> origin, Map<String, Set<TaskTopicInfo>> updated); @Override void stop(); @Override void pause(); @Override void resume(); @Override Class<? extends Task> taskClass(); @Override List<KeyValue> taskConfigs(); void buildRoute(); Map<String, Set<TaskTopicInfo>> getTopicRouteMap(); Set<String> fetchTargetTopics(); void ensureTargetTopic(String srcTopic,
String targetTopic); String generateTargetTopic(String topic); } | @Test public void testGenerateTopic() throws NoSuchFieldException { RmqSourceReplicator rmqSourceReplicator = Mockito.spy(RmqSourceReplicator.class); RmqConnectorConfig config = new RmqConnectorConfig(); KeyValue kv = new DefaultKeyValue(); kv.put(ConfigDefine.CONN_TOPIC_RENAME_FMT, "${topic}.replica"); config.validate(kv); Field field = RmqSourceReplicator.class.getDeclaredField("replicatorConfig"); FieldSetter.setField(rmqSourceReplicator, field, config); String dstTopic = rmqSourceReplicator.generateTargetTopic("dest"); assertThat(dstTopic).isEqualTo("dest.replica"); } |
DefaultAllocateConnAndTaskStrategy implements AllocateConnAndTaskStrategy { @Override public ConnAndTaskConfigs allocate(List<String> allWorker, String curWorker, Map<String, ConnectKeyValue> connectorConfigs, Map<String, List<ConnectKeyValue>> taskConfigs) { ConnAndTaskConfigs allocateResult = new ConnAndTaskConfigs(); if (null == allWorker || 0 == allWorker.size()) { return allocateResult; } List<String> sortedWorkers = new ArrayList<>(allWorker); Collections.sort(sortedWorkers); log.debug("sortedWorkers: {}", sortedWorkers); Map<String, ConnectKeyValue> sortedConnectorConfigs = getSortedMap(connectorConfigs); log.debug("SortedConnectorConfigs: {}", sortedConnectorConfigs); Map<String, List<ConnectKeyValue>> sortedTaskConfigs = getSortedMap(taskConfigs); log.debug("SortedTaskConfigs: {}", sortedTaskConfigs); int index = 0; for (String connectorName : sortedConnectorConfigs.keySet()) { String allocatedWorker = sortedWorkers.get(index % sortedWorkers.size()); index++; if (!curWorker.equals(allocatedWorker)) { continue; } allocateResult.getConnectorConfigs().put(connectorName, sortedConnectorConfigs.get(connectorName)); } for (String connectorName : sortedTaskConfigs.keySet()) { for (ConnectKeyValue keyValue : sortedTaskConfigs.get(connectorName)) { String allocatedWorker = sortedWorkers.get(index % sortedWorkers.size()); index++; if (!curWorker.equals(allocatedWorker)) { continue; } if (null == allocateResult.getTaskConfigs().get(connectorName)) { allocateResult.getTaskConfigs().put(connectorName, new ArrayList<>()); } allocateResult.getTaskConfigs().get(connectorName).add(keyValue); } } return allocateResult; } @Override ConnAndTaskConfigs allocate(List<String> allWorker, String curWorker,
Map<String, ConnectKeyValue> connectorConfigs,
Map<String, List<ConnectKeyValue>> taskConfigs); } | @Test public void testAllocate() { DefaultAllocateConnAndTaskStrategy defaultAllocateConnAndTaskStrategy = new DefaultAllocateConnAndTaskStrategy(); List<String> allWorker = new ArrayList<String>() { { add("workId1"); add("workId2"); add("workId3"); } }; String curWorker = "workId3"; Map<String, ConnectKeyValue> connectorConfigs = new HashMap<String, ConnectKeyValue>() { { put("connectorConfig1", new ConnectKeyValue()); put("connectorConfig2", new ConnectKeyValue()); put("connectorConfig3", new ConnectKeyValue()); } }; ConnectKeyValue connectKeyValue1 = new ConnectKeyValue(); ConnectKeyValue connectKeyValue2 = new ConnectKeyValue(); ConnectKeyValue connectKeyValue3 = new ConnectKeyValue(); ConnectKeyValue connectKeyValue4 = new ConnectKeyValue(); ConnectKeyValue connectKeyValue5 = new ConnectKeyValue(); ConnectKeyValue connectKeyValue6 = new ConnectKeyValue(); List<ConnectKeyValue> taskConfig1 = new ArrayList<ConnectKeyValue>() { { add(connectKeyValue1); } }; List<ConnectKeyValue> taskConfig2 = new ArrayList<ConnectKeyValue>() { { add(connectKeyValue2); add(connectKeyValue3); } }; List<ConnectKeyValue> taskConfig3 = new ArrayList<ConnectKeyValue>() { { add(connectKeyValue4); add(connectKeyValue5); add(connectKeyValue6); } }; Map<String, List<ConnectKeyValue>> taskConfigs = new HashMap<String, List<ConnectKeyValue>>() { { put("connectorConfig1", taskConfig1); put("connectorConfig2", taskConfig2); put("connectorConfig3", taskConfig3); } }; ConnAndTaskConfigs allocate = defaultAllocateConnAndTaskStrategy.allocate(allWorker, curWorker, connectorConfigs, taskConfigs); assertNotNull(allocate); Map<String, ConnectKeyValue> connectorConfigs3 = allocate.getConnectorConfigs(); assertNotNull(connectorConfigs3); assertNotNull(connectorConfigs3.get("connectorConfig3")); assertNull(connectorConfigs3.get("connectorConfig2")); assertNull(connectorConfigs3.get("connectorConfig1")); Map<String, List<ConnectKeyValue>> taskConfigs1 = allocate.getTaskConfigs(); assertNotNull(taskConfigs1); assertNull(taskConfigs1.get("connectorConfig1")); List<ConnectKeyValue> connectorConfig1 = taskConfigs1.get("connectorConfig2"); assertNotNull(connectorConfig1); assertEquals(1, connectorConfig1.size()); assertEquals(connectKeyValue3, connectorConfig1.get(0)); List<ConnectKeyValue> connectorConfig2 = taskConfigs1.get("connectorConfig3"); assertNotNull(connectorConfig2); assertEquals(1, connectorConfig2.size()); assertEquals(connectKeyValue6, connectorConfig2.get(0)); } |
URISpecParser { public static Map<String, String> parseURI(String uri) { Preconditions.checkArgument(null != uri && !uri.trim().isEmpty(), "Uri can not be empty!"); Map<String, String> results = Maps.newHashMap(); String broker = uri.substring(0, uri.indexOf(":")); results.put(CommonConstant.PROVIDER, broker); if (broker.equals(DEFAULT_BROKER)) { String queryStr = uri.substring(uri.indexOf("?") + 1, uri.length()); if (StringUtils.isNotEmpty(queryStr)) { String[] params = queryStr.split("&"); for (String param : params) { if (param.contains("=")) { String[] values = param.split("=", 2); results.put(values[0], values[1]); } } } } else { throw new IllegalArgumentException("Broker must be rocketmq"); } return results; } static Map<String, String> parseURI(String uri); } | @Test public void parseURI_NormalTest() { Map<String, String> result = URISpecParser.parseURI("rocketmq: System.out.println(result); result = URISpecParser .parseURI("rocketmq: System.out.println(result); result = URISpecParser.parseURI("rocketmq:!@#$%^&*() System.out.println(result); }
@Test(expected = IllegalArgumentException.class) public void parseURI_AbnormalTest() { URISpecParser.parseURI("metaq3: } |
JmsObjectMessage extends JmsBaseMessage implements ObjectMessage { public Serializable getObject() throws JMSException { return this.body; } JmsObjectMessage(Serializable object); JmsObjectMessage(); Serializable getObject(); void setObject(Serializable object); } | @Test public void testGetObject() { JmsObjectMessage jmsObjectMessage = new JmsObjectMessage(new User("jack", 20)); try { Assert.assertEquals(jmsObjectMessage.getObject(), new User("jack", 20)); } catch (JMSException e) { e.printStackTrace(); } }
@Test public void testGetBody() { JmsObjectMessage jmsObjectMessage = new JmsObjectMessage(new User("jack", 20)); try { User user = (User)jmsObjectMessage.getBody(Object.class); System.out.println(user.getName() + ": " + user.getAge()); Assert.assertEquals(jmsObjectMessage.getBody(Object.class), jmsObjectMessage.getObject()); } catch (JMSException e) { e.printStackTrace(); } } |
JmsBytesMessage extends JmsBaseMessage implements BytesMessage { public byte[] getData() { if (bytesOut != null) { return bytesOut.toByteArray(); } else { return bytesIn; } } JmsBytesMessage(byte[] data); JmsBytesMessage(); long getBodyLength(); byte[] getData(); boolean readBoolean(); byte readByte(); int readUnsignedByte(); short readShort(); int readUnsignedShort(); char readChar(); int readInt(); long readLong(); float readFloat(); double readDouble(); String readUTF(); int readBytes(byte[] value); int readBytes(byte[] value, int length); void writeBoolean(boolean value); void writeByte(byte value); void writeShort(short value); void writeChar(char value); void writeInt(int value); void writeLong(long value); void writeFloat(float value); void writeDouble(double value); void writeUTF(String value); void writeBytes(byte[] value); void writeBytes(byte[] value, int offset, int length); void writeObject(Object value); void reset(); } | @Test public void testGetData() throws Exception { JmsBytesMessage readMessage = new JmsBytesMessage(receiveData); System.out.println(new String(readMessage.getData())); Assert.assertEquals(new String(receiveData), new String(readMessage.getData())); JmsBytesMessage sendMessage = new JmsBytesMessage(); sendMessage.writeBytes(sendData, 0, sendData.length); System.out.println(new String(sendMessage.getData())); Assert.assertEquals(new String(sendData), new String(sendMessage.getData())); } |
JmsBytesMessage extends JmsBaseMessage implements BytesMessage { public long getBodyLength() throws JMSException { return getData().length; } JmsBytesMessage(byte[] data); JmsBytesMessage(); long getBodyLength(); byte[] getData(); boolean readBoolean(); byte readByte(); int readUnsignedByte(); short readShort(); int readUnsignedShort(); char readChar(); int readInt(); long readLong(); float readFloat(); double readDouble(); String readUTF(); int readBytes(byte[] value); int readBytes(byte[] value, int length); void writeBoolean(boolean value); void writeByte(byte value); void writeShort(short value); void writeChar(char value); void writeInt(int value); void writeLong(long value); void writeFloat(float value); void writeDouble(double value); void writeUTF(String value); void writeBytes(byte[] value); void writeBytes(byte[] value, int offset, int length); void writeObject(Object value); void reset(); } | @Test public void testGetBodyLength() throws Exception { JmsBytesMessage bytesMessage = new JmsBytesMessage(receiveData); System.out.println(bytesMessage.getBodyLength()); Assert.assertEquals(bytesMessage.getBodyLength(), receiveData.length); } |
JmsBytesMessage extends JmsBaseMessage implements BytesMessage { public int readBytes(byte[] value) throws JMSException { return readBytes(value, value.length); } JmsBytesMessage(byte[] data); JmsBytesMessage(); long getBodyLength(); byte[] getData(); boolean readBoolean(); byte readByte(); int readUnsignedByte(); short readShort(); int readUnsignedShort(); char readChar(); int readInt(); long readLong(); float readFloat(); double readDouble(); String readUTF(); int readBytes(byte[] value); int readBytes(byte[] value, int length); void writeBoolean(boolean value); void writeByte(byte value); void writeShort(short value); void writeChar(char value); void writeInt(int value); void writeLong(long value); void writeFloat(float value); void writeDouble(double value); void writeUTF(String value); void writeBytes(byte[] value); void writeBytes(byte[] value, int offset, int length); void writeObject(Object value); void reset(); } | @Test public void testReadBytes() throws Exception { JmsBytesMessage bytesMessage = new JmsBytesMessage(receiveData); Assert.assertEquals(bytesMessage.getBodyLength(), receiveData.length); byte[] receiveValue = new byte[receiveData.length]; bytesMessage.readBytes(receiveValue); System.out.println(new String(receiveValue)); Assert.assertEquals(new String(receiveValue), new String(receiveData)); }
@Test public void testReadBytes1() throws Exception { JmsBytesMessage bytesMessage = new JmsBytesMessage(receiveData); byte[] receiveValue1 = new byte[2]; bytesMessage.readBytes(receiveValue1, 2); System.out.println(new String(receiveValue1)); Assert.assertEquals(new String(receiveData).substring(0, 2), new String(receiveValue1)); byte[] receiceValue2 = new byte[2]; bytesMessage.readBytes(receiceValue2, 2); System.out.println(new String(receiceValue2)); Assert.assertEquals(new String(receiveData).substring(2, 4), new String(receiceValue2)); } |
JmsBytesMessage extends JmsBaseMessage implements BytesMessage { public void writeBytes(byte[] value) throws JMSException { if (dataAsOutput == null) { throw new MessageNotWriteableException("Message is not writable! "); } try { dataAsOutput.write(value); } catch (IOException e) { throw handleOutputException(e); } } JmsBytesMessage(byte[] data); JmsBytesMessage(); long getBodyLength(); byte[] getData(); boolean readBoolean(); byte readByte(); int readUnsignedByte(); short readShort(); int readUnsignedShort(); char readChar(); int readInt(); long readLong(); float readFloat(); double readDouble(); String readUTF(); int readBytes(byte[] value); int readBytes(byte[] value, int length); void writeBoolean(boolean value); void writeByte(byte value); void writeShort(short value); void writeChar(char value); void writeInt(int value); void writeLong(long value); void writeFloat(float value); void writeDouble(double value); void writeUTF(String value); void writeBytes(byte[] value); void writeBytes(byte[] value, int offset, int length); void writeObject(Object value); void reset(); } | @Test public void testWriteBytes() throws Exception { JmsBytesMessage jmsBytesMessage = new JmsBytesMessage(); jmsBytesMessage.writeBytes(sendData); System.out.println(new String(jmsBytesMessage.getData())); Assert.assertEquals(new String(jmsBytesMessage.getData()), new String(sendData)); } |
RocketMQReceiver extends Receiver<Message> { public RocketMQReceiver(Properties properties, StorageLevel storageLevel) { super(storageLevel); this.properties = properties; } RocketMQReceiver(Properties properties, StorageLevel storageLevel); @Override void onStart(); boolean process(List<MessageExt> msgs); @Override void onStop(); } | @Test public void testRocketMQReceiver() { SparkConf conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount"); JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(5)); Properties properties = new Properties(); properties.setProperty(RocketMQConfig.NAME_SERVER_ADDR, NAMESERVER_ADDR); properties.setProperty(RocketMQConfig.CONSUMER_GROUP, CONSUMER_GROUP); properties.setProperty(RocketMQConfig.CONSUMER_TOPIC, CONSUMER_TOPIC); JavaInputDStream ds = RocketMqUtils.createJavaMQPushStream(jssc, properties, StorageLevel.MEMORY_ONLY()); ds.print(); jssc.start(); try { jssc.awaitTerminationOrTimeout(10000); } catch (InterruptedException e) { e.printStackTrace(); } jssc.stop(); } |
ConfigManagementServiceImpl implements ConfigManagementService { @Override public String putConnectorConfig(String connectorName, ConnectKeyValue configs) throws Exception { ConnectKeyValue exist = connectorKeyValueStore.get(connectorName); if (null != exist) { Long updateTimestamp = exist.getLong(RuntimeConfigDefine.UPDATE_TIMESATMP); if (null != updateTimestamp) { configs.put(RuntimeConfigDefine.UPDATE_TIMESATMP, updateTimestamp); } } if (configs.equals(exist)) { return "Connector with same config already exist."; } Long currentTimestamp = System.currentTimeMillis(); configs.put(RuntimeConfigDefine.UPDATE_TIMESATMP, currentTimestamp); for (String requireConfig : RuntimeConfigDefine.REQUEST_CONFIG) { if (!configs.containsKey(requireConfig)) { return "Request config key: " + requireConfig; } } String connectorClass = configs.getString(RuntimeConfigDefine.CONNECTOR_CLASS); ClassLoader classLoader = plugin.getPluginClassLoader(connectorClass); Class clazz; if (null != classLoader) { clazz = Class.forName(connectorClass, true, classLoader); } else { clazz = Class.forName(connectorClass); } Connector connector = (Connector) clazz.newInstance(); String errorMessage = connector.verifyAndSetConfig(configs); if (errorMessage != null && errorMessage.length() > 0) { return errorMessage; } connectorKeyValueStore.put(connectorName, configs); recomputeTaskConfigs(connectorName, connector, currentTimestamp); return ""; } ConfigManagementServiceImpl(ConnectConfig connectConfig, Plugin plugin); @Override void start(); @Override void stop(); @Override Map<String, ConnectKeyValue> getConnectorConfigs(); @Override Map<String, ConnectKeyValue> getConnectorConfigsIncludeDeleted(); @Override String putConnectorConfig(String connectorName, ConnectKeyValue configs); @Override void recomputeTaskConfigs(String connectorName, Connector connector, Long currentTimestamp); @Override void removeConnectorConfig(String connectorName); @Override Map<String, List<ConnectKeyValue>> getTaskConfigs(); @Override void persist(); @Override void registerListener(ConnectorConfigUpdateListener listener); Plugin getPlugin(); } | @Test public void testPutConnectorConfig() throws Exception { ConnectKeyValue connectKeyValue1 = connectorKeyValueStore.get(connectorName); List<ConnectKeyValue> connectKeyValues = taskKeyValueStore.get(connectorName); assertNull(connectKeyValue1); assertNull(connectKeyValues); configManagementService.putConnectorConfig(connectorName, connectKeyValue); connectKeyValue1 = connectorKeyValueStore.get(connectorName); connectKeyValues = taskKeyValueStore.get(connectorName); assertNotNull(connectKeyValue1); assertNotNull(connectKeyValues); } |
ReliableRocketMQReceiver extends RocketMQReceiver { public ReliableRocketMQReceiver(Properties properties, StorageLevel storageLevel) { super(properties, storageLevel); } ReliableRocketMQReceiver(Properties properties, StorageLevel storageLevel); @Override void onStart(); @Override boolean process(List<MessageExt> msgs); void ack(Object msgId); void fail(Object msgId); @Override void onStop(); } | @Test public void testReliableRocketMQReceiver() { SparkConf conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount"); JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(5)); Properties properties = new Properties(); properties.setProperty(RocketMQConfig.NAME_SERVER_ADDR, NAMESERVER_ADDR); properties.setProperty(RocketMQConfig.CONSUMER_GROUP, CONSUMER_GROUP); properties.setProperty(RocketMQConfig.CONSUMER_TOPIC, CONSUMER_TOPIC); JavaInputDStream ds = RocketMqUtils.createJavaReliableMQPushStream(jssc, properties, StorageLevel.MEMORY_ONLY()); ds.print(); jssc.start(); try { jssc.awaitTerminationOrTimeout(10000); } catch (InterruptedException e) { e.printStackTrace(); } jssc.stop(); } |
RocketMQRedisReplicator extends AbstractReplicator { @Override public void open() throws IOException { if (this.replicator instanceof RedisSocketReplicator) { boolean single = configure.getString(DEPLOY_MODEL).equals(DEPLOY_MODEL_SINGLE); if (single) { this.replicator.open(); } else { String address = configure.getString(CONFIG_PROP_ZK_ADDRESS); final CuratorFramework client = newClient(address, new ExponentialBackoffRetry(1000, 3)); client.start(); String path = ROOT_DIR + "/" + uri.getHost() + "-" + uri.getPort(); final LeaderSelector selector = new LeaderSelector(client, path, new LeaderSelectorListenerAdapter() { @Override public void takeLeadership(final CuratorFramework client) throws Exception { RocketMQRedisReplicator.this.addCloseListener(r -> client.close()); replicator.open(); } }); selector.start(); } } else { this.replicator.open(); } } RocketMQRedisReplicator(Configure configure); @Override void builtInCommandParserRegister(); @Override CommandParser<? extends Command> getCommandParser(CommandName command); @Override void addCommandParser(CommandName command, CommandParser<T> parser); @Override CommandParser<? extends Command> removeCommandParser(CommandName command); @Override ModuleParser<? extends Module> getModuleParser(String moduleName, int moduleVersion); @Override void addModuleParser(String moduleName, int moduleVersion, ModuleParser<T> parser); @Override ModuleParser<? extends Module> removeModuleParser(String moduleName, int moduleVersion); @Override void setRdbVisitor(RdbVisitor rdbVisitor); @Override RdbVisitor getRdbVisitor(); @Override boolean addEventListener(EventListener listener); @Override boolean removeEventListener(EventListener listener); @Override boolean addCloseListener(CloseListener listener); @Override boolean removeCloseListener(CloseListener listener); @Override boolean addExceptionListener(ExceptionListener listener); @Override boolean removeExceptionListener(ExceptionListener listener); @Override boolean verbose(); @Override Configuration getConfiguration(); @Override void open(); @Override void close(); static void main(String[] args); } | @Test public void open() throws Exception { Configure configure = new Configure(properties); Replicator replicator = new RocketMQRedisReplicator(configure); final RocketMQRedisProducer producer = new RocketMQRedisProducer(configure); producer.open(); final AtomicInteger test = new AtomicInteger(); replicator.addEventListener(new EventListener() { @Override public void onEvent(Replicator replicator, Event event) { if (event instanceof KeyValuePair<?, ?>) { try { boolean success = producer.send(event); if (success) { test.incrementAndGet(); } } catch (Exception e) { LOGGER.error("Fail to send KeyValuePair", e); } } else if (event instanceof Command) { try { boolean success = producer.send(event); if (success) { test.incrementAndGet(); } } catch (Exception e) { LOGGER.error("Fail to send command", e); } } } }); replicator.addCloseListener(new CloseListener() { @Override public void handle(Replicator replicator) { producer.close(); } }); replicator.open(); assertEquals(19, test.get()); } |
BaseJmsSourceConnector extends SourceConnector { @Override public String verifyAndSetConfig(KeyValue config) { for (String requestKey : getRequiredConfig()) { if (!config.containsKey(requestKey)) { return "Request config key: " + requestKey; } } this.config = config; return ""; } @Override String verifyAndSetConfig(KeyValue config); @Override void start(); @Override void stop(); @Override void pause(); @Override void resume(); @Override abstract Class<? extends Task> taskClass(); @Override List<KeyValue> taskConfigs(); abstract Set<String> getRequiredConfig(); } | @Test public void verifyAndSetConfigTest() { KeyValue keyValue = new DefaultKeyValue(); for (String requestKey : Config.REQUEST_CONFIG) { assertEquals(connector.verifyAndSetConfig(keyValue), "Request config key: " + requestKey); keyValue.put(requestKey, requestKey); } assertEquals(connector.verifyAndSetConfig(keyValue), ""); } |
BaseJmsSourceConnector extends SourceConnector { @Override public abstract Class<? extends Task> taskClass(); @Override String verifyAndSetConfig(KeyValue config); @Override void start(); @Override void stop(); @Override void pause(); @Override void resume(); @Override abstract Class<? extends Task> taskClass(); @Override List<KeyValue> taskConfigs(); abstract Set<String> getRequiredConfig(); } | @Test public void taskClassTest() { assertEquals(connector.taskClass(), BaseJmsSourceTask.class); } |
BaseJmsSourceConnector extends SourceConnector { @Override public List<KeyValue> taskConfigs() { List<KeyValue> config = new ArrayList<>(); config.add(this.config); return config; } @Override String verifyAndSetConfig(KeyValue config); @Override void start(); @Override void stop(); @Override void pause(); @Override void resume(); @Override abstract Class<? extends Task> taskClass(); @Override List<KeyValue> taskConfigs(); abstract Set<String> getRequiredConfig(); } | @Test public void taskConfigsTest() { assertEquals(connector.taskConfigs().get(0), null); KeyValue keyValue = new DefaultKeyValue(); for (String requestKey : Config.REQUEST_CONFIG) { keyValue.put(requestKey, requestKey); } connector.verifyAndSetConfig(keyValue); assertEquals(connector.taskConfigs().get(0), keyValue); } |
MqttConnectionHandler extends ChannelInboundHandlerAdapter { @Override public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception { if (evt instanceof IdleStateEvent) { IdleStateEvent idleStateEvent = (IdleStateEvent) evt; if (IdleState.ALL_IDLE.equals(idleStateEvent.state())) { doDisconnect(ctx.channel()); } } else if (evt instanceof DisconnectChannelEvent) { DisconnectChannelEvent disconnectChannelEvent = (DisconnectChannelEvent) evt; doDisconnect(disconnectChannelEvent.getChannel()); } ctx.fireUserEventTriggered(evt); } MqttConnectionHandler(ClientManager clientManager, SubscriptionStore subscriptionStore); @Override void userEventTriggered(ChannelHandlerContext ctx, Object evt); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); } | @Test public void testHandleDisconnectChannelEvent() throws Exception { DisconnectChannelEvent event = new DisconnectChannelEvent(channel); handler.userEventTriggered(ctx, event); Mockito.verify(clientManager).remove(channel); Mockito.verify(channel).close(); }
@Test public void testHandleIdleStateEvent() throws Exception { IdleStateEvent idleStateEvent = IdleStateEvent.ALL_IDLE_STATE_EVENT; handler.userEventTriggered(ctx, idleStateEvent); Mockito.verify(clientManager, Mockito.times(1)).remove(channel); Mockito.verify(channel, Mockito.times(1)).close(); } |
RocketMQJsonSerializer implements RocketMQSerializer<T> { @Override public byte[] serialize(T obj) { Validate.notNull(obj); return JSON.toJSONString(obj).getBytes(StandardCharsets.UTF_8); } @Override byte[] serialize(T obj); } | @Test public void testSerializeAndDeserialize() throws Exception { RocketMQJsonSerializer<User> jsonSerializer = new RocketMQJsonSerializer<>(); User user = new User(); user.setName("tom"); user.setAge(16); byte[] result = jsonSerializer.serialize(user); RocketMQJsonDeserializer<User> jsonDeserializer = new RocketMQJsonDeserializer<>(User.class); assertEquals(user, jsonDeserializer.deserialize(result)); } |
RocketMQStringSerializer implements RocketMQSerializer<String> { @Override public byte[] serialize(String obj) { Validate.notNull(obj); return obj.getBytes(StandardCharsets.UTF_8); } @Override byte[] serialize(String obj); } | @Test public void testSerializeAndDeserialize() throws Exception { RocketMQStringSerializer stringSerializer = new RocketMQStringSerializer(); String obj = new String("hello rocket!"); byte[] result = stringSerializer.serialize(obj); RocketMQStringDeserializer stringDeserializer = new RocketMQStringDeserializer(); assertEquals(obj, stringDeserializer.deserialize(result)); } |
RocketMQAvroSpecifiedSerializer implements RocketMQSerializer<T> { @Override public byte[] serialize(T obj) { Validate.notNull(obj); DatumWriter<T> datumWriter = new SpecificDatumWriter<T>(schema); ByteArrayOutputStream out = new ByteArrayOutputStream(); Encoder encoder = EncoderFactory.get().directBinaryEncoder(out, null); try { datumWriter.write(obj, encoder); encoder.flush(); byte[] bytes = out.toByteArray(); out.close(); return bytes; } catch (IOException e) { throw new RuntimeException(e); } } RocketMQAvroSpecifiedSerializer(Schema schema); @Override byte[] serialize(T obj); } | @Test public void testSerializeAndDeserialize() throws Exception { Schema schema = AvroUtils.newSchema(new File("src/test/avro/user.avsc")); RocketMQAvroSpecifiedSerializer<User> avroSpecifiedSerializer = new RocketMQAvroSpecifiedSerializer<>(schema); User user = new User(); user.setName("tom"); user.setAge(16); byte[] result = avroSpecifiedSerializer.serialize(user); RocketMQAvroSpecifiedDeserializer<User> avroSpecifiedDeserializer = new RocketMQAvroSpecifiedDeserializer<>(schema); assertEquals(user, avroSpecifiedDeserializer.deserialize(result)); } |
ConfigManagementServiceImpl implements ConfigManagementService { @Override public Map<String, ConnectKeyValue> getConnectorConfigs() { Map<String, ConnectKeyValue> result = new HashMap<>(); Map<String, ConnectKeyValue> connectorConfigs = connectorKeyValueStore.getKVMap(); for (String connectorName : connectorConfigs.keySet()) { ConnectKeyValue config = connectorConfigs.get(connectorName); if (0 != config.getInt(RuntimeConfigDefine.CONFIG_DELETED)) { continue; } result.put(connectorName, config); } return result; } ConfigManagementServiceImpl(ConnectConfig connectConfig, Plugin plugin); @Override void start(); @Override void stop(); @Override Map<String, ConnectKeyValue> getConnectorConfigs(); @Override Map<String, ConnectKeyValue> getConnectorConfigsIncludeDeleted(); @Override String putConnectorConfig(String connectorName, ConnectKeyValue configs); @Override void recomputeTaskConfigs(String connectorName, Connector connector, Long currentTimestamp); @Override void removeConnectorConfig(String connectorName); @Override Map<String, List<ConnectKeyValue>> getTaskConfigs(); @Override void persist(); @Override void registerListener(ConnectorConfigUpdateListener listener); Plugin getPlugin(); } | @Test public void testGetConnectorConfigs() throws Exception { Map<String, ConnectKeyValue> connectorConfigs = configManagementService.getConnectorConfigs(); ConnectKeyValue connectKeyValue = connectorConfigs.get(connectorName); assertNull(connectKeyValue); configManagementService.putConnectorConfig(connectorName, this.connectKeyValue); connectorConfigs = configManagementService.getConnectorConfigs(); connectKeyValue = connectorConfigs.get(connectorName); assertNotNull(connectKeyValue); } |
RocketMQAvroSerializer implements RocketMQSerializer<GenericRecord> { @Override public byte[] serialize(GenericRecord obj) { Validate.notNull(obj); DatumWriter<GenericRecord> writer = new GenericDatumWriter<>(obj.getSchema()); ByteArrayOutputStream out = new ByteArrayOutputStream(); Encoder encoder = EncoderFactory.get().directBinaryEncoder(out, null); try { writer.write(obj, encoder); encoder.flush(); byte[] bytes = out.toByteArray(); out.close(); return bytes; } catch (IOException e) { throw new RuntimeException(e); } } @Override byte[] serialize(GenericRecord obj); } | @Test public void testSerializeAndDeserialize() throws Exception { Schema schema = AvroUtils.newSchema(new File("src/test/avro/user.avsc")); RocketMQAvroSerializer avroSerializer = new RocketMQAvroSerializer(); HashMap<String,Object> map = new HashMap<>(); map.put("name", "tom"); map.put("age", 16); GenericRecord obj = AvroUtils.newGenericRecordFromMap(schema, map); byte[] result = avroSerializer.serialize(obj); RocketMQAvroDeserializer avroDeserializer = new RocketMQAvroDeserializer(schema); assertEquals(obj, avroDeserializer.deserialize(result)); } |
JdbcSourceConnector extends SourceConnector { @Override public String verifyAndSetConfig(KeyValue config) { log.info("JdbcSourceConnector verifyAndSetConfig enter"); for (String requestKey : Config.REQUEST_CONFIG) { if (!config.containsKey(requestKey)) { return "Request config key: " + requestKey; } } try { this.dbConnectorConfig.validate(config); } catch (IllegalArgumentException e) { return e.getMessage(); } this.configValid = true; return ""; } JdbcSourceConnector(); @Override String verifyAndSetConfig(KeyValue config); @Override void start(); @Override void stop(); @Override void pause(); @Override void resume(); @Override Class<? extends Task> taskClass(); @Override List<KeyValue> taskConfigs(); } | @Test public void verifyAndSetConfigTest() { KeyValue keyValue = new DefaultKeyValue(); for (String requestKey : Config.REQUEST_CONFIG) { assertEquals(connector.verifyAndSetConfig(keyValue), "Request config key: " + requestKey); keyValue.put(requestKey, requestKey); } assertEquals(connector.verifyAndSetConfig(keyValue), ""); } |
JdbcSourceConnector extends SourceConnector { @Override public Class<? extends Task> taskClass() { return JdbcSourceTask.class; } JdbcSourceConnector(); @Override String verifyAndSetConfig(KeyValue config); @Override void start(); @Override void stop(); @Override void pause(); @Override void resume(); @Override Class<? extends Task> taskClass(); @Override List<KeyValue> taskConfigs(); } | @Test public void taskClassTest() { assertEquals(connector.taskClass(), JdbcSourceTask.class); } |
JdbcSourceConnector extends SourceConnector { @Override public List<KeyValue> taskConfigs() { log.info("List.start"); if (!configValid) { return new ArrayList<KeyValue>(); } TaskDivideConfig tdc = new TaskDivideConfig( this.dbConnectorConfig.getDbUrl(), this.dbConnectorConfig.getDbPort(), this.dbConnectorConfig.getDbUserName(), this.dbConnectorConfig.getDbPassword(), this.dbConnectorConfig.getConverter(), DataType.COMMON_MESSAGE.ordinal(), this.dbConnectorConfig.getTaskParallelism(), this.dbConnectorConfig.getMode() ); return this.dbConnectorConfig.getTaskDivideStrategy().divide(this.dbConnectorConfig, tdc); } JdbcSourceConnector(); @Override String verifyAndSetConfig(KeyValue config); @Override void start(); @Override void stop(); @Override void pause(); @Override void resume(); @Override Class<? extends Task> taskClass(); @Override List<KeyValue> taskConfigs(); } | @Test public void taskConfigsTest() { assertEquals(connector.taskConfigs().get(0), null); KeyValue keyValue = new DefaultKeyValue(); for (String requestKey : Config.REQUEST_CONFIG) { keyValue.put(requestKey, requestKey); } connector.verifyAndSetConfig(keyValue); assertEquals(connector.taskConfigs().get(0), keyValue); } |
SimpleTopicSelector implements TopicSelector<Map> { @Override public String getTopic(Map tuple) { if (tuple.containsKey(topicFieldName)) { Object topic = tuple.get(topicFieldName); return topic != null ? topic.toString() : defaultTopicName; } else { LOG.warn("Field {} Not Found. Returning default topic {}", topicFieldName, defaultTopicName); return defaultTopicName; } } SimpleTopicSelector(String topicFieldName, String defaultTopicName, String tagFieldName, String defaultTagName); @Override String getTopic(Map tuple); @Override String getTag(Map tuple); } | @Test public void getTopic() throws Exception { SimpleTopicSelector selector = new SimpleTopicSelector("tpc", "dtpc", "tg", "dtg"); Map tuple = new HashMap(); tuple.put("id", "x001"); tuple.put("name", "vesense"); tuple.put("tpc", "tpc1"); tuple.put("tg", "tg1"); assertEquals("tpc1", selector.getTopic(tuple)); assertEquals("tg1", selector.getTag(tuple)); tuple = new HashMap(); tuple.put("id", "x001"); tuple.put("name", "vesense"); assertEquals("dtpc", selector.getTopic(tuple)); assertEquals("dtg", selector.getTag(tuple)); } |
DefaultTopicSelector implements TopicSelector<T> { @Override public String getTopic(T tuple) { return topicName; } DefaultTopicSelector(final String topicName, final String tagName); DefaultTopicSelector(final String topicName); @Override String getTopic(T tuple); @Override String getTag(T tuple); } | @Test public void getTopic() throws Exception { DefaultTopicSelector selector = new DefaultTopicSelector("rocket"); assertEquals("rocket", selector.getTopic(null)); assertEquals("", selector.getTag(null)); selector = new DefaultTopicSelector("rocket", "tg"); assertEquals("rocket", selector.getTopic(null)); assertEquals("tg", selector.getTag(null)); } |
RocketMQSource extends RichParallelSourceFunction<OUT> implements CheckpointedFunction, CheckpointListener, ResultTypeQueryable<OUT> { @Override public void run(SourceContext context) throws Exception { LOG.debug("source run...."); final Object lock = context.getCheckpointLock(); int delayWhenMessageNotFound = getInteger(props, RocketMQConfig.CONSUMER_DELAY_WHEN_MESSAGE_NOT_FOUND, RocketMQConfig.DEFAULT_CONSUMER_DELAY_WHEN_MESSAGE_NOT_FOUND); String tag = props.getProperty(RocketMQConfig.CONSUMER_TAG, RocketMQConfig.DEFAULT_CONSUMER_TAG); int pullPoolSize = getInteger(props, RocketMQConfig.CONSUMER_PULL_POOL_SIZE, RocketMQConfig.DEFAULT_CONSUMER_PULL_POOL_SIZE); int pullBatchSize = getInteger(props, RocketMQConfig.CONSUMER_BATCH_SIZE, RocketMQConfig.DEFAULT_CONSUMER_BATCH_SIZE); pullConsumerScheduleService.setPullThreadNums(pullPoolSize); pullConsumerScheduleService.registerPullTaskCallback(topic, new PullTaskCallback() { @Override public void doPullTask(MessageQueue mq, PullTaskContext pullTaskContext) { try { long offset = getMessageQueueOffset(mq); if (offset < 0) { return; } PullResult pullResult = consumer.pull(mq, tag, offset, pullBatchSize); boolean found = false; switch (pullResult.getPullStatus()) { case FOUND: List<MessageExt> messages = pullResult.getMsgFoundList(); for (MessageExt msg : messages) { byte[] key = msg.getKeys() != null ? msg.getKeys().getBytes(StandardCharsets.UTF_8) : null; byte[] value = msg.getBody(); OUT data = schema.deserializeKeyAndValue(key, value); synchronized (lock) { context.collectWithTimestamp(data, msg.getBornTimestamp()); } } found = true; break; case NO_MATCHED_MSG: LOG.debug("No matched message after offset {} for queue {}", offset, mq); break; case NO_NEW_MSG: break; case OFFSET_ILLEGAL: LOG.warn("Offset {} is illegal for queue {}", offset, mq); break; default: break; } synchronized (lock) { putMessageQueueOffset(mq, pullResult.getNextBeginOffset()); } if (found) { pullTaskContext.setPullNextDelayTimeMillis(0); } else { pullTaskContext.setPullNextDelayTimeMillis(delayWhenMessageNotFound); } } catch (Exception e) { throw new RuntimeException(e); } } }); try { pullConsumerScheduleService.start(); } catch (MQClientException e) { throw new RuntimeException(e); } runningChecker.setRunning(true); awaitTermination(); } RocketMQSource(KeyValueDeserializationSchema<OUT> schema, Properties props); @Override void open(Configuration parameters); @Override void run(SourceContext context); @Override void cancel(); @Override void close(); @Override void snapshotState(FunctionSnapshotContext context); @Override void initializeState(FunctionInitializationContext context); @Override TypeInformation<OUT> getProducedType(); @Override void notifyCheckpointComplete(long checkpointId); } | @Test public void testSource() throws Exception { List<MessageExt> msgFoundList = new ArrayList<>(); MessageExt messageExt = new MessageExt(); messageExt.setKeys("keys"); messageExt.setBody("body data".getBytes()); messageExt.setBornTimestamp(System.currentTimeMillis()); msgFoundList.add(messageExt); PullResult pullResult = new PullResult(PullStatus.FOUND, 3, 1, 5, msgFoundList); when(consumer.fetchConsumeOffset(any(MessageQueue.class), anyBoolean())).thenReturn(2L); when(consumer.pull(any(MessageQueue.class), anyString(), anyLong(), anyInt())).thenReturn(pullResult); SourceContext context = mock(SourceContext.class); when(context.getCheckpointLock()).thenReturn(new Object()); rocketMQSource.run(context); Set<MessageQueue> set = new HashSet(); set.add(new MessageQueue(topic, "brk", 1)); pullConsumerScheduleService.putTask(topic, set); MessageExt msg = pullResult.getMsgFoundList().get(0); verify(context, atLeastOnce()).collectWithTimestamp(deserializationSchema.deserializeKeyAndValue(msg.getKeys().getBytes(), msg.getBody()), msg.getBornTimestamp()); } |
RocketMQSource extends RichParallelSourceFunction<OUT> implements CheckpointedFunction, CheckpointListener, ResultTypeQueryable<OUT> { @Override public void close() throws Exception { LOG.debug("close ..."); try { cancel(); } finally { super.close(); } } RocketMQSource(KeyValueDeserializationSchema<OUT> schema, Properties props); @Override void open(Configuration parameters); @Override void run(SourceContext context); @Override void cancel(); @Override void close(); @Override void snapshotState(FunctionSnapshotContext context); @Override void initializeState(FunctionInitializationContext context); @Override TypeInformation<OUT> getProducedType(); @Override void notifyCheckpointComplete(long checkpointId); } | @Test public void close() throws Exception { rocketMQSource.close(); verify(consumer).shutdown(); } |
RocketMQSink extends RichSinkFunction<IN> implements CheckpointedFunction { @Override public void invoke(IN input, Context context) throws Exception { Message msg = prepareMessage(input); if (batchFlushOnCheckpoint) { batchList.add(msg); if (batchList.size() >= batchSize) { flushSync(); } return; } if (async) { try { producer.send(msg, new SendCallback() { @Override public void onSuccess(SendResult sendResult) { LOG.debug("Async send message success! result: {}", sendResult); } @Override public void onException(Throwable throwable) { if (throwable != null) { LOG.error("Async send message failure!", throwable); } } }); } catch (Exception e) { LOG.error("Async send message failure!", e); } } else { try { SendResult result = producer.send(msg); LOG.debug("Sync send message result: {}", result); if (result.getSendStatus() != SendStatus.SEND_OK) { throw new RemotingException(result.toString()); } } catch (Exception e) { LOG.error("Sync send message failure!", e); throw e; } } } RocketMQSink(KeyValueSerializationSchema<IN> schema, TopicSelector<IN> topicSelector, Properties props); @Override void open(Configuration parameters); @Override void invoke(IN input, Context context); RocketMQSink<IN> withAsync(boolean async); RocketMQSink<IN> withBatchFlushOnCheckpoint(boolean batchFlushOnCheckpoint); RocketMQSink<IN> withBatchSize(int batchSize); @Override void close(); @Override void snapshotState(FunctionSnapshotContext context); @Override void initializeState(FunctionInitializationContext context); } | @Test public void testSink() throws Exception { Map tuple = new HashMap(); tuple.put("id", "x001"); tuple.put("name", "vesense"); tuple.put("tpc", "tpc1"); rocketMQSink.invoke(tuple, null); verify(producer).send(any(Message.class)); } |
RocketMQSink extends RichSinkFunction<IN> implements CheckpointedFunction { @Override public void close() throws Exception { if (producer != null) { try { flushSync(); } catch (Exception e) { LOG.error("FlushSync failure!", e); } producer.shutdown(); } } RocketMQSink(KeyValueSerializationSchema<IN> schema, TopicSelector<IN> topicSelector, Properties props); @Override void open(Configuration parameters); @Override void invoke(IN input, Context context); RocketMQSink<IN> withAsync(boolean async); RocketMQSink<IN> withBatchFlushOnCheckpoint(boolean batchFlushOnCheckpoint); RocketMQSink<IN> withBatchSize(int batchSize); @Override void close(); @Override void snapshotState(FunctionSnapshotContext context); @Override void initializeState(FunctionInitializationContext context); } | @Test public void close() throws Exception { rocketMQSink.close(); verify(producer).shutdown(); } |
ConfigManagementServiceImpl implements ConfigManagementService { @Override public void removeConnectorConfig(String connectorName) { ConnectKeyValue config = connectorKeyValueStore.get(connectorName); config.put(RuntimeConfigDefine.UPDATE_TIMESATMP, System.currentTimeMillis()); config.put(RuntimeConfigDefine.CONFIG_DELETED, 1); List<ConnectKeyValue> taskConfigList = taskKeyValueStore.get(connectorName); taskConfigList.add(config); connectorKeyValueStore.put(connectorName, config); putTaskConfigs(connectorName, taskConfigList); log.info("[ISSUE #2027] After removal The configs are:\n" + getConnectorConfigs().toString()); sendSynchronizeConfig(); triggerListener(); } ConfigManagementServiceImpl(ConnectConfig connectConfig, Plugin plugin); @Override void start(); @Override void stop(); @Override Map<String, ConnectKeyValue> getConnectorConfigs(); @Override Map<String, ConnectKeyValue> getConnectorConfigsIncludeDeleted(); @Override String putConnectorConfig(String connectorName, ConnectKeyValue configs); @Override void recomputeTaskConfigs(String connectorName, Connector connector, Long currentTimestamp); @Override void removeConnectorConfig(String connectorName); @Override Map<String, List<ConnectKeyValue>> getTaskConfigs(); @Override void persist(); @Override void registerListener(ConnectorConfigUpdateListener listener); Plugin getPlugin(); } | @Test public void testRemoveConnectorConfig() throws Exception { configManagementService.putConnectorConfig(connectorName, this.connectKeyValue); Map<String, ConnectKeyValue> connectorConfigs = configManagementService.getConnectorConfigs(); ConnectKeyValue connectKeyValue = connectorConfigs.get(connectorName); Map<String, List<ConnectKeyValue>> taskConfigs = configManagementService.getTaskConfigs(); List<ConnectKeyValue> connectKeyValues = taskConfigs.get(connectorName); assertNotNull(connectKeyValue); assertNotNull(connectKeyValues); configManagementService.removeConnectorConfig(connectorName); connectorConfigs = configManagementService.getConnectorConfigs(); connectKeyValue = connectorConfigs.get(connectorName); taskConfigs = configManagementService.getTaskConfigs(); connectKeyValues = taskConfigs.get(connectorName); assertNull(connectKeyValue); assertNull(connectKeyValues); } |
DashboardServiceImpl implements DashboardService { @Override public Map<String, List<String>> queryBrokerData(String date) { return dashboardCollectService.getBrokerCache(date); } @Override Map<String, List<String>> queryBrokerData(String date); @Override Map<String, List<String>> queryTopicData(String date); @Override List<String> queryTopicData(String date, String topicName); @Override List<String> queryTopicCurrentData(); } | @Test public void queryBrokerData() throws Exception { } |
DashboardServiceImpl implements DashboardService { @Override public Map<String, List<String>> queryTopicData(String date) { return dashboardCollectService.getTopicCache(date); } @Override Map<String, List<String>> queryBrokerData(String date); @Override Map<String, List<String>> queryTopicData(String date); @Override List<String> queryTopicData(String date, String topicName); @Override List<String> queryTopicCurrentData(); } | @Test public void queryTopicData() throws Exception { } |
DashboardServiceImpl implements DashboardService { @Override public List<String> queryTopicCurrentData() { Date date = new Date(); DateFormat format = new SimpleDateFormat("yyyy-MM-dd"); Map<String, List<String>> topicCache = dashboardCollectService.getTopicCache(format.format(date)); List<String> result = Lists.newArrayList(); for (Map.Entry<String, List<String>> entry : topicCache.entrySet()) { List<String> value = entry.getValue(); result.add(entry.getKey() + "," + value.get(value.size() - 1).split(",")[4]); } return result; } @Override Map<String, List<String>> queryBrokerData(String date); @Override Map<String, List<String>> queryTopicData(String date); @Override List<String> queryTopicData(String date, String topicName); @Override List<String> queryTopicCurrentData(); } | @Test public void queryTopicCurrentData() throws Exception { } |
MonitorServiceImpl implements MonitorService { @Override public boolean createOrUpdateConsumerMonitor(String name, ConsumerMonitorConfig config) { configMap.put(name, config); writeToFile(getConsumerMonitorConfigDataPath(), configMap); return true; } @Override boolean createOrUpdateConsumerMonitor(String name, ConsumerMonitorConfig config); @Override Map<String, ConsumerMonitorConfig> queryConsumerMonitorConfig(); @Override ConsumerMonitorConfig queryConsumerMonitorConfigByGroupName(String consumeGroupName); @Override boolean deleteConsumerMonitor(String consumeGroupName); } | @Test public void createOrUpdateConsumerMonitor() throws Exception { } |
MonitorServiceImpl implements MonitorService { @Override public Map<String, ConsumerMonitorConfig> queryConsumerMonitorConfig() { return configMap; } @Override boolean createOrUpdateConsumerMonitor(String name, ConsumerMonitorConfig config); @Override Map<String, ConsumerMonitorConfig> queryConsumerMonitorConfig(); @Override ConsumerMonitorConfig queryConsumerMonitorConfigByGroupName(String consumeGroupName); @Override boolean deleteConsumerMonitor(String consumeGroupName); } | @Test public void queryConsumerMonitorConfig() throws Exception { } |
MonitorServiceImpl implements MonitorService { @Override public ConsumerMonitorConfig queryConsumerMonitorConfigByGroupName(String consumeGroupName) { return configMap.get(consumeGroupName); } @Override boolean createOrUpdateConsumerMonitor(String name, ConsumerMonitorConfig config); @Override Map<String, ConsumerMonitorConfig> queryConsumerMonitorConfig(); @Override ConsumerMonitorConfig queryConsumerMonitorConfigByGroupName(String consumeGroupName); @Override boolean deleteConsumerMonitor(String consumeGroupName); } | @Test public void queryConsumerMonitorConfigByGroupName() throws Exception { } |
MonitorServiceImpl implements MonitorService { @Override public boolean deleteConsumerMonitor(String consumeGroupName) { configMap.remove(consumeGroupName); writeToFile(getConsumerMonitorConfigDataPath(), configMap); return true; } @Override boolean createOrUpdateConsumerMonitor(String name, ConsumerMonitorConfig config); @Override Map<String, ConsumerMonitorConfig> queryConsumerMonitorConfig(); @Override ConsumerMonitorConfig queryConsumerMonitorConfigByGroupName(String consumeGroupName); @Override boolean deleteConsumerMonitor(String consumeGroupName); } | @Test public void deleteConsumerMonitor() throws Exception { } |
ClusterServiceImpl implements ClusterService { @Override public Map<String, Object> list() { try { Map<String, Object> resultMap = Maps.newHashMap(); ClusterInfo clusterInfo = mqAdminExt.examineBrokerClusterInfo(); logger.info("op=look_clusterInfo {}", JsonUtil.obj2String(clusterInfo)); Map<String, Map<Long, Object>> brokerServer = Maps.newHashMap(); for (BrokerData brokerData : clusterInfo.getBrokerAddrTable().values()) { Map<Long, Object> brokerMasterSlaveMap = Maps.newHashMap(); for (Map.Entry<Long, String> brokerAddr : brokerData.getBrokerAddrs().entrySet()) { KVTable kvTable = mqAdminExt.fetchBrokerRuntimeStats(brokerAddr.getValue()); brokerMasterSlaveMap.put(brokerAddr.getKey(), kvTable.getTable()); } brokerServer.put(brokerData.getBrokerName(), brokerMasterSlaveMap); } resultMap.put("clusterInfo", clusterInfo); resultMap.put("brokerServer", brokerServer); return resultMap; } catch (Exception err) { throw Throwables.propagate(err); } } @Override Map<String, Object> list(); @Override Properties getBrokerConfig(String brokerAddr); } | @Test @SuppressWarnings("unchecked") public void list() throws Exception { Map<String, Object> clusterMap = clusterService.list(); ClusterInfo clusterInfo = (ClusterInfo)clusterMap.get("clusterInfo"); Map<String, Map<Long, Object>> brokerServerMap = (Map<String, Map<Long, Object>>)clusterMap.get("brokerServer"); Assert.assertNotNull(clusterInfo); Assert.assertNotNull(brokerServerMap); Assert.assertNotNull(clusterInfo.getBrokerAddrTable().get(TestConstant.TEST_BROKER_NAME)); Assert.assertNotNull(brokerServerMap.get(TestConstant.TEST_BROKER_NAME)); } |
ClusterServiceImpl implements ClusterService { @Override public Properties getBrokerConfig(String brokerAddr) { try { return mqAdminExt.getBrokerConfig(brokerAddr); } catch (Exception e) { throw Throwables.propagate(e); } } @Override Map<String, Object> list(); @Override Properties getBrokerConfig(String brokerAddr); } | @Test public void getBrokerConfig() throws Exception { Properties properties = clusterService.getBrokerConfig(BROKER_ADDRESS); Assert.assertNotNull(properties); } |
ProducerServiceImpl implements ProducerService { @Override public ProducerConnection getProducerConnection(String producerGroup, String topic) { try { return mqAdminExt.examineProducerConnectionInfo(producerGroup, topic); } catch (Exception e) { throw Throwables.propagate(e); } } @Override ProducerConnection getProducerConnection(String producerGroup, String topic); } | @Test public void getProducerConnection() throws Exception { ProducerConnection producerConnection=new RetryTempLate<ProducerConnection>() { @Override protected ProducerConnection process() throws Exception { return producerService.getProducerConnection(TEST_PRODUCER_GROUP,TEST_CONSOLE_TOPIC); } }.execute(10,1000); Assert.assertNotNull(producerConnection); Assert.assertTrue(Lists.transform(Lists.newArrayList(producerConnection.getConnectionSet()), new Function<Connection, String>() { @Override public String apply(Connection input) { return input.getClientAddr().split(":")[0]; } }).contains(TestConstant.LOCAL_HOST)); } |
ConfigManagementServiceImpl implements ConfigManagementService { @Override public Map<String, List<ConnectKeyValue>> getTaskConfigs() { Map<String, List<ConnectKeyValue>> result = new HashMap<>(); Map<String, List<ConnectKeyValue>> taskConfigs = taskKeyValueStore.getKVMap(); Map<String, ConnectKeyValue> filteredConnector = getConnectorConfigs(); for (String connectorName : taskConfigs.keySet()) { if (!filteredConnector.containsKey(connectorName)) { continue; } result.put(connectorName, taskConfigs.get(connectorName)); } return result; } ConfigManagementServiceImpl(ConnectConfig connectConfig, Plugin plugin); @Override void start(); @Override void stop(); @Override Map<String, ConnectKeyValue> getConnectorConfigs(); @Override Map<String, ConnectKeyValue> getConnectorConfigsIncludeDeleted(); @Override String putConnectorConfig(String connectorName, ConnectKeyValue configs); @Override void recomputeTaskConfigs(String connectorName, Connector connector, Long currentTimestamp); @Override void removeConnectorConfig(String connectorName); @Override Map<String, List<ConnectKeyValue>> getTaskConfigs(); @Override void persist(); @Override void registerListener(ConnectorConfigUpdateListener listener); Plugin getPlugin(); } | @Test public void testGetTaskConfigs() throws Exception { Map<String, List<ConnectKeyValue>> taskConfigs = configManagementService.getTaskConfigs(); List<ConnectKeyValue> connectKeyValues = taskConfigs.get(connectorName); assertNull(connectKeyValues); configManagementService.putConnectorConfig(connectorName, this.connectKeyValue); taskConfigs = configManagementService.getTaskConfigs(); connectKeyValues = taskConfigs.get(connectorName); assertNotNull(connectKeyValues); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override @MultiMQAdminCmdMethod public List<GroupConsumeInfo> queryGroupList() { Set<String> consumerGroupSet = Sets.newHashSet(); try { ClusterInfo clusterInfo = mqAdminExt.examineBrokerClusterInfo(); for (BrokerData brokerData : clusterInfo.getBrokerAddrTable().values()) { SubscriptionGroupWrapper subscriptionGroupWrapper = mqAdminExt.getAllSubscriptionGroup(brokerData.selectBrokerAddr(), 3000L); consumerGroupSet.addAll(subscriptionGroupWrapper.getSubscriptionGroupTable().keySet()); } } catch (Exception err) { throw Throwables.propagate(err); } List<GroupConsumeInfo> groupConsumeInfoList = Lists.newArrayList(); for (String consumerGroup : consumerGroupSet) { groupConsumeInfoList.add(queryGroup(consumerGroup)); } Collections.sort(groupConsumeInfoList); return groupConsumeInfoList; } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void queryGroupList() throws Exception { List<GroupConsumeInfo> consumeInfoList = consumerService.queryGroupList(); Assert.assertTrue(CollectionUtils.isNotEmpty(consumeInfoList)); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override @MultiMQAdminCmdMethod public GroupConsumeInfo queryGroup(String consumerGroup) { GroupConsumeInfo groupConsumeInfo = new GroupConsumeInfo(); try { ConsumeStats consumeStats = null; try { consumeStats = mqAdminExt.examineConsumeStats(consumerGroup); } catch (Exception e) { logger.warn("examineConsumeStats exception, " + consumerGroup, e); } ConsumerConnection consumerConnection = null; try { consumerConnection = mqAdminExt.examineConsumerConnectionInfo(consumerGroup); } catch (Exception e) { logger.warn("examineConsumerConnectionInfo exception, " + consumerGroup, e); } groupConsumeInfo.setGroup(consumerGroup); if (consumeStats != null) { groupConsumeInfo.setConsumeTps((int)consumeStats.getConsumeTps()); groupConsumeInfo.setDiffTotal(consumeStats.computeTotalDiff()); } if (consumerConnection != null) { groupConsumeInfo.setCount(consumerConnection.getConnectionSet().size()); groupConsumeInfo.setMessageModel(consumerConnection.getMessageModel()); groupConsumeInfo.setConsumeType(consumerConnection.getConsumeType()); groupConsumeInfo.setVersion(MQVersion.getVersionDesc(consumerConnection.computeMinVersion())); } } catch (Exception e) { logger.warn("examineConsumeStats or examineConsumerConnectionInfo exception, " + consumerGroup, e); } return groupConsumeInfo; } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void queryGroup() throws Exception { GroupConsumeInfo consumeInfo = consumerService.queryGroup(TEST_CONSUMER_GROUP); Assert.assertNotNull(consumeInfo); Assert.assertEquals(consumeInfo.getGroup(), TEST_CONSUMER_GROUP); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override public List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName) { return queryConsumeStatsList(null, groupName); } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void queryConsumeStatsListByGroupName() throws Exception { List<TopicConsumerInfo> topicConsumerInfoList = new RetryTempLate<List<TopicConsumerInfo>>() { @Override protected List<TopicConsumerInfo> process() throws Exception { return consumerService.queryConsumeStatsListByGroupName(TEST_CONSUMER_GROUP); } }.execute(10, 2000); Assert.assertNotNull(topicConsumerInfoList); Assert.assertTrue(CollectionUtils.isNotEmpty(topicConsumerInfoList)); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override @MultiMQAdminCmdMethod public List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName) { ConsumeStats consumeStats = null; try { consumeStats = mqAdminExt.examineConsumeStats(groupName, topic); } catch (Exception e) { throw propagate(e); } List<MessageQueue> mqList = Lists.newArrayList(Iterables.filter(consumeStats.getOffsetTable().keySet(), new Predicate<MessageQueue>() { @Override public boolean apply(MessageQueue o) { return StringUtils.isBlank(topic) || o.getTopic().equals(topic); } })); Collections.sort(mqList); List<TopicConsumerInfo> topicConsumerInfoList = Lists.newArrayList(); TopicConsumerInfo nowTopicConsumerInfo = null; Map<MessageQueue, String> messageQueueClientMap = getClientConnection(groupName); for (MessageQueue mq : mqList) { if (nowTopicConsumerInfo == null || (!StringUtils.equals(mq.getTopic(), nowTopicConsumerInfo.getTopic()))) { nowTopicConsumerInfo = new TopicConsumerInfo(mq.getTopic()); topicConsumerInfoList.add(nowTopicConsumerInfo); } QueueStatInfo queueStatInfo = QueueStatInfo.fromOffsetTableEntry(mq, consumeStats.getOffsetTable().get(mq)); queueStatInfo.setClientInfo(messageQueueClientMap.get(mq)); nowTopicConsumerInfo.appendQueueStatInfo(queueStatInfo); } return topicConsumerInfoList; } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void queryConsumeStatsList() throws Exception { List<TopicConsumerInfo> topicConsumerInfoList = new RetryTempLate<List<TopicConsumerInfo>>() { @Override protected List<TopicConsumerInfo> process() throws Exception { return consumerService.queryConsumeStatsList(TEST_CONSOLE_TOPIC, TEST_CONSUMER_GROUP); } }.execute(10, 2000); Assert.assertNotNull(topicConsumerInfoList); Assert.assertTrue(CollectionUtils.isNotEmpty(topicConsumerInfoList)); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override @MultiMQAdminCmdMethod public Map<String , TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic) { Map<String, TopicConsumerInfo> group2ConsumerInfoMap = Maps.newHashMap(); try { GroupList groupList = mqAdminExt.queryTopicConsumeByWho(topic); for (String group : groupList.getGroupList()) { List<TopicConsumerInfo> topicConsumerInfoList = null; try { topicConsumerInfoList = queryConsumeStatsList(topic, group); } catch (Exception ignore) { } group2ConsumerInfoMap.put(group, CollectionUtils.isEmpty(topicConsumerInfoList) ? new TopicConsumerInfo(topic) : topicConsumerInfoList.get(0)); } return group2ConsumerInfoMap; } catch (Exception e) { throw propagate(e); } } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void queryConsumeStatsListByTopicName() throws Exception { Map<String, TopicConsumerInfo> consumeTopicMap = new RetryTempLate<Map<String, TopicConsumerInfo>>() { @Override protected Map<String, TopicConsumerInfo> process() throws Exception { return consumerService.queryConsumeStatsListByTopicName(TEST_CONSOLE_TOPIC); } }.execute(10, 2000); Assert.assertNotNull(consumeTopicMap); Assert.assertNotNull(consumeTopicMap.get(TEST_CONSUMER_GROUP)); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override @MultiMQAdminCmdMethod public Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest) { Map<String, ConsumerGroupRollBackStat> groupRollbackStats = Maps.newHashMap(); for (String consumerGroup : resetOffsetRequest.getConsumerGroupList()) { try { Map<MessageQueue, Long> rollbackStatsMap = mqAdminExt.resetOffsetByTimestamp(resetOffsetRequest.getTopic(), consumerGroup, resetOffsetRequest.getResetTime(), resetOffsetRequest.isForce()); ConsumerGroupRollBackStat consumerGroupRollBackStat = new ConsumerGroupRollBackStat(true); List<RollbackStats> rollbackStatsList = consumerGroupRollBackStat.getRollbackStatsList(); for (Map.Entry<MessageQueue, Long> rollbackStatsEntty : rollbackStatsMap.entrySet()) { RollbackStats rollbackStats = new RollbackStats(); rollbackStats.setRollbackOffset(rollbackStatsEntty.getValue()); rollbackStats.setQueueId(rollbackStatsEntty.getKey().getQueueId()); rollbackStats.setBrokerName(rollbackStatsEntty.getKey().getBrokerName()); rollbackStatsList.add(rollbackStats); } groupRollbackStats.put(consumerGroup, consumerGroupRollBackStat); } catch (MQClientException e) { if (ResponseCode.CONSUMER_NOT_ONLINE == e.getResponseCode()) { try { ConsumerGroupRollBackStat consumerGroupRollBackStat = new ConsumerGroupRollBackStat(true); List<RollbackStats> rollbackStatsList = mqAdminExt.resetOffsetByTimestampOld(consumerGroup, resetOffsetRequest.getTopic(), resetOffsetRequest.getResetTime(), true); consumerGroupRollBackStat.setRollbackStatsList(rollbackStatsList); groupRollbackStats.put(consumerGroup, consumerGroupRollBackStat); continue; } catch (Exception err) { logger.error("op=resetOffset_which_not_online_error", err); } } else { logger.error("op=resetOffset_error", e); } groupRollbackStats.put(consumerGroup, new ConsumerGroupRollBackStat(false, e.getMessage())); } catch (Exception e) { logger.error("op=resetOffset_error", e); groupRollbackStats.put(consumerGroup, new ConsumerGroupRollBackStat(false, e.getMessage())); } } return groupRollbackStats; } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void resetOffset() throws Exception { ResetOffsetRequest resetOffsetRequest = new ResetOffsetRequest(); resetOffsetRequest.setConsumerGroupList(Lists.<String>newArrayList(TEST_CONSUMER_GROUP)); resetOffsetRequest.setForce(true); resetOffsetRequest.setTopic(TEST_CONSOLE_TOPIC); resetOffsetRequest.setResetTime(System.currentTimeMillis() - 1000); Map<String , ConsumerGroupRollBackStat> consumerGroupRollBackStatMap = consumerService.resetOffset(resetOffsetRequest); Assert.assertNotNull(consumerGroupRollBackStatMap); Assert.assertNotNull(consumerGroupRollBackStatMap.get(TEST_CONSUMER_GROUP)); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override @MultiMQAdminCmdMethod public List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group) { List<ConsumerConfigInfo> consumerConfigInfoList = Lists.newArrayList(); try { ClusterInfo clusterInfo = mqAdminExt.examineBrokerClusterInfo(); for (String brokerName : clusterInfo.getBrokerAddrTable().keySet()) { String brokerAddress = clusterInfo.getBrokerAddrTable().get(brokerName).selectBrokerAddr(); SubscriptionGroupConfig subscriptionGroupConfig = mqAdminExt.examineSubscriptionGroupConfig(brokerAddress, group); if (subscriptionGroupConfig == null) { continue; } consumerConfigInfoList.add(new ConsumerConfigInfo(Lists.newArrayList(brokerName), subscriptionGroupConfig)); } } catch (Exception e) { throw propagate(e); } return consumerConfigInfoList; } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void examineSubscriptionGroupConfig() throws Exception { List<ConsumerConfigInfo> configInfoList = consumerService.examineSubscriptionGroupConfig(TEST_CONSUMER_GROUP); Assert.assertTrue(configInfoList.size() == 1); Assert.assertTrue(configInfoList.get(0).getSubscriptionGroupConfig().getGroupName().equals(TEST_CONSUMER_GROUP)); Assert.assertTrue(configInfoList.get(0).getSubscriptionGroupConfig().getRetryQueueNums() == RETRY_QUEUE_NUMS); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override @MultiMQAdminCmdMethod public boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest) { try { ClusterInfo clusterInfo = mqAdminExt.examineBrokerClusterInfo(); for (String brokerName : deleteSubGroupRequest.getBrokerNameList()) { logger.info("addr={} groupName={}", clusterInfo.getBrokerAddrTable().get(brokerName).selectBrokerAddr(), deleteSubGroupRequest.getGroupName()); mqAdminExt.deleteSubscriptionGroup(clusterInfo.getBrokerAddrTable().get(brokerName).selectBrokerAddr(), deleteSubGroupRequest.getGroupName()); } } catch (Exception e) { throw propagate(e); } return true; } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void deleteSubGroup() throws Exception { createAndUpdateSubscriptionGroupConfig(); DeleteSubGroupRequest deleteSubGroupRequest = new DeleteSubGroupRequest(); deleteSubGroupRequest.setBrokerNameList(Lists.<String>newArrayList(TestConstant.TEST_BROKER_NAME)); deleteSubGroupRequest.setGroupName(TEST_CREATE_DELETE_CONSUMER_GROUP); Assert.assertTrue(consumerService.deleteSubGroup(deleteSubGroupRequest)); List<ConsumerConfigInfo> groupConsumeInfoList = consumerService.examineSubscriptionGroupConfig(TEST_CREATE_DELETE_CONSUMER_GROUP); Assert.assertTrue(CollectionUtils.isEmpty(groupConsumeInfoList)); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override public boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo) { try { ClusterInfo clusterInfo = mqAdminExt.examineBrokerClusterInfo(); for (String brokerName : changeToBrokerNameSet(clusterInfo.getClusterAddrTable(), consumerConfigInfo.getClusterNameList(), consumerConfigInfo.getBrokerNameList())) { mqAdminExt.createAndUpdateSubscriptionGroupConfig(clusterInfo.getBrokerAddrTable().get(brokerName).selectBrokerAddr(), consumerConfigInfo.getSubscriptionGroupConfig()); } } catch (Exception err) { throw Throwables.propagate(err); } return true; } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void createAndUpdateSubscriptionGroupConfig() throws Exception { ConsumerConfigInfo consumerConfigInfoForCreate = new ConsumerConfigInfo(); BeanUtils.copyProperties(consumerConfigInfo, consumerConfigInfoForCreate); consumerConfigInfoForCreate.getSubscriptionGroupConfig().setGroupName(TEST_CREATE_DELETE_CONSUMER_GROUP); Assert.assertTrue(consumerService.createAndUpdateSubscriptionGroupConfig(consumerConfigInfoForCreate)); Assert.assertTrue(CollectionUtils.isNotEmpty(consumerService.examineSubscriptionGroupConfig(TEST_CREATE_DELETE_CONSUMER_GROUP))); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override @MultiMQAdminCmdMethod public Set<String> fetchBrokerNameSetBySubscriptionGroup(String group) { Set<String> brokerNameSet = Sets.newHashSet(); try { List<ConsumerConfigInfo> consumerConfigInfoList = examineSubscriptionGroupConfig(group); for (ConsumerConfigInfo consumerConfigInfo : consumerConfigInfoList) { brokerNameSet.addAll(consumerConfigInfo.getBrokerNameList()); } } catch (Exception e) { throw Throwables.propagate(e); } return brokerNameSet; } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void fetchBrokerNameSetBySubscriptionGroup() throws Exception { Set<String> xx = consumerService.fetchBrokerNameSetBySubscriptionGroup(TEST_CONSUMER_GROUP); Assert.assertTrue(xx.contains(TestConstant.TEST_BROKER_NAME)); } |
PositionManagementServiceImpl implements PositionManagementService { @Override public Map<ByteBuffer, ByteBuffer> getPositionTable() { return positionStore.getKVMap(); } PositionManagementServiceImpl(ConnectConfig connectConfig); @Override void start(); @Override void stop(); @Override void persist(); @Override Map<ByteBuffer, ByteBuffer> getPositionTable(); @Override void putPosition(Map<ByteBuffer, ByteBuffer> positions); @Override void removePosition(List<ByteBuffer> partitions); @Override void registerListener(PositionUpdateListener listener); } | @Test public void testGetPositionTable() { Map<ByteBuffer, ByteBuffer> positionTable = positionManagementService.getPositionTable(); ByteBuffer bytes = positionTable.get(sourcePartition); assertNull(bytes); positionManagementService.putPosition(positions); positionTable = positionManagementService.getPositionTable(); bytes = positionTable.get(sourcePartition); assertNotNull(bytes); } |
ConsumerServiceImpl extends AbstractCommonService implements ConsumerService { @Override public ConsumerConnection getConsumerConnection(String consumerGroup) { try { return mqAdminExt.examineConsumerConnectionInfo(consumerGroup); } catch (Exception e) { throw Throwables.propagate(e); } } @Override @MultiMQAdminCmdMethod List<GroupConsumeInfo> queryGroupList(); @Override @MultiMQAdminCmdMethod GroupConsumeInfo queryGroup(String consumerGroup); @Override List<TopicConsumerInfo> queryConsumeStatsListByGroupName(String groupName); @Override @MultiMQAdminCmdMethod List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName); @Override @MultiMQAdminCmdMethod Map<String /*groupName*/, TopicConsumerInfo> queryConsumeStatsListByTopicName(String topic); @Override @MultiMQAdminCmdMethod Map<String, ConsumerGroupRollBackStat> resetOffset(ResetOffsetRequest resetOffsetRequest); @Override @MultiMQAdminCmdMethod List<ConsumerConfigInfo> examineSubscriptionGroupConfig(String group); @Override @MultiMQAdminCmdMethod boolean deleteSubGroup(DeleteSubGroupRequest deleteSubGroupRequest); @Override boolean createAndUpdateSubscriptionGroupConfig(ConsumerConfigInfo consumerConfigInfo); @Override @MultiMQAdminCmdMethod Set<String> fetchBrokerNameSetBySubscriptionGroup(String group); @Override ConsumerConnection getConsumerConnection(String consumerGroup); @Override ConsumerRunningInfo getConsumerRunningInfo(String consumerGroup, String clientId, boolean jstack); } | @Test public void getConsumerConnection() throws Exception { ConsumerConnection consumerConnection = new RetryTempLate<ConsumerConnection>() { @Override protected ConsumerConnection process() throws Exception { return consumerService.getConsumerConnection(TEST_CONSUMER_GROUP); } }.execute(10, 2000); Assert.assertNotNull(consumerConnection); Assert.assertTrue(CollectionUtils.isNotEmpty(consumerConnection.getConnectionSet())); Assert.assertTrue(Lists.transform(Lists.newArrayList(consumerConnection.getConnectionSet()), new Function<Connection, String>() { @Override public String apply(Connection input) { return input.getClientAddr().split(":")[0]; } }).contains(TestConstant.BROKER_IP)); } |
DashboardCollectServiceImpl implements DashboardCollectService { @Override public LoadingCache<String, List<String>> getBrokerMap() { return brokerMap; } @Override LoadingCache<String, List<String>> getBrokerMap(); @Override LoadingCache<String, List<String>> getTopicMap(); @Override Map<String, List<String>> jsonDataFile2map(File file); @Override Map<String, List<String>> getBrokerCache(String date); @Override Map<String, List<String>> getTopicCache(String date); } | @Test public void getBrokerMap() throws Exception { Assert.assertNotNull(dashboardCollectService.getBrokerMap()); } |
DashboardCollectServiceImpl implements DashboardCollectService { @Override public LoadingCache<String, List<String>> getTopicMap() { return topicMap; } @Override LoadingCache<String, List<String>> getBrokerMap(); @Override LoadingCache<String, List<String>> getTopicMap(); @Override Map<String, List<String>> jsonDataFile2map(File file); @Override Map<String, List<String>> getBrokerCache(String date); @Override Map<String, List<String>> getTopicCache(String date); } | @Test public void getTopicMap() throws Exception { Assert.assertNotNull(dashboardCollectService.getTopicMap()); } |
DashboardCollectServiceImpl implements DashboardCollectService { @Override public Map<String, List<String>> jsonDataFile2map(File file) { List<String> strings; try { strings = Files.readLines(file, Charsets.UTF_8); } catch (IOException e) { throw Throwables.propagate(e); } StringBuffer sb = new StringBuffer(); for (String string : strings) { sb.append(string); } JSONObject json = (JSONObject) JSONObject.parse(sb.toString()); Set<Map.Entry<String, Object>> entries = json.entrySet(); Map<String, List<String>> map = Maps.newHashMap(); for (Map.Entry<String, Object> entry : entries) { JSONArray tpsArray = (JSONArray) entry.getValue(); if (tpsArray == null) { continue; } Object[] tpsStrArray = tpsArray.toArray(); List<String> tpsList = Lists.newArrayList(); for (Object tpsObj : tpsStrArray) { tpsList.add("" + tpsObj); } map.put(entry.getKey(), tpsList); } return map; } @Override LoadingCache<String, List<String>> getBrokerMap(); @Override LoadingCache<String, List<String>> getTopicMap(); @Override Map<String, List<String>> jsonDataFile2map(File file); @Override Map<String, List<String>> getBrokerCache(String date); @Override Map<String, List<String>> getTopicCache(String date); } | @Test public void jsonDataFile2map() throws Exception { } |
DashboardCollectServiceImpl implements DashboardCollectService { @Override public Map<String, List<String>> getBrokerCache(String date) { String dataLocationPath = rmqConfigure.getConsoleCollectData(); File file = new File(dataLocationPath + date + ".json"); if (!file.exists()) { throw Throwables.propagate(new ServiceException(1, "This date have't data!")); } return jsonDataFile2map(file); } @Override LoadingCache<String, List<String>> getBrokerMap(); @Override LoadingCache<String, List<String>> getTopicMap(); @Override Map<String, List<String>> jsonDataFile2map(File file); @Override Map<String, List<String>> getBrokerCache(String date); @Override Map<String, List<String>> getTopicCache(String date); } | @Test public void getBrokerCache() throws Exception { } |
DashboardCollectServiceImpl implements DashboardCollectService { @Override public Map<String, List<String>> getTopicCache(String date) { String dataLocationPath = rmqConfigure.getConsoleCollectData(); File file = new File(dataLocationPath + date + "_topic" + ".json"); if (!file.exists()) { log.info(String.format("No dashboard data for data: %s", date)); return Maps.newHashMap(); } return jsonDataFile2map(file); } @Override LoadingCache<String, List<String>> getBrokerMap(); @Override LoadingCache<String, List<String>> getTopicMap(); @Override Map<String, List<String>> jsonDataFile2map(File file); @Override Map<String, List<String>> getBrokerCache(String date); @Override Map<String, List<String>> getTopicCache(String date); } | @Test public void getTopicCache() throws Exception { } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public TopicList fetchAllTopicList(boolean skipSysProcess) { try { TopicList allTopics = mqAdminExt.fetchAllTopicList(); if (skipSysProcess) { return allTopics; } TopicList sysTopics = getSystemTopicList(); Set<String> topics = new HashSet<>(); for (String topic: allTopics.getTopicList()) { if (sysTopics.getTopicList().contains(topic)) { topics.add(String.format("%s%s", "%SYS%", topic)); } else { topics.add(topic); } } allTopics.getTopicList().clear(); allTopics.getTopicList().addAll(topics); return allTopics; } catch (Exception e) { throw Throwables.propagate(e); } } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test public void fetchAllTopicList() throws Exception { TopicList topicList = topicService.fetchAllTopicList(true); Assert.assertNotNull(topicList); Assert.assertTrue(CollectionUtils.isNotEmpty(topicList.getTopicList())); Assert.assertTrue(topicList.getTopicList().contains(TEST_CONSOLE_TOPIC)); } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public TopicStatsTable stats(String topic) { try { return mqAdminExt.examineTopicStats(topic); } catch (Exception e) { throw Throwables.propagate(e); } } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test public void stats() throws Exception { TopicStatsTable topicStatsTable = topicService.stats(TEST_CONSOLE_TOPIC); Assert.assertNotNull(topicStatsTable ); Assert.assertEquals(topicStatsTable.getOffsetTable().size(),READ_QUEUE_NUM); } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public TopicRouteData route(String topic) { try { return mqAdminExt.examineTopicRouteInfo(topic); } catch (Exception ex) { throw Throwables.propagate(ex); } } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test public void route() throws Exception { TopicRouteData topicRouteData = topicService.route(TEST_CONSOLE_TOPIC); Assert.assertNotNull(topicRouteData); Assert.assertEquals(topicRouteData.getBrokerDatas().get(0).getBrokerAddrs().get(MixAll.MASTER_ID),TestConstant.BROKER_ADDRESS); Assert.assertTrue(CollectionUtils.isNotEmpty(topicRouteData.getQueueDatas())); } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public GroupList queryTopicConsumerInfo(String topic) { try { return mqAdminExt.queryTopicConsumeByWho(topic); } catch (Exception e) { throw Throwables.propagate(e); } } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test public void queryTopicConsumerInfo() throws Exception { } |
PositionManagementServiceImpl implements PositionManagementService { @Override public void putPosition(Map<ByteBuffer, ByteBuffer> positions) { positionStore.putAll(positions); sendSynchronizePosition(); } PositionManagementServiceImpl(ConnectConfig connectConfig); @Override void start(); @Override void stop(); @Override void persist(); @Override Map<ByteBuffer, ByteBuffer> getPositionTable(); @Override void putPosition(Map<ByteBuffer, ByteBuffer> positions); @Override void removePosition(List<ByteBuffer> partitions); @Override void registerListener(PositionUpdateListener listener); } | @Test public void testPutPosition() throws Exception { ByteBuffer bytes = positionStore.get(sourcePartition); assertNull(bytes); positionManagementService.putPosition(positions); bytes = positionStore.get(sourcePartition); assertNotNull(bytes); } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest) { TopicConfig topicConfig = new TopicConfig(); BeanUtils.copyProperties(topicCreateOrUpdateRequest, topicConfig); try { ClusterInfo clusterInfo = mqAdminExt.examineBrokerClusterInfo(); for (String brokerName : changeToBrokerNameSet(clusterInfo.getClusterAddrTable(), topicCreateOrUpdateRequest.getClusterNameList(), topicCreateOrUpdateRequest.getBrokerNameList())) { mqAdminExt.createAndUpdateTopicConfig(clusterInfo.getBrokerAddrTable().get(brokerName).selectBrokerAddr(), topicConfig); } } catch (Exception err) { throw Throwables.propagate(err); } } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test public void createOrUpdate() throws Exception { TopicConfigInfo topicConfigInfo = new TopicConfigInfo(); topicConfigInfo.setBrokerNameList(Lists.newArrayList(TestConstant.TEST_BROKER_NAME)); topicConfigInfo.setTopicName(TEST_CREATE_DELETE_TOPIC); topicService.createOrUpdate(topicConfigInfo); TopicList topicList = topicService.fetchAllTopicList(true); Assert.assertNotNull(topicList); Assert.assertTrue(CollectionUtils.isNotEmpty(topicList.getTopicList())); Assert.assertTrue(topicList.getTopicList().contains(TEST_CREATE_DELETE_TOPIC)); } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public TopicConfig examineTopicConfig(String topic, String brokerName) { ClusterInfo clusterInfo = null; try { clusterInfo = mqAdminExt.examineBrokerClusterInfo(); } catch (Exception e) { throw Throwables.propagate(e); } return mqAdminExt.examineTopicConfig(clusterInfo.getBrokerAddrTable().get(brokerName).selectBrokerAddr(), topic); } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test public void examineTopicConfig() throws Exception { List<TopicConfigInfo> topicConfigInfoList = topicService.examineTopicConfig(TEST_CONSOLE_TOPIC); Assert.assertTrue(CollectionUtils.isNotEmpty(topicConfigInfoList)); }
@Test public void examineTopicConfigList() throws Exception { TopicConfig topicConfig = topicService.examineTopicConfig(TEST_CONSOLE_TOPIC,TestConstant.TEST_BROKER_NAME); Assert.assertNotNull(topicConfig); Assert.assertEquals(topicConfig.getReadQueueNums(),READ_QUEUE_NUM); Assert.assertEquals(topicConfig.getWriteQueueNums(),WRITE_QUEUE_NUM); } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public boolean deleteTopic(String topic, String clusterName) { try { if (StringUtils.isBlank(clusterName)) { return deleteTopic(topic); } Set<String> masterSet = CommandUtil.fetchMasterAddrByClusterName(mqAdminExt, clusterName); mqAdminExt.deleteTopicInBroker(masterSet, topic); Set<String> nameServerSet = null; if (StringUtils.isNotBlank(rMQConfigure.getNamesrvAddr())) { String[] ns = rMQConfigure.getNamesrvAddr().split(";"); nameServerSet = new HashSet<String>(Arrays.asList(ns)); } mqAdminExt.deleteTopicInNameServer(nameServerSet, topic); } catch (Exception err) { throw Throwables.propagate(err); } return true; } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test(expected = RuntimeException.class) public void deleteTopic() throws Exception { Assert.assertTrue(topicService.deleteTopic(TEST_CONSOLE_TOPIC)); topicService.examineTopicConfig(TEST_CONSOLE_TOPIC); } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public boolean deleteTopicInBroker(String brokerName, String topic) { try { ClusterInfo clusterInfo = null; try { clusterInfo = mqAdminExt.examineBrokerClusterInfo(); } catch (Exception e) { throw Throwables.propagate(e); } mqAdminExt.deleteTopicInBroker(Sets.newHashSet(clusterInfo.getBrokerAddrTable().get(brokerName).selectBrokerAddr()), topic); } catch (Exception e) { throw Throwables.propagate(e); } return true; } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test public void deleteTopicInBroker() throws Exception { Assert.assertTrue(topicService.deleteTopic(TestConstant.TEST_BROKER_NAME,TEST_CONSOLE_TOPIC)); } |
TopicServiceImpl extends AbstractCommonService implements TopicService { @Override public SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest) { DefaultMQProducer producer = new DefaultMQProducer(MixAll.SELF_TEST_PRODUCER_GROUP); producer.setInstanceName(String.valueOf(System.currentTimeMillis())); producer.setNamesrvAddr(rMQConfigure.getNamesrvAddr()); try { producer.start(); Message msg = new Message(sendTopicMessageRequest.getTopic(), sendTopicMessageRequest.getTag(), sendTopicMessageRequest.getKey(), sendTopicMessageRequest.getMessageBody().getBytes() ); return producer.send(msg); } catch (Exception e) { throw Throwables.propagate(e); } finally { producer.shutdown(); } } @Override TopicList fetchAllTopicList(boolean skipSysProcess); @Override TopicStatsTable stats(String topic); @Override TopicRouteData route(String topic); @Override GroupList queryTopicConsumerInfo(String topic); @Override void createOrUpdate(TopicConfigInfo topicCreateOrUpdateRequest); @Override TopicConfig examineTopicConfig(String topic, String brokerName); @Override List<TopicConfigInfo> examineTopicConfig(String topic); @Override boolean deleteTopic(String topic, String clusterName); @Override boolean deleteTopic(String topic); @Override boolean deleteTopicInBroker(String brokerName, String topic); @Override SendResult sendTopicMessageRequest(SendTopicMessageRequest sendTopicMessageRequest); } | @Test public void sendTopicMessageRequest() throws Exception { SendTopicMessageRequest sendTopicMessageRequest = new SendTopicMessageRequest(); sendTopicMessageRequest.setTopic(TEST_CONSOLE_TOPIC); sendTopicMessageRequest.setMessageBody("sendTopicMessageRequestMessageBody"); sendTopicMessageRequest.setKey("sendTopicMessageRequestKey"); sendTopicMessageRequest.setTag("sendTopicMessageRequestTag"); SendResult sendResult= topicService.sendTopicMessageRequest(sendTopicMessageRequest); Assert.assertNotNull(sendResult); Assert.assertTrue(StringUtils.isNoneBlank(sendResult.getMsgId())); } |
MessageServiceImpl implements MessageService { public Pair<MessageView, List<MessageTrack>> viewMessage(String subject, final String msgId) { try { MessageExt messageExt = mqAdminExt.viewMessage(subject, msgId); List<MessageTrack> messageTrackList = messageTrackDetail(messageExt); return new Pair<>(MessageView.fromMessageExt(messageExt), messageTrackList); } catch (Exception e) { throw new ServiceException(-1, String.format("Failed to query message by Id: %s", msgId)); } } Pair<MessageView, List<MessageTrack>> viewMessage(String subject, final String msgId); @Override List<MessageView> queryMessageByTopicAndKey(String topic, String key); @Override List<MessageView> queryMessageByTopic(String topic, final long begin, final long end); @Override List<MessageTrack> messageTrackDetail(MessageExt msg); @Override ConsumeMessageDirectlyResult consumeMessageDirectly(String topic, String msgId, String consumerGroup,
String clientId); } | @Test public void viewMessage() throws Exception { final String messageId = msgId; Pair<MessageView, List<MessageTrack>> messageViewListPair=new RetryTempLate<Pair<MessageView, List<MessageTrack>>>() { @Override protected Pair<MessageView, List<MessageTrack>> process() throws Exception { return messageService.viewMessage(TEST_CONSOLE_TOPIC,messageId); } }.execute(10,1000); MessageView messageView = messageViewListPair.getObject1(); Assert.assertEquals(messageView.getMessageBody(),TEST_TOPIC_MESSAGE_BODY); } |
MessageServiceImpl implements MessageService { @Override public List<MessageView> queryMessageByTopicAndKey(String topic, String key) { try { return Lists.transform(mqAdminExt.queryMessage(topic, key, QUERY_MESSAGE_MAX_NUM, 0, System.currentTimeMillis()).getMessageList(), new Function<MessageExt, MessageView>() { @Override public MessageView apply(MessageExt messageExt) { return MessageView.fromMessageExt(messageExt); } }); } catch (Exception err) { throw Throwables.propagate(err); } } Pair<MessageView, List<MessageTrack>> viewMessage(String subject, final String msgId); @Override List<MessageView> queryMessageByTopicAndKey(String topic, String key); @Override List<MessageView> queryMessageByTopic(String topic, final long begin, final long end); @Override List<MessageTrack> messageTrackDetail(MessageExt msg); @Override ConsumeMessageDirectlyResult consumeMessageDirectly(String topic, String msgId, String consumerGroup,
String clientId); } | @Test public void queryMessageByTopicAndKey() throws Exception { final String messageId = msgId; List<MessageView> messageViewList=new RetryTempLate<List<MessageView>>() { @Override protected List<MessageView> process() throws Exception { return messageService.queryMessageByTopicAndKey(TEST_CONSOLE_TOPIC,TEST_TOPIC_MESSAGE_KEY); } }.execute(10,1000); Assert.assertTrue(CollectionUtils.isNotEmpty(messageViewList)); Assert.assertTrue(Lists.transform(messageViewList, new Function<MessageView, String>() { @Override public String apply(MessageView input) { return input.getMsgId(); } }).contains(messageId)); } |
MessageServiceImpl implements MessageService { @Override public List<MessageView> queryMessageByTopic(String topic, final long begin, final long end) { DefaultMQPullConsumer consumer = new DefaultMQPullConsumer(MixAll.TOOLS_CONSUMER_GROUP); List<MessageView> messageViewList = Lists.newArrayList(); try { String subExpression = "*"; consumer.start(); Set<MessageQueue> mqs = consumer.fetchSubscribeMessageQueues(topic); for (MessageQueue mq : mqs) { long minOffset = consumer.searchOffset(mq, begin); long maxOffset = consumer.searchOffset(mq, end); READQ: for (long offset = minOffset; offset <= maxOffset; ) { try { if (messageViewList.size() > 2000) { break; } PullResult pullResult = consumer.pull(mq, subExpression, offset, 32); offset = pullResult.getNextBeginOffset(); switch (pullResult.getPullStatus()) { case FOUND: List<MessageView> messageViewListByQuery = Lists.transform(pullResult.getMsgFoundList(), new Function<MessageExt, MessageView>() { @Override public MessageView apply(MessageExt messageExt) { messageExt.setBody(null); return MessageView.fromMessageExt(messageExt); } }); List<MessageView> filteredList = Lists.newArrayList(Iterables.filter(messageViewListByQuery, new Predicate<MessageView>() { @Override public boolean apply(MessageView messageView) { if (messageView.getStoreTimestamp() < begin || messageView.getStoreTimestamp() > end) { logger.info("begin={} end={} time not in range {} {}", begin, end, messageView.getStoreTimestamp(), new Date(messageView.getStoreTimestamp()).toString()); } return messageView.getStoreTimestamp() >= begin && messageView.getStoreTimestamp() <= end; } })); messageViewList.addAll(filteredList); break; case NO_MATCHED_MSG: case NO_NEW_MSG: case OFFSET_ILLEGAL: break READQ; } } catch (Exception e) { break; } } } Collections.sort(messageViewList, new Comparator<MessageView>() { @Override public int compare(MessageView o1, MessageView o2) { if (o1.getStoreTimestamp() - o2.getStoreTimestamp() == 0) { return 0; } return (o1.getStoreTimestamp() > o2.getStoreTimestamp()) ? -1 : 1; } }); return messageViewList; } catch (Exception e) { throw Throwables.propagate(e); } finally { consumer.shutdown(); } } Pair<MessageView, List<MessageTrack>> viewMessage(String subject, final String msgId); @Override List<MessageView> queryMessageByTopicAndKey(String topic, String key); @Override List<MessageView> queryMessageByTopic(String topic, final long begin, final long end); @Override List<MessageTrack> messageTrackDetail(MessageExt msg); @Override ConsumeMessageDirectlyResult consumeMessageDirectly(String topic, String msgId, String consumerGroup,
String clientId); } | @Test public void queryMessageByTopic() throws Exception { final String messageId = msgId; List<MessageView> messageViewList = null; for (int i = 0; i < 10; i++) { messageViewList = messageService.queryMessageByTopic(TEST_CONSOLE_TOPIC, System.currentTimeMillis() - 100000, System.currentTimeMillis()); if (CollectionUtils.isEmpty(messageViewList)) { Thread.sleep(1000); continue; } break; } Assert.assertTrue(CollectionUtils.isNotEmpty(messageViewList)); Assert.assertTrue(Lists.transform(messageViewList, new Function<MessageView, String>() { @Override public String apply(MessageView input) { return input.getMsgId(); } }).contains(messageId)); } |
MessageServiceImpl implements MessageService { @Override public List<MessageTrack> messageTrackDetail(MessageExt msg) { try { return mqAdminExt.messageTrackDetail(msg); } catch (Exception e) { logger.error("op=messageTrackDetailError", e); return Collections.emptyList(); } } Pair<MessageView, List<MessageTrack>> viewMessage(String subject, final String msgId); @Override List<MessageView> queryMessageByTopicAndKey(String topic, String key); @Override List<MessageView> queryMessageByTopic(String topic, final long begin, final long end); @Override List<MessageTrack> messageTrackDetail(MessageExt msg); @Override ConsumeMessageDirectlyResult consumeMessageDirectly(String topic, String msgId, String consumerGroup,
String clientId); } | @Test public void messageTrackDetail() throws Exception { final String messageId = msgId; Pair<MessageView, List<MessageTrack>> messageViewListPair=new RetryTempLate<Pair<MessageView, List<MessageTrack>>>() { @Override protected Pair<MessageView, List<MessageTrack>> process() throws Exception { return messageService.viewMessage(TEST_CONSOLE_TOPIC,messageId); } }.execute(10,1000); final MessageExt messageExt = mqAdminExt.viewMessage(TEST_CONSOLE_TOPIC,messageId); Assert.assertNotNull(messageService.messageTrackDetail(messageExt)); } |
PositionManagementServiceImpl implements PositionManagementService { @Override public void removePosition(List<ByteBuffer> partitions) { if (null == partitions) { return; } for (ByteBuffer partition : partitions) { positionStore.remove(partition); } } PositionManagementServiceImpl(ConnectConfig connectConfig); @Override void start(); @Override void stop(); @Override void persist(); @Override Map<ByteBuffer, ByteBuffer> getPositionTable(); @Override void putPosition(Map<ByteBuffer, ByteBuffer> positions); @Override void removePosition(List<ByteBuffer> partitions); @Override void registerListener(PositionUpdateListener listener); } | @Test public void testRemovePosition() { positionManagementService.putPosition(positions); ByteBuffer bytes = positionStore.get(sourcePartition); assertNotNull(bytes); List<ByteBuffer> sourcePartitions = new ArrayList<ByteBuffer>(8) { { add(sourcePartition); } }; positionManagementService.removePosition(sourcePartitions); bytes = positionStore.get(sourcePartition); assertNull(bytes); } |
MessageServiceImpl implements MessageService { @Override public ConsumeMessageDirectlyResult consumeMessageDirectly(String topic, String msgId, String consumerGroup, String clientId) { if (StringUtils.isNotBlank(clientId)) { try { return mqAdminExt.consumeMessageDirectly(consumerGroup, clientId, topic, msgId); } catch (Exception e) { throw Throwables.propagate(e); } } try { ConsumerConnection consumerConnection = mqAdminExt.examineConsumerConnectionInfo(consumerGroup); for (Connection connection : consumerConnection.getConnectionSet()) { if (StringUtils.isBlank(connection.getClientId())) { continue; } logger.info("clientId={}", connection.getClientId()); return mqAdminExt.consumeMessageDirectly(consumerGroup, connection.getClientId(), topic, msgId); } } catch (Exception e) { throw Throwables.propagate(e); } throw new IllegalStateException("NO CONSUMER"); } Pair<MessageView, List<MessageTrack>> viewMessage(String subject, final String msgId); @Override List<MessageView> queryMessageByTopicAndKey(String topic, String key); @Override List<MessageView> queryMessageByTopic(String topic, final long begin, final long end); @Override List<MessageTrack> messageTrackDetail(MessageExt msg); @Override ConsumeMessageDirectlyResult consumeMessageDirectly(String topic, String msgId, String consumerGroup,
String clientId); } | @Test public void consumeMessageDirectly() throws Exception { } |
OpsServiceImpl extends AbstractCommonService implements OpsService { @Override public Map<String, Object> homePageInfo() { Map<String, Object> homePageInfoMap = Maps.newHashMap(); homePageInfoMap.put("namesvrAddrList", Splitter.on(";").splitToList(rMQConfigure.getNamesrvAddr())); homePageInfoMap.put("useVIPChannel", Boolean.valueOf(rMQConfigure.getIsVIPChannel())); return homePageInfoMap; } @Override Map<String, Object> homePageInfo(); @Override void updateNameSvrAddrList(String nameSvrAddrList); @Override String getNameSvrList(); @Override Map<CheckerType, Object> rocketMqStatusCheck(); @Override boolean updateIsVIPChannel(String useVIPChannel); } | @SuppressWarnings("unchecked") @Test public void homePageInfo() throws Exception { List<String> namesvrAddrList= (List<String>)opsService.homePageInfo().get("namesvrAddrList"); Assert.assertTrue(namesvrAddrList.contains(TestConstant.NAME_SERVER_ADDRESS)); } |
OpsServiceImpl extends AbstractCommonService implements OpsService { @Override public void updateNameSvrAddrList(String nameSvrAddrList) { rMQConfigure.setNamesrvAddr(nameSvrAddrList); } @Override Map<String, Object> homePageInfo(); @Override void updateNameSvrAddrList(String nameSvrAddrList); @Override String getNameSvrList(); @Override Map<CheckerType, Object> rocketMqStatusCheck(); @Override boolean updateIsVIPChannel(String useVIPChannel); } | @Test public void updateNameSvrAddrList() throws Exception { String testChangeNameSvrAddr = "110.110.100.110:1234"; opsService.updateNameSvrAddrList(testChangeNameSvrAddr); Assert.assertEquals(opsService.getNameSvrList(),testChangeNameSvrAddr); opsService.updateNameSvrAddrList(TestConstant.NAME_SERVER_ADDRESS); } |
OpsServiceImpl extends AbstractCommonService implements OpsService { @Override public String getNameSvrList() { return rMQConfigure.getNamesrvAddr(); } @Override Map<String, Object> homePageInfo(); @Override void updateNameSvrAddrList(String nameSvrAddrList); @Override String getNameSvrList(); @Override Map<CheckerType, Object> rocketMqStatusCheck(); @Override boolean updateIsVIPChannel(String useVIPChannel); } | @Test public void getNameSvrList() throws Exception { Assert.assertEquals(opsService.getNameSvrList(),TestConstant.NAME_SERVER_ADDRESS); } |
OpsServiceImpl extends AbstractCommonService implements OpsService { @Override public Map<CheckerType, Object> rocketMqStatusCheck() { Map<CheckerType, Object> checkResultMap = Maps.newHashMap(); for (RocketMqChecker rocketMqChecker : rocketMqCheckerList) { checkResultMap.put(rocketMqChecker.checkerType(), rocketMqChecker.doCheck()); } return checkResultMap; } @Override Map<String, Object> homePageInfo(); @Override void updateNameSvrAddrList(String nameSvrAddrList); @Override String getNameSvrList(); @Override Map<CheckerType, Object> rocketMqStatusCheck(); @Override boolean updateIsVIPChannel(String useVIPChannel); } | @Test public void rocketMqStatusCheck() throws Exception { opsService.rocketMqStatusCheck(); } |
OpsController { @RequestMapping(value = "/homePage.query", method = RequestMethod.GET) @ResponseBody public Object homePage() { return opsService.homePageInfo(); } @RequestMapping(value = "/homePage.query", method = RequestMethod.GET) @ResponseBody Object homePage(); @RequestMapping(value = "/updateNameSvrAddr.do", method = RequestMethod.POST) @ResponseBody Object updateNameSvrAddr(@RequestParam String nameSvrAddrList); @RequestMapping(value = "/updateIsVIPChannel.do", method = RequestMethod.POST) @ResponseBody Object updateIsVIPChannel(@RequestParam String useVIPChannel); @RequestMapping(value = "/rocketMqStatus.query", method = RequestMethod.GET) @ResponseBody Object clusterStatus(); } | @Test public void homePage() throws Exception { } |
OpsController { @RequestMapping(value = "/updateNameSvrAddr.do", method = RequestMethod.POST) @ResponseBody public Object updateNameSvrAddr(@RequestParam String nameSvrAddrList) { opsService.updateNameSvrAddrList(nameSvrAddrList); return true; } @RequestMapping(value = "/homePage.query", method = RequestMethod.GET) @ResponseBody Object homePage(); @RequestMapping(value = "/updateNameSvrAddr.do", method = RequestMethod.POST) @ResponseBody Object updateNameSvrAddr(@RequestParam String nameSvrAddrList); @RequestMapping(value = "/updateIsVIPChannel.do", method = RequestMethod.POST) @ResponseBody Object updateIsVIPChannel(@RequestParam String useVIPChannel); @RequestMapping(value = "/rocketMqStatus.query", method = RequestMethod.GET) @ResponseBody Object clusterStatus(); } | @Test public void updateNameSvrAddr() throws Exception { } |
OpsController { @RequestMapping(value = "/rocketMqStatus.query", method = RequestMethod.GET) @ResponseBody public Object clusterStatus() { return opsService.rocketMqStatusCheck(); } @RequestMapping(value = "/homePage.query", method = RequestMethod.GET) @ResponseBody Object homePage(); @RequestMapping(value = "/updateNameSvrAddr.do", method = RequestMethod.POST) @ResponseBody Object updateNameSvrAddr(@RequestParam String nameSvrAddrList); @RequestMapping(value = "/updateIsVIPChannel.do", method = RequestMethod.POST) @ResponseBody Object updateIsVIPChannel(@RequestParam String useVIPChannel); @RequestMapping(value = "/rocketMqStatus.query", method = RequestMethod.GET) @ResponseBody Object clusterStatus(); } | @Test public void clusterStatus() throws Exception { } |
KafkaSourceTask extends SourceTask { @Override public Collection<SourceDataEntry> poll() { try { ArrayList<SourceDataEntry> entries = new ArrayList<>(); ConsumerRecords<ByteBuffer, ByteBuffer> records = consumer.poll(1000); if (records.count() > 0) { log.info("consumer.poll, records.count {}", records.count()); } for (ConsumerRecord<ByteBuffer, ByteBuffer> record : records) { String topic_partition = record.topic() + "-" + record.partition(); log.info("Received {} record: {} ", topic_partition, record); Schema schema = new Schema(); List<Field> fields = new ArrayList<>(); fields.add(new Field(0, "key", FieldType.BYTES)); fields.add(new Field(1, "value", FieldType.BYTES)); schema.setName(record.topic()); schema.setFields(fields); schema.setDataSource(record.topic()); ByteBuffer sourcePartition = ByteBuffer.wrap(topic_partition.getBytes()); ByteBuffer sourcePosition = ByteBuffer.allocate(8); sourcePosition.asLongBuffer().put(record.offset()); DataEntryBuilder dataEntryBuilder = new DataEntryBuilder(schema); dataEntryBuilder.entryType(EntryType.CREATE); dataEntryBuilder.queue(record.topic()); dataEntryBuilder.timestamp(System.currentTimeMillis()); if (record.key() != null) { dataEntryBuilder.putFiled("key", JSON.toJSONString(record.key().array())); } else { dataEntryBuilder.putFiled("key", null); } dataEntryBuilder.putFiled("value", JSON.toJSONString(record.value().array())); SourceDataEntry entry = dataEntryBuilder.buildSourceDataEntry(sourcePartition, sourcePosition); entries.add(entry); } log.info("poll return entries size {} ", entries.size()); return entries; } catch (Exception e) { e.printStackTrace(); log.error("poll exception {}", e); } return null; } @Override Collection<SourceDataEntry> poll(); @Override void start(KeyValue taskConfig); @Override void stop(); @Override void pause(); @Override void resume(); String toString(); static TopicPartition getTopicPartition(ByteBuffer buffer); } | @Test public void pollTest() throws Exception { KafkaSourceTask task = new KafkaSourceTask(); Field config = KafkaSourceTask.class.getDeclaredField("config"); config.setAccessible(true); Collection<SourceDataEntry> list = task.poll(); Assert.assertEquals(list.size(), 1); list = task.poll(); Assert.assertEquals(list.size(), 0); } |
KafkaSourceConnector extends SourceConnector { @Override public String verifyAndSetConfig(KeyValue config) { log.info("KafkaSourceConnector verifyAndSetConfig enter"); for (String key : config.keySet()) { log.info("connector verifyAndSetConfig: key:{}, value:{}", key, config.getString(key)); } for (String requestKey : ConfigDefine.REQUEST_CONFIG) { if (!config.containsKey(requestKey)) { return "Request Config key: " + requestKey; } } this.connectConfig = config; return ""; } KafkaSourceConnector(); @Override String verifyAndSetConfig(KeyValue config); @Override void start(); @Override void stop(); @Override void pause(); @Override void resume(); @Override Class<? extends Task> taskClass(); @Override List<KeyValue> taskConfigs(); } | @Test public void verifyAndSetConfigTest() { KeyValue keyValue = new DefaultKeyValue(); for (String requestKey : ConfigDefine.REQUEST_CONFIG) { assertEquals(connector.verifyAndSetConfig(keyValue), "Request Config key: " + requestKey); keyValue.put(requestKey, requestKey); } assertEquals(connector.verifyAndSetConfig(keyValue), ""); } |
FileBaseKeyValueStore extends MemoryBasedKeyValueStore<K, V> { public FileBaseKeyValueStore(String configFilePath, Converter keyConverter, Converter valueConverter) { super(); this.configFilePath = configFilePath; this.keyConverter = keyConverter; this.valueConverter = valueConverter; } FileBaseKeyValueStore(String configFilePath,
Converter keyConverter,
Converter valueConverter); String encode(); void decode(String jsonString); @Override boolean load(); @Override void persist(); } | @Test public void testFileBaseKeyValueStore() { FileBaseKeyValueStore<byte[], byte[]> fbkvs = new FileBaseKeyValueStore<>( "target/unit_test_store/testFileBaseKeyValueStore/000", new ByteConverter(), new ByteConverter() ); fbkvs.data = new HashMap<>(); fbkvs.data.put("test_key".getBytes(), "test_value".getBytes()); fbkvs.persist(); boolean flag = fbkvs.load(); assertThat(flag).isEqualTo(true); } |
PathUtils { public static String combine(String parentUrl, String childUrl) { StringBuilder simplyParent = simplyStringBuilder(parentUrl); if (simplyParent.length() == 0 || '/' != simplyParent.charAt(simplyParent.length() - 1)) simplyParent.append('/'); String simplyChild = simplyWithoutPrefix(childUrl); return simplyParent.append(simplyChild).toString(); } private PathUtils(); static File newFile(String pathName); static boolean contains(File parent, File child); static String relativePath(File parent, File child); static String combine(String parentUrl, String childUrl); static String simplyWithoutPrefix(String url); static String simplyWithoutSuffix(String url); static String simply(String url); } | @Test public void testCombine() { Assert.assertEquals(PathUtils.combine("", ""), "/"); Assert.assertEquals(PathUtils.combine("/", ""), "/"); Assert.assertEquals(PathUtils.combine("/", "/"), "/"); Assert.assertEquals(PathUtils.combine("", "/"), "/"); Assert.assertEquals(PathUtils.combine("/opt", "web"), "/opt/web"); Assert.assertEquals(PathUtils.combine("/opt/", "web"), "/opt/web"); Assert.assertEquals(PathUtils.combine("/opt/", "/web"), "/opt/web"); Assert.assertEquals(PathUtils.combine("/opt", "/web"), "/opt/web"); Assert.assertEquals(PathUtils.combine("opt", "/web"), "opt/web"); Assert.assertEquals(PathUtils.combine("opt", "/web/"), "opt/web/"); } |
PathUtils { public static String simplyWithoutPrefix(String url) { StringBuilder simply = simplyStringBuilder(url); if (simply.length() > 0 && '/' == simply.charAt(0)) simply.deleteCharAt(0); return simply.toString(); } private PathUtils(); static File newFile(String pathName); static boolean contains(File parent, File child); static String relativePath(File parent, File child); static String combine(String parentUrl, String childUrl); static String simplyWithoutPrefix(String url); static String simplyWithoutSuffix(String url); static String simply(String url); } | @Test public void testSimplyWithoutPrefix() { String url = "/"; Assert.assertEquals(PathUtils.simplyWithoutPrefix(url), ""); Assert.assertEquals(PathUtils.simplyWithoutSuffix(url), "/"); url = "/opt"; Assert.assertEquals(PathUtils.simplyWithoutPrefix(url), "opt"); Assert.assertEquals(PathUtils.simplyWithoutSuffix(url), "/opt"); url = "/opt/"; Assert.assertEquals(PathUtils.simplyWithoutPrefix(url), "opt/"); Assert.assertEquals(PathUtils.simplyWithoutSuffix(url), "/opt"); url = "opt/"; Assert.assertEquals(PathUtils.simplyWithoutPrefix(url), "opt/"); Assert.assertEquals(PathUtils.simplyWithoutSuffix(url), "opt"); url = ""; Assert.assertEquals(PathUtils.simplyWithoutPrefix(url), ""); Assert.assertEquals(PathUtils.simplyWithoutSuffix(url), ""); } |
PathUtils { public static String relativePath(File parent, File child) { Preconditions.checkArgument(contains(parent, child)); String parentName = conventPath(parent); String childName = conventPath(child); String relative = childName.substring(parentName.length()); if (relative.length() == 0) return "/"; return "/" + relative.substring(0, relative.length() - 1); } private PathUtils(); static File newFile(String pathName); static boolean contains(File parent, File child); static String relativePath(File parent, File child); static String combine(String parentUrl, String childUrl); static String simplyWithoutPrefix(String url); static String simplyWithoutSuffix(String url); static String simply(String url); } | @Test public void testRelativePath() { File parent = new File("/"); File child = new File("/"); Assert.assertEquals(PathUtils.relativePath(parent, child), "/"); parent = new File("/"); child = new File("/opt"); Assert.assertEquals(PathUtils.relativePath(parent, child), "/opt"); parent = new File("/"); child = new File("/opt/"); Assert.assertEquals(PathUtils.relativePath(parent, child), "/opt"); parent = new File("/opt/"); child = new File("/opt"); Assert.assertEquals(PathUtils.relativePath(parent, child), "/"); parent = new File("/opt/"); child = new File("/opt/web"); Assert.assertEquals(PathUtils.relativePath(parent, child), "/web"); parent = new File("/opt/"); child = new File("/opt/web/"); Assert.assertEquals(PathUtils.relativePath(parent, child), "/web"); parent = new File("/opt/"); child = new File("/"); Throwable throwable = testRelativePathException(parent, child); Assert.assertNotNull(throwable); parent = new File("/opt/"); child = new File("/op1"); throwable = testRelativePathException(parent, child); Assert.assertNotNull(throwable); parent = new File("/opt/"); child = new File("/op1/"); throwable = testRelativePathException(parent, child); Assert.assertNotNull(throwable); } |
PathUtils { public static boolean contains(File parent, File child) { String parentName = conventPath(parent); String childName = conventPath(child); return childName.indexOf(parentName) == 0; } private PathUtils(); static File newFile(String pathName); static boolean contains(File parent, File child); static String relativePath(File parent, File child); static String combine(String parentUrl, String childUrl); static String simplyWithoutPrefix(String url); static String simplyWithoutSuffix(String url); static String simply(String url); } | @Test public void testContains() { File parent = new File("/"); File child = new File("/"); Assert.assertTrue(PathUtils.contains(parent, child)); parent = new File("/"); child = new File("/opt"); Assert.assertTrue(PathUtils.contains(parent, child)); parent = new File("/"); child = new File("/opt/"); Assert.assertTrue(PathUtils.contains(parent, child)); parent = new File("/opt/"); child = new File("/opt"); Assert.assertTrue(PathUtils.contains(parent, child)); parent = new File("/opt/"); child = new File("/opt/web"); Assert.assertTrue(PathUtils.contains(parent, child)); parent = new File("/opt/"); child = new File("/opt/web/"); Assert.assertTrue(PathUtils.contains(parent, child)); parent = new File("/opt/"); child = new File("/"); Assert.assertFalse(PathUtils.contains(parent, child)); parent = new File("/opt/"); child = new File("/op1"); Assert.assertFalse(PathUtils.contains(parent, child)); parent = new File("/opt/"); child = new File("/op1/"); Assert.assertFalse(PathUtils.contains(parent, child)); parent = new File("/op/"); child = new File("/opt/"); Assert.assertFalse(PathUtils.contains(parent, child)); } |
PathUtils { static String conventPath(File file) { try { String path = file.getCanonicalPath(); return path.endsWith(File.separator) ? path : path + File.separator; } catch (IOException e) { throw ArgoException.raise(e); } } private PathUtils(); static File newFile(String pathName); static boolean contains(File parent, File child); static String relativePath(File parent, File child); static String combine(String parentUrl, String childUrl); static String simplyWithoutPrefix(String url); static String simplyWithoutSuffix(String url); static String simply(String url); } | @Test public void testConventPath() { File file = new File("/"); String path = PathUtils.conventPath(file); Assert.assertTrue(path.endsWith(File.separator)); if (path.length() >= 2) Assert.assertNotEquals(path.charAt(path.length() - 2), File.separatorChar); file = new File("/opt/web"); path = PathUtils.conventPath(file); Assert.assertTrue(path.endsWith(File.separator)); Assert.assertNotEquals(path.charAt(path.length() - 2), File.separatorChar); file = new File("/opt/web/"); path = PathUtils.conventPath(file); Assert.assertTrue(path.endsWith(File.separator)); Assert.assertNotEquals(path.charAt(path.length() - 2), File.separatorChar); } |
PathUtils { public static String simply(String url) { StringBuilder sb = simplyStringBuilder(url); return sb.toString(); } private PathUtils(); static File newFile(String pathName); static boolean contains(File parent, File child); static String relativePath(File parent, File child); static String combine(String parentUrl, String childUrl); static String simplyWithoutPrefix(String url); static String simplyWithoutSuffix(String url); static String simply(String url); } | @Test public void testSimplyPath() { Assert.assertEquals("", PathUtils.simply("")); Assert.assertEquals("/abc.txt", PathUtils.simply("\\abc.txt")); Assert.assertEquals("/pathFolder/abc.txt", PathUtils.simply("\\pathFolder\\abc.txt")); Assert.assertEquals("/abc.txt", PathUtils.simply("/abc.txt")); Assert.assertEquals("/abc.txt/", PathUtils.simply("/abc.txt/")); Assert.assertEquals("abc.txt", PathUtils.simply("abc.txt")); Assert.assertEquals(".abc.txt", PathUtils.simply(".abc.txt")); Assert.assertEquals(".abc.txt.", PathUtils.simply(".abc.txt.")); Assert.assertEquals(".abc.txt", PathUtils.simply(".abc.txt?")); Assert.assertEquals("/abc.txt", PathUtils.simply("/abc.txt?")); Assert.assertEquals("abc.txt", PathUtils.simply("abc.txt?")); Assert.assertEquals(".abc.txt", PathUtils.simply(".abc.txt?abcd")); Assert.assertEquals(".abc.txt", PathUtils.simply(".abc.txt#abcd")); Assert.assertEquals("/pathFolder/abc.txt", PathUtils.simply("/pathFolder/abc.txt")); Assert.assertEquals("/.pathFolder/abc.txt", PathUtils.simply("/.pathFolder/abc.txt")); Assert.assertEquals("/....pathFolder../abc.txt", PathUtils.simply("/....pathFolder../abc.txt")); Assert.assertEquals("/....pathFolder../abc.txt", PathUtils.simply("/....pathFolder../abc.txt?")); Assert.assertEquals("/....pathFolder../abc.txt", PathUtils.simply("/....pathFolder../abc.txt?abc")); Assert.assertEquals("/....pathFolder../abc.txt", PathUtils.simply("/....pathFolder../abc.txt#abc")); Assert.assertEquals("/....pathFolder../abc.txt", PathUtils.simply("/....pathFolder../abc.txt#abc<>")); Assert.assertEquals("/春节/", PathUtils.simply("/春节/")); ArgoException e = throwCombine(".."); Assert.assertEquals("Illegal URL path!\ncontext: {url=..}", e.getMessage()); Assert.assertNotNull(e); Assert.assertNotNull(throwCombine(".")); Assert.assertNotNull(throwCombine( ".\\")); Assert.assertNotNull(throwCombine("<")); Assert.assertNotNull(throwCombine(">")); Assert.assertNotNull(throwCombine("/aaa/../abc")); Assert.assertNotNull(throwCombine(" Assert.assertNotNull(throwCombine("aaa Assert.assertNotNull(throwCombine("aaa int count = 0; for(char c = 'a'; c <= 'z'; c++, count ++) Assert.assertEquals("" + c, PathUtils.simply(c + "")); Assert.assertEquals(26, count); count = 0; for(char c = 'A'; c <= 'Z'; c++, count ++) Assert.assertEquals("" + c, PathUtils.simply(c + "")); Assert.assertEquals(26, count); count = 0; for(char c = '0'; c <= '9'; c++, count ++) Assert.assertEquals("" + c, PathUtils.simply(c + "")); Assert.assertEquals(10, count); } |
ArgoException extends RuntimeException { public static ArgoExceptionBuilder newBuilder(String message) { return newBuilder(message, null); } ArgoException(); ArgoException(String message); ArgoException(Throwable cause); ArgoException(String message, Throwable cause); static ArgoExceptionBuilder newBuilder(String message); static ArgoExceptionBuilder newBuilder(Throwable cause); static ArgoExceptionBuilder newBuilder(); static ArgoExceptionBuilder newBuilder(String message, Throwable cause); static ArgoException raise(String message); static ArgoException raise(Throwable cause); static ArgoException raise(String message, Throwable cause); } | @Test public void testMessage() { ArgoException ex = ArgoException.newBuilder("This is a message.") .build(); Assert.assertEquals("This is a message.", ex.getMessage()); Assert.assertNull(ex.getCause()); }
@Test public void testCause() { Throwable ta = new RuntimeException("runtime exception."); ArgoException ex = ArgoException.newBuilder(ta).build(); Assert.assertEquals("", ex.getMessage()); Assert.assertEquals(ta, ex.getCause()); }
@Test public void testBoth() { Throwable ta = new RuntimeException(); String message = "This is a message."; ArgoException ex = ArgoException.newBuilder(message, ta) .build(); Assert.assertEquals(message, ex.getMessage()); Assert.assertEquals(ta, ex.getCause()); }
@Test public void testContext() { ArgoException ex = ArgoException.newBuilder() .addContextVariable("url", "http: .addContextVariable("email", "[email protected]") .build(); Assert.assertEquals("\ncontext: {url=http: } |
XmlSource extends ExternalResource { public byte[] asBytes() { return this.data; } private XmlSource(byte[] data); static XmlSource withData(String xml); static XmlSource withData(byte[] xml); static XmlSource withDataFrom(Class<?> clazz, String path); URL asUrl(); InputStream asInputStream(); Document asDocument(); byte[] asBytes(); File asFile(); Reader asReader(String charSet); String asString(String charSet); String asString(); XMLStreamReader asXMLStreamReader(); XMLEventReader asXMLEventReader(); } | @Test public void asBytes() throws UnsupportedEncodingException { assertThat(xml.asBytes(), is("<test/>".getBytes("UTF-8"))); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.