protected void tellActor(ActorContext context, ActorRef target, Object message) { target.tell(message, context.self()); }
private void processClusterUpdate(ClusterUpdateMessage message) { for (Entry<EndpointObjectHash, LocalEndpointActorMetaData> entry : localEndpointSessions.entrySet()) { String globalActorNodeId = getGlobalEndpointActorNodeId(entry.getKey()); if (!globalActorNodeId.equals(entry.getValue().globalActorNodeId)) { entry.getValue().globalActorNodeId = globalActorNodeId; notifyGlobalEndpointActor(entry.getKey(), globalActorNodeId); } } for (GlobalEndpointActorMetaData entry : globalEndpointSessions.values()) { entry.actorRef.tell(message, context().self()); } }
private void forwardMessageQuietly(EndpointActorMetaData actorMetaData, Object msg) { if (actorMetaData != null) { actorMetaData.actorRef.tell(msg, context().self()); } }
protected void sendEventToLocal(ActorContext context, EndpointEventReceiveMessage message) { context.parent().tell(message, context.self()); }
/** * Process a cluster update. * * @param context actor context */ public void processClusterUpdate(ActorContext context) { if (!clusterService.isMainEntityNode(key)) { LOG.debug("[{}] No longer a global endpoint node for {}", endpointKey); routes.clear(); context.stop(context.self()); } }
/** * Process cluster update. * * @param context the actor context */ public void processClusterUpdate(ActorContext context) { if (!eventService.isMainUserNode(userId)) { LOG.trace("No longer a global user node for user {}", userId); map.clear(); context.stop(context.self()); } }
protected void tellParent(ActorContext context, Object response) { context.parent().tell(response, context.self()); }
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()); }
/** * Forward message to OperationsServerActor. * */ public void forward(ActorContext context, SessionAware message) { if (isSdkTokenValid(message.getSessionInfo().getSdkToken())) { LOG.debug("Forwarding session aware message: {}", message); this.opsActor.tell(message, context.self()); } else { LOG.debug("Session aware message ignored. Reason: message {} has invalid sdk token", message); } }
/** * Process an actor timeout message. * * @param context actor context * @param message actor timeout message */ public void processActorTimeoutMessage(ActorContext context, ActorTimeoutMessage message) { if (state.getLastActivityTime() <= message.getLastActivityTime()) { LOG.debug("[{}][{}] Request stop of endpoint actor due to inactivity timeout", endpointKey, actorKey); tellParent(context, new EndpointStopMessage(key, actorKey, 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()); }
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 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 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 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(); } } }
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 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); } }