diff options
Diffstat (limited to 'bindings')
| -rw-r--r-- | bindings/Makefile.am | 15 | ||||
| -rw-r--r-- | bindings/c/zmq.h | 216 | ||||
| -rw-r--r-- | bindings/cpp/zmq.hpp | 283 | ||||
| -rw-r--r-- | bindings/java/Context.cpp | 96 | ||||
| -rw-r--r-- | bindings/java/Makefile.am | 58 | ||||
| -rw-r--r-- | bindings/java/Socket.cpp | 272 | ||||
| -rw-r--r-- | bindings/java/org/zmq/Context.java | 50 | ||||
| -rw-r--r-- | bindings/java/org/zmq/Socket.java | 112 | ||||
| -rw-r--r-- | bindings/python/Makefile.am | 7 | ||||
| -rw-r--r-- | bindings/python/pyzmq.cpp | 528 | ||||
| -rw-r--r-- | bindings/python/setup.py.in | 14 | ||||
| -rw-r--r-- | bindings/ruby/Makefile.am | 11 | ||||
| -rw-r--r-- | bindings/ruby/extconf.rb | 24 | ||||
| -rw-r--r-- | bindings/ruby/rbzmq.cpp | 277 |
14 files changed, 1963 insertions, 0 deletions
diff --git a/bindings/Makefile.am b/bindings/Makefile.am new file mode 100644 index 0000000..77b4ec2 --- /dev/null +++ b/bindings/Makefile.am @@ -0,0 +1,15 @@ +if BUILD_JAVA +DIR_J = java +endif + +if BUILD_PYTHON +DIR_P = python +endif + +if BUILD_RUBY +DIR_R = ruby +endif + +SUBDIRS = $(DIR_J) $(DIR_P) $(DIR_R) +DIST_SUBDIRS = java python ruby + diff --git a/bindings/c/zmq.h b/bindings/c/zmq.h new file mode 100644 index 0000000..732ecb9 --- /dev/null +++ b/bindings/c/zmq.h @@ -0,0 +1,216 @@ +/* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef __ZMQ_H_INCLUDED__ +#define __ZMQ_H_INCLUDED__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stddef.h> + +#if defined ZMQ_BUILDING_LIBZMQ_WITH_MSVC +#define ZMQ_EXPORT __declspec(dllexport) +#else +#define ZMQ_EXPORT +#endif + +// Maximal size of "Very Small Message". VSMs are passed by value +// to avoid excessive memory allocation/deallocation. +// If VMSs larger than 255 bytes are required, type of 'vsm_size' +// field in zmq_msg_t structure should be modified accordingly. +#define ZMQ_MAX_VSM_SIZE 30 + +// Message & notification types. +#define ZMQ_GAP 1 +#define ZMQ_DELIMITER 31 +#define ZMQ_VSM 32 + +// Socket options. +#define ZMQ_HWM 1 // int64_t +#define ZMQ_LWM 2 // int64_t +#define ZMQ_SWAP 3 // int64_t +#define ZMQ_AFFINITY 4 // int64_t +#define ZMQ_IDENTITY 5 // string +#define ZMQ_SUBSCRIBE 6 // string +#define ZMQ_UNSUBSCRIBE 7 // string +#define ZMQ_RATE 8 // int64_t +#define ZMQ_RECOVERY_IVL 9 // int64_t +#define ZMQ_MCAST_LOOP 10 // int64_t + +// The operation should be performed in non-blocking mode. I.e. if it cannot +// be processed immediately, error should be returned with errno set to EAGAIN. +#define ZMQ_NOBLOCK 1 + +// zmq_send should not flush the message downstream immediately. Instead, it +// should batch ZMQ_NOFLUSH messages and send them downstream only if zmq_flush +// is invoked. This is an optimisation for cases where several messages are +// sent in a single business transaction. However, the effect is measurable +// only in extremely high-perf scenarios (million messages a second or so). +// If that's not your case, use standard flushing send instead. See exchange +// example for illustration of ZMQ_NOFLUSH functionality. +#define ZMQ_NOFLUSH 2 + +// Socket to communicate with a single peer. Allows for a singe connect or a +// single accept. There's no message routing or message filtering involved. +#define ZMQ_P2P 0 + +// Socket to distribute data. Recv fuction is not implemented for this socket +// type. Messages are distributed in fanout fashion to all peers. +#define ZMQ_PUB 1 + +// Socket to subscribe to distributed data. Send function is not implemented +// for this socket type. However, subscribe function can be used to modify the +// message filter. +#define ZMQ_SUB 2 + +// Socket to send requests on and receive replies from. Requests are +// load-balanced among all the peers. This socket type doesn't allow for more +// recv's that there were send's. +#define ZMQ_REQ 3 + +// Socket to receive requests from and send replies to. This socket type allows +// only an alternated sequence of recv's and send's. Each send is routed to +// the peer that the previous recv delivered message from. +#define ZMQ_REP 4 + +// Prototype for the message body deallocation functions. +// It is deliberately defined in the way to comply with standard C free. +typedef void (zmq_free_fn) (void *data); + +// A message. If 'shared' is true, message content pointed to by 'content' +// is shared, i.e. reference counting is used to manage its lifetime +// rather than straighforward malloc/free. struct zmq_msg_content is +// not declared in the API. +struct zmq_msg_t +{ + void *content; + unsigned char shared; + unsigned char vsm_size; + unsigned char vsm_data [ZMQ_MAX_VSM_SIZE]; +}; + +// Initialise an empty message (zero bytes long). +ZMQ_EXPORT int zmq_msg_init (struct zmq_msg_t *msg); + +// Initialise a message 'size' bytes long. +// +// Errors: ENOMEM - the size is too large to allocate. +ZMQ_EXPORT int zmq_msg_init_size (struct zmq_msg_t *msg, size_t size); + +// Initialise a message from an existing buffer. Message isn't copied, +// instead 0MQ infrastructure take ownership of the buffer and call +// deallocation functio (ffn) once it's not needed anymore. +ZMQ_EXPORT int zmq_msg_init_data (struct zmq_msg_t *msg, void *data, + size_t size, zmq_free_fn *ffn); + +// Deallocate the message. +ZMQ_EXPORT int zmq_msg_close (struct zmq_msg_t *msg); + +// Move the content of the message from 'src' to 'dest'. The content isn't +// copied, just moved. 'src' is an empty message after the call. Original +// content of 'dest' message is deallocated. +ZMQ_EXPORT int zmq_msg_move (struct zmq_msg_t *dest, struct zmq_msg_t *src); + +// Copy the 'src' message to 'dest'. The content isn't copied, instead +// reference count is increased. Don't modify the message data after the +// call as they are shared between two messages. Original content of 'dest' +// message is deallocated. +ZMQ_EXPORT int zmq_msg_copy (struct zmq_msg_t *dest, struct zmq_msg_t *src); + +// Returns pointer to message data. +ZMQ_EXPORT void *zmq_msg_data (struct zmq_msg_t *msg); + +// Return size of message data (in bytes). +ZMQ_EXPORT size_t zmq_msg_size (struct zmq_msg_t *msg); + +// Returns type of the message. +ZMQ_EXPORT int zmq_msg_type (struct zmq_msg_t *msg); + +// Initialise 0MQ context. 'app_threads' specifies maximal number +// of application threads that can have open sockets at the same time. +// 'io_threads' specifies the size of thread pool to handle I/O operations. +// +// Errors: EINVAL - one of the arguments is less than zero or there are no +// threads declared at all. +ZMQ_EXPORT void *zmq_init (int app_threads, int io_threads); + +// Deinitialise 0MQ context including all the open sockets. Closing +// sockets after zmq_term has been called will result in undefined behaviour. +ZMQ_EXPORT int zmq_term (void *context); + +// Open a socket. +// +// Errors: EINVAL - invalid socket type. +// EMFILE - the number of application threads entitled to hold open +// sockets at the same time was exceeded. +ZMQ_EXPORT void *zmq_socket (void *context, int type); + +// Close the socket. +ZMQ_EXPORT int zmq_close (void *s); + +// Sets an option on the socket. +// EINVAL - unknown option, a value with incorrect length or an invalid value. +ZMQ_EXPORT int zmq_setsockopt (void *s, int option_, const void *optval_, + size_t optvallen_); + +// Bind the socket to a particular address. +ZMQ_EXPORT int zmq_bind (void *s, const char *addr); + +// Connect the socket to a particular address. +ZMQ_EXPORT int zmq_connect (void *s, const char *addr); + +// Send the message 'msg' to the socket 's'. 'flags' argument can be +// combination of following values: +// ZMQ_NOBLOCK - if message cannot be sent, return immediately. +// ZMQ_NOFLUSH - message won't be sent immediately. It'll be sent with either +// subsequent flushing send or explicit call to zmq_flush +// function. +// +// Errors: EAGAIN - message cannot be sent at the moment (applies only to +// non-blocking send). +// EFAULT - function isn't supported by particular socket type. +ZMQ_EXPORT int zmq_send (void *s, struct zmq_msg_t *msg, int flags); + +// Flush the messages that were send using ZMQ_NOFLUSH flag down the stream. +// +// Errors: FAULT - function isn't supported by particular socket type. +ZMQ_EXPORT int zmq_flush (void *s); + +// Send a message from the socket 's'. 'flags' argument can be combination +// of following values: +// ZMQ_NOBLOCK - if message cannot be received, return immediately. +// +// Errors: EAGAIN - message cannot be received at the moment (applies only to +// non-blocking receive). +// EFAULT - function isn't supported by particular socket type. +ZMQ_EXPORT int zmq_recv (void *s, struct zmq_msg_t *msg, int flags); + +// Helper functions used by perf tests so that they don't have to care +// about minutiae of time-related functions on different OS platforms. +ZMQ_EXPORT void *zmq_stopwatch_start (); +ZMQ_EXPORT unsigned long zmq_stopwatch_stop (void *watch_); +ZMQ_EXPORT void zmq_sleep (int seconds_); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/bindings/cpp/zmq.hpp b/bindings/cpp/zmq.hpp new file mode 100644 index 0000000..471d1d8 --- /dev/null +++ b/bindings/cpp/zmq.hpp @@ -0,0 +1,283 @@ +/* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef __ZMQ_HPP_INCLUDED__ +#define __ZMQ_HPP_INCLUDED__ + +#include "zmq.h" + +#include <assert.h> +#include <errno.h> +#include <string.h> +#include <exception> + +namespace zmq +{ + + typedef zmq_free_fn free_fn; + + enum message_type_t + { + message_data = 1 << 0, + message_gap = 1 << ZMQ_GAP, + message_delimiter = 1 << ZMQ_DELIMITER + }; + + // The class masquerades POSIX-style errno error as a C++ exception. + class error_t : public std::exception + { + public: + + error_t () : errnum (errno) {} + + virtual const char *what () const throw () + { +#if defined _MSC_VER +#pragma warning (push) +#pragma warning (disable:4996) +#endif + return strerror (errnum); +#if defined _MSC_VER +#pragma warning (pop) +#endif + } + + private: + + int errnum; + }; + + // A message. Caution: Don't change the body of the message once you've + // copied it - the behaviour is undefined. Don't change the body of the + // received message either - other threads may be accessing it in parallel. + + class message_t : private zmq_msg_t + { + friend class socket_t; + + public: + + // Creates message size_ bytes long. + inline message_t (size_t size_ = 0) + { + int rc = zmq_msg_init_size (this, size_); + if (rc != 0) + throw error_t (); + } + + // Creates message from the supplied buffer. 0MQ takes care of + // deallocating the buffer once it is not needed. The deallocation + // function is supplied in ffn_ parameter. If ffn_ is NULL, no + // deallocation happens - this is useful for sending static buffers. + inline message_t (void *data_, size_t size_, + free_fn *ffn_) + { + int rc = zmq_msg_init_data (this, data_, size_, ffn_); + if (rc != 0) + throw error_t (); + } + + // Destroys the message. + inline ~message_t () + { + int rc = zmq_msg_close (this); + if (rc != 0) + throw error_t (); + } + + // Destroys old content of the message and allocates buffer for the + // new message body. Having this as a separate function allows user + // to reuse once-allocated message for multiple times. + inline void rebuild (size_t size_) + { + int rc = zmq_msg_close (this); + if (rc != 0) + throw error_t (); + rc = zmq_msg_init_size (this, size_); + if (rc != 0) + throw error_t (); + } + + // Same as above, however, the message is rebuilt from the supplied + // buffer. See appropriate constructor for discussion of buffer + // deallocation mechanism. + inline void rebuild (void *data_, size_t size_, free_fn *ffn_) + { + int rc = zmq_msg_close (this); + if (rc != 0) + throw error_t (); + rc = zmq_msg_init_data (this, data_, size_, ffn_); + if (rc != 0) + throw error_t (); + } + + // Moves the message content from one message to the another. If the + // destination message have contained data prior to the operation + // these get deallocated. The source message will contain 0 bytes + // of data after the operation. + inline void move_to (message_t *msg_) + { + int rc = zmq_msg_move (this, (zmq_msg_t*) msg_); + if (rc != 0) + throw error_t (); + } + + // Copies the message content from one message to the another. If the + // destination message have contained data prior to the operation + // these get deallocated. + inline void copy_to (message_t *msg_) + { + int rc = zmq_msg_copy (this, (zmq_msg_t*) msg_); + if (rc != 0) + throw error_t (); + } + + // Returns message type. + inline message_type_t type () + { + return (message_type_t) (1 << zmq_msg_type (this)); + } + + // Returns pointer to message's data buffer. + inline void *data () + { + return zmq_msg_data (this); + } + + // Returns the size of message data buffer. + inline size_t size () + { + return zmq_msg_size (this); + } + + private: + + // Disable implicit message copying, so that users won't use shared + // messages (less efficient) without being aware of the fact. + message_t (const message_t&); + void operator = (const message_t&); + }; + + class context_t + { + friend class socket_t; + + public: + + inline context_t (int app_threads_, int io_threads_) + { + ptr = zmq_init (app_threads_, io_threads_); + if (ptr == NULL) + throw error_t (); + } + + inline ~context_t () + { + int rc = zmq_term (ptr); + assert (rc == 0); + } + + private: + + void *ptr; + + // Disable copying. + context_t (const context_t&); + void operator = (const context_t&); + }; + + class socket_t + { + public: + + inline socket_t (context_t &context_, int type_ = 0) + { + ptr = zmq_socket (context_.ptr, type_); + if (ptr == NULL) + throw error_t (); + } + + inline ~socket_t () + { + int rc = zmq_close (ptr); + if (rc != 0) + throw error_t (); + } + + inline void setsockopt (int option_, const void *optval_, + size_t optvallen_) + { + int rc = zmq_setsockopt (ptr, option_, optval_, optvallen_); + if (rc != 0) + throw error_t (); + } + + inline void bind (const char *addr_) + { + int rc = zmq_bind (ptr, addr_); + if (rc != 0) + throw error_t (); + } + + inline void connect (const char *addr_) + { + int rc = zmq_connect (ptr, addr_); + if (rc != 0) + throw error_t (); + } + + inline bool send (message_t &msg_, int flags_ = 0) + { + int rc = zmq_send (ptr, &msg_, flags_); + if (rc == 0) + return true; + if (rc == -1 && errno == EAGAIN) + return false; + throw error_t (); + } + + inline void flush () + { + int rc = zmq_flush (ptr); + if (rc != 0) + throw error_t (); + } + + inline bool recv (message_t *msg_, int flags_ = 0) + { + int rc = zmq_recv (ptr, msg_, flags_); + if (rc == 0) + return true; + if (rc == -1 && errno == EAGAIN) + return false; + throw error_t (); + } + + private: + + void *ptr; + + // Disable copying. + socket_t (const socket_t&); + void operator = (const socket_t&); + }; + +} + +#endif diff --git a/bindings/java/Context.cpp b/bindings/java/Context.cpp new file mode 100644 index 0000000..67094e8 --- /dev/null +++ b/bindings/java/Context.cpp @@ -0,0 +1,96 @@ +/* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <stdlib.h> +#include <string.h> +#include <assert.h> +#include <errno.h> + +#include "zmq.h" +#include "org_zmq_Context.h" + +static jfieldID ctx_handle_fid = NULL; + +static void raise_exception (JNIEnv *env, int err) +{ + // Get exception class. + jclass exception_class = env->FindClass ("java/lang/Exception"); + assert (exception_class); + + // Get text description of the exception. +#if defined _MSC_VER +#pragma warning (push) +#pragma warning (disable:4996) +#endif + const char *err_msg = strerror (err); +#if defined _MSC_VER +#pragma warning (pop) +#endif + + // Raise the exception. + int rc = env->ThrowNew (exception_class, err_msg); + assert (rc == 0); + + // Free the local ref. + env->DeleteLocalRef (exception_class); +} + +JNIEXPORT void JNICALL Java_org_zmq_Context_construct (JNIEnv *env, jobject obj, + jint app_threads, jint io_threads) +{ + if (ctx_handle_fid == NULL) { + jclass cls = env->GetObjectClass (obj); + assert (cls); + ctx_handle_fid = env->GetFieldID (cls, "contextHandle", "J"); + assert (ctx_handle_fid); + env->DeleteLocalRef (cls); + } + + void *ctx = zmq_init (app_threads, io_threads); + if (ctx == NULL) { + raise_exception (env, errno); + return; + } + + env->SetLongField (obj, ctx_handle_fid, (jlong) ctx); +} + +JNIEXPORT void JNICALL Java_org_zmq_Context_finalize (JNIEnv *env, jobject obj) +{ + void *ctx = (void*) env->GetLongField (obj, ctx_handle_fid); + assert (ctx); + + int rc = zmq_term (ctx); + assert (rc == 0); +} + +JNIEXPORT jlong JNICALL Java_org_zmq_Context_createSocket (JNIEnv *env, + jobject obj, jint type) +{ + void *ctx = (void*) env->GetLongField (obj, ctx_handle_fid); + assert (ctx); + + void *s = zmq_socket (ctx, type); + if (s == NULL) { + raise_exception (env, errno); + return -1; + } + + return (jlong) s; +} diff --git a/bindings/java/Makefile.am b/bindings/java/Makefile.am new file mode 100644 index 0000000..c9e430c --- /dev/null +++ b/bindings/java/Makefile.am @@ -0,0 +1,58 @@ +# We do not want to install Jzmq.class file +# user has to copy it to the right location. +#jzmqdir = /tmp + +jarfile = Zmq.jar +jardir = $(datadir)/java + +$(jarfile): $(dist_noinst_JAVA) + $(JAR) cf $(JARFLAGS) $@ org/zmq/*.class + +jar_DATA = $(jarfile) + +dist_noinst_JAVA = \ + org/zmq/Context.java \ + org/zmq/Socket.java + +lib_LTLIBRARIES = libjzmq.la +libjzmq_la_SOURCES = \ + Context.cpp \ + org_zmq_Context.h \ + Socket.cpp \ + org_zmq_Socket.h + +libjzmq_la_CXXFLAGS = -I$(top_srcdir)/src/libzmq \ +@JAVA_INCLUDE@ -I$(top_srcdir)/bindings/c -Wall +libjzmq_la_LDFLAGS = -version-info @JLTVER@ +libjzmq_la_LIBADD = $(top_builddir)/src/libzmq.la + +BUILT_SOURCES = \ + org/zmq/Context.class \ + org_zmq_Context.h \ + org/zmq/Socket.class \ + org_zmq_Socket.h + +CLEANFILES = \ + org/zmq/Context.class \ + org_zmq_Context.h \ + org/zmq/Socket.class \ + org_zmq_Socket.h \ + Zmq.jar + +$(srcdir)/Context.cpp: org_zmq_Context.h + +org_zmq_Context.h: org/zmq/Context.class + $(CLASSPATH_ENV) $(JAVAH) -jni -classpath . org.zmq.Context + +./org/zmq/Context.class: classdist_noinst.stamp + +$(srcdir)/Socket.cpp: org_zmq_Socket.h + +org_zmq_Socket.h: org/zmq/Socket.class + $(CLASSPATH_ENV) $(JAVAH) -jni -classpath . org.zmq.Socket + +./org/zmq/Socket.class: classdist_noinst.stamp + +dist-hook: + -rm $(distdir)/*.h + diff --git a/bindings/java/Socket.cpp b/bindings/java/Socket.cpp new file mode 100644 index 0000000..2274535 --- /dev/null +++ b/bindings/java/Socket.cpp @@ -0,0 +1,272 @@ +/* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <stdlib.h> +#include <string.h> +#include <assert.h> +#include <errno.h> + +#include "../src/stdint.hpp" + +#include "zmq.h" +#include "org_zmq_Socket.h" + +static jfieldID socket_handle_fid = NULL; +static jmethodID create_socket_mid = NULL; + +static void raise_exception (JNIEnv *env, int err) +{ + // Get exception class. + jclass exception_class = env->FindClass ("java/lang/Exception"); + assert (exception_class); + + // Get text description of the exception. +#if defined _MSC_VER +#pragma warning (push) +#pragma warning (disable:4996) +#endif + const char *err_msg = strerror (err); +#if defined _MSC_VER +#pragma warning (pop) +#endif + + // Raise the exception. + int rc = env->ThrowNew (exception_class, err_msg); + assert (rc == 0); + + // Free the local ref. + env->DeleteLocalRef (exception_class); +} + +JNIEXPORT void JNICALL Java_org_zmq_Socket_construct (JNIEnv *env, jobject obj, + jobject context, jint type) +{ + if (socket_handle_fid == NULL) { + jclass cls = env->GetObjectClass (obj); + assert (cls); + socket_handle_fid = env->GetFieldID (cls, "socketHandle", "J"); + assert (socket_handle_fid); + env->DeleteLocalRef (cls); + } + + if (create_socket_mid == NULL) { + jclass cls = env->FindClass ("org/zmq/Context"); + assert (cls); + create_socket_mid = env->GetMethodID (cls, "createSocket", "(I)J"); + assert (create_socket_mid); + env->DeleteLocalRef (cls); + } + + void *s = (void*) env->CallLongMethod (context, create_socket_mid, type); + if (env->ExceptionCheck ()) + return; + + env->SetLongField (obj, socket_handle_fid, (jlong) s); +} + +JNIEXPORT void JNICALL Java_org_zmq_Socket_finalize (JNIEnv *env, jobject obj) +{ + void *s = (void*) env->GetLongField (obj, socket_handle_fid); + assert (s); + int rc = zmq_close (s); + assert (rc == 0); +} + +JNIEXPORT void JNICALL Java_org_zmq_Socket_setsockopt__IJ (JNIEnv *env, + jobject obj, jint option, jlong optval) +{ + switch (option) { + case ZMQ_HWM: + case ZMQ_LWM: + case ZMQ_SWAP: + case ZMQ_AFFINITY: + case ZMQ_RATE: + case ZMQ_RECOVERY_IVL: + case ZMQ_MCAST_LOOP: + { + void *s = (void*) env->GetLongField (obj, socket_handle_fid); + assert (s); + + int64_t value = optval; + int rc = zmq_setsockopt (s, option, &value, sizeof (value)); + if (rc != 0) + raise_exception (env, errno); + return; + } + default: + raise_exception (env, EINVAL); + return; + } +} + +JNIEXPORT void JNICALL Java_org_zmq_Socket_setsockopt__ILjava_lang_String_2 ( + JNIEnv *env, jobject obj, jint option, jstring optval) +{ + switch (option) { + case ZMQ_IDENTITY: + case ZMQ_SUBSCRIBE: + case ZMQ_UNSUBSCRIBE: + { + if (optval == NULL) { + raise_exception (env, EINVAL); + return; + } + + void *s = (void*) env->GetLongField (obj, socket_handle_fid); + assert (s); + + const char *value = env->GetStringUTFChars (optval, NULL); + assert (value); + int rc = zmq_setsockopt (s, option, value, strlen (value)); + env->ReleaseStringUTFChars (optval, value); + if (rc != 0) + raise_exception (env, errno); + return; + } + default: + raise_exception (env, EINVAL); + return; + } +} + +JNIEXPORT void JNICALL Java_org_zmq_Socket_bind (JNIEnv *env, jobject obj, + jstring addr) +{ + void *s = (void*) env->GetLongField (obj, socket_handle_fid); + assert (s); + + if (addr == NULL) { + raise_exception (env, EINVAL); + return; + } + + const char *c_addr = env->GetStringUTFChars (addr, NULL); + if (c_addr == NULL) { + raise_exception (env, EINVAL); + return; + } + + int rc = zmq_bind (s, c_addr); + env->ReleaseStringUTFChars (addr, c_addr); + + if (rc == -1) + raise_exception (env, errno); +} + +JNIEXPORT void JNICALL Java_org_zmq_Socket_connect (JNIEnv *env, jobject obj, + jstring addr) +{ + void *s = (void*) env->GetLongField (obj, socket_handle_fid); + assert (s); + + if (addr == NULL) { + raise_exception (env, EINVAL); + return; + } + + const char *c_addr = env->GetStringUTFChars (addr, NULL); + if (c_addr == NULL) { + raise_exception (env, EINVAL); + return; + } + + int rc = zmq_connect (s, c_addr); + env->ReleaseStringUTFChars (addr, c_addr); + + if (rc == -1) + raise_exception (env, errno); +} + +JNIEXPORT jboolean JNICALL Java_org_zmq_Socket_send (JNIEnv *env, jobject obj, + jbyteArray msg, jlong flags) +{ + void *s = (void*) env->GetLongField (obj, socket_handle_fid); + assert (s); + + jsize size = env->GetArrayLength (msg); + jbyte *data = env->GetByteArrayElements (msg, 0); + + zmq_msg_t message; + int rc = zmq_msg_init_size (&message, size); + assert (rc == 0); + memcpy (zmq_msg_data (&message), data, size); + + env->ReleaseByteArrayElements (msg, data, 0); + + rc = zmq_send (s, &message, (int) flags); + + if (rc == -1 && errno == EAGAIN) { + rc = zmq_msg_close (&message); + assert (rc == 0); + return JNI_FALSE; + } + + if (rc == -1) { + raise_exception (env, errno); + rc = zmq_msg_close (&message); + assert (rc == 0); + return JNI_FALSE; + } + + rc = zmq_msg_close (&message); + assert (rc == 0); + return JNI_TRUE; +} + +JNIEXPORT void JNICALL Java_org_zmq_Socket_flush (JNIEnv *env, jobject obj) +{ + void *s = (void*) env->GetLongField (obj, socket_handle_fid); + assert (s); + + int rc = zmq_flush (s); + + if (rc == -1) { + raise_exception (env, errno); + return ; + } +} + +JNIEXPORT jbyteArray JNICALL Java_org_zmq_Socket_recv (JNIEnv *env, jobject obj, + jlong flags) +{ + void *s = (void*) env->GetLongField (obj, socket_handle_fid); + assert (s); + + zmq_msg_t message; + zmq_msg_init (&message); + int rc = zmq_recv (s, &message, (int) flags); + + if (rc == -1 && errno == EAGAIN) { + zmq_msg_close (&message); + return NULL; + } + + if (rc == -1) { + raise_exception (env, errno); + zmq_msg_close (&message); + return NULL; + } + + jbyteArray data = env->NewByteArray (zmq_msg_size (&message)); + assert (data); + env->SetByteArrayRegion (data, 0, zmq_msg_size (&message), + (jbyte*) zmq_msg_data (&message)); + + return data; +} diff --git a/bindings/java/org/zmq/Context.java b/bindings/java/org/zmq/Context.java new file mode 100644 index 0000000..c63ef60 --- /dev/null +++ b/bindings/java/org/zmq/Context.java @@ -0,0 +1,50 @@ +/* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +package org.zmq; + +public class Context { + static { + System.loadLibrary("jzmq"); + } + + /** + * Class constructor. + * + * @param appThreads maximum number of application threads. + * @param ioThreads size of the threads pool to handle I/O operations. + */ + public Context (int appThreads, int ioThreads) { + construct (appThreads, ioThreads); + } + + /** + * Internal function. Do not use directly! + */ + public native long createSocket (int type); + + /** Initialize the JNI interface */ + protected native void construct (int appThreads, int ioThreads); + + /** Free resources used by JNI driver. */ + protected native void finalize (); + + /** Opaque data used by JNI driver. */ + private long contextHandle; +} diff --git a/bindings/java/org/zmq/Socket.java b/bindings/java/org/zmq/Socket.java new file mode 100644 index 0000000..501bc16 --- /dev/null +++ b/bindings/java/org/zmq/Socket.java @@ -0,0 +1,112 @@ + /* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +package org.zmq; + +public class Socket +{ + + static { + System.loadLibrary("jzmq"); + } + + public static final int NOBLOCK = 1; + public static final int NOFLUSH = 2; + + public static final int P2P = 0; + public static final int PUB = 1; + public static final int SUB = 2; + public static final int REQ = 3; + public static final int REP = 4; + + public static final int HWM = 1; + public static final int LWM = 2; + public static final int SWAP = 3; + public static final int AFFINITY = 4; + public static final int IDENTITY = 5; + public static final int SUBSCRIBE = 6; + public static final int UNSUBSCRIBE = 7; + public static final int RATE = 8; + public static final int RECOVERY_IVL = 9; + public static final int MCAST_LOOP = 10; + + /** + * Class constructor. + * + * @param context + * @param type + */ + public Socket (Context context, int type) { + construct (context, type); + } + + /** + * Set the socket option value. + * + * @param option ID of the option to set + * @param optval value to set the option to + */ + public native void setsockopt (int option, long optval); + public native void setsockopt (int option, String optval); + + /** + * Bind to network interface. Start listening for new connections. + * + * @param addr + */ + public native void bind (String addr); + + /** + * Connect to remote application. + * + * @param addr + */ + public native void connect (String addr); + + /** + * Send the message. + * + * @param msg + * @param flags + */ + public native boolean send (byte [] msg, long flags); + + /** + * Flush the messages down the stream. + */ + public native void flush (); + + /** + * Receive message. + * + * @param flags + * @return + */ + public native byte [] recv (long flags); + + /** Initialize JNI driver */ + protected native void construct (Context context, int type); + + /** Free all resources used by JNI driver. */ + protected native void finalize (); + + /** Opaque data used by JNI driver. */ + private long socketHandle; + +} diff --git a/bindings/python/Makefile.am b/bindings/python/Makefile.am new file mode 100644 index 0000000..effe8b9 --- /dev/null +++ b/bindings/python/Makefile.am @@ -0,0 +1,7 @@ +INCLUDES = -I$(top_builddir) -I$(top_srcdir) -I$(top_srcdir)/libzmq \ +-I$(top_builddir)/libzmq $(PYTHON_INCLUDES) + +pyexec_LTLIBRARIES = libpyzmq.la +libpyzmq_la_SOURCES = pyzmq.cpp +libpyzmq_la_LIBADD = $(top_builddir)/src/libzmq.la +libpyzmq_la_LDFLAGS = -avoid-version diff --git a/bindings/python/pyzmq.cpp b/bindings/python/pyzmq.cpp new file mode 100644 index 0000000..628d037 --- /dev/null +++ b/bindings/python/pyzmq.cpp @@ -0,0 +1,528 @@ +/* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <stddef.h> +#include <assert.h> +#include <errno.h> +#include <string.h> +#include <Python.h> + +#include "../c/zmq.h" + +#if defined _MSC_VER +#pragma warning (push) +#pragma warning (disable:4996) +#endif + +struct context_t +{ + PyObject_HEAD + void *handle; +}; + +PyObject *context_new (PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + context_t *self = (context_t*) type->tp_alloc (type, 0); + + if (self) + self->handle = NULL; + + return (PyObject*) self; +} + + +int context_init (context_t *self, PyObject *args, PyObject *kwdict) +{ + int app_threads; + int io_threads; + static const char *kwlist [] = {"app_threads", "io_threads", NULL}; + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "ii", (char**) kwlist, + &app_threads, &io_threads)) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return -1; // ? + } + + assert (!self->handle); + self->handle = zmq_init (app_threads, io_threads); + if (!self->handle) { + PyErr_SetString (PyExc_SystemError, strerror (errno)); + return -1; // ? + } + + return 0; +} + +void context_dealloc (context_t *self) +{ + if (self->handle) { + int rc = zmq_term (self->handle); + if (rc != 0) + PyErr_SetString (PyExc_SystemError, strerror (errno)); + } + + self->ob_type->tp_free ((PyObject*) self); +} + +struct socket_t +{ + PyObject_HEAD + void *handle; +}; + +PyObject *socket_new (PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + socket_t *self = (socket_t*) type->tp_alloc (type, 0); + + if (self) + self->handle = NULL; + + return (PyObject*) self; +} + +int socket_init (socket_t *self, PyObject *args, PyObject *kwdict) +{ + context_t *context; + int socket_type; + static const char *kwlist [] = {"context", "type", NULL}; + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "Oi", (char**) kwlist, + &context, &socket_type)) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return NULL; + } + // TODO: Check whether 'context' is really a libpyzmq.Context object. + + assert (!self->handle); + self->handle = zmq_socket (context->handle, socket_type); + if (!self->handle) { + PyErr_SetString (PyExc_SystemError, strerror (errno)); + return -1; // ? + } + + return 0; +} + +void socket_dealloc (socket_t *self) +{ + if (self->handle) { + int rc = zmq_close (self->handle); + if (rc != 0) + PyErr_SetString (PyExc_SystemError, strerror (errno)); + } + + self->ob_type->tp_free ((PyObject*) self); +} + +PyObject *socket_setsockopt (socket_t *self, PyObject *args, PyObject *kwdict) +{ + int option; + PyObject* optval; + static const char *kwlist [] = {"option", "optval", NULL}; + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "iO", (char**) kwlist, + &option, &optval)) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return NULL; + } + + int rc = 0; + + switch (option) { + case ZMQ_HWM: + case ZMQ_LWM: + case ZMQ_SWAP: + case ZMQ_AFFINITY: + case ZMQ_RATE: + case ZMQ_RECOVERY_IVL: + case ZMQ_MCAST_LOOP: + { + int val = PyInt_AsLong (optval); + rc = zmq_setsockopt (self->handle, option, &val, sizeof (int)); + break; + } + case ZMQ_IDENTITY: + case ZMQ_SUBSCRIBE: + case ZMQ_UNSUBSCRIBE: + + rc = zmq_setsockopt (self->handle, option, PyString_AsString (optval), + PyString_Size (optval)); + break; + + default: + rc = -1; + errno = EINVAL; + } + + if (rc != 0) { + PyErr_SetString (PyExc_SystemError, strerror (errno)); + return NULL; + } + + Py_INCREF (Py_None); + return Py_None; +} + +PyObject *socket_bind (socket_t *self, PyObject *args, PyObject *kwdict) +{ + char const *addr; + static const char *kwlist [] = {"addr", NULL}; + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "s", (char**) kwlist, + &addr)) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return NULL; + } + + int rc = zmq_bind (self->handle, addr); + if (rc != 0) { + PyErr_SetString (PyExc_SystemError, strerror (errno)); + return NULL; + } + + Py_INCREF (Py_None); + return Py_None; +} + +PyObject *socket_connect (socket_t *self, PyObject *args, PyObject *kwdict) +{ + char const *addr; + static const char *kwlist [] = {"addr", NULL}; + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "s", (char**) kwlist, + &addr)) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return NULL; + } + + int rc = zmq_connect (self->handle, addr); + if (rc != 0) { + PyErr_SetString (PyExc_SystemError, strerror (errno)); + return NULL; + } + + Py_INCREF (Py_None); + return Py_None; +} + +PyObject *socket_send (socket_t *self, PyObject *args, PyObject *kwdict) +{ + PyObject *msg; /* = PyString_FromStringAndSize (NULL, 0); */ + int flags = 0; + static const char *kwlist [] = {"msg", "flags", NULL}; + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "S|i", (char**) kwlist, + &msg, &flags)) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return NULL; + } + + zmq_msg_t data; + int rc = zmq_msg_init_size (&data, PyString_Size (msg)); + if (rc != 0) { + PyErr_SetString (PyExc_SystemError, strerror (errno)); + return NULL; + } + memcpy (zmq_msg_data (&data), PyString_AsString (msg), + zmq_msg_size (&data)); + + rc = zmq_send (self->handle, &data, flags); + int rc2 = zmq_msg_close (&data); + assert (rc2 == 0); + + if (rc != 0 && errno == EAGAIN) + return PyBool_FromLong (0); + + if (rc != 0) { + PyErr_SetString (PyExc_SystemError, strerror (errno)); + return NULL; + } + + return PyBool_FromLong (1); +} + +PyObject *socket_flush (socket_t *self, PyObject *args, PyObject *kwdict) +{ + static const char *kwlist [] = {NULL}; + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "", (char**) kwlist)) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return NULL; + } + + int rc = zmq_flush (self->handle); + if (rc != 0) { + PyErr_SetString (PyExc_SystemError, strerror (errno)); + return NULL; + } + + Py_INCREF (Py_None); + return Py_None; +} + +PyObject *socket_recv (socket_t *self, PyObject *args, PyObject *kwdict) +{ + int flags = 0; + static const char *kwlist [] = {"flags", NULL}; + if (!PyArg_ParseTupleAndKeywords (args, kwdict, "|i", (char**) kwlist, + &flags)) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return NULL; + } + + zmq_msg_t msg; + int rc = zmq_msg_init (&msg); + assert (rc == 0); + + rc = zmq_recv (self->handle, &msg, flags); + + if (rc != 0 && errno == EAGAIN) { + Py_INCREF (Py_None); + return Py_None; + } + + if (rc != 0) { + PyErr_SetString (PyExc_SystemError, "invalid arguments"); + return NULL; + } + + PyObject *result = PyString_FromStringAndSize ((char*) zmq_msg_data (&msg), + zmq_msg_size (&msg)); + rc = zmq_msg_close (&msg); + assert (rc == 0); + return result; +} + +static PyMethodDef context_methods [] = +{ + { + NULL + } +}; + +static PyTypeObject context_type = +{ + PyObject_HEAD_INIT (NULL) + 0, + "libpyzmq.Context", /* tp_name */ + sizeof (context_t), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) context_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + "", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + context_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc) context_init, /* tp_init */ + 0, /* tp_alloc */ + context_new /* tp_new */ +}; + +static PyMethodDef socket_methods [] = +{ + { + "setsockopt", + (PyCFunction) socket_setsockopt, + METH_VARARGS | METH_KEYWORDS, + "setsockopt (option, optval) -> None\n\n" + }, + { + "bind", + (PyCFunction) socket_bind, + METH_VARARGS | METH_KEYWORDS, + "bind (addr) -> None\n\n" + }, + { + "connect", + (PyCFunction) socket_connect, + METH_VARARGS | METH_KEYWORDS, + "connect (addr) -> None\n\n" + }, + { + "send", + (PyCFunction) socket_send, + METH_VARARGS | METH_KEYWORDS, + "send (msg, [flags]) -> Bool\n\n" + }, + { + "flush", + (PyCFunction) socket_flush, + METH_VARARGS | METH_KEYWORDS, + "flush () -> None\n\n" + }, + { + "recv", + (PyCFunction) socket_recv, + METH_VARARGS | METH_KEYWORDS, + "recv ([flags]) -> String\n\n" + }, + { + NULL + } +}; + +static PyTypeObject socket_type = +{ + PyObject_HEAD_INIT (NULL) + 0, + "libpyzmq.Socket", /* tp_name */ + sizeof (socket_t), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) socket_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + "", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + socket_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc) socket_init, /* tp_init */ + 0, /* tp_alloc */ + socket_new /* tp_new */ +}; + +static PyMethodDef module_methods [] = {{ NULL, NULL, 0, NULL }}; + +static const char* libpyzmq_doc = + "Python API for 0MQ lightweight messaging kernel.\n" + "For more information see http://www.zeromq.org.\n" + "0MQ is distributed under GNU Lesser General Public License v3.\n"; + +#ifndef PyMODINIT_FUNC +#define PyMODINIT_FUNC void +#endif + +PyMODINIT_FUNC initlibpyzmq () +{ + int rc = PyType_Ready (&context_type); + assert (rc == 0); + rc = PyType_Ready (&socket_type); + assert (rc == 0); + + PyObject *module = Py_InitModule3 ("libpyzmq", module_methods, + libpyzmq_doc); + if (!module) + return; + + Py_INCREF (&context_type); + PyModule_AddObject (module, "Context", (PyObject*) &context_type); + Py_INCREF (&socket_type); + PyModule_AddObject (module, "Socket", (PyObject*) &socket_type); + + PyObject *dict = PyModule_GetDict (module); + assert (dict); + PyObject *t; + t = PyInt_FromLong (ZMQ_NOBLOCK); + PyDict_SetItemString (dict, "NOBLOCK", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_NOFLUSH); + PyDict_SetItemString (dict, "NOFLUSH", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_P2P); + PyDict_SetItemString (dict, "P2P", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_PUB); + PyDict_SetItemString (dict, "PUB", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_SUB); + PyDict_SetItemString (dict, "SUB", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_REQ); + PyDict_SetItemString (dict, "REQ", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_REP); + PyDict_SetItemString (dict, "REP", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_HWM); + PyDict_SetItemString (dict, "HWM", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_LWM); + PyDict_SetItemString (dict, "LWM", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_SWAP); + PyDict_SetItemString (dict, "SWAP", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_AFFINITY); + PyDict_SetItemString (dict, "AFFINITY", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_IDENTITY); + PyDict_SetItemString (dict, "IDENTITY", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_SUBSCRIBE); + PyDict_SetItemString (dict, "SUBSCRIBE", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_UNSUBSCRIBE); + PyDict_SetItemString (dict, "UNSUBSCRIBE", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_RATE); + PyDict_SetItemString (dict, "RATE", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_RECOVERY_IVL); + PyDict_SetItemString (dict, "RECOVERY_IVL", t); + Py_DECREF (t); + t = PyInt_FromLong (ZMQ_MCAST_LOOP); + PyDict_SetItemString (dict, "MCAST_LOOP", t); + Py_DECREF (t); + +} + +#if defined _MSC_VER +#pragma warning (pop) +#endif diff --git a/bindings/python/setup.py.in b/bindings/python/setup.py.in new file mode 100644 index 0000000..f7055d5 --- /dev/null +++ b/bindings/python/setup.py.in @@ -0,0 +1,14 @@ +from distutils.core import setup, Extension + +module1 = Extension('libpyzmq', + libraries = ['zmq'], + library_dirs = ['@prefix@/lib'], + include_dirs = ['@PYTHON_SETUP_INCLUDES@','@prefix@/include'], + sources = ['pyzmq.cpp']) + +setup (name = 'libyzmq', + version = '@VERSION@', + description = '0MQ Python library', + ext_modules = [module1]) + + diff --git a/bindings/ruby/Makefile.am b/bindings/ruby/Makefile.am new file mode 100644 index 0000000..148daf0 --- /dev/null +++ b/bindings/ruby/Makefile.am @@ -0,0 +1,11 @@ +INCLUDES = -I$(top_builddir) -I$(top_srcdir)/include -I$(top_builddir)/include + +rblib_LTLIBRARIES = librbzmq.la +rblibdir = @RUBYDIR@ + +librbzmq_la_SOURCES = rbzmq.cpp + +librbzmq_la_LDFLAGS = -version-info @RBLTVER@ +librbzmq_la_CXXFLAGS = -Wall -pedantic -Werror -Wno-long-long +librbzmq_la_LIBADD = $(top_builddir)/src/libzmq.la + diff --git a/bindings/ruby/extconf.rb b/bindings/ruby/extconf.rb new file mode 100644 index 0000000..f931c5e --- /dev/null +++ b/bindings/ruby/extconf.rb @@ -0,0 +1,24 @@ +# +# Copyright (c) 2007-2009 FastMQ Inc. +# +# This file is part of 0MQ. +# +# 0MQ is free software; you can redistribute it and/or modify it under +# the terms of the Lesser GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# 0MQ is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# Lesser GNU General Public License for more details. +# +# You should have received a copy of the Lesser GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +require 'mkmf' +dir_config('libzmq') +have_library('libzmq') +create_makefile("ruby") + + diff --git a/bindings/ruby/rbzmq.cpp b/bindings/ruby/rbzmq.cpp new file mode 100644 index 0000000..bf0d9bc --- /dev/null +++ b/bindings/ruby/rbzmq.cpp @@ -0,0 +1,277 @@ +/* + Copyright (c) 2007-2009 FastMQ Inc. + + This file is part of 0MQ. + + 0MQ is free software; you can redistribute it and/or modify it under + the terms of the Lesser GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + 0MQ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + Lesser GNU General Public License for more details. + + You should have received a copy of the Lesser GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <assert.h> +#include <errno.h> +#include <string.h> +#include <ruby.h> + +#include "../c/zmq.h" + +static void context_free (void *ctx) +{ + if (ctx) { + int rc = zmq_term (ctx); + assert (rc == 0); + } +} + +static VALUE context_alloc (VALUE class_) +{ + return rb_data_object_alloc (class_, NULL, 0, context_free); +} + +static VALUE context_initialize (VALUE self_, VALUE app_threads_, + VALUE io_threads_) +{ + assert (!DATA_PTR (self_)); + void *ctx = zmq_init (NUM2INT (app_threads_), NUM2INT (io_threads_)); + if (!ctx) { + rb_raise (rb_eRuntimeError, strerror (errno)); + return Qnil; + } + + DATA_PTR (self_) = (void*) ctx; + return self_; +} + +static void socket_free (void *s) +{ + if (s) { + int rc = zmq_close (s); + assert (rc == 0); + } +} + +static VALUE socket_alloc (VALUE class_) +{ + return rb_data_object_alloc (class_, NULL, 0, socket_free); +} + +static VALUE socket_initialize (VALUE self_, VALUE context_, VALUE type_) +{ + assert (!DATA_PTR (self_)); + + if (strcmp (rb_obj_classname (context_), "Context") != 0) { + rb_raise (rb_eArgError, "expected Context object"); + return Qnil; + } + + void *s = zmq_socket (DATA_PTR (context_), NUM2INT (type_)); + if (!s) { + rb_raise (rb_eRuntimeError, strerror (errno)); + return Qnil; + } + + DATA_PTR (self_) = (void*) s; + return self_; +} + + +static VALUE socket_setsockopt (VALUE self_, VALUE option_, + VALUE optval_) +{ + + int rc = 0; + + switch (NUM2INT (option_)) { + case ZMQ_HWM: + case ZMQ_LWM: + case ZMQ_SWAP: + case ZMQ_AFFINITY: + case ZMQ_RATE: + case ZMQ_RECOVERY_IVL: + case ZMQ_MCAST_LOOP: + { + long optval = FIX2LONG (optval_); + + // Forward the code to native 0MQ library. + rc = zmq_setsockopt (DATA_PTR (self_), NUM2INT (option_), + (void *) &optval, 4); + } + + break; + case ZMQ_IDENTITY: + case ZMQ_SUBSCRIBE: + case ZMQ_UNSUBSCRIBE: + + // Forward the code to native 0MQ library. + rc = zmq_setsockopt (DATA_PTR (self_), NUM2INT (option_), + (void *) StringValueCStr (optval_), RSTRING_LEN (optval_)); + break; + + default: + rc = -1; + errno = EINVAL; + } + + if (rc != 0) { + rb_raise (rb_eRuntimeError, strerror (errno)); + return Qnil; + } + + return self_; +} + + +static VALUE socket_bind (VALUE self_, VALUE addr_) +{ + assert (DATA_PTR (self_)); + + int rc = zmq_bind (DATA_PTR (self_), rb_string_value_cstr (&addr_)); + if (rc != 0) { + rb_raise (rb_eRuntimeError, strerror (errno)); + return Qnil; + } + + return Qnil; +} + +static VALUE socket_connect (VALUE self_, VALUE addr_) +{ + assert (DATA_PTR (self_)); + + int rc = zmq_connect (DATA_PTR (self_), rb_string_value_cstr (&addr_)); + if (rc != 0) { + rb_raise (rb_eRuntimeError, strerror (errno)); + return Qnil; + } + + return Qnil; +} + +static VALUE socket_send (VALUE self_, VALUE msg_, VALUE flags_) +{ + assert (DATA_PTR (self_)); + + Check_Type (msg_, T_STRING); + + zmq_msg_t msg; + int rc = zmq_msg_init_size (&msg, RSTRING_LEN (msg_)); + if (rc != 0) { + rb_raise (rb_eRuntimeError, strerror (errno)); + return Qnil; + } + memcpy (zmq_msg_data (&msg), RSTRING_PTR (msg_), RSTRING_LEN (msg_)); + + rc = zmq_send (DATA_PTR (self_), &msg, NUM2INT (flags_)); + if (rc != 0 && errno == EAGAIN) { + rc = zmq_msg_close (&msg); + assert (rc == 0); + return Qfalse; + } + + if (rc != 0) { + rb_raise (rb_eRuntimeError, strerror (errno)); + rc = zmq_msg_close (&msg); + assert (rc == 0); + return Qnil; + } + + rc = zmq_msg_close (&msg); + assert (rc == 0); + return Qtrue; +} + +static VALUE socket_flush (VALUE self_) +{ + assert (DATA_PTR (self_)); + + int rc = zmq_flush (DATA_PTR (self_)); + if (rc != 0) { + rb_raise (rb_eRuntimeError, strerror (errno)); + return Qnil; + } + + return Qnil; +} + +static VALUE socket_recv (VALUE self_, VALUE flags_) +{ + assert (DATA_PTR (self_)); + + zmq_msg_t msg; + int rc = zmq_msg_init (&msg); + assert (rc == 0); + + rc = zmq_recv (DATA_PTR (self_), &msg, NUM2INT (flags_)); + if (rc != 0 && errno == EAGAIN) { + rc = zmq_msg_close (&msg); + assert (rc == 0); + return Qnil; + } + + if (rc != 0) { + rb_raise (rb_eRuntimeError, strerror (errno)); + rc = zmq_msg_close (&msg); + assert (rc == 0); + return Qnil; + } + + VALUE message = rb_str_new ((char*) zmq_msg_data (&msg), + zmq_msg_size (&msg)); + rc = zmq_msg_close (&msg); + assert (rc == 0); + return message; +} + +extern "C" void Init_librbzmq () +{ + VALUE context_type = rb_define_class ("Context", rb_cObject); + rb_define_alloc_func (context_type, context_alloc); + rb_define_method (context_type, "initialize", + (VALUE(*)(...)) context_initialize, 2); + + VALUE socket_type = rb_define_class ("Socket", rb_cObject); + rb_define_alloc_func (socket_type, socket_alloc); + rb_define_method (socket_type, "initialize", + (VALUE(*)(...)) socket_initialize, 2); + rb_define_method (socket_type, "setsockopt", + (VALUE(*)(...)) socket_setsockopt, 2); + rb_define_method (socket_type, "bind", + (VALUE(*)(...)) socket_bind, 1); + rb_define_method (socket_type, "connect", + (VALUE(*)(...)) socket_connect, 1); + rb_define_method (socket_type, "send", + (VALUE(*)(...)) socket_send, 2); + rb_define_method (socket_type, "flush", + (VALUE(*)(...)) socket_flush, 0); + rb_define_method (socket_type, "recv", + (VALUE(*)(...)) socket_recv, 1); + + rb_define_global_const ("HWM", INT2NUM (ZMQ_HWM)); + rb_define_global_const ("LWM", INT2NUM (ZMQ_LWM)); + rb_define_global_const ("SWAP", INT2NUM (ZMQ_SWAP)); + rb_define_global_const ("AFFINITY", INT2NUM (ZMQ_AFFINITY)); + rb_define_global_const ("IDENTITY", INT2NUM (ZMQ_IDENTITY)); + rb_define_global_const ("SUBSCRIBE", INT2NUM (ZMQ_SUBSCRIBE)); + rb_define_global_const ("UNSUBSCRIBE", INT2NUM (ZMQ_UNSUBSCRIBE)); + rb_define_global_const ("RATE", INT2NUM (ZMQ_RATE)); + rb_define_global_const ("RECOVERY_IVL", INT2NUM (ZMQ_RECOVERY_IVL)); + rb_define_global_const ("MCAST_LOOP", INT2NUM (ZMQ_MCAST_LOOP)); + + rb_define_global_const ("NOBLOCK", INT2NUM (ZMQ_NOBLOCK)); + rb_define_global_const ("NOFLUSH", INT2NUM (ZMQ_NOFLUSH)); + + rb_define_global_const ("P2P", INT2NUM (ZMQ_P2P)); + rb_define_global_const ("SUB", INT2NUM (ZMQ_SUB)); + rb_define_global_const ("PUB", INT2NUM (ZMQ_PUB)); + rb_define_global_const ("REQ", INT2NUM (ZMQ_REQ)); + rb_define_global_const ("REP", INT2NUM (ZMQ_REP)); +} |