Archiving a bunch of old stuff

oldstuff/zeromq/.gitignore

@@ -0,0 +1,7 @@
+hwserver
+hwclient
+wuserver
+wuclient
+taskvent
+taskwork
+tasksink

oldstuff/zeromq/Makefile

@@ -0,0 +1,18 @@
+CFLAGS += -I. -I/usr/local/include
+LDFLAGS += -lstdc++ -lpthread -luuid -lrt
+LIBZMQ := /usr/local/lib/libzmq.a
+TARGETS := hwserver hwclient wuserver wuclient taskvent taskwork tasksink
+
+
+%:%.c
+	$(CC) $(CFLAGS) -o $@ $^ $(LIBZMQ) $(LDFLAGS)
+
+
+all: $(TARGETS)
+
+
+clean:
+	rm -vf $(TARGETS)
+
+
+.PHONY: all clean

oldstuff/zeromq/hwclient.c

@@ -0,0 +1,32 @@
+#include <zmq.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int main(void)
+{
+    void *context = zmq_init(1);
+
+    printf("Connecting to hello world server.\n");
+    void *requester = zmq_socket(context, ZMQ_REQ);
+    zmq_connect(requester, "tcp://localhost:5555");
+
+    int request_nbr;
+    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
+        zmq_msg_t request;
+        zmq_msg_init_size(&request, 5);
+        memcpy(zmq_msg_data(&request), "Hello", 5);
+        printf("Sending Hello %d...\n", request_nbr);
+        zmq_send(requester, &request, 0);
+        zmq_msg_close(&request);
+
+        zmq_msg_t reply;
+        zmq_msg_init(&reply);
+        zmq_recv(requester, &reply, 0);
+        printf("Received World %d\n", request_nbr);
+        zmq_msg_close(&reply);
+    }
+    zmq_close(requester);
+    zmq_term(context);
+    return 0;
+}

oldstuff/zeromq/hwclient.rb

@@ -0,0 +1,29 @@
+# vim:fileencoding=utf-8:expandtab
+
+require 'zmq'
+
+def main
+  context = ZMQ::Context.new(1)
+
+  puts "Connecting to hello world server…"
+  requester = context.socket(ZMQ::REQ)
+  requester.connect("tcp://localhost:5555")
+  puts "requester is a #{requester.class.inspect}"
+
+  0.upto(9) do |request_nbr|
+    puts "Sending request #{request_nbr}…"
+    if requester.send("Hello")
+      puts "Sent request, now receiving reply"
+      reply = requester.recv
+      puts "Received reply #{request_nbr}: [#{reply}]"
+    end
+  end
+
+  puts "Outside of loop now.  Closing socket..."
+  requester.close
+end
+
+
+if $0 == __FILE__
+  main
+end

oldstuff/zeromq/hwserver.c

@@ -0,0 +1,38 @@
+#include <zmq.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+
+#define BIND_ADDR "tcp://*:5555"
+
+int main(void)
+{
+    void *context = zmq_init(1);
+
+    void *responder = zmq_socket(context, ZMQ_REP);
+    printf("Binding server to %s\n", BIND_ADDR);
+    printf("pid=%d\n", getpid());
+    zmq_bind(responder, BIND_ADDR);
+
+    printf("Starting loop.\n");
+    while(1) {
+        zmq_msg_t request;
+        zmq_msg_init(&request);
+        zmq_recv(responder, &request, 0);
+        printf("Received Hello\n");
+        zmq_msg_close(&request);
+
+        sleep(1);
+
+        zmq_msg_t reply;
+        zmq_msg_init_size(&reply, 5);
+        memcpy(zmq_msg_data(&reply), "World", 5);
+        zmq_send(responder, &reply, 0);
+        zmq_msg_close(&reply);
+    }
+
+    zmq_close(responder);
+    zmq_term(context);
+    return 0;
+}

oldstuff/zeromq/hwserver.py

@@ -0,0 +1,35 @@
+# vim:fileencoding=utf-8
+from __future__ import print_function
+
+import sys
+import time
+
+import zmq
+
+
+BIND_ADDR = 'tcp://*:5555'
+
+
+def main():
+    context = zmq.Context(1)
+    responder = context.socket(zmq.REP)
+
+    print('Binding server to {}'.format(BIND_ADDR))
+    responder.bind(BIND_ADDR)
+
+    print('Starting loop.')
+    try:
+        while True:
+            responder.recv()
+            print('Received Hello')
+            time.sleep(0.25)
+            responder.send("World")
+
+    except KeyboardInterrupt:
+        responder.close()
+        context.term()
+        return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

oldstuff/zeromq/tasksink.c

@@ -0,0 +1,32 @@
+#include "zhelpers.h"
+
+int main(void)
+{
+	void *context = zmq_init(1);
+	void *receiver = zmq_socket(context, ZMQ_PULL);
+	zmq_bind(receiver, "tcp://*:5558");
+
+	char *string = s_recv(receiver);
+	free(string);
+
+	int64_t start_time = s_clock();
+
+	int task_nbr;
+	for (task_nbr = 0; task_nbr < 100; task_nbr++) {
+		char *string = s_recv(receiver);
+		free(string);
+		if ((task_nbr / 10) * 10 == task_nbr) {
+			printf(":");
+		} else {
+			printf(".");
+		}
+		fflush(stdout);
+	}
+
+	printf("\nTotal elapsed time: %d msec\n",
+			(int) (s_clock() - start_time));
+
+	zmq_close(receiver);
+	zmq_term(context);
+	return 0;
+}

oldstuff/zeromq/taskvent.c

@@ -0,0 +1,37 @@
+#include "zhelpers.h"
+
+int main(void)
+{
+    void *context = zmq_init(1);
+
+    void *sender = zmq_socket(context, ZMQ_PUSH);
+    zmq_bind(sender, "tcp://*:5557");
+
+    void *sink = zmq_socket(context, ZMQ_PUSH);
+    zmq_connect(sink, "tcp://localhost:5558");
+
+    printf("Press Enter when the workers are ready: ");
+    getchar();
+    printf("Sending tasks to workers...\n");
+
+    s_send(sink, "0");
+    srandom((unsigned) time(NULL));
+
+    int task_nbr;
+    int total_msec = 0;
+    for (task_nbr = 0; task_nbr < 100; task_nbr++) {
+        int workload;
+        workload = randof(100) + 1;
+        total_msec += workload;
+        char string[10];
+        sprintf(string, "%d", workload);
+        s_send(sender, string);
+    }
+    printf("Total expected cost: %d msec\n", total_msec);
+    sleep(1);
+
+    zmq_close(sink);
+    zmq_close(sender);
+    zmq_term(context);
+    return 0;
+}

oldstuff/zeromq/taskwork.c

@@ -0,0 +1,27 @@
+#include "zhelpers.h"
+
+int main(void)
+{
+    void *context = zmq_init(1);
+
+    void *receiver = zmq_socket(context, ZMQ_PULL);
+    zmq_connect(receiver, "tcp://localhost:5557");
+
+    void *sender = zmq_socket(context, ZMQ_PUSH);
+    zmq_connect(sender, "tcp://localhost:5558");
+
+    while (1) {
+        char *string = s_recv(receiver);
+        fflush(stdout);
+        printf("%s.", string);
+
+        s_sleep(atoi(string));
+        free(string);
+
+        s_send(sender, "");
+    }
+    zmq_close(receiver);
+    zmq_close(sender);
+    zmq_term(context);
+    return 0;
+}

oldstuff/zeromq/wuclient.c

@@ -0,0 +1,30 @@
+#include "zhelpers.h"
+
+int main(int argc, char *argv[])
+{
+    void *context = zmq_init(1);
+
+    printf("Collecting updates from weather server...\n");
+    void *subscriber = zmq_socket(context, ZMQ_SUB);
+    zmq_connect(subscriber, "tcp://localhost:5556");
+
+    // Subscribe to zipcode, default is NYC, 10001
+    char *filter = (argc > 1) ? argv[1]: "10001";
+    zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, filter, strlen(filter));
+
+    int update_nbr;
+    long total_temp = 0;
+    for (update_nbr = 0; update_nbr < 100; update_nbr++) {
+        char *string = s_recv(subscriber);
+        int zipcode, temperature, relhumidity;
+        sscanf(string, "%d %d %d", &zipcode, &temperature, &relhumidity);
+        total_temp += temperature;
+        free(string);
+    }
+
+    printf("Average temperature for zipcode '%s' was %dF\n",
+            filter, (int)(total_temp / update_nbr));
+    zmq_close(subscriber);
+    zmq_term(context);
+    return 0;
+}

oldstuff/zeromq/wuclient.py

@@ -0,0 +1,32 @@
+# vim:fileencoding=utf-8
+
+from __future__ import print_function
+
+import sys
+import zmq
+
+
+def main(sysargs=sys.argv[:]):
+    context = zmq.Context()
+    socket = context.socket(zmq.SUB)
+
+    print("Collecting updates from weather server…")
+    socket.connect("tcp://localhost:5556")
+
+    target_zipcode = sysargs[1] if len(sysargs) > 1 else '10001'
+    socket.setsockopt(zmq.SUBSCRIBE, target_zipcode)
+
+    total_temp = 0
+    for update_nbr in range(100):
+        string = socket.recv()
+        total_temp += int(string.split()[1])
+
+    print("Average temperature for zipcode '{}' was {}F".format(
+        target_zipcode, total_temp / update_nbr
+    ))
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

oldstuff/zeromq/wuserver.c

@@ -0,0 +1,24 @@
+#include "zhelpers.h"
+
+int main(void)
+{
+    void *context = zmq_init(1);
+    void *publisher = zmq_socket(context, ZMQ_PUB);
+    zmq_bind(publisher, "tcp://*:5556");
+    zmq_bind(publisher, "ipc://weather.ipc");
+
+    srandom((unsigned) time (NULL));
+    while (1) {
+        int zipcode, temperature, relhumidity;
+        zipcode = randof(100000);
+        temperature = randof(215) - 80;
+        relhumidity = randof(50) + 10;
+
+        char update[20];
+        sprintf(update, "%05d %d %d", zipcode, temperature, relhumidity);
+        s_send(publisher, update);
+    }
+    zmq_close(publisher);
+    zmq_term(context);
+    return 0;
+}

oldstuff/zeromq/zhelpers.h

@@ -0,0 +1,191 @@
+/*  =====================================================================
+    zhelpers.h
+
+    Helper header file for example applications.
+    =====================================================================
+*/
+
+#ifndef __ZHELPERS_H_INCLUDED__
+#define __ZHELPERS_H_INCLUDED__
+
+//  Include a bunch of headers that we will need in the examples
+
+#include <zmq.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+#include <assert.h>
+#include <signal.h>
+
+//  Version checking, and patch up missing constants to match 2.1
+#if ZMQ_VERSION_MAJOR == 2
+#   if ZMQ_VERSION_MINOR == 0
+#       error "Please upgrade to ZeroMQ/2.1 stable for these examples"
+#   endif
+#elif ZMQ_VERSION_MAJOR == 3
+#   error "Please stick with ZeroMQ/2.1 stable for these examples"
+#endif
+#ifndef ZMQ_ROUTER
+#   define ZMQ_ROUTER ZMQ_ROUTER
+#endif
+#ifndef ZMQ_DEALER
+#   define ZMQ_DEALER ZMQ_DEALER
+#endif
+
+
+//  Provide random number from 0..(num-1)
+#if (defined (__WINDOWS__))
+#   define randof(num)  (int) ((float) (num) * rand () / (RAND_MAX + 1.0))
+#else
+#   define randof(num)  (int) ((float) (num) * random () / (RAND_MAX + 1.0))
+#endif
+
+
+//  Receive 0MQ string from socket and convert into C string
+//  Caller must free returned string. Returns NULL if the context
+//  is being terminated.
+static char *
+s_recv (void *socket) {
+    zmq_msg_t message;
+    zmq_msg_init (&message);
+    if (zmq_recv (socket, &message, 0))
+        return (NULL);
+    int size = zmq_msg_size (&message);
+    char *string = malloc (size + 1);
+    memcpy (string, zmq_msg_data (&message), size);
+    zmq_msg_close (&message);
+    string [size] = 0;
+    return (string);
+}
+
+//  Convert C string to 0MQ string and send to socket
+static int
+s_send (void *socket, char *string) {
+    int rc;
+    zmq_msg_t message;
+    zmq_msg_init_size (&message, strlen (string));
+    memcpy (zmq_msg_data (&message), string, strlen (string));
+    rc = zmq_send (socket, &message, 0);
+    zmq_msg_close (&message);
+    return (rc);
+}
+
+//  Sends string as 0MQ string, as multipart non-terminal
+static int
+s_sendmore (void *socket, char *string) {
+    int rc;
+    zmq_msg_t message;
+    zmq_msg_init_size (&message, strlen (string));
+    memcpy (zmq_msg_data (&message), string, strlen (string));
+    rc = zmq_send (socket, &message, ZMQ_SNDMORE);
+    zmq_msg_close (&message);
+    return (rc);
+}
+
+//  Receives all message parts from socket, prints neatly
+//
+static void
+s_dump (void *socket)
+{
+    puts ("----------------------------------------");
+    while (1) {
+        //  Process all parts of the message
+        zmq_msg_t message;
+        zmq_msg_init (&message);
+        zmq_recv (socket, &message, 0);
+
+        //  Dump the message as text or binary
+        char *data = zmq_msg_data (&message);
+        int size = zmq_msg_size (&message);
+        int is_text = 1;
+        int char_nbr;
+        for (char_nbr = 0; char_nbr < size; char_nbr++)
+            if ((unsigned char) data [char_nbr] < 32
+            ||  (unsigned char) data [char_nbr] > 127)
+                is_text = 0;
+
+        printf ("[%03d] ", size);
+        for (char_nbr = 0; char_nbr < size; char_nbr++) {
+            if (is_text)
+                printf ("%c", data [char_nbr]);
+            else
+                printf ("%02X", (unsigned char) data [char_nbr]);
+        }
+        printf ("\n");
+
+        int64_t more;           //  Multipart detection
+        size_t more_size = sizeof (more);
+        zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
+        zmq_msg_close (&message);
+        if (!more)
+            break;      //  Last message part
+    }
+}
+
+//  Set simple random printable identity on socket
+//
+static void
+s_set_id (void *socket)
+{
+    char identity [10];
+    sprintf (identity, "%04X-%04X", randof (0x10000), randof (0x10000));
+    zmq_setsockopt (socket, ZMQ_IDENTITY, identity, strlen (identity));
+}
+
+
+//  Sleep for a number of milliseconds
+static void
+s_sleep (int msecs)
+{
+#if (defined (__WINDOWS__))
+    Sleep (msecs);
+#else
+    struct timespec t;
+    t.tv_sec  =  msecs / 1000;
+    t.tv_nsec = (msecs % 1000) * 1000000;
+    nanosleep (&t, NULL);
+#endif
+}
+
+//  Return current system clock as milliseconds
+static int64_t
+s_clock (void)
+{
+#if (defined (__WINDOWS__))
+    SYSTEMTIME st;
+    GetSystemTime (&st);
+    return (int64_t) st.wSecond * 1000 + st.wMilliseconds;
+#else
+    struct timeval tv;
+    gettimeofday (&tv, NULL);
+    return (int64_t) (tv.tv_sec * 1000 + tv.tv_usec / 1000);
+#endif
+}
+
+//  Print formatted string to stdout, prefixed by date/time and
+//  terminated with a newline.
+
+static void
+s_console (const char *format, ...)
+{
+    time_t curtime = time (NULL);
+    struct tm *loctime = localtime (&curtime);
+    char *formatted = malloc (20);
+    strftime (formatted, 20, "%y-%m-%d %H:%M:%S ", loctime);
+    printf ("%s", formatted);
+    free (formatted);
+
+    va_list argptr;
+    va_start (argptr, format);
+    vprintf (format, argptr);
+    va_end (argptr);
+    printf ("\n");
+}
+
+#endif  //  __ZHELPERS_H_INCLUDED__