protected void sendEventToLocal(ActorContext context, EndpointEventReceiveMessage message) { context.parent().tell(message, context.self()); }
protected void tellParent(ActorContext context, Object response) { context.parent().tell(response, context.self()); }
private void processEndpointEventSendMessage(EndpointEventSendMessage message) { LOG.debug("[{}] Forwarding message to specific user", appToken, message.getUserId()); context().parent().tell(message, self()); }
/** * Process endpoint registration. * * @param message the message */ private void processEndpointUserRegistration(EndpointUserConnectMessage message) { context().parent().tell(message, self()); }
/** * Process endpoint deregistration. * * @param message the message */ private void processEndpointUserDeregistration(EndpointUserDisconnectMessage message) { context().parent().tell(message, self()); }
private void processEndpointEventDeliveryMessage(EndpointEventDeliveryMessage message) { LOG.debug("[{}] Forwarding message to specific user", appToken, message.getUserId()); context().parent().tell(message, self()); }
private void processStatusRequest(StatusRequestMessage message) { LOG.debug("[{}] Processing status request", message.getId()); int endpointCount = localEndpointSessions.size(); context().parent() .tell(new ApplicationActorStatusResponse(message.getId(), endpointCount), ActorRef.noSender()); }
private <T> void dispatchMsg(ActorContext context, T localMsg, BiConsumer<String, T> biConsumer) { for (EndpointClusterAddress address : routes.getLocalRoutes()) { LOG.info("Forwarding {} to local endpoint actor {}", localMsg, address); ThriftEndpointActorMsg<T> msg = new ThriftEndpointActorMsg<>( address.toEndpointAddress(), ActorClassifier.LOCAL, localMsg); context.parent().tell(msg, context.self()); } for (EndpointClusterAddress address : routes.getRemoteRoutes()) { LOG.info("Forwarding {} to remote endpoint actor {}", localMsg, address); biConsumer.accept(address.getNodeId(), localMsg); } } }
private void sendGlobalRouteUpdate(ActorContext context, GlobalRouteInfo route) { if (eventService.isMainUserNode(userId)) { context.parent().tell(new EndpointRouteUpdateMessage(route), context.self()); } else { LOG.debug("[{}] Sending connect message to global actor", userId); eventService.sendEndpointRouteInfo(route); } }
private void processEndpointUserActionMessage(EndpointUserActionMessage message, boolean escalate) { LocalEndpointActorMetaData endpointMetaData = localEndpointSessions.get(message.getKey()); if (endpointMetaData != null) { LOG.debug("[{}] Found affected endpoint and forwarding message to it", appToken); endpointMetaData.actorRef.tell(message, self()); } else if (escalate) { LOG.debug("[{}] Failed to fing affected endpoint in scope of current application." + " Forwarding message to tenant actor", appToken); EndpointUserActionRouteMessage routeMessage = new EndpointUserActionRouteMessage(message, appToken); context().parent().tell(routeMessage, self()); } }
private void processEndpointEventReceiveMessage(EndpointEventReceiveMessage message) { LocalEndpointActorMetaData endpointActor = localEndpointSessions.get(message.getKey()); if (endpointActor != null) { endpointActor.actorRef.tell(message, self()); } else { LOG.debug("[{}] Can't find endpoint actor that corresponds to {}", appToken, message.getKey()); context().parent() .tell(new EndpointEventDeliveryMessage(message, EventDeliveryStatus.FAILURE), self()); } }
private void processUserAttachRequest(ActorContext context, ClientSync syncRequest, SyncContext responseHolder) { UserClientSync request = syncRequest.getUserSync(); if (request != null && request.getUserAttachRequest() != null) { UserAttachRequest attachRequest = request.getUserAttachRequest(); context.parent().tell(new UserVerificationRequestMessage( context.self(), attachRequest.getUserVerifierId(), attachRequest.getUserExternalId(), attachRequest.getUserAccessToken()), context.self()); LOG.debug("[{}][{}] received and forwarded user attach request {}", endpointKey, actorKey, request.getUserAttachRequest()); if (userAttachResponseMap.size() > 0) { Entry<UUID, UserVerificationResponseMessage> entryToSend = userAttachResponseMap.entrySet() .iterator() .next(); updateResponseWithUserAttachResults(responseHolder.getResponse(), entryToSend.getValue()); userAttachResponseMap.remove(entryToSend.getKey()); } } }
private void sendDisconnectFromOldUser(ActorContext context, EndpointProfileDto endpointProfile) { LOG.debug("[{}][{}] Detected user change from [{}] to [{}]", endpointKey, actorKey, state.getUserId(), endpointProfile.getEndpointUserId()); EndpointUserDisconnectMessage userDisconnectMessage = new EndpointUserDisconnectMessage( state.getUserId(), key, appToken, context.self()); context.parent().tell(userDisconnectMessage, context.self()); }
private void processStatusResponse(ApplicationActorStatusResponse message) { StatusRequestState state = statusRequestStatesMap.get(message.getRequestId()); if (state != null) { if (state.processResponse(message)) { int endpointCount = state.getEndpontCount(); context().parent().tell( new TenantActorStatusResponse(message.getRequestId(), endpointCount), ActorRef.noSender()); } } else { LOG.warn("[{}] State for status request is not found", message.getRequestId()); } }
private void checkHashAndSendNotification(ActorContext context, byte[] newHash, GlobalRouteInfo route) { if (!Arrays.equals(newHash, route.getUcfHash())) { LOG.trace("Sending notification to route {}", route); if (route.isLocal()) { context.parent() .tell( new EndpointUserConfigurationUpdateMessage(toUpdate(newHash, route)), context.self()); } else { eventService .sendEndpointStateInfo(route.getAddress().getServerId(), toUpdate(newHash, route)); } } else { LOG.trace("Ignoring notification to route {} due to matching hashes", route); } }
protected void sendEventsIfPresent(ActorContext context, EventClientSync request) { List<Event> events = request.getEvents(); if (state.getUserId() != null && events != null && !events.isEmpty()) { LOG.debug("[{}][{}] Processing events {} with seq number > {}", endpointKey, actorKey, events, state.getEventSeqNumber()); List<Event> eventsToSend = new ArrayList<>(events.size()); int maxSentEventSeqNum = state.getEventSeqNumber(); for (Event event : events) { if (event.getSeqNum() > state.getEventSeqNumber()) { event.setSource(endpointKey); eventsToSend.add(event); maxSentEventSeqNum = Math.max(event.getSeqNum(), maxSentEventSeqNum); } else { LOG.debug("[{}][{}] Ignoring duplicate/old event {} due to seq number < {}", endpointKey, actorKey, events, state.getEventSeqNumber()); } } state.setEventSeqNumber(maxSentEventSeqNum); if (!eventsToSend.isEmpty()) { EndpointEventSendMessage message = new EndpointEventSendMessage( state.getUserId(), eventsToSend, key, appToken, context.self()); context.parent().tell(message, context.self()); } } }
private void sendConnectToNewUser(ActorContext context, EndpointProfileDto endpointProfile) { List<EventClassFamilyVersion> ecfVersions = EntityConvertUtils.convertToEcfVersions( endpointProfile.getEcfVersionStates()); EndpointUserConnectMessage userRegistrationMessage = new EndpointUserConnectMessage( state.getUserId(), key, ecfVersions, endpointProfile.getConfigurationVersion(), endpointProfile.getUserConfigurationHash(), appToken, context.self()); LOG.debug("[{}][{}] Sending user registration request {}", endpointKey, actorKey, userRegistrationMessage); context.parent().tell(userRegistrationMessage, context.self()); }
protected void removeEndpoint(ActorContext context, EndpointObjectHash endpoint) { LOG.debug("[{}] removing endpoint [{}] from route tables", userId, endpoint); RouteTableAddress address = routeTable.removeLocal(endpoint); versionMap.remove(endpoint); for (String serverId : routeTable.getRemoteServers()) { LOG.debug("[{}] removing endpoint [{}] from remote route table on server {}", userId, endpoint, serverId); eventService.sendRouteInfo( RouteInfo.deleteRouteFromAddress(tenantId, userId, address), serverId); } // cleanup and notify global route actor GlobalRouteInfo route = GlobalRouteInfo.delete(tenantId, userId, address); if (eventService.isMainUserNode(userId)) { context.parent().tell(new EndpointRouteUpdateMessage(route), context.self()); } else { LOG.debug("[{}] Sending disconnect message to global actor", userId); eventService.sendEndpointRouteInfo(route); } }
private void processLogUpload(ActorContext context, ClientSync syncRequest, SyncContext responseHolder) { LogClientSync request = syncRequest.getLogSync(); if (request != null) { if (request.getLogEntries() != null && request.getLogEntries().size() > 0) { LOG.debug("[{}][{}] Processing log upload request {}", endpointKey, actorKey, request.getLogEntries().size()); EndpointProfileDataDto profileDto = convert(responseHolder.getEndpointProfile()); List<LogEvent> logEvents = new ArrayList<>(request.getLogEntries().size()); for (LogEntry logEntry : request.getLogEntries()) { LogEvent logEvent = new LogEvent(); logEvent.setLogData(logEntry.getData().array()); logEvents.add(logEvent); } BaseLogEventPack logPack = new BaseLogEventPack(profileDto, System.currentTimeMillis(), responseHolder.getEndpointProfile().getLogSchemaVersion(), logEvents); logPack.setUserId(state.getUserId()); context.parent().tell(new LogEventPackMessage( request.getRequestId(), context.self(), logPack), context.self()); } if (logUploadResponseMap.size() > 0) { responseHolder.getResponse().setLogSync(EntityConvertUtils.convert(logUploadResponseMap)); logUploadResponseMap.clear(); } } }