public static ReliableSubscriptionService create(Operation subscribe, ServiceSubscriber sr, Consumer<Operation> notificationConsumer) { if (subscribe == null) { throw new IllegalArgumentException("subscribe operation is required"); } if (sr == null) { throw new IllegalArgumentException("subscribe request is required"); } if (notificationConsumer == null) { throw new IllegalArgumentException("notificationConsumer is required"); } ReliableSubscriptionService rss = new ReliableSubscriptionService(subscribe, sr, notificationConsumer); return rss; }
@Override public void handleStart(Operation startPost) { this.subscribeRequest.reference = UriUtils.buildPublicUri(getHost(), getSelfLink()); // we subscribe to the node group associated with our instance. The client should // set the node selector on this service, to match the one on the publisher sendRequest(Operation.createGet(this, getPeerNodeSelectorPath()).setCompletion( (o, e) -> { if (e != null) { startPost.fail(e); return; } NodeSelectorState nss = o.getBody(NodeSelectorState.class); URI callbackUri = getHost().startSubscriptionService( Operation.createPost(this, nss.nodeGroupLink).setReferer(getUri()), this::handleNodeGroupNotification); this.nodeGroupCallbackUri = callbackUri; startPost.complete(); })); }
private void checkAndReSubscribe() { if (getHost().isStopping()) { return; } Operation getSubscriptions = this.subscribeOp.clone().setAction(Action.GET); sendRequest(getSubscriptions.setCompletion((o, e) -> { if (e != null) { selfDeleteDueToFailure(o, e); return; } resubscribe(o); })); }
private void selfDeleteDueToFailure(Operation o, Throwable e) { if (getHost().isStopping()) { return; } logSevere("%s to %s failed with %s :", o.getAction(), o.getUri(), e.toString()); // self DELETE. The client, if they implemented handleRequest on the service instance // will be able to tell something went wrong sendRequest(Operation.createDelete(getUri()) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_NOTIFICATION) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_SKIPPED_NOTIFICATIONS)); } }
private void resubscribe(Operation o) { if (getHost().isStopping()) { return; } // verify we are still included in the publisher's subscriptions ServiceSubscriptionState rsp = o.getBody(ServiceSubscriptionState.class); for (ServiceSubscriber item : rsp.subscribers.values()) { if (item.reference != null && item.reference.getPath().equals(getSelfLink())) { // we found our subscription, all is good. return; } } logWarning("Subscription missing from %s, resubscribing", o.getUri()); Operation reSubscribe = this.subscribeOp.clone() .setBody(this.subscribeRequest) .setCompletion((subOp, subE) -> { if (subE != null) { selfDeleteDueToFailure(subOp, subE); } }); sendRequest(reSubscribe); }
/** * Start a {@code ReliableSubscriptionService} service and using it as the target, subscribe to the * service specified in the subscribe operation URI. Note that this won't replay state: * use the version of startSubscriptionService that takes the ServiceSubscriber as an option * to get that. */ public URI startReliableSubscriptionService( Operation subscribe, Consumer<Operation> notificationConsumer) { ServiceSubscriber sr = ServiceSubscriber.create(false).setUsePublicUri(true); ReliableSubscriptionService notificationTarget = ReliableSubscriptionService.create( subscribe, sr, notificationConsumer); return startSubscriptionService(subscribe, notificationTarget, sr); }
if (getHost().isStopping()) { return; boolean isAvailable = NodeState.isAvailable(ns, getHost().getId(), false); if (isAvailable) { healthyPeerUri = ns.groupReference; logInfo("group update notification but not group not converged"); return; checkAndReSubscribe();
/** * Helper routine to subscribe to notifications * @param host service host to invoke the operation * @param onSuccessConsumer consumer callback to invoke on notification * @param onFailureConsumer consumer callback to invoke on failure * @param taskLink link to the task to subscribe to */ public static void subscribeToNotifications(ServiceHost host, Consumer<Operation> onSuccessConsumer, Consumer<Throwable> onFailureConsumer, String taskLink) { ServiceSubscriber subscribeBody = new ServiceSubscriber(); subscribeBody.replayState = true; subscribeBody.usePublicUri = true; Operation subscribeOp = Operation .createPost(host, taskLink) .setReferer(host.getUri()) .setCompletion((regOp, regEx) -> { if (regEx != null) { onFailureConsumer.accept(regEx); } }); ReliableSubscriptionService notificationTarget = ReliableSubscriptionService.create( subscribeOp, subscribeBody, onSuccessConsumer); host.startSubscriptionService(subscribeOp, notificationTarget, subscribeBody); }
public static void subscribeToNotifications(StatefulService service, Consumer<Operation> notificationConsumer, String taskLink) { ServiceSubscriber subscribeBody = new ServiceSubscriber(); subscribeBody.replayState = true; subscribeBody.usePublicUri = true; Operation subscribeOp = Operation .createPost(service, taskLink) .setReferer(service.getUri()) .setCompletion( (regOp, regEx) -> { if (regEx != null) { sendFailureSelfPatch(service, regEx); return; } }); ReliableSubscriptionService notificationTarget = ReliableSubscriptionService.create( subscribeOp, subscribeBody, notificationConsumer); service.getHost().startSubscriptionService(subscribeOp, notificationTarget, subscribeBody); }
@Override public void handleStop(Operation op) { // Delete the node group subscription which was created at handleStart. sendRequest(Operation.createGet(this, getPeerNodeSelectorPath()).setCompletion( (o, e) -> { if (e != null) { op.fail(e); return; } NodeSelectorState nss = o.getBody(NodeSelectorState.class); Operation delete = Operation.createDelete(this, nss.nodeGroupLink).setReferer(getUri()); getHost().stopSubscriptionService(delete, this.nodeGroupCallbackUri); op.complete(); })); }
public static void subscribeToNotifications(StatefulService service, Consumer<Operation> notificationConsumer, String taskLink) { ServiceSubscriber subscribeBody = new ServiceSubscriber(); subscribeBody.replayState = true; subscribeBody.usePublicUri = true; Operation subscribeOp = Operation .createPost(service, taskLink) .setReferer(service.getUri()) .setCompletion( (regOp, regEx) -> { if (regEx != null) { sendFailureSelfPatch(service, regEx); return; } }); ReliableSubscriptionService notificationTarget = ReliableSubscriptionService.create( subscribeOp, subscribeBody, notificationConsumer); service.getHost().startSubscriptionService(subscribeOp, notificationTarget, subscribeBody); }
StatelessService notificationTarget = ReliableSubscriptionService.create(subscribe, sr, (op) -> handleNotification(op, notificationHandler));
ReliableSubscriptionService notificationTarget = ReliableSubscriptionService.create( subscribe, sr, notifyC); getHost().startSubscriptionService(subscribe, notificationTarget, sr);