@Override
public SubscriptionResponse setsubscription(
final long subscriptionid, final String[] subscriptions, final String[] exclusions) {
final Subscriber subscriber = this.subscribers.get(subscriptionid);
if (subscriber == null) {
return new SubscriptionResponse();
} else {
synchronized (subscriber.getModifyLock()) {
final ArrayList<String> newExclusions = new ArrayList<String>();
if (exclusions != null) {
newExclusions.addAll(Arrays.asList(exclusions));
}
subscriber.setExclusions(newExclusions.toArray(new String[] {}));
final ArrayList<String> newSubscriptions = new ArrayList<String>();
if (subscriptions != null) {
newSubscriptions.addAll(Arrays.asList(subscriptions));
}
subscriber.setSubscriptions(newSubscriptions.toArray(new String[] {}));
}
final SubscriptionResponse ret = new SubscriptionResponse(subscriber);
ret.setSubscribed(true);
return ret;
}
}
@Override
public void listen(
final RemoteAPIRequest request, final RemoteAPIResponse response, final long subscriptionid)
throws APIFileNotFoundException, InternalApiException {
final Subscriber subscriber = this.subscribers.get(subscriptionid);
if (subscriber == null) {
throw new APIFileNotFoundException();
}
final ArrayList<EventObject> events = new ArrayList<EventObject>();
final ArrayList<EventObjectStorable> eventStorables = new ArrayList<EventObjectStorable>();
try {
EventObject event;
while ((event = subscriber.poll(events.size() == 0 ? subscriber.getPollTimeout() : 0)) != null
&& this.subscribers.get(subscriptionid) == subscriber) {
events.add(event);
eventStorables.add(new EventObjectStorable(event));
}
} catch (final InterruptedException e) {
}
try {
response.getRemoteAPI().writeStringResponse(eventStorables, null, request, response);
} catch (final Throwable e) {
subscriber.pushBack(events);
throw new InternalApiException(e);
}
}
public void testTcpURIs() throws Exception {
Subscriber listener = new Subscriber("tcp://localhost:123456");
assertTrue(listener.isTcp());
assertEquals("localhost", listener.getHost());
assertEquals(123456, listener.getPort());
}
public void testNotify_Http() throws Exception {
// create socket listener
SocketListener socketListener = new SocketListener(NOTIFICATION_PORT);
// create notification listener
Subscriber notificationListener = new Subscriber("http://localhost:" + NOTIFICATION_PORT);
// create reports
ECReports reports = ECElementsUtils.createECReports();
// notify listener about reports
notificationListener.notify(reports);
// get input stream
InputStream inputStream = socketListener.getInputStream();
// read from input stream
readHtmlHeaderFromInputStream(inputStream);
ECReports resultReports = DeserializerUtil.deserializeECReports(inputStream);
// close socket listener
socketListener.stop();
// check result
// FIXME
// ECElementsUtils.assertEquals(reports, resultReports);
}
public synchronized void unbind(EndOid oid, Ticket ticket) {
List<Subscriber> subscribers = routes.get(oid);
if (subscribers == null) {
System.err.println("NULL Subscribers for: " + oid.toString());
return;
}
for (Subscriber sub : subscribers) {
if (sub.ticket.equals(ticket)) {
if (sub.continuation != null) {
sub.continuation.resume();
sub.continuation = null;
}
subscribers.remove(sub);
break;
}
}
routes.put(oid, subscribers);
if (subscribers.size() == 0) {
Endpoint ep = registry.get(oid);
if (ep == null) {
System.err.println("Cannot find endpont: " + oid.toString());
return;
}
ep.idle = true;
ep.idleTime = System.currentTimeMillis();
}
}
@Override
public void run() {
waitForReady();
try {
Thread.sleep(new Random().nextInt(200) + 100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
Connection connection = ConnectionFactory.createConnection(brokerIP);
session = connection.createSession();
String topicHierarchy = topicHierarchies[id];
Subscriber subscriber = session.createHierarchicalTopicSubscriber(topicHierarchy);
System.out.println("create subscriber: " + topicHierarchy);
messageReceiver = new TestMessageReceiver();
subscriber.registerMessageReceiver(messageReceiver);
while (!messageReceiver.shutdown) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
done();
}
@Override
public <ET extends Event> void push(ET event) {
List<Subscriber<ET>> subscribers;
synchronized (registeredSubscribers) {
if (!registeredSubscribers.containsKey(event.getClass())) return;
// Inspection disabled because all inserts in to registeredSubscribers are type insured
// due to type erasure, we can not have per-pair types.
// noinspection unchecked
subscribers =
(List<Subscriber<ET>>) new ArrayList(registeredSubscribers.get(event.getClass()));
}
for (Subscriber<ET> subscriber : subscribers) {
boolean txDeterminate = true;
for (ListenerFilter filter : subscriber.getFilters()) {
// This can only occur if someone f***s something up in an annotation, as listeners should
// be typesafe when passed to subscribers
// noinspection unchecked
txDeterminate = txDeterminate && filter.shouldSend(event);
}
if (txDeterminate) subscriber.eventReceived(event);
}
}
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();
ObjectifyService.register(Subscriber.class);
Subscriber newSubscriber = new Subscriber(user.getEmail());
ofy().save().entity(newSubscriber).now();
// MailUpdate.subscribers.add(user);
System.out.println(user.getEmail() + " has subscribed");
List<Subscriber> subscribers = ObjectifyService.ofy().load().type(Subscriber.class).list();
// for (Subscriber subscriber : subscribers){
// ofy().delete().entity(subscriber);
// }
Collections.sort(subscribers);
System.out.println("size" + subscribers.size());
for (Subscriber subscriber : subscribers) {
System.out.println(subscriber.getEmail());
}
// try{
// RequestDispatcher view = req.getRequestDispatcher("");
// view.forward(req, resp);
// } catch (Exception e){}
resp.sendRedirect("/");
}
public static void main(String[] args) {
Subscriber subscriber = new Subscriber();
subscriber.subscribe("FastMovingStockQuotes");
Publisher publisher = new Publisher();
publisher.publishMessages("AllStockQuotes");
subscriber.unsubscribe();
}
@Override
public void onSubscribe(Subscription s) {
if (SubscriptionHelper.validateSubscription(this.s, s)) {
return;
}
this.s = s;
Subscriber<? super U> actual = this.actual;
U b;
try {
b = bufferSupplier.get();
} catch (Throwable e) {
cancelled = true;
s.cancel();
EmptySubscription.error(e, actual);
return;
}
if (b == null) {
cancelled = true;
s.cancel();
EmptySubscription.error(new NullPointerException("The buffer supplied is null"), actual);
return;
}
buffer = b;
Publisher<B> boundary;
try {
boundary = boundarySupplier.get();
} catch (Throwable ex) {
cancelled = true;
s.cancel();
EmptySubscription.error(ex, actual);
return;
}
if (boundary == null) {
cancelled = true;
s.cancel();
EmptySubscription.error(
new NullPointerException("The boundary publisher supplied is null"), actual);
return;
}
BufferBoundarySubscriber<T, U, B> bs = new BufferBoundarySubscriber<T, U, B>(this);
other = bs;
actual.onSubscribe(this);
if (!cancelled) {
s.request(Long.MAX_VALUE);
boundary.subscribe(bs);
}
}
@Override
public SubscriptionResponse subscribe(final String[] subscriptions, final String[] exclusions) {
final Subscriber subscriber = new Subscriber(subscriptions, exclusions);
this.subscribers.put(subscriber.getSubscriptionID(), subscriber);
this.subscribersCleanupThread();
final SubscriptionResponse ret = new SubscriptionResponse(subscriber);
ret.setSubscribed(true);
return ret;
}
@Override
public void unregisterSubscriber(@NotNull Subscriber subscriber) {
final Subscriber delegate = subscriptionDelegate.get(subscriber);
final Subscriber s = delegate != null ? delegate : subscriber;
boolean subscription = subscribers.remove(s);
boolean keySubscription = keySubscribers.remove(s);
if (subscription) removeFromStats("subscription");
if (keySubscription) removeFromStats("keySubscription");
s.onEndOfSubscription();
}
/*
* (non-Javadoc)
*
* @see
* org.appwork.remoteapi.events.EventsAPIInterface#getsubscriptionstatus
* (long)
*/
@Override
public SubscriptionStatusResponse getsubscriptionstatus(final long subscriptionid) {
final Subscriber subscriber = this.subscribers.get(subscriptionid);
if (subscriber == null) {
return new SubscriptionStatusResponse();
} else {
subscriber.keepAlive();
final SubscriptionStatusResponse ret = new SubscriptionStatusResponse(subscriber);
ret.setSubscribed(true);
return ret;
}
}
/** Tick action */
public void tick() {
if (this.subscribers.size() > 0) {
for (Subscriber sub : this.subscribers) {
// Check subscription date
Date now = new Date();
if (sub.getDate().after(now)) {
this.notify(sub);
} else {
this.subscribers.remove(sub);
break;
}
}
}
}
/** Delete subscriber */
public boolean deregister(Subscription sub) throws FailureException {
for (Subscriber subs : subscribers) {
if (subs.getSub().equals(sub)) {
subscribers.remove(new Subscriber(subs.getSub(), subs.getType(), subs.getDate()));
}
}
//
System.out.println(
"Agent "
+ buildingcs.getAID().getName()
+ " deregistered the agent "
+ sub.getMessage().getSender().getName());
return false;
}
@Override
public SubscribeHandle start(List<Subscriber> subscribers) {
CompositeSubscribeHandle handle = new CompositeSubscribeHandle();
for (Subscriber s : subscribers) {
List<Topic> topics = m_metaService.listTopicsByPattern(s.getTopicPattern());
if (topics == null || topics.isEmpty()) {
throw new IllegalArgumentException(
String.format("Can not find any topics matching pattern %s", s.getTopicPattern()));
}
log.info(
"Found topics({}) matching pattern({}), groupId={}.",
CollectionUtil.collect(
topics,
new Transformer() {
@Override
public Object transform(Object topic) {
return ((Topic) topic).getName();
}
}),
s.getTopicPattern(),
s.getGroupId());
for (Topic topic : topics) {
ConsumerContext context =
new ConsumerContext(
topic, s.getGroupId(), s.getConsumer(), s.getMessageClass(), s.getConsumerType());
// FIXME validate all, if fail in any validator, exit
if (validate(topic, context)) {
try {
String endpointType = m_metaService.findEndpointTypeByTopic(topic.getName());
ConsumerBootstrap consumerBootstrap =
m_consumerManager.findConsumerBootStrap(endpointType);
handle.addSubscribeHandle(consumerBootstrap.start(context));
} catch (RuntimeException e) {
log.error(
"Failed to start consumer for topic {}(consumer: groupId={}, sessionId={})",
topic.getName(),
context.getGroupId(),
context.getSessionId(),
e);
throw e;
}
}
}
}
return handle;
}
@Override
public SubscriptionResponse changesubscriptiontimeouts(
final long subscriptionid, final long polltimeout, final long maxkeepalive) {
final Subscriber subscriber = this.subscribers.get(subscriptionid);
if (subscriber == null) {
return new SubscriptionResponse();
} else {
subscriber.setMaxKeepalive(maxkeepalive);
subscriber.setPollTimeout(polltimeout);
subscriber.notifyListener();
final SubscriptionResponse ret = new SubscriptionResponse(subscriber);
ret.setSubscribed(true);
return ret;
}
}
/**
* Subscribes a given Subscriber with the given subscription type
*
* @param subscriber The given Subscriber object
* @param type Type of subscription
* @return Returns true if the subscription was successfully applied for the given type
*/
public boolean subscribe(Subscriber subscriber, String type) {
boolean flag = false;
if (subscriber != null && type != null) {
for (Publisher pub : publishers) {
if (pub.getPublisher().getType().contains(type)) {
flag = true;
break;
}
}
if (!flag) return false;
NewSubscriber newSubscriber = subscriber.getSubscriber();
ArrayList<String> temp = subscriberMap.get(newSubscriber);
if (temp != null) {
if (temp.contains(type)) return false;
subscriberMap.get(newSubscriber).add(type);
return true;
} else {
ArrayList<String> tempType = new ArrayList<String>();
tempType.add(type);
subscriberMap.put(newSubscriber, tempType);
return true;
}
}
return false;
}
@Override
public SubscriptionResponse unsubscribe(final long subscriptionid) {
final Subscriber subscriber = this.subscribers.remove(subscriptionid);
if (subscriber != null) {
subscriber.notifyListener();
try {
for (final EventPublisher publisher : this.publishers) {
publisher.terminatedSubscription(this, subscriptionid);
}
} catch (final Throwable e) {
e.printStackTrace();
}
return new SubscriptionResponse(subscriber);
}
return new SubscriptionResponse();
}
@Override
public void subscribe(final Subscriber<? super String> observer) {
observer.onSubscribe(EmptySubscription.INSTANCE);
t =
new Thread(
new Runnable() {
@Override
public void run() {
for (String s : valuesToReturn) {
if (s == null) {
System.out.println("throwing exception");
try {
Thread.sleep(100);
} catch (Throwable e) {
}
observer.onError(new NullPointerException());
return;
} else {
observer.onNext(s);
}
}
System.out.println("subscription complete");
observer.onComplete();
}
});
t.start();
}
@Override
public void onSubscribe(Subscription s) {
if (SubscriptionHelper.validateSubscription(this.s, s)) {
return;
}
this.s = s;
actual.onSubscribe(s);
}
public void route(Ticket ticket, EndOid toOid, Packet packet) {
List<Subscriber> subscribers = routes.get(toOid);
if (subscribers != null) {
for (Subscriber subscriber : subscribers) {
synchronized (subscriber) {
subscriber.queue.add(packet);
if (subscriber.continuation != null) {
if (subscriber.continuation.isSuspended()) {
subscriber.continuation.resume();
}
subscriber.continuation = null;
subscriber.lastActive = System.currentTimeMillis();
}
}
}
}
}
@Override
public void request(long n) {
if (SubscriptionHelper.validateRequest(n)) {
return;
}
if (compareAndSet(false, true)) {
int i = 0;
final Subscriber<? super Integer> a = s;
final AtomicInteger c = counter;
while (!cancelled) {
a.onNext(i++);
c.incrementAndGet();
}
System.out.println("unsubscribed after: " + i);
}
}
@Override
public void onComplete() {
if (done) {
return;
}
done = true;
actual.onComplete();
}
@Test
public void testBPubSub() throws InterruptedException {
String topic = "test";
// Start pubsub server
Server server =
new Server("127.0.0.1", Settings.CLIENT_SUBSCRIBE_PORT, Settings.CLIENT_PUBLISH_PORT);
server.start();
// Create publisher and subscriber
Publisher publisher = new Publisher("127.0.0.1", Settings.CLIENT_PUBLISH_PORT);
Subscriber subscriber = new Subscriber("127.0.0.1", Settings.CLIENT_SUBSCRIBE_PORT);
// Subscribe to test topic
TestPubSubCallback cb = new TestPubSubCallback();
subscriber.subscribe(topic, cb);
Thread.sleep(1000);
// Publish a message
System.out.println("Publisher publishing " + "hello" + " on topic " + topic);
publisher.publish(topic, PubSubProtos.StringMessage.newBuilder().setMessage("hello").build());
cb.awaitMessage("hello");
// Publish a message
System.out.println("Publisher publishing " + "hello" + " on topic " + "badtest");
publisher.publish(
"badtest", PubSubProtos.StringMessage.newBuilder().setMessage("hello").build());
cb.awaitNoMessage("hello");
// Publish a message
System.out.println("Publisher publishing " + "hello2" + " on topic " + topic);
publisher.publish(topic, PubSubProtos.StringMessage.newBuilder().setMessage("hello2").build());
cb.awaitMessage("hello2");
// Unsubscribe
subscriber.unsubscribe(topic, cb);
Thread.sleep(1000);
// Publish a message
System.out.println("Publisher publishing " + "hello2" + " on topic " + topic);
publisher.publish(topic, PubSubProtos.StringMessage.newBuilder().setMessage("hello2").build());
cb.awaitNoMessage("hello2");
}
@Override
public void subscribe(Subscriber<? super String> observer) {
observer.onSubscribe(EmptySubscription.INSTANCE);
boolean errorThrown = false;
for (String s : valuesToReturn) {
if (s == null) {
System.out.println("throwing exception");
observer.onError(new NullPointerException());
errorThrown = true;
// purposefully not returning here so it will continue calling onNext
// so that we also test that we handle bad sequences like this
} else {
observer.onNext(s);
}
}
if (!errorThrown) {
observer.onComplete();
}
}
public static void main(String[] args) throws XMPPException {
/** Erzeugen von Instanzen */
NodeService service = new NodeService();
Publisher pub = new Publisher();
Subscriber sub = new Subscriber();
/** NodeService erstellt/löscht/verändert Knoten und lässt sich Informationen ausgeben */
service.connect(ups);
service.getNodes();
service.printNode("Bruno");
System.out.println("");
service.disconnect();
System.out.println("");
/**
* Subscriber prüft nach neuen Nachrichten
*
* <p>Publisher löscht/erstellt neue Nachricht
*/
pub.connect(u1);
pub.deleteMessage("1", "Bruno");
pub.addPayloadMessage("1", "Bruno");
pub.disconnect();
System.out.println("");
/*
* Subscriber lässt sich alle Knoten ausgeben und abonniert einen Knoten
*/
sub.connect(u3);
sub.getNodes();
sub.abonnieren("Bruno", u3);
sub.disconnect();
System.out.println("");
/** NodeService lässt sich Infomationen ausgeben */
service.connect(ups);
service.printNode("Bruno");
service.disconnect();
}
/**
* Returns all subscribers for the given listener grouped by the type of event they subscribe to.
*/
private Multimap<Class<?>, Subscriber> findAllSubscribers(Object listener) {
Multimap<Class<?>, Subscriber> methodsInListener = HashMultimap.create();
Class<?> clazz = listener.getClass();
for (Method method : getAnnotatedMethods(clazz)) {
Class<?>[] parameterTypes = method.getParameterTypes();
Class<?> eventType = parameterTypes[0];
methodsInListener.put(eventType, Subscriber.create(bus, listener, method));
}
return methodsInListener;
}
@Override
public void registerKeySubscriber(
@NotNull RequestContext rc, @NotNull Subscriber<K> subscriber, @NotNull Filter<K> filter) {
addToStats("keySubscription");
final Boolean bootstrap = rc.bootstrap();
final Subscriber<K> sub = subscriber(subscriber, filter);
keySubscribers.add(sub);
if (bootstrap != Boolean.FALSE && kvStore != null) {
try {
for (int i = 0; i < kvStore.segments(); i++) kvStore.keysFor(i, sub::onMessage);
if (TRUE.equals(rc.endSubscriptionAfterBootstrap())) {
sub.onEndOfSubscription();
keySubscribers.remove(sub);
}
} catch (InvalidSubscriberException e) {
keySubscribers.remove(sub);
}
}
}
@Override
public void onError(Throwable t) {
if (done) {
RxJavaPlugins.onError(t);
return;
}
done = true;
actual.onError(t);
}
