sapnwrfc 0.23-i686-linux

data/lib/sapnwrfc.rb

@@ -0,0 +1,217 @@
+#
+#
+# = SAPNWRFC - SAP Netweaver RFC support for Ruby
+#
+# Welcome to sapnwrfc !
+#
+# sapnwrfc is an RFC based connector to SAP specifically designed for use with the
+# next generation RFC SDK supplied by SAP for NW2004+ .
+#
+# = Download and Documentation
+#
+# Documentation at: http://www.piersharding.com/download/ruby/sapnwrfc/doc/
+#
+# Project and Download at: http://raa.ruby-lang.org/project/sapnwrfc
+#
+# = Functionality
+#
+# The next generation RFCSDK from SAP provides a number of interesting new features.  The two most
+# important are:
+# * UNICODE support
+# * deep/nested structures
+#
+# The UNICODE support is built fundamentally into the core of the new SDK, and as a result this is reflected in
+# sapnwrfc.  sapnwrfc takes UTF-8 as its only input character set, and handles the translation of this to UTF-16
+# as required by the RFCSDK.
+#
+# Deep and complex structures are now supported fully.  Please see the test_deep.rb example in tests/ for
+# an idea as to how it works.
+#
+# sapnwrfc is a departure to the way the original saprfc (http://raa.ruby-lang.org/project/saprfc) works.
+# It aims to simplify the exchange of native Ruby data types between the user application and the
+# connector.  This means that the following general rules should be observered, when passing values
+# to and from RFC interface parameters and tables:
+#
+# * Tables expect Arrays of Hashes.
+# * Parameters with structures expect Hashes
+# * CHAR, DATE, TIME, STRING, XSTRING, and BYTE type parameters expect String values.
+# * all numeric parameter values must be Fixnum, Bignum or Float.
+#
+#
+# = Building and Installation
+#
+# After you have unpacked your kit, you should have all the files listed in the MANIFEST.
+#
+# In brief, the following should work on most systems: ruby setup.rb
+#
+# if your rfcsdk is not findable in the system search path, then use the command line switches
+# for mkmf/setup.rb like so:
+#   ruby setup.rb config  --with-nwrfcsdk-dir=/path/to/rfcsdk
+#   ruby setup.rb setup
+#   ruby setup.rb install
+#
+# You must otain the latest RFCSDK for Netweaver from SAP - this <b>MUST</b> be the next
+# generation SDK, if you are to have any chance of succeeding.
+#
+#
+# = WIN32 Support
+#
+# When Olivier (or anyone else offering) supplies prebuilt GEM files, I make them available
+# on http://www.piersharding.com/download/ruby/sapnwrfc/ .
+#
+#
+# = Support
+#
+# For both community based, and professional support, I can be contacted at Piers Harding <piers@ompka.net>.
+#
+# = Examples
+#
+# Please see the examples (test/*.rb) distributed with this packages (download source for this) for
+# a comprehensive shake-down on what you can do.
+#
+# Here is a taster using the standard Flight demo BAPIs supplied by SAP:
+#
+#  require 'sapnwrfc'
+#
+#  TEST_FILE = 'ubuntu.yml'
+#
+#  # specify the YAML config source and load
+#  SAPNW::Base.config_location = TEST_FILE
+#  SAPNW::Base.load_config
+#
+#  # Connec to SAP
+#  conn = SAPNW::Base.rfc_connect
+#
+#  # Inspect the connection attributes
+#  attrib = conn.connection_attributes
+#  $stderr.print "Connection Attributes: #{attrib.inspect}\n"
+#
+#  # pull in your RFC definitions
+#  fld = conn.discover("BAPI_FLIGHT_GETLIST")
+#  flgd = conn.discover("BAPI_FLIGHT_GETDETAIL")
+#  fd = conn.discover("BAPI_FLBOOKING_CREATEFROMDATA")
+#
+#  # get a new handle for each function call to be invoked
+#  fl = fld.new_function_call
+#
+#  # set the parameters for the call
+#  fl.AIRLINE = "AA "
+#
+#  # ivoke the call
+#  fl.invoke
+#
+#  # interogate the results
+#  fl.FLIGHT_LIST.each do |row|
+#  	  $stderr.print "row: #{row.inspect}\n"
+#
+#  	  # for each flight now do another RFC call to get the details
+#     flg = flgd.new_function_call
+#  	  flg.AIRLINEID = row['AIRLINEID']
+#  	  flg.CONNECTIONID = row['CONNECTID']
+#  	  flg.FLIGHTDATE = row['FLIGHTDATE']
+#  	  flg.invoke
+#  	  $stderr.print "\tflight data: #{flg.FLIGHT_DATA.inspect}\n"
+#  	  $stderr.print "\tadditional info: #{flg.ADDITIONAL_INFO.inspect}\n"
+#  	  $stderr.print "\tavailability: #{flg.AVAILIBILITY.inspect}\n"
+#  end
+#
+#  # create a new booking
+#  fd.name == "BAPI_FLBOOKING_CREATEFROMDATA"
+#  f = fd.new_function_call
+#  f.BOOKING_DATA = { 'AIRLINEID' => "AA ", 'CONNECTID' => "0001", 'FLIGHTDATE' => "20070130",
+#                     'CLASS' => "F", 'CUSTOMERID' => "00000001", 'AGENCYNUM' => '00000093' }
+#
+#  # trap Function Call exceptions
+#  begin
+#    f.invoke
+#  rescue SAPNW::RFC::FunctionCallException => e
+#    $stderr.print "FunctionCallException: #{e.error.inspect}\n"
+#    raise "gone"
+#  end
+#  f.RETURN.each do |row|
+#    $stderr.print "row: #{row.inspect}\n"
+#  end
+#
+#  # use the standard COMMIT BAPI to commit the update
+#  cd = conn.discover("BAPI_TRANSACTION_COMMIT")
+#  c = cd.new_function_call
+#  c.WAIT = "X"
+#  c.invoke
+#
+#  # close the RFC connection and destroy associated resources
+#  conn.close
+#
+#
+#
+# = A Closer Look At Handling Parameters
+#
+# Complex parameter types map naturally to Ruby data types.
+# Parameters that require structures are represented by a Hash of field/value pairs eg:
+#  f.BOOKING_DATA = { 'AIRLINEID' => "AA ", 'CONNECTID' => "0001", 'FLIGHTDATE' => "20070130",
+#                     'CLASS' => "F", 'CUSTOMERID' => "00000001", 'AGENCYNUM' => '00000093' }
+# Parameters that require tables are represented by an Array of Hashes of field/value pairs eg:
+#  ft.IMPORT_TAB = [{ 'I' => 123, 'C' => 'AbCdEf',
+#                     'STR' =>  'The quick brown fox ...',
+#                     'XSTR' => ["deadbeef"].pack("H*") }]
+#
+#
+# = Building your RFC Call
+#
+# When building a call for client-side RFC, you should always be inspecting the requirements
+# of the RFC call by using transaction SE37 first.  You should also be in the the habit of
+# testing out your RFC calls first using SE37 too.  YOu would be amazed how much this simple
+# approach will save you (and me) time.
+#
+#
+#
+# = Thanks to:
+#
+# * Olivier Boudry - an Open Source guy
+# * Craig Cmehil   - SAP, and SDN
+# * Ulrich Schmidt - SAP
+# For their help in making this possible.
+#
+#
+#
+#
+# Author::   Piers Harding <piers@ompka.net>
+# License::  Copyright (c) 2006-2008 Piers Harding. sapnwrfc is free software, and may be redistributed under the terms specified in the README file of the Ruby distribution.
+# Requires:: Ruby 1.9.0 or later
+#
+
+
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'yaml'
+require 'fileutils'
+require 'logger'
+
+# setup defaults for logging
+SAP_LOGGER = Logger.new(STDERR)
+SAP_LOGGER.datetime_format = "%Y-%m-%d %H:%M:%S"
+SAP_LOGGER.level = Logger::WARN
+
+require 'sapnwrfc/base'
+
+# C extension
+begin
+  require 'nwsaprfc'
+rescue LoadError => e
+  SAP_LOGGER.error("Could not load nwsaprfc. Make sure nwrfcsdk libraries are properly installed: #{e.message}")
+  raise e
+end
+
+require 'sapnwrfc/config'
+require 'sapnwrfc/connection'
+require 'sapnwrfc/server'
+require 'sapnwrfc/functions'
+require 'sapnwrfc/parameters'
+
+SAPNW::Base.class_eval do
+  include SAPNW::Config
+  include SAPNW::Connections
+  include SAPNW::Servers
+  include SAPNW::Functions
+  include SAPNW::Parameters
+end
+

data/lib/sapnwrfc/base.rb

@@ -0,0 +1,41 @@
+# SAPNW is Copyright (c) 2006-2008 Piers Harding.  It is free software, and
+# may be redistributed under the terms specified in the README file of
+# the Ruby distribution.
+#
+# Welcome to sapnwrfc !
+#
+# sapnwrfc is a RFC based connector to SAP specifically designed for use with the
+# next generation RFC SDK supplied by SAP for NW2004+ .
+#
+#
+# 
+
+module SAPNW
+
+  # Some doco in the SAPNW module
+  class Base
+
+    # some doco in Base
+
+    @@rfc_connections = {}
+
+
+#     def rfc_connection(*args)
+#		   return SAPNW::RFC::Connection.connect(args)
+#		end
+#
+#     def rfc_register(*args)
+#		   return SAPNW::RFC::Server.connect(args)
+#		end
+#
+#     def installFunction(*args)
+#		   return SAPNW::RFC::Server.installFunction(args)
+#		end
+#
+    def Base.finalize(id)
+      SAP_LOGGER.debug("[#{self.class}] finalize called")
+    end
+
+  end
+end
+

data/lib/sapnwrfc/config.rb

@@ -0,0 +1,113 @@
+# SAPNW is Copyright (c) 2006-2008 Piers Harding.  It is free software, and
+# may be redistributed under the terms specified in the README file of
+# the Ruby distribution.
+#
+# Configuration for an RFC connection can be passed in two distinct ways, but those two methods
+# can be combined together.
+#
+# (1) Config is loaded via a YAML based config file
+# (2) Config is passed in the code directly into the connection
+# (3) a combination of (1) and (2), where (2) overides (1) at run time.
+#
+# YAML config file format:
+#
+#   ashost: ubuntu.local.net
+#   sysnr: "01"
+#   client: "001"
+#   user: developer
+#   passwd: developer
+#   lang: EN
+#   trace: 2
+#
+# At connection time, any valid parameters can be added or over ridden:
+#
+#   conn = SAPNW::Base.rfc_connect(:user => 'developer', :passwd => 'developer')
+#
+# Valid connection parameters are:
+#   ashost
+#   dest - used in conjunction with sapnwrfc.ini file
+#   mshost
+#   group
+#   sysid
+#   msserv
+#   sysnr
+#   lang
+#   client
+#   user
+#   passwd
+#   trace
+#   tpname
+#   gwhost
+#   gwserv
+#   codepage
+#   x509cert
+#   extiddata
+#   extidtype
+#   mysapsso2
+#   mysapsso
+#   getsso2
+#   snc_mode
+#   snc_qop
+#   snc_myname
+#   snc_partnername
+#   snc_lib
+#
+#
+#
+# Author::   Piers Harding <piers@ompka.net>
+# Requires:: Ruby 1.9 or later
+#
+
+Logger.class_eval do
+  def set_logdev(logfile, logfile_age = 0, logfile_size = 1048576)
+    @logdev = Logger::LogDevice.new(logfile, :shift_age => logfile_age, :shift_size => logfile_size)
+  end
+end
+
+module SAPNW
+  module Config
+    class << SAPNW::Base
+
+      @configuration = {}
+
+      attr_accessor :config_location, :config
+
+      def load_config
+        file = self.config_location || './sap.yml'
+        SAP_LOGGER.fatal("[#{self.name}] Configuration file not found:  #{file}") unless FileTest.exists?(file)
+        self.config = File.open(file) { |f| YAML::load(f) }
+        SAP_LOGGER.debug("[#{self.name}] Configuration: " + self.config.inspect)
+
+        if self.config.key? 'logfile'
+          if /STDOUT/i.match(self.config['logfile'])
+            SAP_LOGGER.set_logdev(STDOUT)
+          else
+            SAP_LOGGER.set_logdev(self.config['logfile'],
+                                  self.config['logfile_age'] || 0,
+                                  self.config['logfile_size'] || 1048576)
+            SAP_LOGGER.datetime_format = "%Y-%m-%d %H:%M:%S"
+          end
+        end
+        if self.config.key? 'loglevel'
+          case self.config['loglevel'].upcase
+            when 'FATAL'
+              SAP_LOGGER.level = Logger::FATAL
+            when 'ERROR'
+              SAP_LOGGER.level = Logger::ERROR
+            when 'WARN'
+              SAP_LOGGER.level = Logger::WARN
+            when 'INFO'
+              SAP_LOGGER.level = Logger::INFO
+            when 'DEBUG'
+              SAP_LOGGER.level = Logger::DEBUG
+          end
+        else
+          # set default
+          SAP_LOGGER.level = Logger::WARN
+        end
+        return self.config
+      end
+
+    end
+  end
+end

data/lib/sapnwrfc/connection.rb

@@ -0,0 +1,153 @@
+# SAPNW is Copyright (c) 2006-2008 Piers Harding.  It is free software, and
+# may be redistributed under the terms specified in the README file of
+# the Ruby distribution.
+#
+# Author::   Piers Harding <piers@ompka.net>
+# Requires:: Ruby 1.9 or later
+#
+
+module SAPNW
+  module Connections
+
+    class << SAPNW::Base
+
+# Build a connection to an R/3 system (ABAP AS)
+#
+# Connection parameters can be passed in a variety of ways
+# (a) via a YAML based configuration file
+# (b) a Hash of parameter arguments
+# (c) a combination of both
+      def rfc_connect(args = nil)
+        parms = {}
+        self.config = {} unless self.config
+        parms[:ashost] = self.config['ashost'] if self.config.key? 'ashost'
+        parms[:dest] = self.config['dest'] if self.config.key? 'dest'
+        parms[:mshost] = self.config['mshost'] if self.config.key? 'mshost'
+        parms[:group] = self.config['group'] if self.config.key? 'group'
+        parms[:sysid] = self.config['sysid'] if self.config.key? 'sysid'
+        parms[:msserv] = self.config['msserv'] if self.config.key? 'msserv'
+        parms[:sysnr] = self.config['sysnr'] if self.config.key? 'sysnr'
+        parms[:lang] = self.config['lang'] if self.config.key? 'lang'
+        parms[:client] = self.config['client'] if self.config.key? 'client'
+        parms[:user] = self.config['user'] if self.config.key? 'user'
+        parms[:passwd] = self.config['passwd'] if self.config.key? 'passwd'
+        parms[:trace] = self.config['trace'].to_i if self.config.key? 'trace'
+        parms[:codepage] = self.config['codepage'].to_i if self.config.key? 'codepage'
+        parms[:x509cert] = self.config['x509cert'] if self.config.key? 'x509cert'
+        parms[:extiddata] = self.config['extiddata'] if self.config.key? 'extiddata'
+        parms[:extidtype] = self.config['extidtype'] if self.config.key? 'extidtype'
+        parms[:mysapsso2] = self.config['mysapsso2'] if self.config.key? 'mysapsso2'
+        parms[:mysapsso] = self.config['mysapsso'] if self.config.key? 'mysapsso'
+        parms[:getsso2] = self.config['getsso2'].to_i if self.config.key? 'getsso2'
+        parms[:snc_mode] = self.config['snc_mode'] if self.config.key? 'snc_mode'
+        parms[:snc_qop] = self.config['snc_qop'] if self.config.key? 'snc_qop'
+        parms[:snc_myname] = self.config['snc_myname'] if self.config.key? 'snc_myname'
+        parms[:snc_partnername] = self.config['snc_partnername'] if self.config.key? 'snc_partnername'
+        parms[:snc_lib] = self.config['snc_lib'] if self.config.key? 'snc_lib'
+        SAP_LOGGER.debug("[" + self.name + "] base parameters to be passed are: " + parms.inspect)
+
+        case args
+          when nil
+          when Hash
+            parms[:ashost] = args[:ashost] if args.key? :ashost
+            parms[:dest] = args[:dest] if args.key? :dest
+            parms[:mshost] = args[:mshost] if args.key? :mshost
+            parms[:sysid] = args[:sysid] if args.key? :sysid
+            parms[:group] = args[:group] if args.key? :group
+            parms[:msserv] = args[:msserv] if args.key? :msserv
+            parms[:sysnr] = args[:sysnr] if args.key? :sysnr
+            parms[:lang] = args[:lang] if args.key? :lang
+            parms[:client] = args[:client] if args.key? :client
+            parms[:user] = args[:user] if args.key? :user
+            parms[:passwd] = args[:passwd] if args.key? :passwd
+            parms[:trace] = args[:trace].to_i if args.key? :trace
+            parms[:codepage] = args[:codepage].to_i if args.key? :codepage
+            parms[:x509cert] = args[:x509cert] if args.key? :x509cert
+            parms[:extiddata] = args[:extiddata] if args.key? :extiddata
+            parms[:extidtype] = args[:extidtype] if args.key? :extidtype
+            parms[:mysapsso2] = args[:mysapsso2] if args.key? :mysapsso2
+            parms[:mysapsso] = args[:mysapsso] if args.key? :mysapsso
+            parms[:getsso2] = args[:getsso2].to_i if args.key? :getsso2
+            parms[:snc_mode] = args[:snc_mode] if args.key? :snc_mode
+            parms[:snc_qop] = args[:snc_qop] if args.key? :snc_qop
+            parms[:snc_myname] = args[:snc_myname] if args.key? :snc_myname
+            parms[:snc_partnername] = args[:snc_partnername] if args.key? :snc_partnername
+            parms[:snc_lib] = args[:snc_lib] if args.key? :snc_lib
+            SAP_LOGGER.debug("[" + self.name + "] with EXTRA parameters to be passed are: " + parms.inspect)
+          else
+            raise "Wrong parameters for Connection - must pass a Hash\n"
+        end
+
+
+        connection = SAPNW::RFC::Connection.new(parms)
+        SAP_LOGGER.debug("completed the connection (#{connection.handle.class}/#{connection.handle.object_id}) ...")
+        return connection
+
+      end
+    end
+  end
+
+  module RFC
+    class Connection
+      attr_accessor :handle
+      attr_reader :connection_parameters, :functions
+
+      def initialize(args = nil)
+        @connection_parameters = []
+        case args
+          when nil
+          when Hash
+            args.each_pair { |key, val|
+              @connection_parameters << {'name' => key.to_s, 'value' => val.to_s}
+            }
+          else
+            raise "Wrong parameters for Connection - must pass a Hash\n"
+        end
+        SAP_LOGGER.debug("In #{self.class} initialize: #{@connection_parameters.inspect} ...")
+        @functions = {}
+        @handle = SAPNW::RFC::Handle.new(self)
+      end
+
+      def connection_attributes
+        SAP_LOGGER.debug("In #{self.class} connection_attributes ...")
+        return self.handle.connection_attributes()
+      end
+
+      # discover() looks up the dictionary definition of an RFC interface
+      # storing away the meta data of the associated Parameters/Tables and returns this
+      # as an instance of SAPNW::RFC::FunctionDescriptor.  This is the MANDATORY starting
+      # point of all client side RFC.
+      def discover(func = nil)
+        SAP_LOGGER.debug("In #{self.class} discover (#{func}) ...")
+        case func
+          when nil
+            return nil
+          else
+            func_def = self.handle.function_lookup(SAPNW::RFC::FunctionDescriptor, SAPNW::RFC::Parameter, func.to_s)
+            @functions[func_def.name] = func_def
+            return func_def
+        end
+      end
+
+      # terminate an established RFC connection.  This will invalidate any currently in-scope
+      # FunctionDescriptors associated with this Connection.
+      def close
+        SAP_LOGGER.debug("In #{self.class} close ...")
+        return nil unless self.handle
+        SAP_LOGGER.debug("In #{self.class} handle: #{self.handle} ...")
+        res = self.handle.close()
+        self.handle = nil
+        # XXX Should destroy all cached functions and structures and types tied to handle ?
+        return true
+      end
+
+      # ping test a connection to see if it is still alive
+      def ping
+        SAP_LOGGER.debug("In #{self.class} ping ...")
+        return nil unless self.handle
+        SAP_LOGGER.debug("In #{self.class} handle: #{self.handle} ...")
+        return self.handle.ping()
+      end
+    end
+  end
+end

data/lib/sapnwrfc/functions.rb

@@ -0,0 +1,179 @@
+# SAPNW is Copyright (c) 2006-2008 Piers Harding.  It is free software, and
+# may be redistributed under the terms specified in the README file of
+# the Ruby distribution.
+#
+# Author::   Piers Harding <piers@ompka.net>
+# Requires:: Ruby 1.9 or later
+#
+
+module SAPNW
+  module Functions
+    class Base
+
+    end
+  end
+
+  module RFC
+
+    # These are automatically created as a result of SAPNW::RFC::Connection#discover() -
+    # do not instantiate these yourself yourself!
+    #
+    class FunctionDescriptor
+      attr_reader :name, :parameters
+      attr_accessor :callback
+
+      # create a new SAPNW::RFC::FunctionCall object for this FunctionDescriptor.
+      #
+      # You must call this each time that you want to invoke() a new function call, as
+      # this creates a one shot container for the passing back and forth of interface parameters.
+      def new_function_call
+        return create_function_call(SAPNW::RFC::FunctionCall)
+      end
+
+      def make_empty_function_call
+        return SAPNW::RFC::FunctionCall.new(self)
+      end
+
+      def callback=(proc)
+        if proc.instance_of?(Proc)
+          @callback = proc
+        else
+          raise "Must pass in an instance of Proc for the callback"
+        end
+        return @callback
+      end
+
+      def handler(function)
+        begin
+          return @callback.call(function)
+        rescue SAPNW::RFC::ServerException => e
+          #$stderr.print "ServerException => #{e.error.inspect}\n"
+          return e
+        rescue StandardError => e
+          #$stderr.print "StandardError => #{e.inspect}/#{e.message}\n"
+          return SAPNW::RFC::ServerException.new({'code' => 3, 'key' => 'RUBY_RUNTIME', 'message' => e.message})
+        end
+      end
+
+      def method_missing(methid, *rest)
+        meth = methid.id2name
+        if @parameters.has_key?(meth)
+          return @parameters[meth]
+        else
+          raise NoMethodError
+        end
+      end
+
+      # internal method used to add parameters from within the C extension
+      #def addParameter(name = nil, direction = 0, type = 0, len = 0, ulen = 0, decimals = 0)
+      def addParameter(*parms)
+        parms = parms.first if parms.class == Array and (parms.first.class == Hash || parms.first.kind_of?(SAPNW::RFC::Parameter))
+        case parms
+          when Array
+            name, direction, type, len, ulen, decimals = parms
+          when Hash
+            name = parms.has_key?(:name) ? parms[:name] : nil
+            direction = parms.has_key?(:direction) ? parms[:direction] : nil
+            type = parms.has_key?(:type) ? parms[:type] : nil
+            len = parms.has_key?(:len) ? parms[:len] : nil
+            ulen = parms.has_key?(:ulen) ? parms[:ulen] : nil
+            decimals = parms.has_key?(:decimals) ? parms[:decimals] : nil
+          when SAPNW::RFC::Export, SAPNW::RFC::Import, SAPNW::RFC::Changing, SAPNW::RFC::Table
+            # this way happens when a function def is manually defined
+            self.add_parameter(parms)
+            @parameters[parms.name] = parms
+            return parms
+          else
+            raise "invalid SAPNW::RFC::FunctionDescriptor parameter supplied: #{parms.inspect}\n"
+        end
+
+        #$stderr.print "parm: #{name} direction: #{direction} type: #{type} len: #{len} decimals: #{decimals}\n"
+        case direction
+          when SAPNW::RFC::IMPORT
+            if @parameters.has_key?(name) and @parameters[name].direction == SAPNW::RFC::EXPORT
+              p = SAPNW::RFC::Changing.new(self, name, type, len, ulen, decimals)
+            else
+              p = SAPNW::RFC::Import.new(self, name, type, len, ulen, decimals)
+            end
+          when SAPNW::RFC::EXPORT
+            if @parameters.has_key?(name) and @parameters[name].direction == SAPNW::RFC::IMPORT
+              p = SAPNW::RFC::Changing.new(self, name, type, len, ulen, decimals)
+            else
+              p = SAPNW::RFC::Export.new(self, name, type, len, ulen, decimals)
+            end
+          when SAPNW::RFC::CHANGING
+            p = SAPNW::RFC::Changing.new(self, name, type, len, ulen, decimals)
+          when SAPNW::RFC::TABLES
+            p = SAPNW::RFC::Table.new(self, name, type, len, ulen, decimals)
+          else
+            raise "unknown direction (#{name}): #{direction}\n"
+        end
+        @parameters[p.name] = p
+        return p
+      end
+
+    end
+
+    class FunctionCall
+      attr_reader :function_descriptor, :name, :parameters
+
+      # These are automatically created as a result of SAPNW::RFC::FunctionDescriptor#new_function_call() -
+      # do not instantiate these yourself!
+      #
+      # SAPNW::RFC::FunctionCall objects allow dynamic method calls of parameter, and table names
+      # for the setting and getting of interface values eg:
+      #   fd = conn.discover("RFC_READ_TABLE")
+      #   f = fd.new_function_call
+      #   f.QUERY_TABLE = "T000" # <- QUERY_TABLE is a dynamic method serviced by method_missing
+      #def initialize(fd=nil)
+      def initialize(fd=nil)
+        @parameters = {}
+        if fd == nil
+          @function_descriptor.parameters.each_pair do |k, v|
+            @parameters[k] = v.clone
+          end
+        else
+          fd.parameters.each_pair do |k, v|
+            @parameters[k] = v.clone
+          end
+        end
+        @parameters_list = @parameters.values || []
+      end
+
+      # activate a parameter - parameters are active by default so it is unlikely that this
+      # would ever need to be called.
+      def activate(parm=nil)
+        raise "Parameter not found: #{parm}\n" unless @parameters.has_key?(parm)
+        return set_active(parm, 1)
+      end
+
+      # deactivate a parameter - parameters can be deactivated for a function call, to reduce the 
+      # amount of RFC traffic on the wire.  This is especially important for unrequired tables, or
+      # parameters that are similar sources of large data transfer.
+      def deactivate(parm=nil)
+        raise "Parameter not found: #{parm}\n" unless @parameters.has_key?(parm)
+        return set_active(parm, 0)
+      end
+
+      # dynamic method calls for parameters and tables
+      def method_missing(methid, *rest)
+        meth = methid.id2name
+        #$stderr.print "method_missing: #{meth}\n"
+        #$stderr.print "parameters: #{@parameters.keys.inspect}\n"
+        if @parameters.has_key?(meth)
+          #$stderr.print "return parm obj\n"
+          return @parameters[meth].value
+        elsif mat = /^(.*?)\=$/.match(meth)
+          #$stderr.print "return parm val\n"
+          if  @parameters.has_key?(mat[1])
+            return @parameters[mat[1]].value = rest[0]
+          else
+            raise NoMethError
+          end
+        else
+          raise NoMethodError
+        end
+      end
+    end
+  end
+end

data/lib/sapnwrfc/parameters.rb

@@ -0,0 +1,332 @@
+# SAPNW is Copyright (c) 2006-2008 Piers Harding.  It is free software, and
+# may be redistributed under the terms specified in the README file of
+# the Ruby distribution.
+#
+# Author::   Piers Harding <piers@ompka.net>
+# Requires:: Ruby 1.9 or later
+#
+
+module SAPNW
+  module Parameters
+
+    # base class for all parameters
+    class Base
+
+      # they all have:
+      #   a name
+      #   may or may not have a structure = a type
+      #   type may be complex or simple
+      #
+      #
+
+    end
+  end
+
+  module RFC
+
+    # Parameter types
+    IMPORT = 1
+    EXPORT = 2
+    CHANGING = 3
+    TABLES = 7
+
+    # basic data types
+    CHAR = 0
+    DATE = 1
+    BCD = 2
+    TIME = 3
+    BYTE = 4
+    TABLE = 5
+    NUM = 6
+    FLOAT = 7
+    INT = 8
+    INT2 = 9
+    INT1 = 10
+    NULL = 14
+    STRUCTURE = 17
+    DECF16 = 23
+    DECF34 = 24
+    XMLDATA = 28
+    STRING = 29
+    XSTRING = 30
+    EXCEPTION = 98
+
+    # return codes
+    RFC_OK = 0
+    RFC_COMMUNICATION_FAILURE = 1
+    RFC_LOGON_FAILURE = 2
+    RFC_ABAP_RUNTIME_FAILURE = 3
+    RFC_ABAP_MESSAGE = 4
+    RFC_ABAP_EXCEPTION = 5
+    RFC_CLOSED = 6
+    RFC_CANCELED = 7
+    RFC_TIMEOUT = 8
+    RFC_MEMORY_INSUFFICIENT = 9
+    RFC_VERSION_MISMATCH = 10
+    RFC_INVALID_PROTOCOL = 11
+    RFC_SERIALIZATION_FAILURE = 12
+    RFC_INVALID_HANDLE = 13
+    RFC_RETRY = 14
+    RFC_EXTERNAL_FAILURE = 15
+    RFC_EXECUTED = 16
+    RFC_NOT_FOUND = 17
+    RFC_NOT_SUPPORTED = 18
+    RFC_ILLEGAL_STATE = 19
+    RFC_INVALID_PARAMETER = 20
+    RFC_CODEPAGE_CONVERSION_FAILURE = 21
+    RFC_CONVERSION_FAILURE = 22
+    RFC_BUFFER_TOO_SMALL = 23
+    RFC_TABLE_MOVE_BOF = 24
+    RFC_TABLE_MOVE_EOF = 25
+
+
+    # Base class for all Parameter types
+    class Parameter < SAPNW::Parameters::Base
+      attr_reader :name, :type, :typdef, :direction, :len, :ulen, :decimals, :value
+
+      # constructor called only from the SAPNW::RFC::Connector#discover process
+      #def initialize(funcdesc, name, type, len, ulen, decimals)
+      def initialize(*parms)
+        parms = parms.first if parms.class == Array and parms.first.class == Hash
+        case parms
+          when Array
+            # this way happens when the interface of the parameter has been discover()ed
+            funcdesc, name, type, len, ulen, decimals, typedef = parms
+          when Hash
+            # This way happens when a parameter is being manually constructed
+            raise "Missing parameter :name => #{parms.inspect}\n" unless parms.has_key?(:name)
+            raise "Missing parameter :type => #{parms.inspect}\n" unless parms.has_key?(:type)
+            case parms[:type]
+              when SAPNW::RFC::CHAR, SAPNW::RFC::DATE, SAPNW::RFC::BCD, SAPNW::RFC::TIME, SAPNW::RFC::BYTE, SAPNW::RFC::TABLE, SAPNW::RFC::NUM, SAPNW::RFC::FLOAT, SAPNW::RFC::INT, SAPNW::RFC::INT2, SAPNW::RFC::INT1, SAPNW::RFC::NULL, SAPNW::RFC::STRUCTURE, SAPNW::RFC::DECF16, SAPNW::RFC::DECF34, SAPNW::RFC::XMLDATA, SAPNW::RFC::STRING, SAPNW::RFC::XSTRING, SAPNW::RFC::EXCEPTION
+              else
+                if parms[:type].class == SAPNW::RFC::Type
+                  parms[:typedef] = parms[:type]
+                  parms[:type] = parms[:typedef].type
+                  raise "Parameter type (#{self.class}) does not match Type type (#{parms[:typedef].inspect})\n" if self.class == SAPNW::RFC::Table and parms[:type] != SAPNW::RFC::TABLE
+                else
+                  raise "Invalid SAPNW::RFC* type supplied (#{parms[:type]})\n"
+                end
+            end
+            funcdesc = nil
+            len = 0
+            ulen = 0
+            decimals = 0
+            name = parms[:name]
+            type = parms[:type]
+            typedef = parms[:typedef] if parms.has_key?(:typedef)
+            len = parms[:len] if parms.has_key?(:len)
+            ulen = parms[:ulen] if parms.has_key?(:ulen)
+            decimals = parms[:decimals] if parms.has_key?(:decimals)
+          else
+            raise "invalid parameters: #{parms.inspect}\n"
+        end
+        @function_descriptor = funcdesc
+        @name = name
+        @type = type
+        @typedef = typedef
+        @len = len
+        @ulen = ulen
+        @decimals = decimals
+        @value = nil
+        #$stderr.print "initilised parameter(#{@name}): #{self.inspect}\n"
+      end
+
+      # method_missing is used to pass on any method call to a parameter
+      # to the underlying native Ruby data type
+      def method_missing(methid, *rest, &block)
+        meth = methid.id2name
+        #$stderr.print "method_missing: #{meth}\n"
+        #$stderr.print "parameters: #{@parameters.keys.inspect}\n"
+        if block
+          @value.send(meth, &block)
+        else
+          #$stderr.print "Export method_missing - no block: #{meth}\n"
+          @value.send(meth, *rest)
+        end
+      end
+
+      # value setting for parameters - does basic Type checking to preserve
+      # sanity for the underlying C extension
+      def value=(val=nil)
+        #$stderr.print "setting: #{@name} type: #{@type} value: #{val}/#{val.class}\n"
+        case @type
+          when SAPNW::RFC::INT, SAPNW::RFC::INT2, SAPNW::RFC::INT1
+            unless val.is_a?(Fixnum)
+              raise TypeError, "Must be Fixnum for INT, INT1, and INT2 (#{@name}/#{@type}/#{val.class})\n"
+            end
+          when SAPNW::RFC::NUM
+            unless val.is_a?(String)
+              raise TypeError, "Must be String for NUMC (#{@name}/#{@type}/#{val.class})\n"
+            end
+          when SAPNW::RFC::BCD
+            unless val.is_a?(Float) || val.is_a?(Fixnum) || val.is_a?(Bignum)
+              raise TypeError, "Must be FLoat or *NUM for BCD (#{@name}/#{@type}/#{val.class})\n"
+            end
+            val = val.to_s
+          when SAPNW::RFC::FLOAT
+            unless val.is_a?(Float)
+              raise TypeError, "Must be FLoat for FLOAT (#{@name}/#{@type}/#{val.class})\n"
+            end
+          when SAPNW::RFC::STRING, SAPNW::RFC::XSTRING
+            unless val.is_a?(String)
+              raise TypeError, "Must be String for STRING, and XSTRING (#{@name}/#{@type}/#{val.class})\n"
+            end
+          when SAPNW::RFC::BYTE
+            unless val.is_a?(String)
+              raise TypeError, "Must be String for BYTE (#{@name}/#{@type}/#{val.class})\n"
+            end
+          when SAPNW::RFC::CHAR, SAPNW::RFC::DATE, SAPNW::RFC::TIME
+            unless val.is_a?(String)
+              raise TypeError, "Must be String for CHAR, DATE, and TIME (#{@name}/#{@type}/#{val.class})\n"
+            end
+          when SAPNW::RFC::TABLE
+            unless val.is_a?(Array)
+              raise TypeError, "Must be Array for table value (#{@name}/#{val.class})\n"
+            end
+            cnt = 0
+            val.each do |row|
+              cnt += 1
+              unless row.is_a?(Hash)
+                raise TypeError, "Must be Hash for table row value (#{@name}/#{cnt}/#{row.class})\n"
+              end
+            end
+          when SAPNW::RFC::STRUCTURE
+            unless val.is_a?(Hash)
+              raise TypeError, "Must be a Hash for a Structure Type (#{@name}/#{@type}/#{val.class})\n"
+            end
+          else # anything - barf
+            raise "unknown SAP data type (#{@name}/#{@type})\n"
+        end
+        @value = val
+        return val
+      end
+
+    end
+
+    # RFC Import Parameters
+    class Import < SAPNW::RFC::Parameter
+      def initialize(*args)
+        @direction = SAPNW::RFC::IMPORT
+        super
+      end
+    end
+
+    # RFC Export Parameters
+    class Export < SAPNW::RFC::Parameter
+      def initialize(*args)
+        @direction = SAPNW::RFC::EXPORT
+        super
+      end
+    end
+
+    # RFC Changing Parameters
+    class Changing < SAPNW::RFC::Parameter
+      def initialize(*args)
+        @direction = SAPNW::RFC::CHANGING
+        super
+      end
+    end
+
+    # RFC Table type Parameters
+    class Table < SAPNW::RFC::Parameter
+      def initialize(*args)
+        @direction = SAPNW::RFC::TABLES
+        super
+      end
+
+      # returns the no. of rows currently in the table
+      def length
+        return @value.length
+      end
+
+      # assign an Array, of rows represented by Hashes to the value of
+      # the Table parameter.
+      def value=(val=[])
+        unless val.is_a?(Array)
+          raise TypeError, "Must be Array for table value (#{@name}/#{val.class})\n"
+        end
+        cnt = 0
+        val.each do |row|
+          cnt += 1
+          unless row.is_a?(Hash)
+            raise TypeError, "Must be Hash for table row value (#{@name}/#{cnt}/#{row.class})\n"
+          end
+        end
+        @value = val
+      end
+
+      # Yields each row of the table to passed Proc
+      def each
+        return nil unless @value
+        @value.each do |row|
+          yield row
+        end
+      end
+    end
+
+    class Type
+
+      attr_reader :name, :type, :len, :ulen, :decimals, :fields
+
+      def initialize(*args)
+        args = args.first if args.class == Array and args.first.class == Hash
+        case args
+          when Array
+            name, type, len, ulen, decimals, fields = args
+          when Hash
+            raise "Missing Type :name => #{args.inspect}\n" unless args.has_key?(:name)
+            raise "Missing Type :type => #{args.inspect}\n" unless args.has_key?(:type)
+            #raise "Missing Type :len => #{args.inspect}\n" unless args.has_key?(:len)
+            case args[:type]
+              when SAPNW::RFC::CHAR, SAPNW::RFC::DATE, SAPNW::RFC::BCD, SAPNW::RFC::TIME, SAPNW::RFC::BYTE, SAPNW::RFC::TABLE, SAPNW::RFC::NUM, SAPNW::RFC::FLOAT, SAPNW::RFC::INT, SAPNW::RFC::INT2, SAPNW::RFC::INT1, SAPNW::RFC::NULL, SAPNW::RFC::STRUCTURE, SAPNW::RFC::DECF16, SAPNW::RFC::DECF34, SAPNW::RFC::XMLDATA, SAPNW::RFC::STRING, SAPNW::RFC::XSTRING, SAPNW::RFC::EXCEPTION
+              else
+                raise "Invalid SAPNW::RFC* type supplied (#{args[:type]})\n"
+            end
+            len = 0
+            ulen = 0
+            decimals = 0
+            name = args[:name]
+            type = args[:type]
+            len = args[:len] if args.has_key?(:len)
+            ulen = 2 * len
+            ulen = args[:ulen] if args.has_key?(:ulen)
+            decimals = args[:decimals] if args.has_key?(:decimals)
+            fields = args[:fields] if args.has_key?(:fields)
+          else
+            raise "invalid parameters in SAPNW::RFC::Type: #{args.inspect}\n"
+        end
+        @name = name
+        @type = type
+        @len = len
+        @ulen = ulen
+        @decimals = decimals
+        if fields
+          raise "Fields must be an Array (#{fields.inspect})\n" unless fields.class == Array
+          slen = 0
+          sulen = 0
+          fields.each do |val|
+            raise "each field definition must be a Hash (#{val.inspect})\n" unless val.class == Hash
+            unless val.has_key?(:name) and
+                val.has_key?(:type) and
+                val.has_key?(:len)
+              raise "each field definition must have :name, :type, and :len (#{val.inspect})\n"
+            end
+            val[:ulen] = val[:len] * 2 unless val.has_key?(:ulen)
+            val[:decimals] = 0 unless val.has_key?(:decimals)
+            slen += val[:len]
+            sulen += val[:ulen]
+            # sort out nested types
+            if val[:type].class == SAPNW::RFC::Type
+              val[:typedef] = val[:type]
+              val[:type] = val[:typedef].type
+            end
+          end
+          @len = slen unless @len > 0
+          @ulen = sulen unless @ulen > 0
+        end
+        @fields = fields
+        #$stderr.print "initilised Type(#{name}): #{type} - #{@fields.inspect}\n"
+      end
+    end
+  end
+end

data/lib/sapnwrfc/server.rb

@@ -0,0 +1,151 @@
+# SAPNW is Copyright (c) 2006-2008 Piers Harding.  It is free software, and
+# may be redistributed under the terms specified in the README file of
+# the Ruby distribution.
+#
+# Author::   Piers Harding <piers@ompka.net>
+# Requires:: Ruby 1.9 or later
+#
+
+module SAPNW
+
+  module Servers
+
+    class << SAPNW::Base
+
+      # registers with an R/3 systems gateway service.  Uses parameters supplied
+      # in the YAML config file by default, but overrides these with any passed
+      # as a Hash.  returns a SAPNW::RFC::Server object
+      def rfc_register(args = nil)
+        parms = {}
+        parms[:trace] = self.config['trace'].to_i if self.config.key? 'trace'
+        parms[:tpname] = self.config['tpname'] if self.config.key? 'tpname'
+        parms[:gwhost] = self.config['gwhost'] if self.config.key? 'gwhost'
+        parms[:gwserv] = self.config['gwserv'] if self.config.key? 'gwserv'
+        SAP_LOGGER.debug("[" + self.name + "] base parameters to be passed are: " + parms.inspect)
+
+        case args
+          when nil
+          when Hash
+            parms[:trace] = args[:trace].to_i if args.key? :trace
+            parms[:tpname] = args[:tpname] if args.key? :tpname
+            parms[:gwhost] = args[:gwhost] if args.key? :gwhost
+            parms[:gwserv] = args[:gwserv] if args.key? :gwserv
+            SAP_LOGGER.debug("[" + self.name + "] with EXTRA parameters to be passed are: " + parms.inspect)
+          else
+            raise "Wrong parameters for Connection - must pass a Hash\n"
+        end
+
+        server = SAPNW::RFC::Server.new(parms)
+        SAP_LOGGER.debug("completed the server connection (#{server.handle.class}/#{server.handle.object_id}) ...")
+        return server
+      end
+    end
+  end
+
+
+  module RFC
+    class ServerException < Exception
+      def initialize(error=nil)
+        unless error.class == Hash
+          error = {'code' => 3, 'key' => 'RUNTIME', 'message' => error.to_s}
+        end
+        @error = error
+      end
+    end
+
+    class Server
+      attr_accessor :handle
+      attr_reader :connection_parameters, :functions
+
+      def initialize(args = nil)
+        @connection_parameters = []
+        case args
+          when nil
+          when Hash
+            args.each_pair { |key, val|
+              @connection_parameters << {'name' => key.to_s, 'value' => val.to_s}
+            }
+          else
+            raise "Wrong parameters for Server Connection - must pass a Hash\n"
+        end
+        SAP_LOGGER.debug("In #{self.class} initialize: #{@connection_parameters.inspect} ...")
+        @functions = {}
+        @attributes = nil
+        @handle = SAPNW::RFC::ServerHandle.new(self)
+      end
+
+      # installs a SAPNW::RFC::FunctionDescriptor object, and optionally associates
+      # this with a particular SysId.
+      def installFunction(*args)
+        args = args.first if args.class == Array and args.first.class == Hash
+        case args
+          when Hash
+            raise "Must pass an instance of SAPNW::RFC::FunctionDescriptor to installFunction()\n" unless args.has_key?(:descriptor) and args[:descriptor].class == SAPNW::RFC::FunctionDescriptor
+            func = args[:descriptor]
+            sysid = args.has_key?(:sysid) ? args[:sysid] : ""
+          when Array
+            raise "Must pass an instance of SAPNW::RFC::FunctionDescriptor to installFunction()\n" unless args.first.class == SAPNW::RFC::FunctionDescriptor
+            func = args.first
+            sysid = args.length > 1 ? args[1] : ""
+          else
+            raise "Must pass an instance of SAPNW::RFC::FunctionDescriptor to installFunction()\n"
+        end
+        #$stderr.print "sysid: #{sysid}\n"
+        res = func.install(sysid)
+        @functions[func.name] = func
+        return res
+      end
+
+      def self.handler(callback=nil, attributes=nil)
+        return if callback == nil
+        begin
+          return callback.call(attributes)
+        rescue SAPNW::RFC::ServerException => e
+          #$stderr.print "ServerException => #{e.error.inspect}\n"
+          return e
+        rescue StandardError => e
+          #$stderr.print "StandardError => #{e.inspect}/#{e.message}\n"
+          return SAPNW::RFC::ServerException.new({'code' => 3, 'key' => 'RUBY_RUNTIME', 'message' => e.message})
+        end
+      end
+
+
+      # fire the accept loop taking optionally a wait time for each loop, and a global
+      # callback to be triggered after each loop/loop timeout.
+      # Callback - if supplied - must be a Proc object, that takes a simgle parameter,
+      # which is a hash of the system connection attributes.
+      def accept(wait=120, callback=nil)
+        trap('INT', 'EXIT')
+        return @handle.accept_loop(wait, callback);
+      end
+
+
+      # similar to the accept() loop only that it does a single RfcListenAndDispatch()
+      # on the SAPNW::RFC::Server connection handle.  The result is the RFC return code
+      # as per the SAPNW::RFC::RFC_* return code constants.
+      # process() optionally takes asingle parameter which is the wait-time.
+      def process(wait=120)
+        trap('INT', 'EXIT')
+        return @handle.process_loop(wait);
+      end
+
+      # Returns a Hash of the connections attributes of this server connection.
+      def connection_attributes
+        SAP_LOGGER.debug("In #{self.class} connection_attributes ...")
+        return @attributes = self.handle.connection_attributes()
+      end
+
+      # terminate an established RFC connection.  This will invalidate any currently in-scope
+      # FunctionDescriptors associated with this Connection.
+      def close
+        SAP_LOGGER.debug("In #{self.class} close ...")
+        return nil unless self.handle
+        SAP_LOGGER.debug("In #{self.class} handle: #{self.handle} ...")
+        res = self.handle.close()
+        self.handle = nil
+        # XXX Should destroy all cached functions and structures and types tied to handle ?
+        return true
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: sapnwrfc
+version: !ruby/object:Gem::Version
+  version: '0.23'
+  prerelease: 
+platform: i686-linux
+authors:
+- Piers Harding
+autorequire:
+- sapnwrfc
+bindir: bin
+cert_chain: []
+date: 2011-07-27 00:00:00.000000000 +02:00
+default_executable: 
+dependencies: []
+description: ! "    sapnwrfc is a ruby module for performing RFC functions and BAPI
+  calls on\n    an SAP Netweaver system NW2004+\n"
+email: piers@ompka.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sapnwrfc/config.rb
+- lib/sapnwrfc/base.rb
+- lib/sapnwrfc/connection.rb
+- lib/sapnwrfc/functions.rb
+- lib/sapnwrfc/server.rb
+- lib/sapnwrfc/parameters.rb
+- lib/sapnwrfc.rb
+- ext/nwsaprfc/nwsaprfc.so
+has_rdoc: true
+homepage: http://www.piersharding.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ext/nwsaprfc
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: SAP Netweaver RFC connector for Ruby
+test_files: []