Package org.serviceconnector.service

Examples of org.serviceconnector.service.Subscription

73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
    int simulation = this.getParameterInt(request, "sim", 0);
    if (simulation > 0) {
      Subscription[] sim = new Subscription[simulation + subscriptions.length];
      System.arraycopy(subscriptions, 0, sim, 0, subscriptions.length);
      for (int i = subscriptions.length; i < simulation; i++) {
        sim[i] = new Subscription(null, "sim " + i, null, 0, 0.0, false);
         }
      subscriptions = sim;
     }
    Paging paging = this.writePagingAttributes(writer, request, subscriptions.length, "");
    // String showSessionsParameter = request.getParameter("showsessions");
    int startIndex = paging.getStartIndex();
    int endIndex = paging.getEndIndex();
    for (int i = startIndex; i < endIndex; i++) {
      Subscription subscription = subscriptions[i];
      writer.writeStartElement("subscription");
      this.writeBean(writer, subscription);
      writer.writeEndElement();
    }
    writer.writeEndElement(); // close subscriptions tag
View Full Code Here
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
    String serviceName = reqMessage.getServiceName();

    // check service is present
    Service abstractService = this.getService(serviceName);
    String cascSubscriptionId = reqMessage.getHeader(SCMPHeaderAttributeKey.CASCADED_SUBSCRIPTION_ID);
    Subscription cascSubscription = this.getSubscriptionById(cascSubscriptionId);
    String cascadedSCMask = reqMessage.getHeader(SCMPHeaderAttributeKey.CASCADED_MASK);
    int oti = reqMessage.getHeaderInt(SCMPHeaderAttributeKey.OPERATION_TIMEOUT);
    PublishMessageQueue<SCMPMessage> publishMessageQueue = ((IPublishService) cascSubscription.getService()).getMessageQueue();

    // update csc subscription id list for cascaded subscription
    cascSubscription.removeCscSubscriptionId(reqMessage.getSessionId());

    switch (abstractService.getType()) {
    case CASCADED_PUBLISH_SERVICE:
      CascadedPublishService cascadedPublishService = (CascadedPublishService) abstractService;
      // publish service is cascaded
      CascadedSC cascadedSC = cascadedPublishService.getCascadedSC();

      if (cascadedSCMask == null) {
        // unsubscribe made by cascaded SC on behalf of his last client
        this.subscriptionRegistry.removeSubscription(cascSubscription.getId());
        publishMessageQueue.unsubscribe(cascSubscription.getId());
        cascSubscription.getServer().removeSession(cascSubscription);
        SubscriptionLogger.logUnsubscribe(serviceName, cascSubscription.getId());
      } else {
        // unsubscribe made by cascaded SC on behalf of his clients
        SubscriptionMask cascSCMask = new SubscriptionMask(cascadedSCMask);
        publishMessageQueue.changeSubscription(cascSubscription.getId(), cascSCMask);
        cascSubscription.setMask(cascSCMask);
        SubscriptionLogger.logChangeSubscribe(serviceName, cascSubscription.getId(), cascadedSCMask);
      }
      CscUnsubscribeCallbackForCasc callback = new CscUnsubscribeCallbackForCasc(request, response, responderCallback,
          cascSubscription);
      cascadedSC.cascadedSCUnsubscribe(cascadedPublishService.getCascClient(), reqMessage, callback, oti);
      // delete unreferenced nodes in queue
      publishMessageQueue.removeNonreferencedNodes();
      return;
    default:
      // code for other types of services is below
      break;
    }

    if (cascadedSCMask == null) {
      // unsubscribe made by cascaded SC on behalf of his last client
      this.subscriptionRegistry.removeSubscription(cascSubscription.getId());
      publishMessageQueue.unsubscribe(cascSubscription.getId());
      cascSubscription.getServer().removeSession(cascSubscription);
      SubscriptionLogger.logUnsubscribe(serviceName, cascSubscription.getId());

      if (reqMessage.getSessionId() == null) {
        // no session id set, cascadedSC unsubscribe on his own because of an error
        SCMPMessage reply = new SCMPMessage();
        reply.setIsReply(true);
        reply.setServiceName(serviceName);
        reply.setMessageType(getKey());
        // no need to forward to server
        response.setSCMP(reply);
        responderCallback.responseCallback(request, response);
        // delete unreferenced nodes in queue
        publishMessageQueue.removeNonreferencedNodes();
        this.abortCascSubscriptions(cascSubscription);
        return;
      }
    } else {
      // unsubscribe made by cascaded SC on behalf of his clients
      SubscriptionMask cascSCMask = new SubscriptionMask(cascadedSCMask);
      publishMessageQueue.changeSubscription(cascSubscription.getId(), cascSCMask);
      cascSubscription.setMask(cascSCMask);
      SubscriptionLogger.logChangeSubscribe(serviceName, cascSubscription.getId(), cascadedSCMask);
    }
    // use server of cascaded client to unsubscribe
    StatefulServer server = (StatefulServer) cascSubscription.getServer();

    // unsubscribe on backend server
    CscUnsubscribeCommandCallback callback;
    int otiOnSCMillis = (int) (oti * basicConf.getOperationTimeoutMultiplier());
    int tries = (otiOnSCMillis / Constants.WAIT_FOR_FREE_CONNECTION_INTERVAL_MILLIS);
View Full Code Here
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
  @Override
  public void run(IRequest request, IResponse response, IResponderCallback responderCallback) throws Exception {
    SCMPMessage reqMessage = request.getMessage();
    String subscriptionId = reqMessage.getSessionId();
    SCMPMessage message = null;
    Subscription subscription = this.getSubscriptionById(subscriptionId);
    // looks up subscription queue
    PublishMessageQueue<SCMPMessage> publishMessageQueue = this.getPublishMessageQueueById(subscription);
    synchronized (publishMessageQueue) {
      // reset subscription timeout to NOI+ECI
      this.subscriptionRegistry.resetSubscriptionTimeout(subscription,
          subscription.getNoDataIntervalMillis() + subscription.getSubscriptionTimeoutMillis());
      // tries polling message
      message = publishMessageQueue.getMessageOrListen(subscriptionId, request, response);
      if (message == null) {
        // no message available, switched to listening mode for new message
        return;
      }
    }
    LOGGER.debug("CRP message found in queue subscriptionId " + subscriptionId);
    // message found in subscription queue set up reply
    SCMPMessage reply = new SCMPMessage();
    if (message.isPart()) {
      // message from queue is of type part - outgoing must be part too, no poll request
      reply = new SCMPPart(false);
    }
    reply.setServiceName(reqMessage.getServiceName());
    reply.setSessionId(reqMessage.getSessionId());
    reply.setMessageType(reqMessage.getMessageType());
    reply.setIsReply(true);
    reply.setBody(message.getBody());
    reply.setHeader(SCMPHeaderAttributeKey.MESSAGE_SEQUENCE_NR, message.getMessageSequenceNr());
    String messageInfo = message.getHeader(SCMPHeaderAttributeKey.MSG_INFO);
    if (messageInfo != null) {
      reply.setHeader(SCMPHeaderAttributeKey.MSG_INFO, messageInfo);
    }
    reply.setHeader(SCMPHeaderAttributeKey.MASK, message.getHeader(SCMPHeaderAttributeKey.MASK));
    response.setSCMP(reply);
    // reset subscription timeout to ECI
    this.subscriptionRegistry.resetSubscriptionTimeout(subscription, subscription.getSubscriptionTimeoutMillis());
    // message already gotten from queue no asynchronous process necessary call callback right away
    responderCallback.responseCallback(request, response);
  }
View Full Code Here
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
    String serviceName = reqMessage.getServiceName();

    // check service is present
    Service abstractService = this.getService(serviceName);
    String cascSubscriptionId = reqMessage.getHeader(SCMPHeaderAttributeKey.CASCADED_SUBSCRIPTION_ID);
    Subscription cascSubscription = this.getSubscriptionById(cascSubscriptionId);
    String cascadedSCMask = reqMessage.getHeader(SCMPHeaderAttributeKey.CASCADED_MASK);
    int oti = reqMessage.getHeaderInt(SCMPHeaderAttributeKey.OPERATION_TIMEOUT);

    // update csc subscription id list for cascaded subscription
    cascSubscription.removeCscSubscriptionId(reqMessage.getSessionId());

    switch (abstractService.getType()) {
    case CASCADED_PUBLISH_SERVICE:
      CascadedPublishService cascadedPublishService = (CascadedPublishService) abstractService;
      // publish service is cascaded
      CascadedSC cascadedSC = cascadedPublishService.getCascadedSC();

      PublishMessageQueue<SCMPMessage> queue = ((IPublishService) cascSubscription.getService()).getMessageQueue();
      if (cascadedSCMask == null) {
        // subscription abort made by cascaded SC on behalf of his last client
        this.subscriptionRegistry.removeSubscription(cascSubscription.getId());
        queue.unsubscribe(cascSubscription.getId());
        cascSubscription.getServer().removeSession(cascSubscription);
        SubscriptionLogger.logUnsubscribe(serviceName, cascSubscription.getId());
      } else {
        // unsubscribe made by cascaded SC on behalf of a clients, others are left
        SubscriptionMask cascSCMask = new SubscriptionMask(cascadedSCMask);
        queue.changeSubscription(cascSubscription.getId(), cascSCMask);
        cascSubscription.setMask(cascSCMask);
        SubscriptionLogger.logChangeSubscribe(serviceName, cascSubscription.getId(), cascadedSCMask);
      }
      CscAbortSubscriptionCommandCallback callback = new CscAbortSubscriptionCommandCallback(request, response,
          responderCallback, cascSubscription);
      cascadedSC.cascadedSCAbortSubscription(cascadedPublishService.getCascClient(), reqMessage, callback, oti);
      return;
    default:
      // code for other types of services is below
      break;
    }
    StatefulServer server = (StatefulServer) cascSubscription.getServer();

    PublishMessageQueue<SCMPMessage> publishMessageQueue = ((IPublishService) cascSubscription.getService()).getMessageQueue();
    if (cascadedSCMask == null) {
      // subscription abort made by cascaded SC on behalf of his last client
      this.subscriptionRegistry.removeSubscription(cascSubscription.getId());
      publishMessageQueue.unsubscribe(cascSubscription.getId());
      cascSubscription.getServer().removeSession(cascSubscription);
      SubscriptionLogger.logUnsubscribe(serviceName, cascSubscription.getId());
    } else {
      // unsubscribe made by cascaded SC on behalf of a clients, others are left
      SubscriptionMask cascSCMask = new SubscriptionMask(cascadedSCMask);
      publishMessageQueue.changeSubscription(cascSubscription.getId(), cascSCMask);
      cascSubscription.setMask(cascSCMask);
      SubscriptionLogger.logChangeSubscribe(serviceName, cascSubscription.getId(), cascadedSCMask);
    }
    // set up abort message
    SCMPMessage abortMessage = new SCMPMessage();
    abortMessage.setHeader(SCMPHeaderAttributeKey.SC_ERROR_CODE, SCMPError.SESSION_ABORT.getErrorCode());
    abortMessage.setHeader(SCMPHeaderAttributeKey.SC_ERROR_TEXT,
View Full Code Here
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
    String serviceName = reqMessage.getServiceName();

    // check service is present
    Service abstractService = this.getService(serviceName);
    String subscriptionId = reqMessage.getSessionId();
    Subscription subscription = this.getSubscriptionById(subscriptionId);

    // enhance ipAddressList
    String ipAddressList = reqMessage.getHeader(SCMPHeaderAttributeKey.IP_ADDRESS_LIST);
    ipAddressList = ipAddressList + Constants.SLASH + request.getRemoteSocketAddress().getAddress().getHostAddress();
    reqMessage.setHeader(SCMPHeaderAttributeKey.IP_ADDRESS_LIST, ipAddressList);
    reqMessage.setHeader(SCMPHeaderAttributeKey.ACTUAL_MASK, subscription.getMask().getValue());

    int oti = reqMessage.getHeaderInt(SCMPHeaderAttributeKey.OPERATION_TIMEOUT);

    switch (abstractService.getType()) {
    case CASCADED_PUBLISH_SERVICE:
      CascadedPublishService cascadedPublishService = (CascadedPublishService) abstractService;
      // publish service is cascaded
      CascadedSC cascadedSC = cascadedPublishService.getCascadedSC();
      ClnChangeSubscriptionCommandCallback callback = new ClnChangeSubscriptionCommandCallback(request, response,
          responderCallback, subscription);
      cascadedSC.cascadedSCChangeSubscription(cascadedPublishService.getCascClient(), reqMessage, callback, oti);
      return;
    default:
      // code for other types of services is below
      break;
    }

    ClnChangeSubscriptionCommandCallback callback = null;
    StatefulServer server = (StatefulServer) subscription.getServer();
    int otiOnSCMillis = (int) (oti * basicConf.getOperationTimeoutMultiplier());
    int tries = (otiOnSCMillis / Constants.WAIT_FOR_FREE_CONNECTION_INTERVAL_MILLIS);
    // Following loop implements the wait mechanism in case of a busy connection pool
    int i = 0;

View Full Code Here
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
    Service abstractService = this.getService(serviceName);
    int oti = reqMessage.getHeaderInt(SCMPHeaderAttributeKey.OPERATION_TIMEOUT);
    // service is cascaded - unsubscribe is made by a normal client
    String subscriptionId = reqMessage.getSessionId();
    // lookup session and checks properness
    Subscription subscription = this.getSubscriptionById(subscriptionId);
    // looks up publish message queue and stops publish mechanism
    PublishMessageQueue<SCMPMessage> publishMessageQueue = this.getPublishMessageQueueById(subscription);
    // first remove subscription than unsubscribe
    this.subscriptionRegistry.removeSubscription(subscription);
    publishMessageQueue.unsubscribe(subscriptionId);

    switch (abstractService.getType()) {
    case CASCADED_PUBLISH_SERVICE:
      CascadedPublishService cascadedPublishService = (CascadedPublishService) abstractService;
      // publish service is cascaded
      CascadedSC cascadedSC = cascadedPublishService.getCascadedSC();
      // free server from subscription
      cascadedSC.removeSession(subscription);
      ClnUnsubscribeCommandCallback callback = new ClnUnsubscribeCommandCallback(request, response, responderCallback,
          subscription);
      cascadedSC.cascadedSCUnsubscribe(cascadedPublishService.getCascClient(), reqMessage, callback, oti);
      return;
    default:
      // code for other types of services is below
      break;
    }
    StatefulServer server = (StatefulServer) subscription.getServer();
    ClnUnsubscribeCommandCallback callback = null;
    int otiOnSCMillis = (int) (oti * basicConf.getOperationTimeoutMultiplier());
    int tries = (otiOnSCMillis / Constants.WAIT_FOR_FREE_CONNECTION_INTERVAL_MILLIS);
    int i = 0;
    // Following loop implements the wait mechanism in case of a busy connection pool
View Full Code Here
95
96
97
98
99
100
101
102
103
104
105
   * @return the subscription by id
   * @throws SCMPCommandException
   *             the sCMP command exception
   */
  protected Subscription getSubscriptionById(String subscriptionId) throws SCMPCommandException {
    Subscription subscription = this.subscriptionRegistry.getSubscription(subscriptionId);

    if (subscription == null) {
      // subscription not found in registry
      LOGGER.info("subscription not found sid=" + subscriptionId);
      SCMPCommandException scmpCommandException = new SCMPCommandException(SCMPError.SUBSCRIPTION_NOT_FOUND, subscriptionId);
View Full Code Here
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
  @Override
  public void receive(SCMPMessage reply) {
    boolean rejectSubscriptionFlag = reply.getHeaderFlag(SCMPHeaderAttributeKey.REJECT_SESSION);
    if (reply.isFault() == false && rejectSubscriptionFlag == false) {
      // subscription successfully created
      Subscription cscScSubscription = this.commandCallback.getSubscription();
      try {
        // forward reply to client
        this.commandCallback.receive(reply);
        // adding client subscription id to cascaded client
        this.cascClient.addClientSubscriptionId(cscScSubscription.getId(), cscScSubscription.getMask());
        if (cscScSubscription.isCascaded() == true) {
          // update csc subscription id list for cascaded subscription
          cscScSubscription.addCscSubscriptionId(this.request.getMessage().getSessionId(), new SubscriptionMask(request
              .getMessage().getHeader(SCMPHeaderAttributeKey.MASK)));
        }
        this.cascClient.setSubscriptionMask(new SubscriptionMask(this.request.getMessage().getHeader(
            SCMPHeaderAttributeKey.CASCADED_MASK)));
        // release permit
View Full Code Here
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
  @Override
  public void receive(SCMPMessage reply) {
    boolean rejectSubscriptionFlag = reply.getHeaderFlag(SCMPHeaderAttributeKey.REJECT_SESSION);
    if (reply.isFault() == false && rejectSubscriptionFlag == false) {
      // subscription successfully created
      Subscription cscScSubscription = this.commandCallback.getSubscription();
      try {
        // forward reply to client
        this.commandCallback.receive(reply);
        // adding client subscription id to cascaded client
        this.cascClient.addClientSubscriptionId(cscScSubscription.getId(), cscScSubscription.getMask());
        this.cascClient.setSubscriptionMask(new SubscriptionMask(this.request.getMessage().getHeader(
            SCMPHeaderAttributeKey.CASCADED_MASK)));
        // release permit
        this.cascClient.getCascClientSemaphore().release();
        return;
View Full Code Here
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
  /** {@inheritDoc} */
  @Override
  public void receive(SCMPMessage reply) {
    boolean rejectSubscriptionFlag = reply.getHeaderFlag(SCMPHeaderAttributeKey.REJECT_SESSION);
    if (reply.isFault() == false && rejectSubscriptionFlag == false) {
      Subscription cscScSubscription = this.commandCallback.getSubscription();
      try {
        // needs to be done before, reply changes in receive
        this.cascClient.setSubscriptionId(reply.getSessionId());
        // forward reply to client
        this.commandCallback.receive(reply);
        // subscription successfully created
        this.cascClient.setSubscribed(true);
        this.cascClient.setSubscriptionMask(new SubscriptionMask(tmpCscMask));
        this.cascClient.receivePublication();
        // adding client subscription id to cascaded client
        this.cascClient.addClientSubscriptionId(cscScSubscription.getId(), cscScSubscription.getMask());
        if (cscScSubscription.isCascaded() == true) {
          // update csc subscription id list for cascaded subscription
          cscScSubscription.addCscSubscriptionId(this.commandCallback.getRequest().getMessage().getSessionId(),
              new SubscriptionMask(this.tmpCscMask));
        }
        // release permit
        this.cascClient.getCascClientSemaphore().release();
        return;
View Full Code Here
TOP

Related Classes of org.serviceconnector.service.Subscription

  • org.serviceconnector.cmd.casc.CscChangeSubscriptionActiveCascClientCallback
  • org.serviceconnector.cmd.casc.CscSubscribeActiveCascClientCallback
  • org.serviceconnector.cmd.casc.CscSubscribeInactiveCascClientCallback
  • org.serviceconnector.cmd.sc.ClnChangeSubscriptionCommand
  • org.serviceconnector.cmd.sc.ClnSubscribeCommand
  • org.serviceconnector.cmd.sc.ClnUnsubscribeCommand
  • org.serviceconnector.cmd.sc.CommandAdapter
  • org.serviceconnector.cmd.sc.CscAbortSubscriptionCommand
  • org.serviceconnector.cmd.sc.CscChangeSubscriptionCommand
  • org.serviceconnector.cmd.sc.CscSubscribeCommand
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.