WireAPI 0.3

data/amq_session.h

@@ -0,0 +1,5 @@
+#ifndef AMQ_SESSION_HEADER
+#define AMQ_SESSION_HEADER
+
+void init_session();
+#endif

data/amq_types.c

@@ -0,0 +1,273 @@
+
+#include <ruby.h>
+#include "amq_types.h"
+
+
+
+/*  session allocator, destructor , accessor */
+
+
+amq_session_cls* get_amq_session_cls(VALUE rb_obj,int raise) {
+  amq_session_cls *result=0;
+  Data_Get_Struct(rb_obj,amq_session_cls,result);
+  if (raise && !result->session) {
+    rb_raise(rb_amq_error,"Session already destroyed");
+  }
+  if (!rb_obj_is_instance_of(rb_obj, amqp_session)) {
+	rb_raise(rb_eTypeError, "expected an AMQ_Session object");
+  }
+  return result;
+}
+
+void free_amq_session_cls( amq_session_cls *obj) {
+  if (obj && obj->session) {
+    amq_client_session_destroy (&(obj->session));
+    obj->session=0;
+  }
+  if (obj)
+    free(obj);
+}
+
+VALUE create_amq_session_cls(amq_client_session_t  *session) {
+  VALUE rb_session;
+  amq_session_cls *obj=ALLOC(amq_session_cls);
+  obj->session=session;    
+  rb_session = Data_Wrap_Struct(amqp_session,0,free_amq_session_cls,obj);  
+  return rb_session;  
+}
+
+
+/*  content allocator, destructor , accessor */
+amq_content_cls* get_amq_content_cls(VALUE rb_obj,int raise) {
+  amq_content_cls *result=0;
+  Data_Get_Struct(rb_obj,amq_content_cls,result);
+  if (raise && !result->content) {
+    rb_raise(rb_amq_error,"Content already destroyed");
+  }
+  if (!rb_obj_is_instance_of(rb_obj, amqp_content)) {
+	rb_raise(rb_eTypeError, "expected an AMQ_ContentBasic object");
+  }
+  return result;
+}
+
+void free_amq_content_cls( amq_content_cls *obj) {
+  if (obj && obj->content) {
+    amq_content_basic_unlink(&(obj->content));
+    obj->content=0;
+  }
+  if (obj)
+    free(obj);
+}
+
+VALUE create_amq_content_cls(amq_content_basic_t  *content) {
+  VALUE rb_content;
+  amq_content_cls *obj=ALLOC(amq_content_cls);
+  obj->content=content;    
+  rb_content = Data_Wrap_Struct(amqp_content,0,free_amq_content_cls,obj);  
+  return rb_content;  
+}
+ 
+
+/*  connection allocator, destructor , accessor */
+
+amq_connection_cls* get_amq_connection_cls(VALUE rb_obj,int raise) {
+  amq_connection_cls *result=0;
+  Data_Get_Struct(rb_obj,amq_connection_cls,result);
+  if (raise && !result->connection) {
+    rb_raise(rb_amq_error,"Connection already destroyed");
+  }
+  if (!rb_obj_is_instance_of(rb_obj, amqp_connection)) {
+	rb_raise(rb_eTypeError, "expected an AMQ_Connection object");
+  }
+  return result;
+}
+
+void free_amq_connection_cls( amq_connection_cls *obj) {
+  if (obj && obj->connection) {
+    amq_client_connection_destroy(&(obj->connection));
+    obj->connection=0;
+  }
+  if (obj)
+    free(obj);
+}
+
+VALUE create_amq_connection_cls(amq_client_connection_t  *connection) {
+  VALUE rb_connection;
+  amq_connection_cls *obj=ALLOC(amq_connection_cls);
+  obj->connection=connection;    
+  rb_connection = Data_Wrap_Struct(amqp_connection,0,free_amq_connection_cls,obj);  
+  return rb_connection;  
+}
+ 
+
+ 
+
+/*  connection allocator, destructor , accessor */
+
+amq_auth_cls* get_amq_auth_cls(VALUE rb_obj,VALUE raise) {
+  amq_auth_cls *result=0;
+  Data_Get_Struct(rb_obj,amq_auth_cls,result);
+  if (raise && !result->auth) {
+    rb_raise(rb_amq_error,"Auth_data already destroyed");
+  }
+  if (!rb_obj_is_instance_of(rb_obj, amqp_auth)) {
+	rb_raise(rb_eTypeError, "expected an AMQ_Auth object");
+  }
+  return result;
+}
+
+
+void free_amq_auth_cls( amq_auth_cls *obj) {
+  if (obj && obj->auth) {
+	icl_longstr_destroy(&(obj->auth));
+    obj->auth=0;
+  }
+  if (obj)
+    free(obj);
+}
+
+
+VALUE create_amq_auth_cls(icl_longstr_t *auth) {
+  VALUE rb_auth;
+  amq_auth_cls *obj=ALLOC(amq_auth_cls);
+  obj->auth=auth;    
+  rb_auth = Data_Wrap_Struct(amqp_auth,0,free_amq_auth_cls,obj);  
+  return rb_auth;  
+}
+ 
+
+/*  int6_t allocator, destructor , accessor */
+amq_int64_cls* get_amq_int64_cls(VALUE rb_obj) {
+  amq_int64_cls *result=0;
+  if (!rb_obj_is_instance_of(rb_obj, amqp_int64)) {
+	rb_raise(rb_eTypeError, "expected an AMQ_int64 object");
+  }
+  Data_Get_Struct(rb_obj,amq_int64_cls,result);
+  return result;
+}
+
+void free_amq_int64_cls( amq_int64_cls *obj) {
+  if (obj && obj->value) {
+    obj->value=0;
+  }
+  if (obj)
+    free(obj);
+}
+
+VALUE create_amq_int64_cls(int64_t int64) {
+  VALUE rb_int64;
+  amq_int64_cls *obj=ALLOC(amq_int64_cls);
+  obj->value=int64;    
+  rb_int64 = Data_Wrap_Struct(amqp_int64,0,free_amq_int64_cls,obj);  
+  return rb_int64;  
+}
+ 
+
+int VALUE2bool (VALUE v,const char *msg) {
+  if (v==Qtrue)
+	return 1;
+  if (v==Qfalse)
+	return 0;
+  char total_msg[250];
+  if (TYPE(v)!= T_ICLASS) {
+	sprintf(total_msg,"%s (%x)",msg,TYPE(v));
+  } else {
+	sprintf(total_msg,"%s (%s)",msg,rb_obj_classname(v));
+
+  }
+  
+  rb_raise(rb_amq_error,total_msg);
+  return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+/*  connection allocator, destructor , accessor */
+
+amq_field_list_cls* get_amq_field_list_cls(VALUE rb_obj,VALUE raise) {
+  amq_field_list_cls *result=0;
+  Data_Get_Struct(rb_obj,amq_field_list_cls,result);
+  if (raise && !result->field_list) {
+    rb_raise(rb_amq_error,"field_list already destroyed");
+  }
+  if (!rb_obj_is_instance_of(rb_obj, amqp_field_list)) {
+	rb_raise(rb_eTypeError, "expected an AMQ_FieldList");
+  }
+
+  return result;
+}
+
+
+void free_amq_field_list_cls( amq_field_list_cls *obj) {
+  if (obj && obj->field_list) {
+	asl_field_list_destroy (&(obj->field_list));
+    obj->field_list=0;
+  }
+  if (obj)
+    free(obj);
+}
+
+
+VALUE create_amq_field_list_cls(asl_field_list_t *field_list) {
+  VALUE rb_field_list;
+  amq_field_list_cls *obj=ALLOC(amq_field_list_cls);
+  obj->field_list=field_list;    
+  rb_field_list = Data_Wrap_Struct(amqp_field_list,0,free_amq_field_list_cls,obj);  
+  return rb_field_list;  
+}
+
+
+
+
+/*  rb_wireapi allocator, destructor , accessor */
+static int wire_api_ref_counter=0;
+static int wire_api_instance_counter=0;
+
+amq_wire_api_cls* get_amq_wire_api_cls(VALUE rb_obj,VALUE raise) {
+  amq_wire_api_cls *result=0;
+  Data_Get_Struct(rb_obj,amq_wire_api_cls,result);
+  if (raise && !result) {
+    rb_raise(rb_amq_error,"WireAPI already destroyed");
+  }
+  if (!rb_obj_is_instance_of(rb_obj, rb_wireapi)) {
+	rb_raise(rb_eTypeError, "expected an WireAPI object");
+  }
+  return result;
+}
+
+
+void free_amq_wire_api_cls( amq_wire_api_cls *obj) {
+  if (obj && obj->instance_id) {
+    obj->instance_id=0;
+	--wire_api_ref_counter;
+	if (wire_api_ref_counter<=0) {
+	  icl_system_terminate ();
+	}
+  }
+  if (obj)
+    free(obj);
+}
+
+
+VALUE create_amq_wire_api_cls() {
+  VALUE rb_wapi;
+  amq_wire_api_cls *obj=ALLOC(amq_wire_api_cls);
+  //  obj->field_list=field_list;    
+  rb_wapi = Data_Wrap_Struct(rb_wireapi,0,free_amq_wire_api_cls,obj);  
+  if (wire_api_ref_counter==0) {
+	icl_system_initialise (0,0);
+  }
+  ++wire_api_ref_counter;
+  obj->instance_id=++wire_api_instance_counter;
+  return rb_wapi;
+}

data/amq_types.h

@@ -0,0 +1,128 @@
+#ifndef AMQ_TYPES_HEADER
+#define AMQ_TYPES_HEADER
+
+#include "asl.h"
+#include "amq_client_connection.h"
+#include "amq_client_session.h"
+#include "amq_client_agent.h"
+#include "amq_exchange.h"
+
+extern VALUE amqp_content;
+
+extern VALUE rb_wireapi;
+
+extern VALUE amqp_connection;
+
+extern VALUE amqp_session;
+
+extern VALUE amqp_auth;
+
+extern VALUE amqp_field_list;
+
+extern VALUE rb_amq_error;
+
+extern VALUE rb_amq_server_error;
+
+extern VALUE amqp_int64;
+
+
+struct _amq_session_cls {
+  amq_client_session_t  *session;
+};
+
+typedef struct _amq_session_cls amq_session_cls;
+
+/* */
+
+struct _amq_content_cls {
+  amq_content_basic_t  *content;
+};
+
+typedef struct _amq_content_cls amq_content_cls;
+/* */
+
+struct _amq_connection_cls {
+  amq_client_connection_t  *connection;
+};
+
+typedef struct _amq_connection_cls amq_connection_cls;
+
+
+
+struct _amq_auth_cls {
+  icl_longstr_t  *auth;
+};
+
+typedef struct _amq_auth_cls amq_auth_cls;
+
+struct _amq_int64_cls {
+  int64_t value;
+};
+
+typedef struct _amq_int64_cls amq_int64_cls;
+
+
+struct _amq_field_list_cls {
+  asl_field_list_t *field_list;
+};
+
+typedef struct _amq_field_list_cls amq_field_list_cls;
+
+
+
+struct _amq_wire_api_cls {
+  int instance_id;
+};
+
+typedef struct _amq_wire_api_cls amq_wire_api_cls;
+
+
+/*  session allocator, destructor , accessor */
+amq_session_cls* get_amq_session_cls(VALUE rb_obj,int raise);
+void free_amq_session_cls( amq_session_cls *obj);
+VALUE create_amq_session_cls(amq_client_session_t  *session);
+
+
+/*  content allocator, destructor , accessor */
+amq_content_cls* get_amq_content_cls(VALUE rb_obj,int raise);
+void free_amq_content_cls( amq_content_cls *obj);
+VALUE create_amq_content_cls(amq_content_basic_t  *content);
+ 
+
+/*  connection allocator, destructor , accessor */
+amq_connection_cls* get_amq_connection_cls(VALUE rb_obj,int raise);
+void free_amq_connection_cls( amq_connection_cls *obj);
+VALUE create_amq_connection_cls(amq_client_connection_t  *connection);
+
+ 
+
+/*  connection allocator, destructor , accessor */
+amq_auth_cls* get_amq_auth_cls(VALUE rb_obj,VALUE raise);
+void free_amq_auth_cls( amq_auth_cls *obj) ;
+VALUE create_amq_auth_cls(icl_longstr_t *auth);
+
+
+/*  int64_t allocator, destructor , accessor */
+amq_int64_cls* get_amq_int64_cls(VALUE rb_obj) ;
+void free_amq_int64_cls( amq_int64_cls *obj) ;
+VALUE create_amq_int64_cls(int64_t int64);
+
+
+/*  field_list allocator, destructor , accessor */
+amq_field_list_cls* get_amq_field_list_cls(VALUE rb_obj,VALUE raise);
+void free_amq_field_list_cls( amq_field_list_cls *obj) ;
+VALUE create_amq_field_list_cls(asl_field_list_t *field_list);
+
+
+/*  wire_api allocator, destructor , accessor */
+amq_wire_api_cls* get_amq_wire_api_cls(VALUE rb_obj,VALUE raise);
+void free_amq_wire_api_cls( amq_wire_api_cls *obj) ;
+VALUE create_amq_wire_api_cls();
+
+
+
+
+int VALUE2bool (VALUE v,const char *msg);
+
+
+#endif

data/amq_wireapi.c

@@ -0,0 +1,195 @@
+/*===========================================================================
+ *
+ *  OpenAMQ Ruby module
+ *
+ *  Copyright (c) 2008 Benjamin April
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *===========================================================================*/
+
+
+
+#include "ruby.h"
+#include "asl.h"
+#include "amq_client_connection.h"
+#include "amq_client_session.h"
+#include "amq_client_agent.h"
+#include "amq_exchange.h"
+#include "version.h"
+#include <dlfcn.h>
+#include <unistd.h>
+
+VALUE rb_amq_error;
+VALUE rb_amq_server_error;
+
+
+// The order of these includes matters.
+#include "amq_types.h"
+#include "amq_content.h"
+#include "amq_session.h"
+#include "amq_connection.h"
+#include "amq_field_list.h"
+
+VALUE rb_wireapi;
+VALUE amqp_auth;
+
+
+static VALUE rbWireAPI_new(int argc, VALUE *argv,VALUE class)  {
+
+  VALUE self=create_amq_wire_api_cls();
+  rb_obj_call_init(self, argc, argv);
+
+  return self;  
+}
+
+
+static VALUE rbWireAPI_init(int argc, VALUE *argv,VALUE self)
+
+{
+  VALUE trace;
+  rb_scan_args(argc,argv,"01",&trace); 
+  
+  int opt_trace = 0;
+  if  FIXNUM_P(trace) {
+	  opt_trace=FIX2INT(trace) ;
+	}
+  
+  if (opt_trace) {
+	amq_client_connection_animate(opt_trace&4);
+	amq_client_session_animate (opt_trace&8);
+  }
+  return (self);
+}
+
+
+static VALUE rbWireAPI_debug_connection(VALUE self, VALUE val)
+{
+  int connection_debug=VALUE2bool(val,"flag must be boolean");	
+  amq_client_connection_animate (connection_debug);
+  return (self);
+}
+
+
+static VALUE rbWireAPI_debug_session(VALUE self, VALUE val)
+{
+  int session_debug=VALUE2bool(val,"flag must be boolean");	
+  amq_client_session_animate (session_debug);
+  return (self);
+}
+
+
+
+static VALUE rbWireAPI_client_connection_auth_plain (VALUE self, VALUE username, VALUE password)
+{
+    icl_longstr_t   *auth_data;          
+    VALUE           rb_auth_data;
+    char *_username;
+    char *_password;
+    if (TYPE(username) == T_STRING)
+        _username = StringValuePtr(username);
+
+    else 
+    {
+        rb_raise(rb_eTypeError,"Username was not a string");
+        return Qnil;
+    }
+    if (TYPE(password) == T_STRING)
+        _password = StringValuePtr(password);
+
+    else 
+    {
+        rb_raise(rb_eTypeError,"Password was not a string");
+        return Qnil;
+    }
+    auth_data = amq_client_connection_auth_plain (_username, _password);
+    rb_auth_data = create_amq_auth_cls(auth_data);
+    return(rb_auth_data);
+}
+
+static VALUE rbWireAPI_client_connection_new(VALUE self, 
+	VALUE host, 
+	VALUE vhost,
+	VALUE rb_auth_data, 
+	VALUE client_name,
+	VALUE trace, 
+	VALUE timeout)
+{
+    icl_longstr_t *auth_data;
+    amq_client_connection_t  *connection = NULL;  
+    VALUE rb_connection;
+    char *_hostname = StringValuePtr(host);
+    char *_vhost = "/";
+	amq_auth_cls  *auth_obj= get_amq_auth_cls(rb_auth_data,1);          
+    if (TYPE(vhost)==T_STRING) {
+      _vhost = StringValuePtr(vhost);
+    }
+    char *_client_name = StringValuePtr(client_name);
+	int _trace=NUM2INT(trace) & 3; // trace (0-3)
+	int _timeout=NUM2INT(timeout);
+	  
+    //  Open all connections
+    Data_Get_Struct(rb_auth_data,icl_longstr_t,auth_data);
+    connection = amq_client_connection_new (_hostname, _vhost, 
+											 auth_obj->auth, 
+											 _client_name, 
+											 _trace, 
+											 _timeout);
+    if (!connection)
+        rb_raise(rb_amq_error,"Could not connect to server");
+
+    rb_connection =  create_amq_connection_cls(connection);
+    return (rb_connection);
+}
+
+
+void Init_WireAPI()
+{
+   rb_wireapi = rb_define_class("WireAPI",rb_cObject);
+   amqp_auth = rb_define_class_under(rb_wireapi,"AMQ_Auth",rb_cObject);
+   rb_amq_error= rb_define_class_under(rb_wireapi,"AMQ_Error",rb_eRuntimeError);
+   rb_amq_server_error= rb_define_class_under(rb_wireapi,"AMQ_ServerError",rb_amq_error);
+
+   // WireAPI
+   rb_define_singleton_method(rb_wireapi, "new"   , 
+							  rbWireAPI_new      , -1);
+
+   rb_define_method(rb_wireapi,"initialize", 
+					rbWireAPI_init,-1);
+
+   rb_define_method(rb_wireapi,"auth_plain", 
+					rbWireAPI_client_connection_auth_plain,2); 
+
+   rb_define_method(rb_wireapi,"connection_new", 
+					rbWireAPI_client_connection_new,6); 
+
+   rb_define_method(rb_wireapi,"debug_connection=", 
+					rbWireAPI_debug_connection,1); 
+
+   rb_define_method(rb_wireapi,"debug_session=", 
+					rbWireAPI_debug_session,1); 
+
+   init_content();
+   init_connection();
+   init_session();
+   init_field_list();
+}

data/extconf.rb

@@ -0,0 +1,30 @@
+require 'mkmf'
+
+$INCFLAGS += ' -I${AMQ_HOME}/include'
+$LIBS += ' -L${AMQ_HOME}/lib -Wl,-rpath=${AMQ_HOME}/lib -lamq_wireapi -lamq_common -lsmt -licl -lipr -lasl -lapr -laprutil -lpcre'
+
+
+unless ENV.include?('AMQ_HOME')
+  raise "Missing environment variable AMQ_HOME"
+end
+
+unless find_library("amq_wireapi", "amq_client_connection_auth_plain", "#{ENV['AMQ_HOME']}/lib")
+  raise "missing libamq_wireapi"
+end
+
+
+[
+ "amq_client_agent.h"      ,
+ "amq_client_connection.h" , 
+ "amq_client_session.h"    ,
+ "asl.h"                   ,
+ "icl.h"                   ,
+ "wireapi.h"               ,
+].each do |header_file|
+  unless find_header(header_file, "#{ENV['AMQ_HOME']}/include")
+    raise "missing #{header_file}"
+  end
+end
+
+
+create_makefile("WireAPI")

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: WireAPI
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- Jurgen Van Ham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-04 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: jvh@vasco.com
+executables: []
+
+extensions: 
+- ./extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ./amq_field_list.c
+- ./amq_types.c
+- ./amq_session.c
+- ./amq_content.c
+- ./amq_wireapi.c
+- ./amq_connection.c
+- ./extconf.rb
+- ./amq_field_list.h
+- ./amq_types.h
+- ./amq_session.h
+- ./amq_content.h
+- ./amq_connection.h
+has_rdoc: false
+homepage: http://svn.able.be/svn/ruby_OpenAMQ
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Ruby binding to OpenAMQ WireAPI
+test_files: []
+