kazusa
/
skywalking-java
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

agg save mock finish

This commit is contained in:
pengys5 2017-04-07 11:22:26 +08:00
parent 7f2295b0a8
commit f377cfb824
35 changed files with 1085 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
skywalking-collector/skywalking-collector-worker/pom.xml
View File

@ -48,5 +48,10 @@
<version>${project.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.jetbrains</groupId>
<artifactId>annotations</artifactId>
<version>RELEASE</version>
</dependency>
</dependencies>
</project>

122
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/WorkerConfig.java
View File

@ -19,43 +19,9 @@ public class WorkerConfig extends ClusterConfig {
}
}
public static class Worker {
public static class TraceSegmentReceiver {
public static int Num = 10;
}
public static class DAGNodeReceiver {
public static int Num = 10;
}
public static class NodeInstanceReceiver {
public static int Num = 10;
}
public static class ResponseCostReceiver {
public static int Num = 10;
}
public static class ResponseSummaryReceiver {
public static int Num = 10;
}
public static class DAGNodeRefReceiver {
public static int Num = 10;
}
}
public static class WorkerNum {
public static class Node {
public static class NodeDayAgg {
public static int Value = 10;
}
public static class NodeHourAgg {
public static int Value = 10;
}
public static class NodeMinuteAgg {
public static class NodeCompAgg {
public static int Value = 10;
}
@ -71,10 +37,52 @@ public class WorkerConfig extends ClusterConfig {
public static int Value = 10;
}
}
public static class NodeRef {
public static class NodeRefDayAgg {
public static int Value = 10;
}
public static class NodeRefHourAgg {
public static int Value = 10;
}
public static class NodeRefMinuteAgg {
public static int Value = 10;
}
public static class NodeRefResSumDayAgg {
public static int Value = 10;
}
public static class NodeRefResSumHourAgg {
public static int Value = 10;
}
public static class NodeRefResSumMinuteAgg {
public static int Value = 10;
}
}
public static class GlobalTrace {
public static class GlobalTraceAgg {
public static int Value = 10;
}
}
}
public static class Queue {
public static class GlobalTrace {
public static class GlobalTraceSave {
public static int Size = 1024;
}
}
public static class Segment {
public static class SegmentPost {
public static int Size = 1024;
}
public static class SegmentCostSave {
public static int Size = 1024;
}
@ -160,52 +168,8 @@ public class WorkerConfig extends ClusterConfig {
}
}
public static class Persistence {
public static class DAGNodePersistence {
public static int Size = 1024;
}
public static class NodeInstancePersistence {
public static int Size = 1024;
}
public static class ResponseCostPersistence {
public static int Size = 1024;
}
public static class ResponseSummaryPersistence {
public static int Size = 1024;
}
public static class DAGNodeRefPersistence {
public static int Size = 1024;
}
}
public static class TraceSegmentRecordAnalysis {
public static int Size = 1024;
}
public static class NodeInstanceAnalysis {
public static int Size = 1024;
}
public static class DAGNodeAnalysis {
public static int Size = 1024;
}
public static class ResponseCostAnalysis {
public static int Size = 1024;
}
public static class ResponseSummaryAnalysis {
public static int Size = 1024;
}
public static class DAGNodeRefAnalysis {
public static int Size = 1024;
}
}
}

23
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/globaltrace/entity/TreeNode.java
View File

@ -1,23 +0,0 @@
package com.a.eye.skywalking.collector.worker.globaltrace.entity;
import java.util.ArrayList;
import java.util.List;
/**
* @author pengys5
*/
public class TreeNode {
private String spanId;
private List<TreeNode> childNodes;
public TreeNode(String spanId) {
this.spanId = spanId;
childNodes = new ArrayList<>();
}
public void addChild(TreeNode childNode) {
childNodes.add(childNode);
}
}

4
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/globaltrace/persistence/GlobalTraceAgg.java
View File

@ -15,7 +15,7 @@ public class GlobalTraceAgg extends AbstractClusterWorker {
private Logger logger = LogManager.getFormatterLogger(GlobalTraceAgg.class);
private GlobalTraceAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
GlobalTraceAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -48,7 +48,7 @@ public class GlobalTraceAgg extends AbstractClusterWorker {
@Override
public int workerNum() {
return WorkerConfig.Worker.DAGNodeReceiver.Num;
return WorkerConfig.WorkerNum.GlobalTrace.GlobalTraceAgg.Value;
}
}

8
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/globaltrace/persistence/GlobalTraceSave.java
View File

@ -4,7 +4,7 @@ package com.a.eye.skywalking.collector.worker.globaltrace.persistence;
import com.a.eye.skywalking.collector.actor.AbstractLocalAsyncWorkerProvider;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
import com.a.eye.skywalking.collector.worker.MergePersistenceMember;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
@ -15,7 +15,7 @@ import com.a.eye.skywalking.collector.worker.globaltrace.GlobalTraceIndex;
*/
public class GlobalTraceSave extends MergePersistenceMember {
private GlobalTraceSave(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
GlobalTraceSave(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -39,7 +39,7 @@ public class GlobalTraceSave extends MergePersistenceMember {
@Override
public int queueSize() {
return WorkerConfig.Queue.TraceSegmentRecordAnalysis.Size;
return WorkerConfig.Queue.GlobalTrace.GlobalTraceSave.Size;
}
@Override
@ -58,7 +58,7 @@ public class GlobalTraceSave extends MergePersistenceMember {
@Override
public WorkerSelector workerSelector() {
return new RollingSelector();
return new HashCodeSelector();
}
}
}

5
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/httpserver/HttpServer.java
View File

@ -25,11 +25,6 @@ public enum HttpServer {
ServletsCreator.INSTANCE.boot(servletContextHandler, clusterContext);
// ServerConnector serverConnector = new ServerConnector(server);
// serverConnector.setHost("127.0.0.1");
// serverConnector.setPort(7001);
// serverConnector.setIdleTimeout(5000);
server.setHandler(servletContextHandler);
server.start();
server.join();

8
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeCompAgg.java
View File

@ -11,7 +11,7 @@ import com.a.eye.skywalking.collector.worker.storage.RecordData;
*/
public class NodeCompAgg extends AbstractClusterWorker {
public NodeCompAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
NodeCompAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -24,9 +24,7 @@ public class NodeCompAgg extends AbstractClusterWorker {
protected void onWork(Object message) throws Exception {
if (message instanceof RecordData) {
getSelfContext().lookup(NodeCompSave.Role.INSTANCE).tell(message);
} else {
throw new IllegalArgumentException("message instance must RecordData");
}
} else throw new IllegalArgumentException("message instance must RecordData");
}
public static class Factory extends AbstractClusterWorkerProvider<NodeCompAgg> {
@ -44,7 +42,7 @@ public class NodeCompAgg extends AbstractClusterWorker {
@Override
public int workerNum() {
return WorkerConfig.WorkerNum.Node.NodeDayAgg.Value;
return WorkerConfig.WorkerNum.Node.NodeCompAgg.Value;
}
}

94
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/noderef/NodeRefGetWithTimeSlice.java
View File

@ -1,94 +0,0 @@
package com.a.eye.skywalking.collector.worker.noderef;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.Role;
import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
import com.a.eye.skywalking.collector.worker.httpserver.AbstractGet;
import com.a.eye.skywalking.collector.worker.httpserver.AbstractGetProvider;
import com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefSearchWithTimeSlice;
import com.a.eye.skywalking.collector.worker.tools.ParameterTools;
import com.google.gson.JsonObject;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.Arrays;
import java.util.Map;
/**
* @author pengys5
*/
public class NodeRefGetWithTimeSlice extends AbstractGet {
private Logger logger = LogManager.getFormatterLogger(NodeRefGetWithTimeSlice.class);
private NodeRefGetWithTimeSlice(Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@Override
public void preStart() throws ProviderNotFoundException {
getClusterContext().findProvider(NodeRefSearchWithTimeSlice.WorkerRole.INSTANCE).create(this);
}
@Override
protected void onSearch(Map<String, String[]> request, JsonObject response) throws Exception {
if (!request.containsKey("startTime") || !request.containsKey("endTime") || !request.containsKey("timeSliceType")) {
throw new IllegalArgumentException("the request parameter must contains startTime,endTime,timeSliceType");
}
logger.debug("startTime: %s, endTime: %s, timeSliceType: %s", Arrays.toString(request.get("startTime")),
Arrays.toString(request.get("endTime")), Arrays.toString(request.get("timeSliceType")));
long startTime;
try {
startTime = Long.valueOf(ParameterTools.INSTANCE.toString(request, "startTime"));
} catch (NumberFormatException e) {
throw new IllegalArgumentException("the request parameter startTime must numeric with long type");
}
long endTime;
try {
endTime = Long.valueOf(ParameterTools.INSTANCE.toString(request, "endTime"));
} catch (NumberFormatException e) {
throw new IllegalArgumentException("the request parameter endTime must numeric with long type");
}
NodeRefSearchWithTimeSlice.RequestEntity requestEntity;
requestEntity = new NodeRefSearchWithTimeSlice.RequestEntity(ParameterTools.INSTANCE.toString(request, "timeSliceType"), startTime, endTime);
getSelfContext().lookup(NodeRefSearchWithTimeSlice.WorkerRole.INSTANCE).ask(requestEntity, response);
}
public static class Factory extends AbstractGetProvider<NodeRefGetWithTimeSlice> {
@Override
public Role role() {
return WorkerRole.INSTANCE;
}
@Override
public NodeRefGetWithTimeSlice workerInstance(ClusterWorkerContext clusterContext) {
return new NodeRefGetWithTimeSlice(role(), clusterContext, new LocalWorkerContext());
}
@Override
public String servletPath() {
return "/nodeRef/timeSlice";
}
}
public enum WorkerRole implements Role {
INSTANCE;
@Override
public String roleName() {
return NodeRefGetWithTimeSlice.class.getSimpleName();
}
@Override
public WorkerSelector workerSelector() {
return new RollingSelector();
}
}
}

94
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/noderef/NodeRefResSumGetWithTimeSlice.java
View File

@ -1,94 +0,0 @@
package com.a.eye.skywalking.collector.worker.noderef;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.Role;
import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
import com.a.eye.skywalking.collector.worker.httpserver.AbstractGet;
import com.a.eye.skywalking.collector.worker.httpserver.AbstractGetProvider;
import com.a.eye.skywalking.collector.worker.noderef.persistence.NodeRefResSumSearchWithTimeSlice;
import com.a.eye.skywalking.collector.worker.tools.ParameterTools;
import com.google.gson.JsonObject;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.Arrays;
import java.util.Map;
/**
* @author pengys5
*/
public class NodeRefResSumGetWithTimeSlice extends AbstractGet {
private Logger logger = LogManager.getFormatterLogger(NodeRefResSumGetWithTimeSlice.class);
private NodeRefResSumGetWithTimeSlice(Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@Override
public void preStart() throws ProviderNotFoundException {
getClusterContext().findProvider(NodeRefResSumSearchWithTimeSlice.WorkerRole.INSTANCE).create(this);
}
@Override
protected void onSearch(Map<String, String[]> request, JsonObject response) throws Exception {
if (!request.containsKey("startTime") || !request.containsKey("endTime") || !request.containsKey("timeSliceType")) {
throw new IllegalArgumentException("the request parameter must contains startTime,endTime,timeSliceType");
}
logger.debug("startTime: %s, endTime: %s, timeSliceType: %s", Arrays.toString(request.get("startTime")),
Arrays.toString(request.get("endTime")), Arrays.toString(request.get("timeSliceType")));
long startTime;
try {
startTime = Long.valueOf(ParameterTools.INSTANCE.toString(request, "startTime"));
} catch (NumberFormatException e) {
throw new IllegalArgumentException("the request parameter startTime must numeric with long type");
}
long endTime;
try {
endTime = Long.valueOf(ParameterTools.INSTANCE.toString(request, "endTime"));
} catch (NumberFormatException e) {
throw new IllegalArgumentException("the request parameter endTime must numeric with long type");
}
NodeRefResSumSearchWithTimeSlice.RequestEntity requestEntity;
requestEntity = new NodeRefResSumSearchWithTimeSlice.RequestEntity(ParameterTools.INSTANCE.toString(request, "timeSliceType"), startTime, endTime);
getSelfContext().lookup(NodeRefResSumSearchWithTimeSlice.WorkerRole.INSTANCE).ask(requestEntity, response);
}
public static class Factory extends AbstractGetProvider<NodeRefResSumGetWithTimeSlice> {
@Override
public Role role() {
return WorkerRole.INSTANCE;
}
@Override
public NodeRefResSumGetWithTimeSlice workerInstance(ClusterWorkerContext clusterContext) {
return new NodeRefResSumGetWithTimeSlice(role(), clusterContext, new LocalWorkerContext());
}
@Override
public String servletPath() {
return "/nodeRef/resSum/timeSlice";
}
}
public enum WorkerRole implements Role {
INSTANCE;
@Override
public String roleName() {
return NodeRefResSumGetWithTimeSlice.class.getSimpleName();
}
@Override
public WorkerSelector workerSelector() {
return new RollingSelector();
}
}
}

4
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefDayAgg.java
View File

@ -15,7 +15,7 @@ public class NodeRefDayAgg extends AbstractClusterWorker {
private Logger logger = LogManager.getFormatterLogger(NodeRefDayAgg.class);
public NodeRefDayAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
NodeRefDayAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -48,7 +48,7 @@ public class NodeRefDayAgg extends AbstractClusterWorker {
@Override
public int workerNum() {
return WorkerConfig.Worker.DAGNodeRefReceiver.Num;
return WorkerConfig.WorkerNum.NodeRef.NodeRefDayAgg.Value;
}
}

4
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefHourAgg.java
View File

@ -15,7 +15,7 @@ public class NodeRefHourAgg extends AbstractClusterWorker {
private Logger logger = LogManager.getFormatterLogger(NodeRefHourAgg.class);
public NodeRefHourAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
NodeRefHourAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -48,7 +48,7 @@ public class NodeRefHourAgg extends AbstractClusterWorker {
@Override
public int workerNum() {
return WorkerConfig.Worker.DAGNodeRefReceiver.Num;
return WorkerConfig.WorkerNum.NodeRef.NodeRefHourAgg.Value;
}
}

4
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefMinuteAgg.java
View File

@ -15,7 +15,7 @@ public class NodeRefMinuteAgg extends AbstractClusterWorker {
private Logger logger = LogManager.getFormatterLogger(NodeRefMinuteAgg.class);
public NodeRefMinuteAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
NodeRefMinuteAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -48,7 +48,7 @@ public class NodeRefMinuteAgg extends AbstractClusterWorker {
@Override
public int workerNum() {
return WorkerConfig.Worker.DAGNodeRefReceiver.Num;
return WorkerConfig.WorkerNum.NodeRef.NodeRefMinuteAgg.Value;
}
}

4
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumDayAgg.java
View File

@ -15,7 +15,7 @@ public class NodeRefResSumDayAgg extends AbstractClusterWorker {
private Logger logger = LogManager.getFormatterLogger(NodeRefResSumDayAgg.class);
private NodeRefResSumDayAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
NodeRefResSumDayAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -48,7 +48,7 @@ public class NodeRefResSumDayAgg extends AbstractClusterWorker {
@Override
public int workerNum() {
return WorkerConfig.Worker.ResponseSummaryReceiver.Num;
return WorkerConfig.WorkerNum.NodeRef.NodeRefResSumDayAgg.Value;
}
}

4
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumHourAgg.java
View File

@ -15,7 +15,7 @@ public class NodeRefResSumHourAgg extends AbstractClusterWorker {
private Logger logger = LogManager.getFormatterLogger(NodeRefResSumHourAgg.class);
private NodeRefResSumHourAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
NodeRefResSumHourAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -48,7 +48,7 @@ public class NodeRefResSumHourAgg extends AbstractClusterWorker {
@Override
public int workerNum() {
return WorkerConfig.Worker.ResponseSummaryReceiver.Num;
return WorkerConfig.WorkerNum.NodeRef.NodeRefResSumHourAgg.Value;
}
}

4
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumMinuteAgg.java
View File

@ -15,7 +15,7 @@ public class NodeRefResSumMinuteAgg extends AbstractClusterWorker {
private Logger logger = LogManager.getFormatterLogger(NodeRefResSumMinuteAgg.class);
private NodeRefResSumMinuteAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
NodeRefResSumMinuteAgg(com.a.eye.skywalking.collector.actor.Role role, ClusterWorkerContext clusterContext, LocalWorkerContext selfContext) {
super(role, clusterContext, selfContext);
}
@ -48,7 +48,7 @@ public class NodeRefResSumMinuteAgg extends AbstractClusterWorker {
@Override
public int workerNum() {
return WorkerConfig.Worker.ResponseSummaryReceiver.Num;
return WorkerConfig.WorkerNum.NodeRef.NodeRefResSumMinuteAgg.Value;
}
}

3
skywalking-collector/skywalking-collector-worker/src/main/java/com/a/eye/skywalking/collector/worker/segment/SegmentPost.java
View File

@ -7,6 +7,7 @@ import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.Role;
import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
import com.a.eye.skywalking.collector.actor.selector.WorkerSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.globaltrace.analysis.GlobalTraceAnalysis;
import com.a.eye.skywalking.collector.worker.httpserver.AbstractPost;
import com.a.eye.skywalking.collector.worker.httpserver.AbstractPostProvider;
@ -134,7 +135,7 @@ public class SegmentPost extends AbstractPost {
@Override
public int queueSize() {
return 128;
return WorkerConfig.Queue.Segment.SegmentPost.Size;
}
@Override

24
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/TimeSliceTestCase.java Normal file
View File

@ -0,0 +1,24 @@
package com.a.eye.skywalking.collector.worker;
import org.junit.Assert;
import org.junit.Test;
/**
* @author pengys5
*/
public class TimeSliceTestCase {
@Test
public void test() {
TestTimeSlice timeSlice = new TestTimeSlice("A", 10L, 20L);
Assert.assertEquals("A", timeSlice.getSliceType());
Assert.assertEquals(10L, timeSlice.getStartTime());
Assert.assertEquals(20L, timeSlice.getEndTime());
}
class TestTimeSlice extends TimeSlice {
public TestTimeSlice(String sliceType, long startTime, long endTime) {
super(sliceType, startTime, endTime);
}
}
}

85
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/globaltrace/persistence/GlobalTraceAggTestCase.java Normal file
View File

@ -0,0 +1,85 @@
package com.a.eye.skywalking.collector.worker.globaltrace.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.MergeDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import com.a.eye.skywalking.collector.worker.tools.MergeDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
/**
* @author pengys5
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({LocalWorkerContext.class})
@PowerMockIgnore({"javax.management.*"})
public class GlobalTraceAggTestCase {
private GlobalTraceAgg agg;
private MergeDataAnswer mergeDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
@Before
public void init() throws Exception {
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
LocalWorkerContext localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
WorkerRefs workerRefs = mock(WorkerRefs.class);
mergeDataAnswer = new MergeDataAnswer();
doAnswer(mergeDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
when(localWorkerContext.lookup(GlobalTraceSave.Role.INSTANCE)).thenReturn(workerRefs);
agg = new GlobalTraceAgg(GlobalTraceAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
public void testRole() {
Assert.assertEquals(GlobalTraceAgg.class.getSimpleName(), GlobalTraceAgg.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), GlobalTraceAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(GlobalTraceAgg.class.getSimpleName(), GlobalTraceAgg.Factory.INSTANCE.role().roleName());
Assert.assertEquals(GlobalTraceAgg.class.getSimpleName(), GlobalTraceAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.WorkerNum.GlobalTrace.GlobalTraceAgg.Value = testSize;
Assert.assertEquals(testSize, GlobalTraceAgg.Factory.INSTANCE.workerNum());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(GlobalTraceSave.Role.INSTANCE)).thenReturn(GlobalTraceSave.Factory.INSTANCE);
ArgumentCaptor<GlobalTraceSave.Role> argumentCaptor = ArgumentCaptor.forClass(GlobalTraceSave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWork() throws Exception {
MergeDataAggTools.INSTANCE.testOnWork(agg, mergeDataAnswer);
}
@Test
public void testOnWorkError() throws Exception {
agg.onWork(new Object());
}
}

51
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/globaltrace/persistence/GlobalTraceSaveTestCase.java Normal file
View File

@ -0,0 +1,51 @@
package com.a.eye.skywalking.collector.worker.globaltrace.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.globaltrace.GlobalTraceIndex;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* @author pengys5
*/
public class GlobalTraceSaveTestCase {
private GlobalTraceSave save;
@Before
public void init() {
ClusterWorkerContext cluster = new ClusterWorkerContext(null);
LocalWorkerContext local = new LocalWorkerContext();
save = new GlobalTraceSave(GlobalTraceSave.Role.INSTANCE, cluster, local);
}
@Test
public void testEsIndex() {
Assert.assertEquals(GlobalTraceIndex.Index, save.esIndex());
}
@Test
public void testEsType() {
Assert.assertEquals(GlobalTraceIndex.Type_Record, save.esType());
}
@Test
public void testRole() {
Assert.assertEquals(GlobalTraceSave.class.getSimpleName(), GlobalTraceSave.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), GlobalTraceSave.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(GlobalTraceSave.class.getSimpleName(), GlobalTraceSave.Factory.INSTANCE.role().roleName());
Assert.assertEquals(GlobalTraceSave.class.getSimpleName(), GlobalTraceSave.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.Queue.GlobalTrace.GlobalTraceSave.Size = testSize;
Assert.assertEquals(testSize, GlobalTraceSave.Factory.INSTANCE.queueSize());
}
}

27
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/MergeDataAnswer.java Normal file
View File

@ -0,0 +1,27 @@
package com.a.eye.skywalking.collector.worker.mock;
import com.a.eye.skywalking.collector.worker.storage.MergeData;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import java.util.HashMap;
import java.util.Map;
/**
* @author pengys5
*/
public class MergeDataAnswer implements Answer<Object> {
public Map<String, String> mergeObj = new HashMap<>();
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
MergeData mergeData = (MergeData) invocation.getArguments()[0];
for (Map.Entry<String, String> entry : mergeData.toMap().entrySet()) {
System.out.printf("key: %s, value: %s \n", entry.getKey(), entry.getValue());
mergeObj.put(entry.getKey(), entry.getValue());
}
return null;
}
}

25
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/mock/MetricDataAnswer.java Normal file
View File

@ -0,0 +1,25 @@
package com.a.eye.skywalking.collector.worker.mock;
import com.a.eye.skywalking.collector.worker.storage.MetricData;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import java.util.HashMap;
import java.util.Map;
/**
* @author pengys5
*/
public class MetricDataAnswer implements Answer<Object> {
public Map<String, Object> metricObj = new HashMap<>();
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
MetricData metricData = (MetricData) invocation.getArguments()[0];
for (Map.Entry<String, Object> entry : metricData.toMap().entrySet()) {
metricObj.put(entry.getKey(), entry.getValue());
}
return null;
}
}

88
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeCompAggTestCase.java Normal file
View File

@ -0,0 +1,88 @@
package com.a.eye.skywalking.collector.worker.node.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.Const;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import com.a.eye.skywalking.collector.worker.tools.RecordDataAggTools;
import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
/**
* @author pengys5
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({LocalWorkerContext.class})
@PowerMockIgnore({"javax.management.*"})
public class NodeCompAggTestCase {
private NodeCompAgg agg;
private RecordDataAnswer recordDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
private LocalWorkerContext localWorkerContext;
@Before
public void init() throws Exception {
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
WorkerRefs workerRefs = mock(WorkerRefs.class);
recordDataAnswer = new RecordDataAnswer();
doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
when(localWorkerContext.lookup(NodeCompSave.Role.INSTANCE)).thenReturn(workerRefs);
agg = new NodeCompAgg(NodeCompAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
public void testRole() {
Assert.assertEquals(NodeCompAgg.class.getSimpleName(), NodeCompAgg.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeCompAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(NodeCompAgg.class.getSimpleName(), NodeCompAgg.Factory.INSTANCE.role().roleName());
Assert.assertEquals(NodeCompAgg.class.getSimpleName(), NodeCompAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.WorkerNum.Node.NodeCompAgg.Value = testSize;
Assert.assertEquals(testSize, NodeCompAgg.Factory.INSTANCE.workerNum());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeCompSave.Role.INSTANCE)).thenReturn(NodeCompSave.Factory.INSTANCE);
ArgumentCaptor<NodeCompSave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeCompSave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test(expected = IllegalArgumentException.class)
public void testOnWorkError() throws Exception {
agg.onWork(new Object());
}
@Test
public void testOnWork() throws Exception {
RecordDataAggTools.INSTANCE.testOnWork(agg, recordDataAnswer);
}
}

40
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingDayAggTestCase.java
View File

@ -1,25 +1,25 @@
package com.a.eye.skywalking.collector.worker.node.persistence;
import com.a.eye.skywalking.collector.actor.*;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.Const;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
import com.google.gson.JsonObject;
import com.a.eye.skywalking.collector.worker.tools.RecordDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.util.List;
import static org.mockito.Mockito.*;
/**
@ -30,7 +30,7 @@ import static org.mockito.Mockito.*;
@PowerMockIgnore({"javax.management.*"})
public class NodeMappingDayAggTestCase {
private NodeMappingDayAgg nodeMappingDayAgg;
private NodeMappingDayAgg agg;
private RecordDataAnswer recordDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
@ -45,7 +45,7 @@ public class NodeMappingDayAggTestCase {
doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
when(localWorkerContext.lookup(NodeMappingDaySave.Role.INSTANCE)).thenReturn(workerRefs);
nodeMappingDayAgg = new NodeMappingDayAgg(NodeMappingDayAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
agg = new NodeMappingDayAgg(NodeMappingDayAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
@ -64,30 +64,22 @@ public class NodeMappingDayAggTestCase {
Assert.assertEquals(testSize, NodeMappingDayAgg.Factory.INSTANCE.workerNum());
}
@Test(expected = Exception.class)
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeMappingDaySave.Role.INSTANCE)).thenThrow(new Exception());
nodeMappingDayAgg.preStart();
when(clusterWorkerContext.findProvider(NodeMappingDaySave.Role.INSTANCE)).thenReturn(NodeMappingDaySave.Factory.INSTANCE);
ArgumentCaptor<NodeMappingDaySave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeMappingDaySave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWork() throws Exception {
String id = "2017" + Const.ID_SPLIT + "TestNodeMappingDayAgg";
JsonObject record = new JsonObject();
record.addProperty("Column", "TestData");
RecordData recordData = new RecordData(id);
recordData.setRecord(record);
nodeMappingDayAgg.onWork(recordData);
List<RecordData> recordDataList = recordDataAnswer.recordObj.getRecordData();
RecordData data = RecordDataTool.INSTANCE.getRecord(recordDataList, id);
Assert.assertEquals("TestNodeMappingDayAgg", data.getRecord().get("aggId").getAsString());
Assert.assertEquals("TestData", data.getRecord().get("Column").getAsString());
RecordDataAggTools.INSTANCE.testOnWork(agg, recordDataAnswer);
}
@Test(expected = IllegalArgumentException.class)
public void testOnWorkError() throws Exception {
nodeMappingDayAgg.onWork(new Object());
agg.onWork(new Object());
}
}

35
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingHourAggTestCase.java
View File

@ -5,24 +5,21 @@ import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.Const;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
import com.google.gson.JsonObject;
import com.a.eye.skywalking.collector.worker.tools.RecordDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.util.List;
import static org.mockito.Mockito.*;
/**
@ -33,7 +30,7 @@ import static org.mockito.Mockito.*;
@PowerMockIgnore({"javax.management.*"})
public class NodeMappingHourAggTestCase {
private NodeMappingHourAgg nodeMappingHourAgg;
private NodeMappingHourAgg agg;
private RecordDataAnswer recordDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
@ -48,7 +45,7 @@ public class NodeMappingHourAggTestCase {
doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
when(localWorkerContext.lookup(NodeMappingHourSave.Role.INSTANCE)).thenReturn(workerRefs);
nodeMappingHourAgg = new NodeMappingHourAgg(NodeMappingHourAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
agg = new NodeMappingHourAgg(NodeMappingHourAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
@ -67,30 +64,22 @@ public class NodeMappingHourAggTestCase {
Assert.assertEquals(testSize, NodeMappingHourAgg.Factory.INSTANCE.workerNum());
}
@Test(expected = Exception.class)
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeMappingHourSave.Role.INSTANCE)).thenThrow(new Exception());
nodeMappingHourAgg.preStart();
when(clusterWorkerContext.findProvider(NodeMappingHourSave.Role.INSTANCE)).thenReturn(NodeMappingHourSave.Factory.INSTANCE);
ArgumentCaptor<NodeMappingHourSave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeMappingHourSave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWork() throws Exception {
String id = "2017" + Const.ID_SPLIT + "TestNodeMappingHourAgg";
JsonObject record = new JsonObject();
record.addProperty("Column", "TestData");
RecordData recordData = new RecordData(id);
recordData.setRecord(record);
nodeMappingHourAgg.onWork(recordData);
List<RecordData> recordDataList = recordDataAnswer.recordObj.getRecordData();
RecordData data = RecordDataTool.INSTANCE.getRecord(recordDataList, id);
Assert.assertEquals("TestNodeMappingHourAgg", data.getRecord().get("aggId").getAsString());
Assert.assertEquals("TestData", data.getRecord().get("Column").getAsString());
RecordDataAggTools.INSTANCE.testOnWork(agg, recordDataAnswer);
}
@Test(expected = IllegalArgumentException.class)
public void testOnWorkError() throws Exception {
nodeMappingHourAgg.onWork(new Object());
agg.onWork(new Object());
}
}

35
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/node/persistence/NodeMappingMinuteAggTestCase.java
View File

@ -5,24 +5,21 @@ import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.Const;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import com.a.eye.skywalking.collector.worker.tools.RecordDataTool;
import com.google.gson.JsonObject;
import com.a.eye.skywalking.collector.worker.tools.RecordDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.util.List;
import static org.mockito.Mockito.*;
/**
@ -33,7 +30,7 @@ import static org.mockito.Mockito.*;
@PowerMockIgnore({"javax.management.*"})
public class NodeMappingMinuteAggTestCase {
private NodeMappingMinuteAgg nodeMappingMinuteAgg;
private NodeMappingMinuteAgg agg;
private RecordDataAnswer recordDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
@ -48,7 +45,7 @@ public class NodeMappingMinuteAggTestCase {
doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
when(localWorkerContext.lookup(NodeMappingMinuteSave.Role.INSTANCE)).thenReturn(workerRefs);
nodeMappingMinuteAgg = new NodeMappingMinuteAgg(NodeMappingMinuteAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
agg = new NodeMappingMinuteAgg(NodeMappingMinuteAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
@ -67,30 +64,22 @@ public class NodeMappingMinuteAggTestCase {
Assert.assertEquals(testSize, NodeMappingMinuteAgg.Factory.INSTANCE.workerNum());
}
@Test(expected = Exception.class)
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeMappingDaySave.Role.INSTANCE)).thenThrow(new Exception());
nodeMappingMinuteAgg.preStart();
when(clusterWorkerContext.findProvider(NodeMappingMinuteSave.Role.INSTANCE)).thenReturn(NodeMappingMinuteSave.Factory.INSTANCE);
ArgumentCaptor<NodeMappingMinuteSave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeMappingMinuteSave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWork() throws Exception {
String id = "2017" + Const.ID_SPLIT + "TestNodeMappingMinuteAgg";
JsonObject record = new JsonObject();
record.addProperty("Column", "TestData");
RecordData recordData = new RecordData(id);
recordData.setRecord(record);
nodeMappingMinuteAgg.onWork(recordData);
List<RecordData> recordDataList = recordDataAnswer.recordObj.getRecordData();
RecordData data = RecordDataTool.INSTANCE.getRecord(recordDataList, id);
Assert.assertEquals("TestNodeMappingMinuteAgg", data.getRecord().get("aggId").getAsString());
Assert.assertEquals("TestData", data.getRecord().get("Column").getAsString());
RecordDataAggTools.INSTANCE.testOnWork(agg, recordDataAnswer);
}
@Test(expected = IllegalArgumentException.class)
public void testOnWorkError() throws Exception {
nodeMappingMinuteAgg.onWork(new Object());
agg.onWork(new Object());
}
}

86
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefDayAggTestCase.java Normal file
View File

@ -0,0 +1,86 @@
package com.a.eye.skywalking.collector.worker.noderef.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import com.a.eye.skywalking.collector.worker.tools.RecordDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
/**
* @author pengys5
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({LocalWorkerContext.class})
@PowerMockIgnore({"javax.management.*"})
public class NodeRefDayAggTestCase {
private NodeRefDayAgg agg;
private RecordDataAnswer recordDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
private LocalWorkerContext localWorkerContext;
@Before
public void init() throws Exception {
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
WorkerRefs workerRefs = mock(WorkerRefs.class);
recordDataAnswer = new RecordDataAnswer();
doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
when(localWorkerContext.lookup(NodeRefDaySave.Role.INSTANCE)).thenReturn(workerRefs);
agg = new NodeRefDayAgg(NodeRefDayAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
public void testRole() {
Assert.assertEquals(NodeRefDayAgg.class.getSimpleName(), NodeRefDayAgg.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeRefDayAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(NodeRefDayAgg.class.getSimpleName(), NodeRefDayAgg.Factory.INSTANCE.role().roleName());
Assert.assertEquals(NodeRefDayAgg.class.getSimpleName(), NodeRefDayAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.WorkerNum.NodeRef.NodeRefDayAgg.Value = testSize;
Assert.assertEquals(testSize, NodeRefDayAgg.Factory.INSTANCE.workerNum());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeRefDaySave.Role.INSTANCE)).thenReturn(NodeRefDaySave.Factory.INSTANCE);
ArgumentCaptor<NodeRefDaySave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeRefDaySave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWorkError() throws Exception {
agg.onWork(new Object());
}
@Test
public void testOnWork() throws Exception {
RecordDataAggTools.INSTANCE.testOnWork(agg, recordDataAnswer);
}
}

86
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefHourAggTestCase.java Normal file
View File

@ -0,0 +1,86 @@
package com.a.eye.skywalking.collector.worker.noderef.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import com.a.eye.skywalking.collector.worker.tools.RecordDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
/**
* @author pengys5
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({LocalWorkerContext.class})
@PowerMockIgnore({"javax.management.*"})
public class NodeRefHourAggTestCase {
private NodeRefHourAgg agg;
private RecordDataAnswer recordDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
private LocalWorkerContext localWorkerContext;
@Before
public void init() throws Exception {
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
WorkerRefs workerRefs = mock(WorkerRefs.class);
recordDataAnswer = new RecordDataAnswer();
doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
when(localWorkerContext.lookup(NodeRefHourSave.Role.INSTANCE)).thenReturn(workerRefs);
agg = new NodeRefHourAgg(NodeRefHourAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
public void testRole() {
Assert.assertEquals(NodeRefHourAgg.class.getSimpleName(), NodeRefHourAgg.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeRefHourAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(NodeRefHourAgg.class.getSimpleName(), NodeRefHourAgg.Factory.INSTANCE.role().roleName());
Assert.assertEquals(NodeRefHourAgg.class.getSimpleName(), NodeRefHourAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.WorkerNum.NodeRef.NodeRefHourAgg.Value = testSize;
Assert.assertEquals(testSize, NodeRefHourAgg.Factory.INSTANCE.workerNum());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeRefHourSave.Role.INSTANCE)).thenReturn(NodeRefHourSave.Factory.INSTANCE);
ArgumentCaptor<NodeRefHourSave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeRefHourSave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWorkError() throws Exception {
agg.onWork(new Object());
}
@Test
public void testOnWork() throws Exception {
RecordDataAggTools.INSTANCE.testOnWork(agg, recordDataAnswer);
}
}

86
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefMinuteAggTestCase.java Normal file
View File

@ -0,0 +1,86 @@
package com.a.eye.skywalking.collector.worker.noderef.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import com.a.eye.skywalking.collector.worker.tools.RecordDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
/**
* @author pengys5
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({LocalWorkerContext.class})
@PowerMockIgnore({"javax.management.*"})
public class NodeRefMinuteAggTestCase {
private NodeRefMinuteAgg agg;
private RecordDataAnswer recordDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
private LocalWorkerContext localWorkerContext;
@Before
public void init() throws Exception {
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
WorkerRefs workerRefs = mock(WorkerRefs.class);
recordDataAnswer = new RecordDataAnswer();
doAnswer(recordDataAnswer).when(workerRefs).tell(Mockito.any(RecordData.class));
when(localWorkerContext.lookup(NodeRefMinuteSave.Role.INSTANCE)).thenReturn(workerRefs);
agg = new NodeRefMinuteAgg(NodeRefMinuteAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
public void testRole() {
Assert.assertEquals(NodeRefMinuteAgg.class.getSimpleName(), NodeRefMinuteAgg.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeRefMinuteAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(NodeRefMinuteAgg.class.getSimpleName(), NodeRefMinuteAgg.Factory.INSTANCE.role().roleName());
Assert.assertEquals(NodeRefMinuteAgg.class.getSimpleName(), NodeRefMinuteAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.WorkerNum.NodeRef.NodeRefMinuteAgg.Value = testSize;
Assert.assertEquals(testSize, NodeRefMinuteAgg.Factory.INSTANCE.workerNum());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeRefMinuteSave.Role.INSTANCE)).thenReturn(NodeRefMinuteSave.Factory.INSTANCE);
ArgumentCaptor<NodeRefMinuteSave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeRefMinuteSave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWorkError() throws Exception {
agg.onWork(new Object());
}
@Test
public void testOnWork() throws Exception {
RecordDataAggTools.INSTANCE.testOnWork(agg, recordDataAnswer);
}
}

86
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumDayAggTestCase.java Normal file
View File

@ -0,0 +1,86 @@
package com.a.eye.skywalking.collector.worker.noderef.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.MetricDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.MetricData;
import com.a.eye.skywalking.collector.worker.tools.MetricDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
/**
* @author pengys5
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({LocalWorkerContext.class})
@PowerMockIgnore({"javax.management.*"})
public class NodeRefResSumDayAggTestCase {
private NodeRefResSumDayAgg agg;
private MetricDataAnswer metricDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
private LocalWorkerContext localWorkerContext;
@Before
public void init() throws Exception {
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
WorkerRefs workerRefs = mock(WorkerRefs.class);
metricDataAnswer = new MetricDataAnswer();
doAnswer(metricDataAnswer).when(workerRefs).tell(Mockito.any(MetricData.class));
when(localWorkerContext.lookup(NodeRefResSumDaySave.Role.INSTANCE)).thenReturn(workerRefs);
agg = new NodeRefResSumDayAgg(NodeRefResSumDayAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
public void testRole() {
Assert.assertEquals(NodeRefResSumDayAgg.class.getSimpleName(), NodeRefResSumDayAgg.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeRefResSumDayAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(NodeRefResSumDayAgg.class.getSimpleName(), NodeRefResSumDayAgg.Factory.INSTANCE.role().roleName());
Assert.assertEquals(NodeRefResSumDayAgg.class.getSimpleName(), NodeRefResSumDayAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.WorkerNum.NodeRef.NodeRefResSumDayAgg.Value = testSize;
Assert.assertEquals(testSize, NodeRefResSumDayAgg.Factory.INSTANCE.workerNum());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeRefResSumDaySave.Role.INSTANCE)).thenReturn(NodeRefResSumDaySave.Factory.INSTANCE);
ArgumentCaptor<NodeRefResSumDaySave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeRefResSumDaySave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWorkError() throws Exception {
agg.onWork(new Object());
}
@Test
public void testOnWork() throws Exception {
MetricDataAggTools.INSTANCE.testOnWork(agg, metricDataAnswer);
}
}

86
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumHourAggTestCase.java Normal file
View File

@ -0,0 +1,86 @@
package com.a.eye.skywalking.collector.worker.noderef.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.MetricDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.MetricData;
import com.a.eye.skywalking.collector.worker.tools.MetricDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
/**
* @author pengys5
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({LocalWorkerContext.class})
@PowerMockIgnore({"javax.management.*"})
public class NodeRefResSumHourAggTestCase {
private NodeRefResSumHourAgg agg;
private MetricDataAnswer metricDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
private LocalWorkerContext localWorkerContext;
@Before
public void init() throws Exception {
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
WorkerRefs workerRefs = mock(WorkerRefs.class);
metricDataAnswer = new MetricDataAnswer();
doAnswer(metricDataAnswer).when(workerRefs).tell(Mockito.any(MetricData.class));
when(localWorkerContext.lookup(NodeRefResSumHourSave.Role.INSTANCE)).thenReturn(workerRefs);
agg = new NodeRefResSumHourAgg(NodeRefResSumHourAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
public void testRole() {
Assert.assertEquals(NodeRefResSumHourAgg.class.getSimpleName(), NodeRefResSumHourAgg.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeRefResSumHourAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(NodeRefResSumHourAgg.class.getSimpleName(), NodeRefResSumHourAgg.Factory.INSTANCE.role().roleName());
Assert.assertEquals(NodeRefResSumHourAgg.class.getSimpleName(), NodeRefResSumHourAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.WorkerNum.NodeRef.NodeRefResSumHourAgg.Value = testSize;
Assert.assertEquals(testSize, NodeRefResSumHourAgg.Factory.INSTANCE.workerNum());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeRefResSumHourSave.Role.INSTANCE)).thenReturn(NodeRefResSumHourSave.Factory.INSTANCE);
ArgumentCaptor<NodeRefResSumHourSave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeRefResSumHourSave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWorkError() throws Exception {
agg.onWork(new Object());
}
@Test
public void testOnWork() throws Exception {
MetricDataAggTools.INSTANCE.testOnWork(agg, metricDataAnswer);
}
}

86
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/noderef/persistence/NodeRefResSumMinuteAggTestCase.java Normal file
View File

@ -0,0 +1,86 @@
package com.a.eye.skywalking.collector.worker.noderef.persistence;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.ProviderNotFoundException;
import com.a.eye.skywalking.collector.actor.WorkerRefs;
import com.a.eye.skywalking.collector.actor.selector.HashCodeSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.mock.MetricDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.MetricData;
import com.a.eye.skywalking.collector.worker.tools.MetricDataAggTools;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
/**
* @author pengys5
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest({LocalWorkerContext.class})
@PowerMockIgnore({"javax.management.*"})
public class NodeRefResSumMinuteAggTestCase {
private NodeRefResSumMinuteAgg agg;
private MetricDataAnswer metricDataAnswer;
private ClusterWorkerContext clusterWorkerContext;
private LocalWorkerContext localWorkerContext;
@Before
public void init() throws Exception {
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
localWorkerContext = PowerMockito.mock(LocalWorkerContext.class);
WorkerRefs workerRefs = mock(WorkerRefs.class);
metricDataAnswer = new MetricDataAnswer();
doAnswer(metricDataAnswer).when(workerRefs).tell(Mockito.any(MetricData.class));
when(localWorkerContext.lookup(NodeRefResSumMinuteSave.Role.INSTANCE)).thenReturn(workerRefs);
agg = new NodeRefResSumMinuteAgg(NodeRefResSumMinuteAgg.Role.INSTANCE, clusterWorkerContext, localWorkerContext);
}
@Test
public void testRole() {
Assert.assertEquals(NodeRefResSumMinuteAgg.class.getSimpleName(), NodeRefResSumMinuteAgg.Role.INSTANCE.roleName());
Assert.assertEquals(HashCodeSelector.class.getSimpleName(), NodeRefResSumMinuteAgg.Role.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(NodeRefResSumMinuteAgg.class.getSimpleName(), NodeRefResSumMinuteAgg.Factory.INSTANCE.role().roleName());
Assert.assertEquals(NodeRefResSumMinuteAgg.class.getSimpleName(), NodeRefResSumMinuteAgg.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
int testSize = 10;
WorkerConfig.WorkerNum.NodeRef.NodeRefResSumMinuteAgg.Value = testSize;
Assert.assertEquals(testSize, NodeRefResSumMinuteAgg.Factory.INSTANCE.workerNum());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(NodeRefResSumMinuteSave.Role.INSTANCE)).thenReturn(NodeRefResSumMinuteSave.Factory.INSTANCE);
ArgumentCaptor<NodeRefResSumMinuteSave.Role> argumentCaptor = ArgumentCaptor.forClass(NodeRefResSumMinuteSave.Role.class);
agg.preStart();
verify(clusterWorkerContext).findProvider(argumentCaptor.capture());
}
@Test
public void testOnWorkError() throws Exception {
agg.onWork(new Object());
}
@Test
public void testOnWork() throws Exception {
MetricDataAggTools.INSTANCE.testOnWork(agg, metricDataAnswer);
}
}

105
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/segment/SegmentPostTestCase.java
View File

@ -1,21 +1,20 @@
package com.a.eye.skywalking.collector.worker.segment;
import com.a.eye.skywalking.collector.actor.ClusterWorkerContext;
import com.a.eye.skywalking.collector.actor.LocalWorkerContext;
import com.a.eye.skywalking.collector.actor.WorkerRef;
import com.a.eye.skywalking.collector.actor.*;
import com.a.eye.skywalking.collector.actor.selector.RollingSelector;
import com.a.eye.skywalking.collector.worker.WorkerConfig;
import com.a.eye.skywalking.collector.worker.globaltrace.analysis.GlobalTraceAnalysis;
import com.a.eye.skywalking.collector.worker.node.analysis.NodeCompAnalysis;
import com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingDayAnalysis;
import com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingHourAnalysis;
import com.a.eye.skywalking.collector.worker.node.analysis.NodeMappingMinuteAnalysis;
import com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefDayAnalysis;
import com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefHourAnalysis;
import com.a.eye.skywalking.collector.worker.noderef.analysis.NodeRefMinuteAnalysis;
import com.a.eye.skywalking.collector.worker.noderef.analysis.*;
import com.a.eye.skywalking.collector.worker.segment.mock.SegmentMock;
import com.a.eye.skywalking.collector.worker.segment.persistence.SegmentCostSave;
import com.a.eye.skywalking.collector.worker.segment.persistence.SegmentExceptionSave;
import com.a.eye.skywalking.collector.worker.segment.persistence.SegmentSave;
import com.a.eye.skywalking.collector.worker.tools.DateTools;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@ -23,15 +22,21 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatcher;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.powermock.api.mockito.PowerMockito.*;
import static org.mockito.Mockito.*;
import static org.mockito.Mockito.when;
import static org.powermock.api.mockito.PowerMockito.doAnswer;
import static org.powermock.api.mockito.PowerMockito.doReturn;
import static org.powermock.api.mockito.PowerMockito.mock;
/**
* @author pengys5
@ -46,23 +51,95 @@ public class SegmentPostTestCase {
private SegmentMock segmentMock;
private SegmentPost segmentPost;
private LocalWorkerContext localWorkerContext;
private ClusterWorkerContext clusterWorkerContext;
@Before
public void init() throws Exception {
segmentMock = new SegmentMock();
ClusterWorkerContext clusterWorkerContext = new ClusterWorkerContext(null);
clusterWorkerContext = PowerMockito.mock(ClusterWorkerContext.class);
localWorkerContext = new LocalWorkerContext();
segmentPost = new SegmentPost(SegmentPost.WorkerRole.INSTANCE, clusterWorkerContext, localWorkerContext);
initNodeNodeMappingAnalysis();
initNodeCompAnalysis();
initNodeRefAnalysis();
initSegmentExceptionSave();
initSegmentSave();
initSegmentCostSave();
initGlobalTraceAnalysis();
initSegmentExceptionSave();
initNodeRefAnalysis();
initNodeCompAnalysis();
initNodeNodeMappingAnalysis();
}
segmentPost = spy(new SegmentPost(SegmentPost.WorkerRole.INSTANCE, clusterWorkerContext, localWorkerContext));
@Test
public void testRole() {
Assert.assertEquals(SegmentPost.class.getSimpleName(), SegmentPost.WorkerRole.INSTANCE.roleName());
Assert.assertEquals(RollingSelector.class.getSimpleName(), SegmentPost.WorkerRole.INSTANCE.workerSelector().getClass().getSimpleName());
}
@Test
public void testFactory() {
Assert.assertEquals(SegmentPost.class.getSimpleName(), SegmentPost.Factory.INSTANCE.role().roleName());
Assert.assertEquals(SegmentPost.class.getSimpleName(), SegmentPost.Factory.INSTANCE.workerInstance(null).getClass().getSimpleName());
Assert.assertEquals("/segments", SegmentPost.Factory.INSTANCE.servletPath());
int testSize = 10;
WorkerConfig.Queue.Segment.SegmentPost.Size = testSize;
Assert.assertEquals(testSize, SegmentPost.Factory.INSTANCE.queueSize());
}
@Test
public void testPreStart() throws ProviderNotFoundException {
when(clusterWorkerContext.findProvider(GlobalTraceAnalysis.Role.INSTANCE)).thenReturn(GlobalTraceAnalysis.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(NodeCompAnalysis.Role.INSTANCE)).thenReturn(NodeCompAnalysis.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(SegmentSave.Role.INSTANCE)).thenReturn(SegmentSave.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(SegmentCostSave.Role.INSTANCE)).thenReturn(SegmentCostSave.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(SegmentExceptionSave.Role.INSTANCE)).thenReturn(SegmentExceptionSave.Factory.INSTANCE);
NodeRefMinuteAnalysis.Factory.INSTANCE.setClusterContext(clusterWorkerContext);
when(clusterWorkerContext.findProvider(NodeRefResSumMinuteAnalysis.Role.INSTANCE)).thenReturn(NodeRefResSumMinuteAnalysis.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(NodeRefMinuteAnalysis.Role.INSTANCE)).thenReturn(NodeRefMinuteAnalysis.Factory.INSTANCE);
NodeRefHourAnalysis.Factory.INSTANCE.setClusterContext(clusterWorkerContext);
when(clusterWorkerContext.findProvider(NodeRefResSumHourAnalysis.Role.INSTANCE)).thenReturn(NodeRefResSumHourAnalysis.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(NodeRefHourAnalysis.Role.INSTANCE)).thenReturn(NodeRefHourAnalysis.Factory.INSTANCE);
NodeRefDayAnalysis.Factory.INSTANCE.setClusterContext(clusterWorkerContext);
when(clusterWorkerContext.findProvider(NodeRefResSumDayAnalysis.Role.INSTANCE)).thenReturn(NodeRefResSumDayAnalysis.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(NodeRefDayAnalysis.Role.INSTANCE)).thenReturn(NodeRefDayAnalysis.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(NodeMappingDayAnalysis.Role.INSTANCE)).thenReturn(NodeMappingDayAnalysis.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(NodeMappingHourAnalysis.Role.INSTANCE)).thenReturn(NodeMappingHourAnalysis.Factory.INSTANCE);
when(clusterWorkerContext.findProvider(NodeMappingMinuteAnalysis.Role.INSTANCE)).thenReturn(NodeMappingMinuteAnalysis.Factory.INSTANCE);
ArgumentCaptor<Role> argumentCaptor = ArgumentCaptor.forClass(Role.class);
segmentPost.preStart();
verify(clusterWorkerContext, times(14)).findProvider(argumentCaptor.capture());
Assert.assertEquals(GlobalTraceAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(0).roleName());
Assert.assertEquals(NodeCompAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(1).roleName());
Assert.assertEquals(SegmentSave.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(2).roleName());
Assert.assertEquals(SegmentCostSave.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(3).roleName());
Assert.assertEquals(SegmentExceptionSave.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(4).roleName());
Assert.assertEquals(NodeRefMinuteAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(5).roleName());
Assert.assertEquals(NodeRefResSumMinuteAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(6).roleName());
Assert.assertEquals(NodeRefHourAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(7).roleName());
Assert.assertEquals(NodeRefResSumHourAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(8).roleName());
Assert.assertEquals(NodeRefDayAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(9).roleName());
Assert.assertEquals(NodeRefResSumDayAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(10).roleName());
Assert.assertEquals(NodeMappingDayAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(11).roleName());
Assert.assertEquals(NodeMappingHourAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(12).roleName());
Assert.assertEquals(NodeMappingMinuteAnalysis.Role.INSTANCE.roleName(), argumentCaptor.getAllValues().get(13).roleName());
}
@Test
public void testValidateData() throws Exception {
JsonArray segmentArray = new JsonArray();
JsonObject segmentJsonObj = new JsonObject();
segmentJsonObj.addProperty("et", 1491277162066L);
segmentArray.add(segmentJsonObj);
segmentPost.onReceive(segmentArray.toString());
}
private SegmentSaveAnswer segmentSaveAnswer_1;

22
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/tools/MergeDataAggTools.java Normal file
View File

@ -0,0 +1,22 @@
package com.a.eye.skywalking.collector.worker.tools;
import com.a.eye.skywalking.collector.actor.AbstractClusterWorker;
import com.a.eye.skywalking.collector.worker.Const;
import com.a.eye.skywalking.collector.worker.mock.MergeDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.MergeData;
import org.junit.Assert;
/**
* @author pengys5
*/
public enum MergeDataAggTools {
INSTANCE;
public void testOnWork(AbstractClusterWorker agg, MergeDataAnswer mergeDataAnswer) throws Exception {
String id = "2016" + Const.ID_SPLIT + "A" + Const.ID_SPLIT + "B";
MergeData mergeData = new MergeData(id);
mergeData.setMergeData("Column", "Value");
agg.allocateJob(mergeData);
Assert.assertEquals("Value", mergeDataAnswer.mergeObj.get("Column"));
}
}

23
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/tools/MetricDataAggTools.java Normal file
View File

@ -0,0 +1,23 @@
package com.a.eye.skywalking.collector.worker.tools;
import com.a.eye.skywalking.collector.actor.AbstractClusterWorker;
import com.a.eye.skywalking.collector.worker.Const;
import com.a.eye.skywalking.collector.worker.mock.MetricDataAnswer;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.MetricData;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import org.junit.Assert;
/**
* @author pengys5
*/
public enum MetricDataAggTools {
INSTANCE;
public void testOnWork(AbstractClusterWorker agg, MetricDataAnswer metricDataAnswer) throws Exception {
String id = "2016" + Const.ID_SPLIT + "A" + Const.ID_SPLIT + "B";
MetricData metricData = new MetricData(id);
agg.allocateJob(metricData);
Assert.assertEquals("A" + Const.ID_SPLIT + "B", metricDataAnswer.metricObj.get("aggId"));
}
}

22
skywalking-collector/skywalking-collector-worker/src/test/java/com/a/eye/skywalking/collector/worker/tools/RecordDataAggTools.java Normal file
View File

@ -0,0 +1,22 @@
package com.a.eye.skywalking.collector.worker.tools;
import com.a.eye.skywalking.collector.actor.AbstractClusterWorker;
import com.a.eye.skywalking.collector.worker.Const;
import com.a.eye.skywalking.collector.worker.mock.RecordDataAnswer;
import com.a.eye.skywalking.collector.worker.storage.RecordData;
import org.junit.Assert;
/**
* @author pengys5
*/
public enum RecordDataAggTools {
INSTANCE;
public void testOnWork(AbstractClusterWorker agg, RecordDataAnswer recordDataAnswer) throws Exception {
String id = "2016" + Const.ID_SPLIT + "A" + Const.ID_SPLIT + "B";
RecordData recordData = new RecordData(id);
agg.allocateJob(recordData);
RecordData result = RecordDataTool.INSTANCE.getRecord(recordDataAnswer.recordObj.getRecordData(), id);
Assert.assertEquals("A" + Const.ID_SPLIT + "B", result.getRecord().get("aggId").getAsString());
}
}