Examples with SessionInfoProto org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto used on opensource projects

Example 1 with SessionInfoProto

use of org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto in project thingsboard by thingsboard.

the class DefaultLwM2mUplinkMsgHandler method onRegistered.

/**
 * Start registration device
 * Create session: Map<String <registrationId >, LwM2MClient>
 * 1. replaceNewRegistration -> (solving the problem of incorrect termination of the previous session with this endpoint)
 * 1.1 When we initialize the registration, we register the session by endpoint.
 * 1.2 If the server has incomplete requests (canceling the registration of the previous session),
 * delete the previous session only by the previous registration.getId
 * 1.2 Add Model (Entity) for client (from registration & observe) by registration.getId
 * 1.2 Remove from sessions Model by enpPoint
 * Next ->  Create new LwM2MClient for current session -> setModelClient...
 *
 * @param registration         - Registration LwM2M Client
 * @param previousObservations - may be null
 */
public void onRegistered(Registration registration, Collection<Observation> previousObservations) {
    executor.submit(() -> {
        LwM2mClient lwM2MClient = this.clientContext.getClientByEndpoint(registration.getEndpoint());
        try {
            log.debug("[{}] [{{}] Client: create after Registration", registration.getEndpoint(), registration.getId());
            Optional<SessionInfoProto> oldSessionInfo = this.clientContext.register(lwM2MClient, registration);
            if (oldSessionInfo.isPresent()) {
                log.info("[{}] Closing old session: {}", registration.getEndpoint(), new UUID(oldSessionInfo.get().getSessionIdMSB(), oldSessionInfo.get().getSessionIdLSB()));
                sessionManager.deregister(oldSessionInfo.get());
            }
            logService.log(lwM2MClient, LOG_LWM2M_INFO + ": Client registered with registration id: " + registration.getId() + " version: " + registration.getLwM2mVersion() + " and modes: " + registration.getQueueMode() + ", " + registration.getBindingMode());
            sessionManager.register(lwM2MClient.getSession());
            this.initClientTelemetry(lwM2MClient);
            this.initAttributes(lwM2MClient, true);
            otaService.init(lwM2MClient);
            lwM2MClient.getRetryAttempts().set(0);
        } catch (LwM2MClientStateException stateException) {
            if (LwM2MClientState.UNREGISTERED.equals(stateException.getState())) {
                log.info("[{}] retry registration due to race condition: [{}].", registration.getEndpoint(), stateException.getState());
                // Race condition detected and the client was in progress of unregistration while new registration arrived. Let's try again.
                if (lwM2MClient.getRetryAttempts().incrementAndGet() <= 5) {
                    context.getScheduler().schedule(() -> onRegistered(registration, previousObservations), 1, TimeUnit.SECONDS);
                } else {
                    logService.log(lwM2MClient, LOG_LWM2M_WARN + ": Client registration failed due to retry attempts: " + lwM2MClient.getRetryAttempts().get());
                }
            } else {
                logService.log(lwM2MClient, LOG_LWM2M_WARN + ": Client registration failed due to invalid state: " + stateException.getState());
            }
        } catch (Throwable t) {
            log.error("[{}] endpoint [{}] error Unable registration.", registration.getEndpoint(), t);
            logService.log(lwM2MClient, LOG_LWM2M_WARN + ": Client registration failed due to: " + t.getMessage());
        }
    });
}

Example 2 with SessionInfoProto

use of org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto in project thingsboard by thingsboard.

the class DeviceActorMessageProcessor method restoreSessions.

void restoreSessions() {
    if (systemContext.isLocalCacheType()) {
        return;
    }
    log.debug("[{}] Restoring sessions from cache", deviceId);
    DeviceSessionsCacheEntry sessionsDump = null;
    try {
        sessionsDump = DeviceSessionsCacheEntry.parseFrom(systemContext.getDeviceSessionCacheService().get(deviceId));
    } catch (InvalidProtocolBufferException e) {
        log.warn("[{}] Failed to decode device sessions from cache", deviceId);
        return;
    }
    if (sessionsDump.getSessionsCount() == 0) {
        log.debug("[{}] No session information found", deviceId);
        return;
    }
    // TODO: Take latest max allowed sessions size from cache
    for (SessionSubscriptionInfoProto sessionSubscriptionInfoProto : sessionsDump.getSessionsList()) {
        SessionInfoProto sessionInfoProto = sessionSubscriptionInfoProto.getSessionInfo();
        UUID sessionId = getSessionId(sessionInfoProto);
        SessionInfo sessionInfo = new SessionInfo(SessionType.ASYNC, sessionInfoProto.getNodeId());
        SubscriptionInfoProto subInfo = sessionSubscriptionInfoProto.getSubscriptionInfo();
        SessionInfoMetaData sessionMD = new SessionInfoMetaData(sessionInfo, subInfo.getLastActivityTime());
        sessions.put(sessionId, sessionMD);
        if (subInfo.getAttributeSubscription()) {
            attributeSubscriptions.put(sessionId, sessionInfo);
            sessionMD.setSubscribedToAttributes(true);
        }
        if (subInfo.getRpcSubscription()) {
            rpcSubscriptions.put(sessionId, sessionInfo);
            sessionMD.setSubscribedToRPC(true);
        }
        log.debug("[{}] Restored session: {}", deviceId, sessionMD);
    }
    log.debug("[{}] Restored sessions: {}, rpc subscriptions: {}, attribute subscriptions: {}", deviceId, sessions.size(), rpcSubscriptions.size(), attributeSubscriptions.size());
}

Example 3 with SessionInfoProto

use of org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto in project thingsboard by thingsboard.

the class DeviceActorMessageProcessor method processUplinkNotificationMsg.

private void processUplinkNotificationMsg(TbActorCtx context, SessionInfoProto sessionInfo, TransportProtos.UplinkNotificationMsg uplinkNotificationMsg) {
    String nodeId = sessionInfo.getNodeId();
    sessions.entrySet().stream().filter(kv -> kv.getValue().getSessionInfo().getNodeId().equals(nodeId) && (kv.getValue().isSubscribedToAttributes() || kv.getValue().isSubscribedToRPC())).forEach(kv -> {
        ToTransportMsg msg = ToTransportMsg.newBuilder().setSessionIdMSB(kv.getKey().getMostSignificantBits()).setSessionIdLSB(kv.getKey().getLeastSignificantBits()).setUplinkNotificationMsg(uplinkNotificationMsg).build();
        systemContext.getTbCoreToTransportService().process(kv.getValue().getSessionInfo().getNodeId(), msg);
    });
}

Example 4 with SessionInfoProto

use of org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto in project thingsboard by thingsboard.

the class DeviceActorMessageProcessor method dumpSessions.

private void dumpSessions() {
    if (systemContext.isLocalCacheType()) {
        return;
    }
    log.debug("[{}] Dumping sessions: {}, rpc subscriptions: {}, attribute subscriptions: {} to cache", deviceId, sessions.size(), rpcSubscriptions.size(), attributeSubscriptions.size());
    List<SessionSubscriptionInfoProto> sessionsList = new ArrayList<>(sessions.size());
    sessions.forEach((uuid, sessionMD) -> {
        if (sessionMD.getSessionInfo().getType() == SessionType.SYNC) {
            return;
        }
        SessionInfo sessionInfo = sessionMD.getSessionInfo();
        SubscriptionInfoProto subscriptionInfoProto = SubscriptionInfoProto.newBuilder().setLastActivityTime(sessionMD.getLastActivityTime()).setAttributeSubscription(sessionMD.isSubscribedToAttributes()).setRpcSubscription(sessionMD.isSubscribedToRPC()).build();
        SessionInfoProto sessionInfoProto = SessionInfoProto.newBuilder().setSessionIdMSB(uuid.getMostSignificantBits()).setSessionIdLSB(uuid.getLeastSignificantBits()).setNodeId(sessionInfo.getNodeId()).build();
        sessionsList.add(SessionSubscriptionInfoProto.newBuilder().setSessionInfo(sessionInfoProto).setSubscriptionInfo(subscriptionInfoProto).build());
        log.debug("[{}] Dumping session: {}", deviceId, sessionMD);
    });
    systemContext.getDeviceSessionCacheService().put(deviceId, DeviceSessionsCacheEntry.newBuilder().addAllSessions(sessionsList).build().toByteArray());
}

Example 5 with SessionInfoProto

use of org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto in project thingsboard by thingsboard.

the class DefaultLwM2mUplinkMsgHandler method doUnReg.

private void doUnReg(Registration registration, LwM2mClient client) {
    try {
        logService.log(client, LOG_LWM2M_INFO + ": Client unRegistration");
        clientContext.unregister(client, registration);
        SessionInfoProto sessionInfo = client.getSession();
        if (sessionInfo != null) {
            sessionManager.deregister(sessionInfo);
            sessionStore.remove(registration.getEndpoint());
            log.info("Client close session: [{}] unReg [{}] name  [{}] profile ", registration.getId(), registration.getEndpoint(), sessionInfo.getDeviceType());
        } else {
            log.error("Client close session: [{}] unReg [{}] name  [{}] sessionInfo ", registration.getId(), registration.getEndpoint(), null);
        }
    } catch (LwM2MClientStateException stateException) {
        log.info("[{}] delete registration: [{}] {}.", registration.getEndpoint(), stateException.getState(), stateException.getMessage());
    } catch (Throwable t) {
        log.error("[{}] endpoint [{}] error Unable un registration.", registration.getEndpoint(), t);
        logService.log(client, LOG_LWM2M_ERROR + String.format(": Client Unable un Registration, %s", t.getMessage()));
    }
}