nwrfc 0.0.0 → 0.0.1

data/README.rdoc

@@ -59,6 +59,11 @@ On Windows
 
     gem install nwrfc
 
+== Documentation
+
+Documentation is installed locally when you install the gem, but you can install it with `rdoc` or `yard` or whatever
+if you have cloned the repository from GitHub.
+
 == Running the tests
 The test are located in the tests/ directory. The file `login_params.yaml` contains parameters that you will need
 to customize to log on to your local system that you are testing with. The YAML file contains parameters for multiple

data/lib/dev_rfc.trc

@@ -131,3 +131,10 @@ ERROR pfuuid_init returns error -> UUIDs cannot be generated
  Hostname: martin-laptop, IP address: 127.0.1.1, IP address_v6: 127.0.1.1
 
 ERROR pfuuid_init returns error -> UUIDs cannot be generated
+
+**** Trace file opened at 2012-02-17, 12:38:41 SAST
+ RFC library: 720, Current working directory: /home/martin/Development/ruby/sapnwrfc/lib, Program: irb
+ Hardware: Intel x86 with Linux i686, Operating_system: Linux 3.0.0-14-generic-pae, Kernel_release: 720 patchlevel 2
+ Hostname: martin-laptop, IP address: 127.0.1.1, IP address_v6: 127.0.1.1
+
+ERROR pfuuid_init returns error -> UUIDs cannot be generated

data/lib/nwrfc.rb

@@ -6,6 +6,7 @@
 # No ownership over any of these is asserted by Martin Ceronio
 
 require File.dirname(__FILE__)+'/nwrfc/nwrfclib'
+require File.dirname(__FILE__)+'/nwrfc/datacontainer'
 
 require 'date'
 require 'time'
@@ -89,6 +90,45 @@ module NWRFC
 
   end
 
+  def NWRFC.abap_bool(value)
+    return true if value == 'X'
+    return false if value == ' '
+    nil
+  end
+
+  def NWRFC.bool_abap(value)
+    return 'X' if value == true
+    return ' ' if value == false
+    nil
+  end
+
+  # Represents a function parameter
+  class Parameter
+
+    attr_accessor :handle
+
+    # Create a parameter by setting parameter attributes
+    def initialize(*args)
+      attr = args[0]
+      @handle                 = NWRFCLib::RFCFuncParam.new
+      @handle[:name]          = attr[:name].cU if attr[:name]
+      @handle[:direction]     = NWRFCLib::RFC_DIRECTION[attr[:direction]] if attr[:direction]
+      @handle[:type]          = NWRFCLib::RFC_TYPE[attr[:type]] if attr[:type]
+      @handle[:ucLength]      = attr[:length] * 2 if attr[:length]
+      @handle[:nucLength]     = attr[:length] if attr[:length]
+      @handle[:decimals]      = attr[:decimals] if attr[:decimals]
+      # TODO: Add support for type description
+      #@handle[:typeDescHandle]
+      @handle[:defaultValue]  = attr[:defaultValue].cU if attr[:defaultValue]
+      @handle[:parameterText] = attr[:parameterText].cU if attr[:parameterText]
+      @handle[:optional]      = abap_bool(attr[:optional]) if attr[:optional]
+    end
+  end
+
+  class Type
+    
+  end
+
   # Represents a remote-enabled function module for RFC, can be instantiated either by the caller
   # or by calling Connection#get_function. This only represents the description of the function;
   # to call a function, an instance of a function call must be obtained with #get_function_call
@@ -96,12 +136,28 @@ module NWRFC
     attr_reader :desc, :connection, :function_name
 
     # Get a function module instance; can also be obtained by calling Connection#get_function
-    def initialize(connection, function_name)
-      @function_name = function_name
+    # Takes either: (connection, function_name) or (function_name)
+    # When passed only `function_name`, creates a new function description locally, instead of
+    # fetching it form the server pointed to by connection
+    def initialize(*args)#(connection, function_name)
+      raise("Must initialize function with 1 or 2 arguments") if args.size != 1 && args.size != 2
       @error =  NWRFCLib::RFCError.new
-      @desc = NWRFCLib.get_function_desc(connection.handle, function_name.cU, @error.to_ptr)
-      @connection = connection
-      NWRFC.check_error(@error)
+      if args.size == 2
+        @function_name = args[1] #function_name
+        @desc = NWRFCLib.get_function_desc(args[0].handle, args[1].cU, @error.to_ptr)
+        NWRFC.check_error(@error)
+        @connection = args[0]
+      else
+        @function_name = args[0] #function_name
+        @desc = NWRFCLib::create_function_desc(args[0].cU, @error)
+        NWRFC.check_error(@error)
+        @connection = nil
+      end
+    end
+
+    def add_parameter(parameter)
+      rc = NWRFCLib.add_parameter(@desc, parameter.handle, @error)
+      NWRFC.check_error(@error) if rc > 0
     end
 
     # Create and return a callable instance of this function module
@@ -119,209 +175,6 @@ module NWRFC
 
   end
 
-  # Representation of a data container (function, structure or table)
-  class DataContainer
-    attr_reader :handle, :desc
-
-    def initialize(handle)
-      @error = NWRFCLib::RFCError.new
-      @handle = handle
-      @desc = NWRFCLib.describe_type(@handle, @error)
-      @member_metadata = {} #Cache of metadata for members
-      NWRFC.check_error(@error)
-    end
-
-    # Return the member specified by string or symbol
-    def [](element)
-      member = element.to_s.upcase
-      metadata = member_metadata(element)
-      case metadata[:type]
-      when :RFCTYPE_CHAR
-        # TODO: Try use :string parameter in get_chars
-        return read_chars(metadata)
-      when :RFCTYPE_DATE
-        return Date.parse(read_chars(metadata))
-        #return Date.new(date[0..3].to_i, date[4..5].to_i, date[6..7].to_i)
-      when :RFCTYPE_BCD
-        size = metadata[:ucLength]
-        cb = FFI::MemoryPointer.new :char, size * 2
-        rc = NWRFCLib.get_chars(@handle, metadata[:name].cU, cb, size * 2, @error.to_ptr)
-        NWRFC.check_error(@error) if rc > 0
-        cb.read_string(size).uC
-      when :RFCTYPE_TIME
-        # TODO: See whether we can optimize this
-        timec = read_chars(metadata)
-        return Time.parse("#{timec[0..1]}:#{timec[2..3]}:#{timec[4..5]}")
-      when :RFCTYPE_BYTE
-        return read_chars(metadata)
-      when :RFCTYPE_TABLE
-        new_handle = NWRFCLib::RFCDataContainer.new
-        rc = NWRFCLib.get_table(@handle, member.cU, new_handle.to_ptr, @error.to_ptr)
-        NWRFC.check_error(@error) if rc > 0
-        # CAVEAT: Other calls using the handle require "handle" field
-        # of the RFC_DATA_CONTAINER struct for some reason.
-        new_handle = new_handle[:handle]
-        value = Table.new(new_handle)
-      when :RFCTYPE_NUM
-        return read_chars(metadata).to_i
-      when :RFCTYPE_FLOAT
-        double = FFI::MemoryPointer.new :double
-        rc = NWRFCLib.get_float(@handle, member.cU, double, @error)
-        NWRFC.check_error(@error) if rc > 0
-        return double.get_double(0)
-      when :RFCTYPE_INT
-        int = FFI::MemoryPointer.new :int
-        rc = NWRFCLib.get_int(@handle, member.cU, int, @error)
-        NWRFC.check_error(@error) if rc > 0
-        return int.get_int(0)
-      when :RFCTYPE_INT2
-        short = FFI::MemoryPointer.new :short
-        rc = NWRFCLib.get_int2(@handle, member.cU, short, @error)
-        NWRFC.check_error(@error) if rc > 0
-        return short.get_short(0)
-      when :RFCTYPE_INT1
-        int1 = FFI::MemoryPointer.new :uint8
-        rc = NWRFCLib.get_int1(@handle, member.cU, int1, @error)
-        NWRFC.check_error(@error) if rc > 0
-        return int1.get_uint8(0)
-      when :RFCTYPE_NULL
-        raise "Unsupported type RFCTYPE_NULL" #You should never run into this
-      when :RFCTYPE_STRUCTURE
-        new_handle = NWRFCLib::RFCDataContainer.new
-        rc = NWRFCLib.get_structure(@handle, member.cU, new_handle.to_ptr, @error.to_ptr)
-        NWRFC.check_error(@error) if rc > 0
-        new_handle = new_handle[:handle]
-        value = Structure.new(new_handle)
-      when :RFCTYPE_DECF16
-        return read_chars(metadata).to_f
-      when :RFCTYPE_DECF34
-        return read_chars(metadata).to_f
-      when :RFCTYPE_XMLDATA
-        raise "Unsupported type RFCTYPE_XMLDATA (no longer used)" #You should never run into this
-      when :RFCTYPE_STRING
-        return read_string(metadata)
-      when :RFCTYPE_XSTRING
-      else
-        raise "Illegal member type #{metadata[:type]}"
-      end
-      NWRFC.check_error(@error)
-      value
-    end
-
-    def []=(element, value)
-      member = element.to_s.upcase
-      metadata = member_metadata(element)
-      case metadata[:type]
-      when :RFCTYPE_CHAR
-        NWRFCLib.set_chars(@handle, member.cU, value.cU, value.length, @error.to_ptr)
-      when :RFCTYPE_DATE
-        value = value_to_date(value)
-        NWRFCLib.set_date(@handle, member.cU, value.cU, @error.to_ptr)
-      when :RFCTYPE_BCD
-      when :RFCTYPE_TIME
-        value = value_to_time(value)
-        NWRFCLib.set_time(@handle, member.cU, value.cU, @error.to_ptr)
-      when :RFCTYPE_BYTE
-      when :RFCTYPE_TABLE
-      when :RFCTYPE_NUM
-      when :RFCTYPE_FLOAT
-        NWRFCLib.set_float(@handle, member.cU, value.to_f, @error.to_ptr)
-        #NWRFCLib.set_chars(@handle, member.cU, value.to_s.cU, value.to_s.length, @error.to_ptr)
-      when :RFCTYPE_INT
-        NWRFCLib.set_int(@handle, member.cU, value.to_i, @error.to_ptr)
-      when :RFCTYPE_INT2
-        NWRFCLib.set_int2(@handle, member.cU, value.to_i, @error.to_ptr)
-      when :RFCTYPE_INT1
-        NWRFCLib.set_int1(@handle, member.cU, value.to_i, @error.to_ptr)
-      when :RFCTYPE_NULL
-        raise "Unsupported type RFCTYPE_NULL" #You should never run into this
-      when :RFCTYPE_STRUCTURE
-      when :RFCTYPE_DECF16
-      when :RFCTYPE_DECF34
-      when :RFCTYPE_XMLDATA
-      when :RFCTYPE_STRING
-      when :RFCTYPE_XSTRING
-      else
-        raise "Illegal member type #{@members[:type]}"
-      end
-      NWRFC.check_error(@error)
-    end
-
-    def value_to_time(value)
-      return value.strftime(NW_TIME_FORMAT) if value.respond_to? :strftime
-      value.to_s
-    end
-
-    def value_to_date(value)
-      return value.strftime(NW_DATE_FORMAT) if value.respond_to? :strftime
-      # Force the resulting string into 8 characters otherwise
-      value = value.to_s
-      value << ' ' until value.size == 8 if value.size < 8
-      value = value[0..7] if value.size > 8
-      value
-    end
-
-    def value_to_time(value)
-      return value.strftime(NW_TIME_FORMAT) if value.respond_to? :strftime
-      # Force the resulting string into 6 characters otherwise
-      value = value.to_s
-      value << ' ' until value.size == 6 if value.size < 6
-      value = value[0..6] if value.size > 6
-      value
-    end
-
-    # Get the metadata of a member (function, structure or table)
-    def member_metadata(member_name)
-      member = member_name.to_s.upcase
-      if self.class == NWRFC::FunctionCall
-        fpar = NWRFCLib::RFCFuncParam.new
-        rc = NWRFCLib.get_parameter_desc_by_name(@desc, member.cU, fpar.to_ptr, @error.to_ptr)
-        NWRFC.check_error(@error) if rc > 0
-        member_to_hash(fpar)
-      elsif self.class == NWRFC::Table || self.class == NWRFC::Structure
-        fd = NWRFCLib::RFCFieldDesc.new
-        rc = NWRFCLib.get_field_desc_by_name(@desc, member.cU, fd.to_ptr, @error.to_ptr)
-        NWRFC.check_error(@error) if rc > 0 
-        member_to_hash(fd)
-      end
-    end
-
-    private
-    # Returns the subset of metadata values common to both a function parameter
-    # and a type field
-    def member_to_hash(member)
-      {
-        :name => member[:name].get_str,
-        :type => NWRFCLib::RFCTYPE[member[:type]],
-        :nucLength => member[:nucLength],
-        :ucLength => member[:ucLength],
-        :decimals => member[:decimals],
-        :typeDescHandle => member[:typeDescHandle]
-      }
-    end
-
-    def read_chars(metadata)
-      size = metadata[:ucLength]
-      cb = FFI::MemoryPointer.new :char, size
-      rc = NWRFCLib.get_chars(@handle, metadata[:name].cU, cb, metadata[:nucLength], @error.to_ptr)
-      NWRFC.check_error(@error) if rc > 0
-      cb.read_string(size).uC
-    end
-
-    def read_string(metadata)
-      #size = metadata[:ucLength]
-      size = FFI::MemoryPointer.new(:uint)
-      rc = NWRFCLib.get_string_length(@handle, metadata[:name].cU, size, @error)
-      NWRFC.check_error(@error) if rc > 0
-      buf_len = size.read_uint + 1
-      sbuf = FFI::MemoryPointer.new :char, buf_len * NWRFCLib::B_SIZE
-      rc = NWRFCLib.get_string(@handle, metadata[:name].cU, sbuf, buf_len, size, @error)
-      NWRFC.check_error(@error) if rc > 0
-      sbuf.read_string(sbuf.size).uC
-    end
-
-  end
-
   class FunctionCall < DataContainer
     attr_reader :handle, :desc, :connection, :function
 

data/lib/nwrfc/datacontainer.rb

@@ -0,0 +1,235 @@
+module NWRFC
+
+  # Representation of a data container (function, structure or table)
+  class DataContainer
+    attr_reader :handle, :desc
+
+    def initialize(handle)
+      @error = NWRFCLib::RFCError.new
+      @handle = handle
+      @desc = NWRFCLib.describe_type(@handle, @error)
+      @member_metadata = {} #Cache of metadata for members
+      NWRFC.check_error(@error)
+    end
+
+    # Return the member specified by string or symbol
+    def [](element)
+      member = element.to_s.upcase
+      metadata = member_metadata(element)
+      case metadata[:type]
+      when :RFCTYPE_CHAR
+        # TODO: Try use :string parameter in get_chars
+        return read_chars(metadata)
+      when :RFCTYPE_DATE
+        return Date.parse(read_chars(metadata))
+        #return Date.new(date[0..3].to_i, date[4..5].to_i, date[6..7].to_i)
+      when :RFCTYPE_BCD
+        size = metadata[:ucLength]
+        cb = FFI::MemoryPointer.new :char, size * 2
+        rc = NWRFCLib.get_chars(@handle, metadata[:name].cU, cb, size * 2, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        cb.read_string(size).uC
+      when :RFCTYPE_TIME
+        # TODO: See whether we can optimize this
+        timec = read_chars(metadata)
+        return Time.parse("#{timec[0..1]}:#{timec[2..3]}:#{timec[4..5]}")
+      when :RFCTYPE_BYTE
+        return read_chars(metadata)
+      when :RFCTYPE_TABLE
+        new_handle = NWRFCLib::RFCDataContainer.new
+        rc = NWRFCLib.get_table(@handle, member.cU, new_handle.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        # CAVEAT: Other calls using the handle require "handle" field
+        # of the RFC_DATA_CONTAINER struct for some reason.
+        new_handle = new_handle[:handle]
+        value = Table.new(new_handle)
+      when :RFCTYPE_NUM
+        return read_chars(metadata).to_i
+      when :RFCTYPE_FLOAT
+        double = FFI::MemoryPointer.new :double
+        rc = NWRFCLib.get_float(@handle, member.cU, double, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return double.get_double(0)
+      when :RFCTYPE_INT
+        int = FFI::MemoryPointer.new :int
+        rc = NWRFCLib.get_int(@handle, member.cU, int, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return int.get_int(0)
+      when :RFCTYPE_INT2
+        short = FFI::MemoryPointer.new :short
+        rc = NWRFCLib.get_int2(@handle, member.cU, short, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return short.get_short(0)
+      when :RFCTYPE_INT1
+        int1 = FFI::MemoryPointer.new :uint8
+        rc = NWRFCLib.get_int1(@handle, member.cU, int1, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return int1.get_uint8(0)
+      when :RFCTYPE_NULL
+        raise "Unsupported type RFCTYPE_NULL" #You should never run into this
+      when :RFCTYPE_STRUCTURE
+        new_handle = NWRFCLib::RFCDataContainer.new
+        rc = NWRFCLib.get_structure(@handle, member.cU, new_handle.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        new_handle = new_handle[:handle]
+        value = Structure.new(new_handle)
+      when :RFCTYPE_DECF16
+        double = FFI::MemoryPointer.new :double
+        rc = NWRFCLib.get_dec_f16(@handle, member.cU, double, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return double.get_double(0)
+      when :RFCTYPE_DECF34
+        double = FFI::MemoryPointer.new :double, 2
+        rc = NWRFCLib.get_dec_f34(@handle, member.cU, double, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return double.get_double(0)
+      when :RFCTYPE_XMLDATA
+        raise "Unsupported type RFCTYPE_XMLDATA (no longer used)" #You should never run into this
+      when :RFCTYPE_STRING
+        return read_string(metadata)
+      when :RFCTYPE_XSTRING
+        size = FFI::MemoryPointer.new(:uint)
+        rc = NWRFCLib.get_string_length(@handle, metadata[:name].cU, size, @error)
+        NWRFC.check_error(@error) if rc > 0
+        buf_len = size.read_uint
+        sbuf = FFI::MemoryPointer.new :uchar, buf_len
+        rc = NWRFCLib.get_x_string(@handle, metadata[:name].cU, sbuf, buf_len, size, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return sbuf.read_string(sbuf.size)
+      else
+        raise "Illegal member type #{metadata[:type]}"
+      end
+      NWRFC.check_error(@error)
+      value
+    end
+
+    def []=(element, value)
+      member = element.to_s.upcase
+      metadata = member_metadata(element)
+      case metadata[:type]
+      when :RFCTYPE_CHAR
+        NWRFCLib.set_chars(@handle, member.cU, value.cU, value.length, @error.to_ptr)
+      when :RFCTYPE_DATE
+        value = value_to_date(value)
+        NWRFCLib.set_date(@handle, member.cU, value.cU, @error.to_ptr)
+      when :RFCTYPE_BCD
+      when :RFCTYPE_TIME
+        value = value_to_time(value)
+        NWRFCLib.set_time(@handle, member.cU, value.cU, @error.to_ptr)
+      when :RFCTYPE_BYTE
+      when :RFCTYPE_TABLE
+      when :RFCTYPE_NUM
+      when :RFCTYPE_FLOAT
+        NWRFCLib.set_float(@handle, member.cU, value.to_f, @error.to_ptr)
+        #NWRFCLib.set_chars(@handle, member.cU, value.to_s.cU, value.to_s.length, @error.to_ptr)
+      when :RFCTYPE_INT
+        NWRFCLib.set_int(@handle, member.cU, value.to_i, @error.to_ptr)
+      when :RFCTYPE_INT2
+        NWRFCLib.set_int2(@handle, member.cU, value.to_i, @error.to_ptr)
+      when :RFCTYPE_INT1
+        NWRFCLib.set_int1(@handle, member.cU, value.to_i, @error.to_ptr)
+      when :RFCTYPE_NULL
+        raise "Unsupported type RFCTYPE_NULL" #You should never run into this
+      when :RFCTYPE_STRUCTURE
+      when :RFCTYPE_DECF16
+        raise "#{@members[:type]}: decfloat16 not supported yet"
+        double = NWRFCLib::RFC_DECF16.new #FFI::MemoryPointer.new :double
+        double[:align] = value.to_f
+        #double.put_double(0, value.to_f)
+        #double = FFI::Pointer.new 4
+        NWRFCLib.set_dec_f16(@handle, member.cU, double.pointer, @error)
+      when :RFCTYPE_DECF34
+        raise "#{@members[:type]}: decfloat34 not supported yet"
+        #        double = FFI::MemoryPointer.new :double, 2
+        #        double.put_double(0, value.to_f)
+        double = NWRFCLib::RFC_DECF34.new #FFI::MemoryPointer.new :double
+        double[:align] = value.to_f
+        NWRFCLib.set_dec_f34(@handle, member.cU, double, @error)
+      when :RFCTYPE_XMLDATA
+        raise "Unsupported type RFCTYPE_XMLDATA (no longer used)" #You should never run into this
+      when :RFCTYPE_STRING
+      when :RFCTYPE_XSTRING
+        m = FFI::MemoryPointer.new value.size
+        m.put_bytes 0, value
+        NWRFCLib.set_x_string(@handle, member.cU, m, value.size, @error)
+      else
+        raise "Illegal member type #{@members[:type]}"
+      end
+      NWRFC.check_error(@error)
+    end
+
+    def value_to_time(value)
+      return value.strftime(NW_TIME_FORMAT) if value.respond_to? :strftime
+      value.to_s
+    end
+
+    def value_to_date(value)
+      return value.strftime(NW_DATE_FORMAT) if value.respond_to? :strftime
+      # Force the resulting string into 8 characters otherwise
+      value = value.to_s
+      value << ' ' until value.size == 8 if value.size < 8
+      value = value[0..7] if value.size > 8
+      value
+    end
+
+    def value_to_time(value)
+      return value.strftime(NW_TIME_FORMAT) if value.respond_to? :strftime
+      # Force the resulting string into 6 characters otherwise
+      value = value.to_s
+      value << ' ' until value.size == 6 if value.size < 6
+      value = value[0..6] if value.size > 6
+      value
+    end
+
+    # Get the metadata of a member (function, structure or table)
+    def member_metadata(member_name)
+      member = member_name.to_s.upcase
+      if self.class == NWRFC::FunctionCall
+        fpar = NWRFCLib::RFCFuncParam.new
+        rc = NWRFCLib.get_parameter_desc_by_name(@desc, member.cU, fpar.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        member_to_hash(fpar)
+      elsif self.class == NWRFC::Table || self.class == NWRFC::Structure
+        fd = NWRFCLib::RFCFieldDesc.new
+        rc = NWRFCLib.get_field_desc_by_name(@desc, member.cU, fd.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        member_to_hash(fd)
+      end
+    end
+
+    private
+    # Returns the subset of metadata values common to both a function parameter
+    # and a type field
+    def member_to_hash(member)
+      {
+        :name => member[:name].get_str,
+        :type => NWRFCLib::RFC_TYPE[member[:type]],
+        :nucLength => member[:nucLength],
+        :ucLength => member[:ucLength],
+        :decimals => member[:decimals],
+        :typeDescHandle => member[:typeDescHandle]
+      }
+    end
+
+    def read_chars(metadata)
+      size = metadata[:ucLength]
+      cb = FFI::MemoryPointer.new :char, size
+      rc = NWRFCLib.get_chars(@handle, metadata[:name].cU, cb, metadata[:nucLength], @error.to_ptr)
+      NWRFC.check_error(@error) if rc > 0
+      cb.read_string(size).uC
+    end
+
+    def read_string(metadata)
+      size = FFI::MemoryPointer.new(:uint)
+      rc = NWRFCLib.get_string_length(@handle, metadata[:name].cU, size, @error)
+      NWRFC.check_error(@error) if rc > 0
+      buf_len = size.read_uint + 1
+      sbuf = FFI::MemoryPointer.new :char, buf_len * NWRFCLib::B_SIZE
+      rc = NWRFCLib.get_string(@handle, metadata[:name].cU, sbuf, buf_len, size, @error)
+      NWRFC.check_error(@error) if rc > 0
+      sbuf.read_string(sbuf.size).uC
+    end
+
+  end
+
+end

data/lib/nwrfc/dev_rfc.trc

@@ -0,0 +1,28 @@
+
+**** Trace file opened at 2012-02-17, 14:29:25 SAST
+ RFC library: 720, Current working directory: /home/martin/Development/ruby/sapnwrfc/lib/nwrfc, Program: irb
+ Hardware: Intel x86 with Linux i686, Operating_system: Linux 3.0.0-14-generic-pae, Kernel_release: 720 patchlevel 2
+ Hostname: martin-laptop, IP address: 127.0.1.1, IP address_v6: 127.0.1.1
+
+ERROR pfuuid_init returns error -> UUIDs cannot be generated
+
+**** Trace file opened at 2012-02-17, 14:35:20 SAST
+ RFC library: 720, Current working directory: /home/martin/Development/ruby/sapnwrfc/lib/nwrfc, Program: irb
+ Hardware: Intel x86 with Linux i686, Operating_system: Linux 3.0.0-14-generic-pae, Kernel_release: 720 patchlevel 2
+ Hostname: martin-laptop, IP address: 127.0.1.1, IP address_v6: 127.0.1.1
+
+ERROR pfuuid_init returns error -> UUIDs cannot be generated
+
+**** Trace file opened at 2012-02-17, 14:50:20 SAST
+ RFC library: 720, Current working directory: /home/martin/Development/ruby/sapnwrfc/lib/nwrfc, Program: irb
+ Hardware: Intel x86 with Linux i686, Operating_system: Linux 3.0.0-14-generic-pae, Kernel_release: 720 patchlevel 2
+ Hostname: martin-laptop, IP address: 127.0.1.1, IP address_v6: 127.0.1.1
+
+ERROR pfuuid_init returns error -> UUIDs cannot be generated
+
+**** Trace file opened at 2012-02-17, 15:04:13 SAST
+ RFC library: 720, Current working directory: /home/martin/Development/ruby/sapnwrfc/lib/nwrfc, Program: irb
+ Hardware: Intel x86 with Linux i686, Operating_system: Linux 3.0.0-14-generic-pae, Kernel_release: 720 patchlevel 2
+ Hostname: martin-laptop, IP address: 127.0.1.1, IP address_v6: 127.0.1.1
+
+ERROR pfuuid_init returns error -> UUIDs cannot be generated

data/lib/nwrfc/nwrfclib.rb

@@ -15,6 +15,7 @@ RUBY_VERSION_18 = RUBY_VERSION[0..2] == "1.8"
 # See http://stackoverflow.com/questions/9035661/ruby-ffi-memorypointer-read-int-present-in-1-9-but-not-1-8
 # Probably not good to interpret an unsigned int as an int, but we don't expect to use it for big values
 # that could result in sign conversion
+# FIXME - This must go! Replace with calls to get_* defined in FFI::MemoryPointer
 if RUBY_VERSION_18
   FFI::MemoryPointer.class_eval{ alias :read_uint :read_int}
 end
@@ -59,27 +60,24 @@ class String
   end
 
 end
-#String.class_eval{define_method(:cU){ NWRFCLib::Cutf8_to_utf16le.iconv(self+"\0") }}
 
 # Enhancement to FFI::StructLayout::CharArray to add a get_str method that changes the
 # string value of the character array by enforcing encoding of UTF-16LE (as used in NW RFC SDK)
 # and strips off blanks at the end to return a readable String
 class FFI::StructLayout::CharArray
   def get_str
-    #Iconv.conv("UTF8", "UTF-16LE", self.to_ptr.read_string(self.size)).strip
     NWRFCLib::Cutf16le_to_utf8.iconv(self.to_ptr.read_string(self.size)).strip
   end
 end
 
 # Library wrapper around NW RFC SDK shared library using RUBY-FFI
-# FIXME: Make structs managed structs and deconstruct them on GC
 module NWRFCLib
 
-  Cutf8_to_utf16le = Iconv.new("UTF-16LE", "UTF8")
-  Cutf16le_to_utf8 = Iconv.new("UTF8", "UTF-16LE")
+  Cutf8_to_utf16le = Iconv.new("UTF-16LE", "UTF-8")
+  Cutf16le_to_utf8 = Iconv.new("UTF-8", "UTF-16LE")
 
   extend FFI::Library
-  ffi_lib '/home/martin/nwrfcsdk/lib/libsapnwrfc.so'
+  ffi_lib 'sapnwrfc'
 
   # Multiplier for providing correct byte size for String passed to RFC library
   #TODO: Make platform-dependent size based on RUBY_PLATFORM
@@ -132,7 +130,7 @@ module NWRFCLib
     :RFC_TABLES, 7
   )
 
-  RFCTYPE = enum(
+  RFC_TYPE = enum(
     :RFCTYPE_CHAR   , 0,
     :RFCTYPE_DATE   , 1,
     :RFCTYPE_BCD    , 2,
@@ -245,59 +243,29 @@ module NWRFCLib
     layout :handle, :pointer
   end
 
-  #---
-  #  attach_function :init, :RfcInit, [], :void
-  #  # Connection handling:
-  #  attach_function :open_connection, :RfcOpenConnection,
-  #    [:pointer, :uint, :pointer], :pointer
-  #  attach_function :close_connection, :RfcCloseConnection,
-  #    [:pointer, :pointer], :void #(handle, error)
-  #  attach_function :get_connection_attributes, :RfcGetConnectionAttributes,
-  #    [:pointer, :pointer, :pointer], :void #(conn_handle, conninfo, error)
-  #  # Function Handling & Calling
-  #  attach_function :get_function_desc, :RfcGetFunctionDesc,
-  #    [:pointer, :pointer, :pointer], :pointer #(conn_handle, func_name, error)
-  #  attach_function :create_function, :RfcCreateFunction,
-  #    [:pointer, :pointer], :pointer #(fd_handle, error), :func_handle
-  #  attach_function :invoke, :RfcInvoke,
-  #    [:pointer, :pointer, :pointer], :int #(conn_handle, func_handle, error), RC
-  #  #TODO: Do we want to include RfcDestroyFunction for releasing its memory?
-  #  attach_function :get_param_count, :RfcGetParameterCount,
-  #    [:pointer, :pointer, :pointer], :void #(fd_handle, uint, error)
-  #  attach_function :get_parameter_desc_by_index, :RfcGetParameterDescByIndex,
-  #    [:pointer, :uint, :pointer, :pointer], :void #(fd_handle, idx, param, error)
-  #  # Field Handling
-  #  # RFC_RC RfcGetChars(handle, name, buffer, length, error)
-  #  attach_function :get_chars, :RfcGetChars,
-  #    [:pointer, :pointer, :pointer, :uint, :pointer], :RFC_RC
-  #  # RFC_RC RfcGetChars(handle, name, buffer, length, error)
-  #  attach_function :get_num, :RfcGetNum,
-  #    [:pointer, :pointer, :pointer, :uint, :pointer], :RFC_RC
-  #  # RFC_RC RfcGetDate
-  #  attach_function :get_date, :RfcGetDate,
-  #    [:pointer, :pointer, [:char, 8], :pointer], :RFC_RC
-  #  # RFC_RC RfcGetDate
-  #  attach_function :get_time, :RfcGetTime,
-  #    [:pointer, :pointer, [:char, 6], :pointer], :RFC_RC
-  #  # RFC_RC RfcGetString
-  #  #  attach_function :get_string, :RfcGetString,
-  #  #    [:pointer, :pointer, :pointer], :RFC_RC
-  #  # RFC RfcGetBytes
-  #  attach_function :get_bytes, :RfcGetBytes,
-  #    [:pointer, :pointer, :pointer, :uint, :pointer], :RFC_RC
-  #  # RFC_RC RfcGetXString
-  #  attach_function :get_xstring, :RfcGetXString,
-  #    [:pointer, :pointer, :pointer, :uint, :pointer, :pointer], :RFC_RC
-  #  # RFC_RC RfcGetStringLength(dataHandle, name, *length, error)
-  #  attach_function :get_string_length, :RfcGetStringLength,
-  #    [:pointer, :pointer, :pointer, :pointer], :int
-  #  # void RfcSetChars(dataHandle, name, value, length, error)
-  #  attach_function :set_chars, :RfcSetChars,
-  #    [:pointer, :pointer, :pointer, :uint, :pointer], :void
-  #+++
+  class RFC_DECF16 < FFI::Union
+    layout :bytes, [:uchar, 8],
+      :align, :double
+  end
+
+#  class SAP_MAX_ALIGN_T < FFI::Union
+#    layout :align1, :long,
+#      :align2, :double,
+#      :align3, :pointer,
+#      :align4,
+#  end
+
+#  class RFC_DECF34 < FFI::Union
+#    layout :bytes, [:uchar, 16],
+#      :align, 16
+#  end
 
   #############################################################################################################
   # ATTACH FUNCTIONS
+  # The functions here were obtained by parsing content from the doxygen files from the documentation
+  # accompanying the NW RFC SDK, and were tweaked here and there afterward. Most of them are actually not
+  # yet used in our NWRFC library, so calling them may not work. For best results, consult sapnwrfc.h from
+  # the SDK
   #############################################################################################################
   [
     [:add_exception, :RfcAddException, [:pointer, :pointer, :pointer], :int],
@@ -399,7 +367,8 @@ module NWRFCLib
     [:set_bytes, :RfcSetBytes, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
     [:set_chars, :RfcSetChars, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
     [:set_date, :RfcSetDate, [:pointer, :pointer, :pointer, :pointer], :int],
-    [:set_dec_f16, :RfcSetDecF16, [:pointer, :pointer, :pointer, :pointer], :int],
+    #[:set_dec_f16, :RfcSetDecF16, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:set_dec_f16, :RfcSetDecF16, [:pointer, :pointer, RFC_DECF16.by_value, :pointer], :int],
     [:set_dec_f34, :RfcSetDecF34, [:pointer, :pointer, :pointer, :pointer], :int],
     [:set_float, :RfcSetFloat, [:pointer, :pointer, :double, :pointer], :int],
     [:set_ini_path, :RfcSetIniPath, [:pointer, :pointer], :int],
@@ -423,12 +392,13 @@ module NWRFCLib
     [:submit_transaction, :RfcSubmitTransaction, [:pointer, :pointer], :int],
     [:utf8_to_sapuc, :RfcUTF8ToSAPUC, [:pointer, :uint, :pointer, :pointer, :pointer, :pointer], :int]
   ].each{|funcsig|
-    #    puts funcsig.to_s
     attach_function(funcsig[0], funcsig[1], funcsig[2], funcsig[3])
   }
 
   # Take Hash of connection parameters and returns FFI pointer to an array
   # for passing to connection
+  # ---
+  # TODO - Ideally, this method should live in nwrfc.rb
   def NWRFCLib.make_conn_params(params) #https://github.com/ffi/ffi/wiki/Structs
     par = FFI::MemoryPointer.new(RFCConnParam, params.length)
     pars = params.length.times.collect do |i|

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: nwrfc
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: 
   segments: 
   - 0
   - 0
-  - 0
-  version: 0.0.0
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - Martin Ceronio
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-30 00:00:00 Z
+date: 2012-02-20 00:00:00 Z
 dependencies: []
 
 description: SAP Netweaver RFC Library Wrapper using Ruby-FFI
@@ -29,9 +29,10 @@ extra_rdoc_files:
 files: 
 - README.rdoc
 - Rakefile
-- lib/nwrfc.old.rb
 - lib/nwrfc.rb
+- lib/nwrfc/datacontainer.rb
 - lib/nwrfc/nwrfclib.rb
+- lib/nwrfc/dev_rfc.trc
 - lib/dev_rfc.trc
 homepage: http://rubygems.org/gems/nwrfc
 licenses: []

data/lib/nwrfc.old.rb

@@ -1,338 +0,0 @@
-require File.dirname(__FILE__)+'/nwrfc/nwrfclib'
-
-# This library provides a way to call the functions of the SAP Netweaver RFC
-# SDK, i.e. opening a connection to an ABAP system, calling functions etc., as
-# well as running an RFC service
-#---
-# *TODO*: Create an error class that wraps the SAP error struct, so it can
-# be raised and the caller can get all the information from there
-#+++
-
-module NWRFC
-
-  def inspect
-    self.to_s
-  end
-  
-  def NWRFC.check_error(error_handle)
-    raise "Error code #{error_handle[:code]} group #{error_handle[:group]} message #{error_handle[:message].get_str}" \
-      if error_handle[:code] > 0
-  end
-
-  # Representation of a data container (function, structure or table)
-  module DataContainer
-
-    def initialize(handle)
-      @handle = handle
-      @error = NWRFCLib::RFCError.new
-    end
-
-    # Return the member specified by string or symbol
-    def [](element)
-      element = element.upcase
-      metadata = member_metadata(element)
-      case metadata[:type]
-      when :RFCTYPE_CHAR
-        # TODO: Try use :string parameter in get_chars
-        size = metadata[:ucLength]
-        cb = FFI::MemoryPointer.new :char, size
-        NWRFCLib.get_chars(@handle, element.cU, cb, metadata[:nucLength], @error.to_ptr)
-        value = cb.read_string(size).uC
-      when :RFCTYPE_DATE
-      when :RFCTYPE_BCD
-      when :RFCTYPE_TIME
-      when :RFCTYPE_BYTE
-      when :RFCTYPE_TABLE
-        value = get_data_container(element, :table)
-      when :RFCTYPE_NUM
-      when :RFCTYPE_FLOAT
-      when :RFCTYPE_INT
-      when :RFCTYPE_INT2
-      when :RFCTYPE_INT1
-      when :RFCTYPE_NULL
-      when :RFCTYPE_STRUCTURE
-        value = get_data_container(element, :structure)
-      when :RFCTYPE_DECF16
-      when :RFCTYPE_DECF34
-      when :RFCTYPE_XMLDATA
-      when :RFCTYPE_STRING
-      when :RFCTYPE_XSTRING
-      else
-        raise "Illegal member type #{metadata[:type]}"
-      end
-      NWRFC.check_error(@error)
-      value
-    end
-
-    def []=(element, value)
-      metadata = member_metadata(element)
-      case member_metadata[element][:type]
-      when :RFCTYPE_CHAR
-        NWRFCLib.set_chars(@handle, element.cU, value.cU, value.length, @error.to_ptr)
-      when :RFCTYPE_DATE
-      when :RFCTYPE_BCD
-      when :RFCTYPE_TIME
-      when :RFCTYPE_BYTE
-      when :RFCTYPE_TABLE
-      when :RFCTYPE_NUM
-      when :RFCTYPE_FLOAT
-      when :RFCTYPE_INT
-      when :RFCTYPE_INT2
-      when :RFCTYPE_INT1
-      when :RFCTYPE_NULL
-      when :RFCTYPE_STRUCTURE
-      when :RFCTYPE_DECF16
-      when :RFCTYPE_DECF34
-      when :RFCTYPE_XMLDATA
-      when :RFCTYPE_STRING
-      when :RFCTYPE_XSTRING
-      else
-        raise "Illegal member type #{@members[:type]}"
-      end
-      NWRFC.check_error(@error)
-    end
-
-    # Get the metadata of a member (function, structure or table)
-    def member_metadata(member)
-      if self.class == NWRFC::FunctionCall
-        self.function_description.member_metadata(member)
-      elsif self.class.instance_of?(Table) || self.class.instance_of?(Structure)
-        NWRFCLib.get_field_desc_by_name(@handle, member.uC, )
-      end
-    end
-
-    private
-
-    # Returns the subset of metadata values common to both a function parameter
-    # and a type field
-    def member_to_hash(member)
-        {
-          :type => NWRFCLib::RFCTYPE[member[:type]],
-          :nucLength => member[:nucLength],
-          :ucLength => member[:ucLength],
-          :decimals => member[:decimals],
-          :typeDescHandle => member[:typeDescHandle]
-        }
-    end
-
-    # Return either table or structure representing the element given
-    # from the current data container
-    def get_data_container(element, type)
-        datac = FFI::MemoryPointer.new NWRFCLib::RFCDataContainer
-        if type == :table
-          NWRFCLib.get_table(@handle, element.cU, datac, @error.to_ptr)
-          @components[element] = Table.new(datac)
-        end
-        if type == :structure
-          NWRFCLib.get_structure(@handle, element.cU, datac, @error.to_ptr)
-          @components[element] = Structure.new(datac)
-        end
-        NWRFC.check_error(@error)
-    end
-
-  end
-
-  # Represents a connection to a SAP system that can be used to invoke
-  # remote-enabled functions
-  class Connection
-
-    attr_reader :handle, :error
-    
-    # Opens a connection to the SAP system with the given connection parameters
-    # (described in the NW RFC SDK document), passed in the form of a Hash, e.g.
-    #   Connection.new { 'ashost' :=> 'ajax.domain.com', ... }
-    def initialize(conn_params)
-      conn_params.untaint #For params loaded from file, e.g.
-      raise "Connection parameters must be a Hash" unless conn_params.instance_of? Hash
-      #NWRFCLib.init
-      @cparams = NWRFCLib.make_conn_params(conn_params)
-      raise "Could not create valid pointer from parameters" unless @cparams.instance_of? FFI::MemoryPointer
-      #@errp = FFI::MemoryPointer.new(NWRFCLib::RFCError)
-      @error =  NWRFCLib::RFCError.new #@errp
-      @handle = NWRFCLib.open_connection(@cparams, conn_params.length, @error.to_ptr)
-      NWRFC.check_error(@error)
-      self
-    end
-
-    # Call the NW RFC SDK's RfcCloseConnection() function with the current
-    # connection; this (should - *TODO* - check) invalidate the connection handle
-    # and cause an error on any subsequent use of this connection
-    def disconnect
-      NWRFCLib.close_connection(@handle, @error.to_ptr)
-      NWRFC.check_error(@error)
-    end
-    
-    # Return details about the current connection and the system
-    def connection_info
-      return @get_connection_attributes if @get_connection_attributes
-      conn_info = NWRFCLib::RFCConnection.new
-      NWRFCLib.get_connection_attributes(@handle, conn_info.to_ptr, @error.to_ptr)
-      check_error
-      @get_connection_attributes = conn_info.members.inject({}) {|hash, member|
-        hash[member] = conn_info[member].get_str #get_str, own definition in nwrfclib.rb, FFI::StructLayout::CharArray#get_str
-        hash
-      }
-    end
-
-    def get_function(func_name)
-      Function.new(self, func_name)
-    end
-    
-    # Check the status of the error structure; raise an exception if it
-    # contains an error
-    # *TODO* - Raise a more meaningful error
-    def check_error
-      raise "Error code #{@error[:code]} group #{@error[:group]}" if @error[:code] > 0
-    end
-
-  end
-
-  # Represents a remote-enabled function module for RFC, can be instantiated either by the caller
-  # or by calling Connection#get_function. This only represents the description of the function;
-  # to call a function, an instance of a function call must be obtained with #get_function_call
-  #---
-  # FIXME: We are using a shared error object in the connection, so what happens in a
-  # multi-threaded situation? Functions should each have their own error handle
-  #+++
-  class Function
-    attr_reader :func_desc, :connection, :function_name, :members
-
-    # Get a function module instance; can also be obtained by calling Connection#get_function
-    def initialize(connection, func_name)
-      @connection = connection
-      @func_desc = NWRFCLib.get_function_desc(@connection.handle, func_name.cU, @connection.error.to_ptr)
-      NWRFC.check_error(@connection.error)
-      @function_name = func_name
-      @error =  NWRFCLib::RFCError.new
-      @members = self_describe # Load the metadata of the function description
-    end
-
-    # Create and return a callable instance of this function module
-    def get_function_call
-      FunctionCall.new(self)
-    end
-
-    def parameter_count
-      pcount = FFI::MemoryPointer.new(:uint)
-      NWRFCLib.get_parameter_count(@func_desc, pcount, @error.to_ptr)
-      NWRFC.check_error(@error)
-      pcount.read_uint
-    end
-
-    # Returns the definitions of parameters associated with this function module (lazy loading)
-    def parameters
-      @members
-    end
-
-    def [](param)
-      member_metadata(param)
-    end
-
-    # Look up parameter by method name given, returns parameter instance
-    # if it refers to a valid parameter 
-    def method_missing(method_sym, *args, &block)
-      param_name = method_sym.to_s.upcase
-      fpar = NWRFCLib::RFCFuncParam.new
-      rc = NWRFCLib.get_parameter_desc_by_name(@func_desc, param_name.cU, fpar.to_ptr, @error.to_ptr)
-      NWRFC.check_error(@error) if rc > 0
-      parameter_to_hash(fpar)
-    end
-
-    def member_metadata(param)
-      param_name = param.to_s.upcase
-      fpar = NWRFCLib::RFCFuncParam.new
-      rc = NWRFCLib.get_parameter_desc_by_name(@func_desc, param_name.cU, fpar.to_ptr, @error.to_ptr)
-      NWRFC.check_error(@error) if rc > 0
-      parameter_to_hash(fpar)
-    end
-
-    private
-
-    def parameter_to_hash(param)
-        {
-          :type => NWRFCLib::RFCTYPE[param[:type]],
-          :direction => NWRFCLib::RFC_DIRECTION[param[:direction]],
-          :nucLength => param[:nucLength],
-          :ucLength => param[:ucLength],
-          :decimals => param[:decimals],
-          :typeDescHandle => param[:typeDescHandle],
-          :defaultValue => param[:defaultValue].get_str,
-          :parameterText => param[:parameterText].get_str,
-          :optional => param[:optional]
-        }
-    end
-
-    # Load the metadata of the function description (only called during init)
-    def self_describe
-      parameter_count.times.inject({}) do |params, index|
-        param = NWRFCLib::RFCFuncParam.new
-        NWRFCLib.get_parameter_desc_by_index(@func_desc, index, param.to_ptr, @error.to_ptr)
-        params[param[:name].get_str] = {
-          :type => NWRFCLib::RFCTYPE[param[:type]],
-          :direction => NWRFCLib::RFC_DIRECTION[param[:direction]],
-          :nucLength => param[:nucLength],
-          :ucLength => param[:ucLength],
-          :decimals => param[:decimals],
-          :typeDescHandle => param[:typeDescHandle],
-          :defaultValue => param[:defaultValue].get_str,
-          :parameterText => param[:parameterText].get_str,
-          :optional => param[:optional]
-        }
-        params
-      end
-    end
-
-  end
-
-  # Represents a callable instance of a function module, using a function module description
-  # obtained previously. Can be obtained by passing either a function description or
-  # calling Function#get_function_call
-  class FunctionCall
-    include DataContainer
-    attr_reader :function_description, :handle, :connection
-    
-    def initialize(function_description)
-      @error = NWRFCLib::RFCError.new
-      @function_description = function_description
-      @connection = function_description.connection
-      @handle = NWRFCLib.create_function(@function_description.func_desc, @error.to_ptr)
-      @members = function_description
-      NWRFC.check_error(@error)
-    end
-
-    # Execute the function call on the SAP server
-    def invoke
-      rc = NWRFCLib.invoke(@connection.handle, @handle, @connection.error.to_ptr)
-      NWRFC.check_error(@error) if rc > 0
-    end
-
-    def method_missing(method_sym, *args, &block)
-      param_name = method_sym.to_s.upcase
-#      fpar = NWRFCLib::RFCFuncParam.new
-#      rc = NWRFCLib.get_parameter_desc_by_name(@function_description, param_name.cU, fpar.to_ptr, @error.to_ptr)
-#      NWRFC.check_error(@error) if rc > 0
-      if param_name[-1..-1] == "="
-        self[:param_name] = *args[0]
-      else
-        self[:param_name]
-      end
-    end
-
-  end
-
-  # Represents a structure
-  class Structure
-    include DataContainer
-  end
-
-  # Represents a table
-  class Table
-    include DataContainer
-  end
-
-  # Wrapper around the RFC Server functionality
-  class Server
-
-  end
-
-end