updated corefx to use consolidated event streaming

corefx/src/main/java/com/core/client/grpc/CoreGrpcClient.java

@@ -1073,31 +1073,54 @@ public class CoreGrpcClient implements ICoreClient {
         logger.info("setting up event handlers");
         handlingEvents = true;
         try {
-            handleSessionEvents(controller);
+            CoreProto.EventsRequest request = CoreProto.EventsRequest.newBuilder()
-            handleNodeEvents(controller);
+                    .setSessionId(sessionId)
-            handleExceptionEvents(controller);
+                    .build();
-            handleConfigEvents(controller);
+
-            handleLinkEvents(controller);
+            Iterator<CoreProto.Event> events = blockingStub.events(request);
-            handleFileEvents(controller);
+            executorService.submit(() -> {
+                try {
+                    while (handlingEvents) {
+                        CoreProto.Event event = events.next();
+                        logger.info("handling event: {}", event);
+                        switch (event.getEventTypeCase()) {
+                            case SESSION_EVENT:
+                                handleSessionEvents(controller, event.getSessionEvent());
+                                break;
+                            case NODE_EVENT:
+                                handleNodeEvents(controller, event.getNodeEvent());
+                                break;
+                            case LINK_EVENT:
+                                handleLinkEvents(controller, event.getLinkEvent());
+                                break;
+                            case CONFIG_EVENT:
+                                handleConfigEvents(controller, event.getConfigEvent());
+                                break;
+                            case EXCEPTION_EVENT:
+                                handleExceptionEvents(controller, event.getExceptionEvent());
+                                break;
+                            case FILE_EVENT:
+                                handleFileEvents(controller, event.getFileEvent());
+                                break;
+                            default:
+                                logger.error("unknown event type: {}", event.getEventTypeCase());
+                        }
+                    }
+                } catch (StatusRuntimeException ex) {
+                    logger.error("error handling session events", ex);
+                }
+            });
         } catch (StatusRuntimeException ex) {
             throw new IOException("setup event handlers error", ex);
         }
     }
 
-    private void handleSessionEvents(Controller controller) {
+    private void handleSessionEvents(Controller controller, CoreProto.SessionEvent event) {
-        CoreProto.SessionEventsRequest request = CoreProto.SessionEventsRequest.newBuilder()
-                .setSessionId(sessionId)
-                .build();
-        Iterator<CoreProto.SessionEvent> events = blockingStub.sessionEvents(request);
-        executorService.submit(() -> {
-            try {
-                while (handlingEvents) {
-                    CoreProto.SessionEvent event = events.next();
         logger.info("session event: {}", event);
         SessionState state = SessionState.get(event.getEvent());
         if (state == null) {
-                        logger.warn("unknown event type: {}", event.getEvent());
+            logger.warn("unknown session event: {}", event.getEvent());
-                        continue;
+            return;
         }
 
         // session state event
@@ -1117,73 +1140,22 @@ public class CoreGrpcClient implements ICoreClient {
             mobilityPlayerDialog.event(state, start, end);
         }
     }
-            } catch (StatusRuntimeException ex) {
-                logger.error("error handling session events", ex);
-            }
-        });
-    }
 
-    private void handleNodeEvents(Controller controller) {
+    private void handleNodeEvents(Controller controller, CoreProto.NodeEvent event) {
-        CoreProto.NodeEventsRequest request = CoreProto.NodeEventsRequest.newBuilder().setSessionId(sessionId)
-                .build();
-        Iterator<CoreProto.NodeEvent> events = blockingStub.nodeEvents(request);
-        executorService.submit(() -> {
-            try {
-                while (handlingEvents) {
-                    CoreProto.NodeEvent event = events.next();
         logger.info("node event: {}", event);
         CoreNode node = protoToNode(event.getNode());
         controller.getNetworkGraph().setNodeLocation(node);
     }
-            } catch (StatusRuntimeException ex) {
-                logger.error("error handling node events", ex);
-            }
-        });
-    }
 
-    private void handleExceptionEvents(Controller controller) {
+    private void handleExceptionEvents(Controller controller, CoreProto.ExceptionEvent event) {
-        CoreProto.ExceptionEventsRequest request = CoreProto.ExceptionEventsRequest.newBuilder()
-                .setSessionId(sessionId)
-                .build();
-        Iterator<CoreProto.ExceptionEvent> events = blockingStub.exceptionEvents(request);
-        executorService.submit(() -> {
-            try {
-                while (handlingEvents) {
-                    CoreProto.ExceptionEvent event = events.next();
         logger.info("exception event: {}", event);
     }
-            } catch (StatusRuntimeException ex) {
-                logger.error("error handling exception events", ex);
-            }
-        });
-    }
 
-    private void handleConfigEvents(Controller controller) {
+    private void handleConfigEvents(Controller controller, CoreProto.ConfigEvent event) {
-        CoreProto.ConfigEventsRequest request = CoreProto.ConfigEventsRequest.newBuilder()
-                .setSessionId(sessionId)
-                .build();
-        Iterator<CoreProto.ConfigEvent> events = blockingStub.configEvents(request);
-        executorService.submit(() -> {
-            try {
-                while (handlingEvents) {
-                    CoreProto.ConfigEvent event = events.next();
         logger.info("config event: {}", event);
     }
-            } catch (StatusRuntimeException ex) {
-                logger.error("error handling config events", ex);
-            }
-        });
-    }
 
-    private void handleLinkEvents(Controller controller) {
+    private void handleLinkEvents(Controller controller, CoreProto.LinkEvent event) {
-        CoreProto.LinkEventsRequest request = CoreProto.LinkEventsRequest.newBuilder()
-                .setSessionId(sessionId)
-                .build();
-        Iterator<CoreProto.LinkEvent> events = blockingStub.linkEvents(request);
-        executorService.submit(() -> {
-            try {
-                while (handlingEvents) {
-                    CoreProto.LinkEvent event = events.next();
         logger.info("link event: {}", event);
         CoreLink link = protoToLink(event.getLink());
         MessageFlags flag = MessageFlags.get(event.getMessageTypeValue());
@@ -1196,26 +1168,8 @@ public class CoreGrpcClient implements ICoreClient {
         }
         controller.getNetworkGraph().getGraphViewer().repaint();
     }
-            } catch (StatusRuntimeException ex) {
-                logger.error("error handling link events", ex);
-            }
-        });
-    }
 
-    private void handleFileEvents(Controller controller) {
+    private void handleFileEvents(Controller controller, CoreProto.FileEvent event) {
-        CoreProto.FileEventsRequest request = CoreProto.FileEventsRequest.newBuilder()
-                .setSessionId(sessionId)
-                .build();
-        Iterator<CoreProto.FileEvent> events = blockingStub.fileEvents(request);
-        executorService.submit(() -> {
-            try {
-                while (handlingEvents) {
-                    CoreProto.FileEvent event = events.next();
         logger.info("file event: {}", event);
     }
-            } catch (StatusRuntimeException ex) {
-                logger.error("error handling file events", ex);
-            }
-        });
-    }
 }