Examples with Socket org.zeromq.ZMQ.Socket used on opensource projects

Example 6 with Socket

use of org.zeromq.ZMQ.Socket in project jeromq by zeromq.

the class lvcache method main.

public static void main(String[] args) {
    ZContext context = new ZContext();
    Socket frontend = context.createSocket(ZMQ.SUB);
    frontend.bind("tcp://*:5557");
    Socket backend = context.createSocket(ZMQ.XPUB);
    backend.bind("tcp://*:5558");
    //  Subscribe to every single topic from publisher
    frontend.subscribe(ZMQ.SUBSCRIPTION_ALL);
    //  Store last instance of each topic in a cache
    Map<String, String> cache = new HashMap<String, String>();
    Poller poller = context.createPoller(2);
    poller.register(frontend, Poller.POLLIN);
    poller.register(backend, Poller.POLLIN);
    //  if anything:
    while (true) {
        if (poller.poll(1000) == -1)
            //  Interrupted
            break;
        //  Any new topic data we cache and then forward
        if (poller.pollin(0)) {
            String topic = frontend.recvStr();
            String current = frontend.recvStr();
            if (topic == null)
                break;
            cache.put(topic, current);
            backend.sendMore(topic);
            backend.send(current);
        }
        //  When we get a new subscription, we pull data from the cache:
        if (poller.pollin(1)) {
            ZFrame frame = ZFrame.recvFrame(backend);
            if (frame == null)
                break;
            //  Event is one byte 0=unsub or 1=sub, followed by topic
            byte[] event = frame.getData();
            if (event[0] == 1) {
                String topic = new String(event, 1, event.length - 1, ZMQ.CHARSET);
                System.out.printf("Sending cached topic %s\n", topic);
                String previous = cache.get(topic);
                if (previous != null) {
                    backend.sendMore(topic);
                    backend.send(previous);
                }
            }
            frame.destroy();
        }
    }
    context.destroy();
}

Example 7 with Socket

use of org.zeromq.ZMQ.Socket in project jeromq by zeromq.

the class espresso method main.

//  .split main thread
//  The main task starts the subscriber and publisher, and then sets
//  itself up as a listening proxy. The listener runs as a child thread:
public static void main(String[] argv) {
    //  Start child threads
    ZContext ctx = new ZContext();
    ZThread.fork(ctx, new Publisher());
    ZThread.fork(ctx, new Subscriber());
    Socket subscriber = ctx.createSocket(ZMQ.XSUB);
    subscriber.connect("tcp://localhost:6000");
    Socket publisher = ctx.createSocket(ZMQ.XPUB);
    publisher.bind("tcp://*:6001");
    Socket listener = ZThread.fork(ctx, new Listener());
    ZMQ.proxy(subscriber, publisher, listener);
    System.out.println(" interrupted");
    //  Tell attached threads to exit
    ctx.destroy();
}

Example 8 with Socket

use of org.zeromq.ZMQ.Socket in project jeromq by zeromq.

the class ppqueue method main.

//  The main task is an LRU queue with heartbeating on workers so we can
//  detect crashed or blocked worker tasks:
public static void main(String[] args) {
    ZContext ctx = new ZContext();
    Socket frontend = ctx.createSocket(ZMQ.ROUTER);
    Socket backend = ctx.createSocket(ZMQ.ROUTER);
    //  For clients
    frontend.bind("tcp://*:5555");
    //  For workers
    backend.bind("tcp://*:5556");
    //  List of available workers
    ArrayList<Worker> workers = new ArrayList<Worker>();
    //  Send out heartbeats at regular intervals
    long heartbeat_at = System.currentTimeMillis() + HEARTBEAT_INTERVAL;
    Poller poller = ctx.createPoller(2);
    poller.register(backend, Poller.POLLIN);
    poller.register(frontend, Poller.POLLIN);
    while (true) {
        boolean workersAvailable = workers.size() > 0;
        int rc = poller.poll(HEARTBEAT_INTERVAL);
        if (rc == -1)
            //  Interrupted
            break;
        //  Handle worker activity on backend
        if (poller.pollin(0)) {
            //  Use worker address for LRU routing
            ZMsg msg = ZMsg.recvMsg(backend);
            if (msg == null)
                //  Interrupted
                break;
            //  Any sign of life from worker means it's ready
            ZFrame address = msg.unwrap();
            Worker worker = new Worker(address);
            worker.ready(workers);
            //  Validate control message, or return reply to client
            if (msg.size() == 1) {
                ZFrame frame = msg.getFirst();
                String data = new String(frame.getData(), ZMQ.CHARSET);
                if (!data.equals(PPP_READY) && !data.equals(PPP_HEARTBEAT)) {
                    System.out.println("E: invalid message from worker");
                    msg.dump(System.out);
                }
                msg.destroy();
            } else
                msg.send(frontend);
        }
        if (workersAvailable && poller.pollin(1)) {
            //  Now get next client request, route to next worker
            ZMsg msg = ZMsg.recvMsg(frontend);
            if (msg == null)
                //  Interrupted
                break;
            msg.push(Worker.next(workers));
            msg.send(backend);
        }
        if (System.currentTimeMillis() >= heartbeat_at) {
            for (Worker worker : workers) {
                worker.address.send(backend, ZFrame.REUSE + ZFrame.MORE);
                ZFrame frame = new ZFrame(PPP_HEARTBEAT);
                frame.send(backend, 0);
            }
            heartbeat_at = System.currentTimeMillis() + HEARTBEAT_INTERVAL;
        }
        Worker.purge(workers);
    }
    //  When we're done, clean up properly
    while (workers.size() > 0) {
        Worker worker = workers.remove(0);
    }
    workers.clear();
    ctx.destroy();
}

Example 9 with Socket

use of org.zeromq.ZMQ.Socket in project jeromq by zeromq.

the class ppworker method main.

//  We have a single task, which implements the worker side of the
//  Paranoid Pirate Protocol (PPP). The interesting parts here are
//  the heartbeating, which lets the worker detect if the queue has
//  died, and vice-versa:
public static void main(String[] args) {
    ZContext ctx = new ZContext();
    Socket worker = worker_socket(ctx);
    Poller poller = ctx.createPoller(1);
    poller.register(worker, Poller.POLLIN);
    //  If liveness hits zero, queue is considered disconnected
    int liveness = HEARTBEAT_LIVENESS;
    int interval = INTERVAL_INIT;
    //  Send out heartbeats at regular intervals
    long heartbeat_at = System.currentTimeMillis() + HEARTBEAT_INTERVAL;
    Random rand = new Random(System.nanoTime());
    int cycles = 0;
    while (true) {
        int rc = poller.poll(HEARTBEAT_INTERVAL);
        if (rc == -1)
            //  Interrupted
            break;
        if (poller.pollin(0)) {
            //  Get message
            //  - 3-part envelope + content -> request
            //  - 1-part HEARTBEAT -> heartbeat
            ZMsg msg = ZMsg.recvMsg(worker);
            if (msg == null)
                //  Interrupted
                break;
            //  first:
            if (msg.size() == 3) {
                cycles++;
                if (cycles > 3 && rand.nextInt(5) == 0) {
                    System.out.println("I: simulating a crash\n");
                    msg.destroy();
                    msg = null;
                    break;
                } else if (cycles > 3 && rand.nextInt(5) == 0) {
                    System.out.println("I: simulating CPU overload\n");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        break;
                    }
                }
                System.out.println("I: normal reply\n");
                msg.send(worker);
                liveness = HEARTBEAT_LIVENESS;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    break;
                }
            //  Do some heavy work
            } else //  queue was (recently) alive, so reset our liveness indicator:
            if (msg.size() == 1) {
                ZFrame frame = msg.getFirst();
                if (PPP_HEARTBEAT.equals(new String(frame.getData(), ZMQ.CHARSET)))
                    liveness = HEARTBEAT_LIVENESS;
                else {
                    System.out.println("E: invalid message\n");
                    msg.dump(System.out);
                }
                msg.destroy();
            } else {
                System.out.println("E: invalid message\n");
                msg.dump(System.out);
            }
            interval = INTERVAL_INIT;
        } else //  discarding any messages we might have sent in the meantime://
        if (--liveness == 0) {
            System.out.println("W: heartbeat failure, can't reach queue\n");
            System.out.printf("W: reconnecting in %sd msec\n", interval);
            try {
                Thread.sleep(interval);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (interval < INTERVAL_MAX)
                interval *= 2;
            ctx.destroySocket(worker);
            worker = worker_socket(ctx);
            liveness = HEARTBEAT_LIVENESS;
        }
        //  Send heartbeat to queue if it's time
        if (System.currentTimeMillis() > heartbeat_at) {
            heartbeat_at = System.currentTimeMillis() + HEARTBEAT_INTERVAL;
            System.out.println("I: worker heartbeat\n");
            ZFrame frame = new ZFrame(PPP_HEARTBEAT);
            frame.send(worker, 0);
        }
    }
    ctx.destroy();
}

Example 10 with Socket

use of org.zeromq.ZMQ.Socket in project jeromq by zeromq.

the class psenvpub method main.

public static void main(String[] args) throws Exception {
    // Prepare our context and publisher
    Context context = ZMQ.context(1);
    Socket publisher = context.socket(ZMQ.PUB);
    publisher.bind("tcp://*:5563");
    while (!Thread.currentThread().isInterrupted()) {
        // Write two messages, each with an envelope and content
        publisher.sendMore("A");
        publisher.send("We don't want to see this");
        publisher.sendMore("B");
        publisher.send("We would like to see this");
    }
    publisher.close();
    context.term();
}