@Override public void subscribe() { /* subscribe to DB events */ _messageBus.subscribe(EventTypes.EVENT_PROJECT_CREATE, MessageDispatcher.getDispatcher(this)); _messageBus.subscribe(EventTypes.EVENT_PROJECT_DELETE, MessageDispatcher.getDispatcher(this)); _messageBus.subscribe(EventTypes.EVENT_DOMAIN_CREATE, MessageDispatcher.getDispatcher(this)); _messageBus.subscribe(EventTypes.EVENT_DOMAIN_DELETE, MessageDispatcher.getDispatcher(this)); } }
public void notifySubscribers(String senderAddress, String subject, Object args) { for (MessageSubscriber subscriber : _subscribers) { subscriber.onPublishMessage(senderAddress, subject, args); } }
public void close() { if (_subjects != null) { assert (_messageBus != null); for (String subject : _subjects) { _messageBus.unsubscribe(subject, this); } } }
public void open(MessageBus messageBus, String[] subjects) { assert (messageBus != null); assert (subjects != null); _messageBus = messageBus; _subjects = subjects; if (subjects != null) { for (String subject : subjects) { messageBus.subscribe(subject, this); } } }
public void Publish(String subject, Object args) { assert (_eventBus != null); _eventBus.publish(_sender, subject, _scope, args); } }
@Override public void prune() { if (_gate.enter()) { if (s_logger.isTraceEnabled()) { s_logger.trace("Enter gate in message bus prune"); } try { doPrune(); } finally { _gate.leave(); } } else { synchronized (_pendingActions) { _pendingActions.add(new ActionRecord(ActionType.Prune, null, null)); } } }
@Override public void subscribe(String subject, MessageSubscriber subscriber) { assert (subject != null); assert (subscriber != null); if (_gate.enter()) { if (s_logger.isTraceEnabled()) { s_logger.trace("Enter gate in message bus subscribe"); } try { SubscriptionNode current = locate(subject, null, true); assert (current != null); current.addSubscriber(subscriber); } finally { _gate.leave(); } } else { synchronized (_pendingActions) { _pendingActions.add(new ActionRecord(ActionType.Subscribe, subject, subscriber)); } } }
@Override public void unsubscribe(String subject, MessageSubscriber subscriber) { if (_gate.enter()) { if (s_logger.isTraceEnabled()) { s_logger.trace("Enter gate in message bus unsubscribe"); } try { if (subject != null) { SubscriptionNode current = locate(subject, null, false); if (current != null) current.removeSubscriber(subscriber, false); } else { _subscriberRoot.removeSubscriber(subscriber, true); } } finally { _gate.leave(); } } else { synchronized (_pendingActions) { _pendingActions.add(new ActionRecord(ActionType.Unsubscribe, subject, subscriber)); } } }
public MessageBusBase() { _gate = new Gate(); _pendingActions = new ArrayList<ActionRecord>(); _subscriberRoot = new SubscriptionNode(null, "/", null); }
@Override public void onPublishMessage(String senderAddress, String subject, Object args) { dispatch(_targetObject, subject, senderAddress, args); }
public boolean enter() { return enter(false); }
@Override public void onPublishMessage(String senderAddress, String subject, Object args) { if (subjectMatched(subject)) { synchronized (this) { notifyAll(); } } }
public MessageDispatcher(Object targetObject) { _targetObject = targetObject; buildHandlerMethodCache(targetObject.getClass()); }
private SubscriptionNode locate(String subject, List<SubscriptionNode> chainFromTop, boolean createPath) { assert (subject != null); // "/" is special name for root node if (subject.equals("/")) return _subscriberRoot; String[] subjectPathTokens = subject.split("\\."); return locate(subjectPathTokens, _subscriberRoot, chainFromTop, createPath); }
public static MessageDispatcher getDispatcher(Object targetObject) { MessageDispatcher dispatcher; synchronized (s_targetMap) { dispatcher = s_targetMap.get(targetObject); if (dispatcher == null) { dispatcher = new MessageDispatcher(targetObject); s_targetMap.put(targetObject, dispatcher); } } return dispatcher; }
@Override public boolean configure(final String name, final Map<String, Object> params) throws ConfigurationException { messageBus.subscribe(AsyncJob.Topics.JOB_EVENT_PUBLISH, MessageDispatcher.getDispatcher(this)); return true; }
private void configureMessageBusListener() { messageBus.subscribe(EventTypes.EVENT_CONFIGURATION_VALUE_EDIT, new MessageSubscriber() { @Override public void onPublishMessage(final String senderAddress, String subject, Object args) { final String globalSettingUpdated = (String) args; if (Strings.isNullOrEmpty(globalSettingUpdated)) { return; } if (globalSettingUpdated.equals(ApiServiceConfiguration.ManagementServerAddresses.key()) || globalSettingUpdated.equals(IndirectAgentLBAlgorithm.key())) { propagateMSListToAgents(); } } }); }
private void publishOnEventBus(AsyncJob job, String jobEvent) { _messageBus.publish(null, AsyncJob.Topics.JOB_EVENT_PUBLISH, PublishScope.LOCAL, new Pair<AsyncJob, String>(job, jobEvent)); }
@Override public void clearAll() { if (_gate.enter()) { if (s_logger.isTraceEnabled()) { s_logger.trace("Enter gate in message bus clearAll"); } try { _subscriberRoot.clearAll(); doPrune(); } finally { _gate.leave(); } } else { synchronized (_pendingActions) { _pendingActions.add(new ActionRecord(ActionType.ClearAll, null, null)); } } }
@Override public boolean configure(String name, Map<String, Object> params) throws ConfigurationException { _messageBus.subscribe(AsyncJob.Topics.JOB_HEARTBEAT, MessageDispatcher.getDispatcher(this)); _timer.scheduleAtFixedRate(new ManagedContextTimerTask() { @Override protected void runInContext() { heartbeat(); } }, _inactivityCheckIntervalMs, _inactivityCheckIntervalMs); return true; }