erlix 0.5.0a

data/_extconf.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby
+#-*- ruby -*-
+# project : erlix
+# author : kdr2
+#
+
+findei=File.join(File.dirname(__FILE__),"findei.erl")
+File.chmod(0755,findei)
+ei_dir=`#{findei}`.chomp
+src_dir=File.join(File.dirname(__FILE__),"src")
+mkmf=File.join(File.dirname(__FILE__),"extconf.rb")
+cmd=[
+  "ruby #{mkmf}",
+  "--with-ei-dir=#{ei_dir}",
+  "--with-cflags=\"-std=c99\"",
+  "--with-ldflags=\"-lei -lerl_interface -lpthread\"",
+  "--srcdir=#{src_dir}"].join(" ")
+
+env=[
+  "--with-ei-dir=#{ei_dir}",
+  "--with-cflags=\"-std=c99\"",
+  "--with-ldflags=\"-lei -lerl_interface -lpthread\"",
+  "--srcdir=#{src_dir}"].join(" ")
+puts cmd
+puts `#{cmd}`
+
+

data/configure

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby
+#-*- ruby -*-
+# project : erlix
+# author : kdr2
+#
+
+findei=File.join(File.dirname(__FILE__),"findei.erl")
+File.chmod(0755,findei)
+ei_dir=`#{findei}`.chomp
+src_dir=File.join(File.dirname(__FILE__),"src")
+mkmf=File.join(File.dirname(__FILE__),"extconf.rb")
+cmd=[
+  "ruby #{mkmf}",
+  "--with-ei-dir=#{ei_dir}",
+  "--with-cflags=\"-std=c99\"",
+  "--with-ldflags=\"-lei -lerl_interface -lpthread\"",
+  "--srcdir=#{src_dir}"].join(" ")
+
+env=[
+  "--with-ei-dir=#{ei_dir}",
+  "--with-cflags=\"-std=c99\"",
+  "--with-ldflags=\"-lei -lerl_interface -lpthread\"",
+  "--srcdir=#{src_dir}"].join(" ")
+puts cmd
+puts `#{cmd}`
+
+

data/extconf.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+#
+# project : erlix
+# author : kdr2
+#
+
+require "mkmf"
+
+dir_config("ei")
+
+if have_library("ei","erl_init") and
+    have_library("erl_interface","erl_init")
+then
+  create_makefile("erlix")
+else
+  puts "error: erl_interface not found!"
+end

data/findei.erl

@@ -0,0 +1,6 @@
+#!/usr/bin/env escript
+%%% Author : KDr2
+%%% Find the location of erl_interface.
+
+main(_) ->
+    io:format("~s~n", [code:lib_dir(erl_interface)]).

data/src/erlix.c

@@ -0,0 +1,30 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+#include <stdlib.h>
+
+#include "erlix_term.h"
+
+
+
+
+void Init_erlix(){
+    VALUE mod_erlix;
+    mod_erlix=rb_define_module("Erlix");
+    erl_init(NULL,0);
+    init_erlix_term(mod_erlix);
+    init_erlix_int(mod_erlix);
+    init_erlix_uint(mod_erlix);
+    init_erlix_float(mod_erlix);
+    init_erlix_pid(mod_erlix);
+    init_erlix_ref(mod_erlix);
+    init_erlix_atom(mod_erlix);
+    init_erlix_list(mod_erlix);
+    init_erlix_node(mod_erlix);
+    init_erlix_tuple(mod_erlix);
+    init_erlix_binary(mod_erlix);
+    init_erlix_message(mod_erlix);
+    init_erlix_connection(mod_erlix);
+}

data/src/erlix_atom.c

@@ -0,0 +1,62 @@
+/* -*- c-*-
+ *
+ * project : erlix
+ * author : KDr2
+ *
+ */
+
+#include "erlix_term.h"
+
+VALUE erlix_cErlixAtom;
+
+VALUE erlix_atom_alloc(VALUE klass){
+    ErlixTerm* atom;
+    VALUE obj;
+    atom=new_erlix_term();
+    atom->type=TYPE_ATOM;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,atom);
+    return obj;
+}
+
+static VALUE erlix_atom_init(VALUE self,VALUE string){
+    ErlixTerm* atom;
+    VALUE str=StringValue(string);
+    Data_Get_Struct(self,ErlixTerm,atom);
+    atom->term=erl_mk_atom(RSTRING_PTR(str));
+    return self;
+}
+
+
+static VALUE erlix_atom_size(VALUE self){
+    ErlixTerm *atom;
+    int l;
+    Data_Get_Struct(self,ErlixTerm,atom);
+    l=ERL_ATOM_SIZE(atom->term);
+    return INT2FIX(l);
+}
+
+static VALUE erlix_atom_inspect(VALUE self){
+    VALUE ret=rb_str_new2("#<Erlix::Atom:");
+    ID concat=rb_intern("concat");
+    rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
+    rb_funcall(ret,concat,1,rb_str_new2(">"));
+    return ret;
+}
+
+static VALUE erlix_atom_etype(VALUE self){
+    return rb_str_new2("atom");
+}
+
+void init_erlix_atom(VALUE erlix){
+    erlix_cErlixAtom=rb_define_class_under(erlix,"Atom",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixAtom,erlix_atom_alloc);
+    rb_define_method(erlix_cErlixAtom,"initialize",erlix_atom_init,1);
+    rb_define_method(erlix_cErlixAtom,"size",erlix_atom_size,0);
+    rb_define_method(erlix_cErlixAtom,"etype",erlix_atom_etype,0);
+    rb_define_method(erlix_cErlixAtom,"inspect",erlix_atom_inspect,0);
+
+    rb_include_module(erlix_cErlixAtom,erlix_mErlixTerm);
+}
+
+

data/src/erlix_binary.c

@@ -0,0 +1,67 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include "erlix_term.h"
+
+VALUE erlix_cErlixBinary;
+
+VALUE erlix_binary_alloc(VALUE klass){
+    ErlixTerm* binary;
+    VALUE obj;
+    binary=new_erlix_term();
+    binary->type=TYPE_BINARY;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_term,binary);
+    return obj;
+}
+
+static VALUE erlix_binary_init(VALUE self,VALUE string){
+    ErlixTerm* binary;
+    VALUE str=StringValue(string);
+    Data_Get_Struct(self,ErlixTerm,binary);
+    //TODO length limit
+    binary->term=erl_mk_binary(RSTRING_PTR(str),(uint32_t)RSTRING_LEN(str));
+    return self;
+}
+
+
+static VALUE erlix_binary_data(VALUE self){
+    ErlixTerm* binary;
+    Data_Get_Struct(self,ErlixTerm,binary);
+    return rb_str_new(ERL_BIN_PTR(binary->term),ERL_BIN_SIZE(binary->term));
+}
+
+static VALUE erlix_binary_size(VALUE self){
+    ErlixTerm *binary;
+    int l;
+    Data_Get_Struct(self,ErlixTerm,binary);
+    l=ERL_BIN_SIZE(binary->term);
+    return INT2FIX(l);
+}
+
+static VALUE erlix_binary_inspect(VALUE self){
+    VALUE ret=rb_str_new2("#<Erlix::Binary:");
+    ID concat=rb_intern("concat");
+    rb_funcall(ret,concat,1,rb_funcall(self,rb_intern("to_s"),0));
+    rb_funcall(ret,concat,1,rb_str_new2(">"));
+    return ret;
+}
+
+static VALUE erlix_binary_etype(VALUE self){
+    return rb_str_new2("binary");
+}
+
+void init_erlix_binary(VALUE erlix){
+    erlix_cErlixBinary=rb_define_class_under(erlix, "Binary",rb_cObject);
+
+    rb_define_alloc_func(erlix_cErlixBinary,erlix_binary_alloc);
+    rb_define_method(erlix_cErlixBinary,"initialize",erlix_binary_init,1);
+    rb_define_method(erlix_cErlixBinary,"data",erlix_binary_data,0);
+    rb_define_method(erlix_cErlixBinary,"size",erlix_binary_size,0);
+    rb_define_method(erlix_cErlixBinary,"inspect",erlix_binary_inspect,0);
+    rb_define_method(erlix_cErlixBinary,"etype",erlix_binary_etype,0);
+
+    rb_include_module(erlix_cErlixBinary,erlix_mErlixTerm);
+}

data/src/erlix_connection.c

@@ -0,0 +1,247 @@
+/*
+ * project : erlix
+ * author : kdr2
+ *
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+
+#include "erlix_term.h"
+#include "erlix_node.h"
+#include "erlix_connection.h"
+
+extern ErlixNode* erlix_node;
+extern VALUE erlix_cErlixMessage;
+
+VALUE erlix_cErlixConnection;
+
+ErlixConnection* new_erlix_connection(){
+    ErlixConnection* ret=(ErlixConnection*)malloc(sizeof(ErlixConnection));
+    ret->status=0;
+    return ret;
+}
+
+void free_erlix_connection(void *econ){
+    ErlixConnection* ep=econ;
+    ERLIX_CONNECTION_DEAD(ep);
+    erl_close_connection(ep->sock_fd);
+    free(ep);
+}
+
+VALUE erlix_connection_alloc(VALUE klass){
+    ErlixConnection* ec=new_erlix_connection();
+    VALUE obj;
+    obj=Data_Wrap_Struct(klass,0,free_erlix_connection,ec);
+    return obj;
+}
+
+static VALUE erlix_connection_init(VALUE self,VALUE pnode){
+    VALUE node;
+    int sockfd;
+    ErlixConnection *conn;
+        
+    if(erlix_node==NULL){
+        rb_raise(rb_eException,"call Erlix::Node.init(name,cookie) first please!");
+        return Qnil;
+    }
+    node=StringValue(pnode);
+    if((sockfd = erl_connect(RSTRING_PTR(node)))<0){
+        rb_raise(rb_eException,"erl_connect failed");
+        return Qnil;
+    }
+
+    Data_Get_Struct(self,ErlixConnection,conn);
+    conn->peer_node=rb_str_new2(RSTRING_PTR(node));
+    conn->sock_fd=sockfd;
+    ERLIX_CONNECTION_BORN(conn);
+    return self;
+}
+
+
+static VALUE erlix_connection_init_copy(VALUE copy,VALUE orig){
+    ErlixConnection *tcopy,*tsrc;
+
+    if(copy==orig)return copy;
+    if(TYPE(orig)!=T_DATA||RDATA(orig)->dfree!=(RUBY_DATA_FUNC)free_erlix_connection){
+        rb_raise(rb_eTypeError,"wrong argument type!");
+    }
+    
+    Data_Get_Struct(copy,ErlixConnection,tcopy);
+    Data_Get_Struct(orig,ErlixConnection,tsrc);
+    
+    if(!ERLIX_CONNECTION_ALIVE(tsrc)){
+        rb_raise(rb_eException,"the connection has been disconnected!");
+        return Qnil;
+    }
+
+    tcopy->status=tsrc->status;
+    tcopy->peer_node=rb_str_new2(RSTRING_PTR(tsrc->peer_node));
+    tcopy->sock_fd=tsrc->sock_fd;
+
+    return copy;
+}
+
+
+static VALUE erlix_connection_to_str(VALUE self);
+
+//peer node name
+static VALUE erlix_connection_peer(VALUE self){
+    ErlixConnection *con;
+    Data_Get_Struct(self,ErlixConnection,con);
+    if(!ERLIX_CONNECTION_ALIVE(con)){
+        rb_raise(rb_eException,"the connection has been disconnected!");
+        return Qnil;
+    }
+    return con->peer_node;
+}
+
+static VALUE erlix_connection_etype(VALUE self){
+    return rb_str_new2("erlix_connection");
+}
+
+static VALUE erlix_connection_mkpid(VALUE self);
+
+static VALUE erlix_connection_send(VALUE self,VALUE pid,VALUE term){
+    ErlixConnection *con;
+    ErlixTerm * ep;
+
+    if(!IS_ETERM(term)){
+        rb_raise(rb_eTypeError,"wrong argument type,the data is not an ErlixTerm!");
+        return Qnil;
+    }
+    Data_Get_Struct(self,ErlixConnection,con);
+    Data_Get_Struct(term,ErlixTerm,ep);
+    if(!ERLIX_CONNECTION_ALIVE(con)){
+        rb_raise(rb_eException,"the connection has been disconnected!");
+        return Qnil;
+    }
+    if(TYPE(pid)==T_STRING){
+        if(erl_reg_send(con->sock_fd,RSTRING_PTR(pid),ep->term)==1){
+            return term;
+        }else if(erl_errno==EIO){
+            ERLIX_CONNECTION_DEAD(con);
+            rb_raise(rb_eException,"IO Error!");
+            return Qnil;
+        }
+    }
+    return Qnil;
+}
+
+extern int rb_io_wait_readable(int);
+
+static VALUE erlix_connection_recv(VALUE self){
+    ErlixConnection *con;
+    ErlMessage emsg;
+        
+    Data_Get_Struct(self,ErlixConnection,con);
+
+    if(!ERLIX_CONNECTION_ALIVE(con)){
+        rb_raise(rb_eException,"the connection has been disconnected!");
+        return Qnil;
+    }
+    for(;;){
+        //bugfixed! for 1.8.7 thread block!
+        if(rb_io_wait_readable(con->sock_fd)!=Qtrue){
+            rb_thread_wait_fd(con->sock_fd);
+        }
+        int ret;
+        VALUE m;
+        ErlMessage *newm;
+
+        ret=erl_receive_msg(con->sock_fd,NULL,0,&emsg);
+        if (ret == ERL_MSG) {
+            m=erlix_message_alloc(erlix_cErlixMessage);
+            Data_Get_Struct(m,ErlMessage,newm);
+            newm->type=emsg.type;
+            if(emsg.type==ERL_SEND){
+                newm->msg=erl_copy_term(emsg.msg);
+                newm->to=erl_copy_term(emsg.to);
+            }else if(emsg.type==ERL_REG_SEND){
+                newm->msg=erl_copy_term(emsg.msg);
+                newm->from=erl_copy_term(emsg.from);
+            }else if(emsg.type==ERL_LINK ||emsg.type==ERL_UNLINK){
+                newm->from=erl_copy_term(emsg.from);
+                newm->to=erl_copy_term(emsg.to);
+            }else if(emsg.type==ERL_EXIT){
+                newm->msg=erl_copy_term(emsg.msg);
+                newm->from=erl_copy_term(emsg.from);
+                newm->to=erl_copy_term(emsg.to);
+            }
+            memcpy(newm->to_name,emsg.to_name,MAXREGLEN);
+            return m;
+        }else if(ret == ERL_TICK){
+            continue;
+        }else{
+            rb_raise(rb_eException,"receive error!");
+            return Qnil;
+        }
+    }
+    return Qnil;
+}
+
+static VALUE erlix_connection_rpc(VALUE self,VALUE module,VALUE func,VALUE args){
+
+    VALUE m;
+    VALUE f;
+    ErlixTerm* a;
+    ErlixConnection *con;
+    ETERM *result;
+    
+    m=StringValue(module);
+    f=StringValue(func);
+    if(!IS_ETERM(args)){
+        rb_raise(rb_eTypeError,"wrong argument type,the data is not an ErlixList!");
+        return Qnil;
+    }
+    Data_Get_Struct(args,ErlixTerm,a);
+    if(a->type!=TYPE_LIST){
+        rb_raise(rb_eTypeError,"wrong argument type,the data is not an ErlixList!");
+        return Qnil;
+    }
+    Data_Get_Struct(self,ErlixConnection,con);
+    result=erl_rpc(con->sock_fd, RSTRING_PTR(m),RSTRING_PTR(f), a->term);
+    if(result==NULL){
+        if(erl_errno==ENOMEM){
+            rb_raise(rb_eException,"rpc error: no memory");
+        }else if(erl_errno==EIO){
+            rb_raise(rb_eException,"rpc error: I/O error");
+        }else if(erl_errno==ETIMEDOUT){
+            rb_raise(rb_eException,"rpc error: timeout");
+        }else if(erl_errno==EAGAIN){
+            rb_raise(rb_eException,"rpc error: Temporary error, Try again");
+        }
+        return Qnil;
+    }
+    return erlix_term(result);
+}
+
+static VALUE erlix_connection_close(VALUE self){
+    ErlixConnection *con;
+    Data_Get_Struct(self,ErlixConnection,con);
+    ERLIX_CONNECTION_DEAD(con);
+    close(con->sock_fd);
+    return Qtrue;
+}
+
+static VALUE erlix_connection_isclosed(VALUE self){
+    ErlixConnection *con;
+    Data_Get_Struct(self,ErlixConnection,con);
+    if(ERLIX_CONNECTION_ALIVE(con)){
+        return Qfalse;
+    }
+    return Qtrue;
+}
+
+void init_erlix_connection(VALUE erlix){
+    erlix_cErlixConnection=rb_define_class_under(erlix,"Connection",rb_cObject);
+    rb_define_alloc_func(erlix_cErlixConnection,erlix_connection_alloc);
+    rb_define_method(erlix_cErlixConnection,"initialize",erlix_connection_init,1);
+    rb_define_method(erlix_cErlixConnection,"initialize_copy",erlix_connection_init_copy,1);
+    rb_define_method(erlix_cErlixConnection,"peer",erlix_connection_peer,0);
+    rb_define_method(erlix_cErlixConnection,"esend",erlix_connection_send,2);
+    rb_define_method(erlix_cErlixConnection,"erecv",erlix_connection_recv,0);
+    rb_define_method(erlix_cErlixConnection,"rpc",erlix_connection_rpc,3);
+    rb_define_method(erlix_cErlixConnection,"close",erlix_connection_close,0);
+    rb_define_method(erlix_cErlixConnection,"closed?",erlix_connection_isclosed,0);
+}