xmlservice 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 114a61cefcaa6e77f1e035ab1e9050c0c71ceacf
+  data.tar.gz: a51dcc0231ce9bfefa0de147b0735682fde3bb85
+SHA512:
+  metadata.gz: 553705198c19344a963e5512dab5d962c5b62e2e40d5d4cfea3b65ce95b63ead5c2205f59dd45050a57df1e7090944426419a5ed083226292ae462b4963b2799
+  data.tar.gz: fde89c8f5fd22cb3aab8bf0315c71d354c91530be1647851a119cda82ffcbb055eb81b17b0548b8eb4f27bb65b8d7806529e68525ba97caced9572b5ce413d04

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 IBM Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README_IBM_i

@@ -0,0 +1,62 @@
+==================
+Introduction
+==================
+The following notes Ruby with IBM i.
+
+==================
+install
+==================
+> cd xmlservice
+> gem install ./xmlservice-1.3.0.gem --local --force --ignore-dependencies --no-rdoc
+-- or --
+> cd xmlservice
+> ./zzall.sh
+
+=================
+run tests (script)
+=================
+-- change values --
+> cd xmlservice
+> edit zztestdb2.sh zztestrest.sh
+export TEST_URL=http://174.79.32.155/cgi-bin/xmlcgi.pgm
+export TEST_USER=DB2
+export TEST_PWD=PWD
+
+-- run --
+> cd xmlservice
+> ./zztestdb2.sh    (test db2 driver)
+> ./zztestrest.sh   (test rest driver)
+
+
+=================
+run tests (manually)
+=================
+-- set up --
+> export PATH=/PowerRuby/{version}/bin:$PATH
+> export LIBPATH=/PowerRuby/{version}/lib
+> export TEST_URL=http://174.79.32.155/cgi-bin/xmlcgi.pgm --or-- ibm_db
+> export TEST_DATABASE=*LOCAL
+> export TEST_USER=*NONE
+> export TEST_PWD=*NONE
+-- optional --
+> export TEST_CTL=*here --or-- *sbmjob
+> export TEST_IPC=*na   --or-- /tmp/privatextoolkitjobroute  (*sbmjob) 
+> export TEST_XMLSERVICE=XMLSERVICE
+> export TEST_LIB=RUBYTEST
+
+-- main directory --
+> cd xmlservice
+> rake
+
+-- test directory --
+> cd xmlservice/test
+> rake test
+
+-- individual --
+> xmlservice/test/test_60000_toolkit_driver
+> ruby test_60310_DriverCMD.rb
+
+
+
+
+

data/lib/adapters/abstract_adapter.rb

@@ -0,0 +1,82 @@
+require "rexml/document"
+
+module XMLServiceAdapters
+  # adapter factory (singleton)
+  def self.adapter_factory(config)
+    conn = config[:connection]
+    # rest adapter (no db2 connections)
+    if conn.to_s.include?"/"
+      require 'adapters/rest_adapter'
+      adapter = RESTAdapter.new(conn, config)
+    # assume db2 adpater
+    else
+      require 'adapters/db2_adapter'
+      adapter = IBM_DBAdapter.new(conn, config)
+    end
+    adapter
+  end
+  class AbstractAdapter
+    def initialize(conn,options)
+      @xml_conn = conn
+      @xml_options = options
+      if !options.has_key?(:install)
+        options[:install] = ActiveXMLService::XINSTALL
+      end
+      if !options.has_key?(:ctl)
+        options[:ctl] = ActiveXMLService::XCTL
+      end
+      if !options.has_key?(:ipc)
+        options[:ipc] = ActiveXMLService::XIPC
+      end
+      if !options.has_key?(:size)
+        options[:size] = ActiveXMLService::XSIZE
+      end
+      if !options.has_key?(:head)
+        options[:head] = ActiveXMLService::XHEAD
+      end
+      if !options.has_key?(:database)
+        options[:database] = ActiveXMLService::XDATABASE
+      end
+      if !options.has_key?(:username)
+        options[:username] = ActiveXMLService::XUSERNAME
+      end
+      if !options.has_key?(:password)
+        options[:password] = ActiveXMLService::XPASSWORD
+      end
+      @xml_install = options[:install]
+      @xml_ctl = options[:ctl]
+      @xml_ipc = options[:ipc]
+      @xml_size = options[:size]
+      @xml_head = options[:head]
+      @xml_database = options[:database]
+      @xml_username = options[:username]
+      @xml_password = options[:password]
+      @xml_xmlin = ""
+      @xml_xmlin << @xml_head
+      @xml_xmlout = ""
+      @xml_xmlout << @xml_head
+      @xml_doc = nil
+    end
+    def adapter_name
+      'Abstract'
+    end
+    def xmlservice(callme)
+    end
+    def raw_connection
+      @xml_conn
+    end
+    def raw_options
+      @xml_options
+    end
+    def out_xml
+      @xml_xmlout
+    end
+    def out_doc
+      if @xml_doc == nil
+        @xml_doc = REXML::Document.new(@xml_xmlout)
+      end
+      @xml_doc
+    end
+  end # class AbstractAdapter
+end # module XMLServiceAdapters
+

data/lib/adapters/db2_adapter.rb

@@ -0,0 +1,70 @@
+require 'adapters/abstract_adapter'
+require 'active_record'                                                          
+require 'ibm_db'
+
+module XMLServiceAdapters
+  class IBM_DBAdapter < AbstractAdapter
+    def initialize(conn,options)
+      # yaml connection string "ActiveRecord",
+      # so use if active, or start new connection 
+      if conn.to_s == "ActiveRecord"
+        for i in 0..1
+          begin
+            conn = ActiveRecord::Base.connection
+          rescue
+            ActiveRecord::Base.establish_connection(options)
+          end
+        end
+      end
+      # raw_connection gives access to actual IBM_DB::Connection
+      if conn.is_a?(ActiveRecord::ConnectionAdapters::IBM_DBAdapter)
+        super(conn.raw_connection, options)
+      elsif conn.is_a?(IBM_DB::Connection)
+        super(conn, options)
+      else
+        raise "#{self.class.name} invalid connection."
+      end
+    end
+    def adapter_name
+      'XMLSERVICE_IBM_DB'
+    end
+    def xmlservice(callme)
+      case @xml_size 
+      when @xml_size<=4096
+        sql = "CALL #{@xml_install}.iPLUG4K(?,?,?,?)"
+      when @xml_size>4096 && @xml_size<=32768
+        sql = "CALL #{@xml_install}.iPLUG32K(?,?,?,?)"
+      when @xml_size>32768 && @xml_size<=65536
+        sql = "CALL #{@xml_install}.iPLUG65K(?,?,?,?)"
+      when @xml_size>65536 && @xml_size<=524288
+        sql = "CALL #{@xml_install}.iPLUG512K(?,?,?,?)"
+      when @xml_size>524288 && @xml_size<=1048576
+        sql = "CALL #{@xml_install}.iPLUG1M(?,?,?,?)"
+      when @xml_size>1048576 && @xml_size<=5242880
+        sql = "CALL #{@xml_install}.iPLUG5M(?,?,?,?)"
+      when @xml_size>5242880 && @xml_size<=10485760
+        sql = "CALL #{@xml_install}.iPLUG10M(?,?,?,?)"
+      when @xml_size>10485760
+        sql = "CALL #{@xml_install}.iPLUG15M(?,?,?,?)"
+      else
+        sql = "CALL #{@xml_install}.iPLUG512K(?,?,?,?)"
+      end
+      ctl = @xml_ctl
+      ipc = @xml_ipc
+      xmlin = ""
+      xmlin << @xml_head
+      xmlin << "\n<myscript>\n"
+      xmlin << callme.to_xml
+      xmlin << "</myscript>\n"
+      xmlout = ""
+      stmt = IBM_DB::prepare(@xml_conn, sql)
+      ret = IBM_DB::bind_param(stmt, 1, "ipc", IBM_DB::SQL_PARAM_INPUT)
+      ret = IBM_DB::bind_param(stmt, 2, "ctl", IBM_DB::SQL_PARAM_INPUT)
+      ret = IBM_DB::bind_param(stmt, 3, "xmlin", IBM_DB::SQL_PARAM_INPUT)
+      ret = IBM_DB::bind_param(stmt, 4, "xmlout", IBM_DB::SQL_PARAM_OUTPUT)
+      ret = IBM_DB::execute(stmt)
+      @xml_xmlout = xmlout
+      @xml_doc = nil
+    end
+  end
+end # module XMLServiceAdapters

data/lib/adapters/rest_adapter.rb

@@ -0,0 +1,32 @@
+require 'adapters/abstract_adapter'
+require 'net/http'
+require 'uri'
+
+module XMLServiceAdapters
+  class RESTAdapter < AbstractAdapter
+    def adapter_name
+      'XMLSERVICE_REST'
+    end
+    def xmlservice(callme)
+      xmlin = ""
+      xmlin << @xml_head
+      xmlin << "\n<myscript>\n"
+      xmlin << callme.to_xml
+      xmlin << "</myscript>\n"
+      xmlout = ""
+      post_args = { 
+       :db2 => @xml_database,
+       :uid => @xml_username,
+       :pwd => @xml_password,
+       :ipc => @xml_ipc,
+       :ctl => @xml_ctl,
+       :xmlin => URI::encode(xmlin),
+       :xmlout => @xml_size
+      }
+      uri = URI(@xml_conn)
+      res = Net::HTTP.post_form(uri, post_args)
+      @xml_xmlout = res.body
+      @xml_doc = nil
+    end
+  end 
+end # module XMLServiceAdapters

data/lib/password/password.rb

@@ -0,0 +1,229 @@
+require 'openssl'
+require "base64"
+require "uri"
+require 'pathname'
+
+# Sample utility for encrypted password
+# require 'active_record'
+# require 'ibm_db'
+# $db = "LP0364D"
+# $user = "DB2"
+# $pass = "NICE2DB2"
+# ActiveXMLService::Base.establish_connection(
+#    :adapter    => 'ibm_db',
+#    :database   => $db,
+#    :username   => $user,
+#    :password   => $pass
+#    :connection => "ActiveRecord"
+#    :install    => XMLSERVICE
+#    :ctl        => "*sbmjob"
+#    :ipc        => /tmp/ruby042
+#    :size       => 15000000
+#    :head       => "<?xml version='1.0'?>"
+# )
+# key = ActiveXMLService::Base.generate_key()
+# puts "key is #{key}"
+# penc = ActiveXMLService::Base.generate_password($pass,key)
+# puts "password ( #{$pass} ) + ( key #{key} ) = encrypted password ( #{penc} )"
+
+# Sample yaml files 
+# 1) config/database.yml -- standard config/database.yml loaded by Rails automatic
+# 2) /path/password.yml  -- operator maintained user/password/attributes file (QTMHHTTP access only) 
+# 3) /path/key.yml       -- operator maintained passkey file used in runtime decode password (QTMHHTTP access only) 
+# ==== file 1) standard database.yml (key="development" RAILS_ENV) =====
+# xmlservice: &xmlservice
+#   connection: "ActiveRecord"
+#   install: XMLSERVICE
+#   ctl: "*sbmjob"
+#   ipc: /tmp/ruby042
+#   size: 15000000
+#   head: "<?xml version='1.0'?>"
+# development:
+#   adapter: ibm_db
+#   database: LP0364D
+#   username: DB2
+#   pwd_yaml: /path/password.yml
+#   <<: *xmlservice
+# production:
+#   adapter: ibm_db
+#   database: LP0364D
+#   username: DB2
+#   pwd_yaml: /path/password.yml
+#   <<: *xmlservice
+# test:
+#   adapter: ibm_db
+#   database: LP0364D
+#   username: DB2
+#   pwd_yaml: /path/password.yml
+#   <<: *xmlservice
+# ==== file 2) password.yml (key="username")=====
+# key_yaml: /path/key.yml
+# DB2: 
+#   pwd_enc: "YiYNfodSh5MGZVX7TXktEPSrnVlrAPjoyzzn48SdC/k=%0A"
+#            ... possibly other attributes custom DB2, db2_yaml.yml, etc
+# user2: 
+#   pwd_enc: "YiYNfodSh5MGOHBOYFLINROCKIlrAPjoyzzn48SdC/k=%0A"
+#            ... possibly other attributes custom DB2, db2_yaml.yml, etc
+# ==== file 3) key.yml (key="*ALL") ===== (used runtime)
+# pwd_key: "YIPS4321AAAAAAAAAAAAAAA132424245"
+#          ... possibly other attributes, DB2, etc ...
+module XMLSERVICEPassword
+  PWD_TYPE = "aes-256-cbc"                          # encryption type
+  PWD_KEY = "YIPS4321AAAAAAAAAAAAAAA132424245"      # 32 characters required
+                                                    # of course PWD_KEY should not be in script
+                                                    # but this is an example (people read)
+  class Encrypt
+    @xml_pwdkey = nil
+
+    # ------------------
+    # callable functions
+    # ------------------
+
+    # decrypt using password.yml (possible key.yml) (see top module)
+    def self.parse_user_config(config)
+      if config.has_key?(:username)
+        if config.has_key?(:pwd_yaml)
+          # password.yml file
+          config = XMLSERVICEPassword::Encrypt.parse_yaml(config, config[:pwd_yaml].to_s, config[:username].to_s)
+          config = XMLSERVICEPassword::Encrypt.symbolize_keys(config)
+        end
+        if config.has_key?(:pwd_enc)
+          if !config.has_key?(:pwd_key)
+            config[:pwd_key] = "*DEFAULT"
+          end
+          config[:password] = XMLSERVICEPassword::Encrypt.decrypt(config[:pwd_enc].to_s, config[:pwd_key].to_s)
+        end
+      end
+      config
+    end
+
+    # password decrypt
+    def self.decrypt(encoded, key = "*DEFAULT")
+      XMLSERVICEPassword::Encrypt.establish_key(key);
+      decoded = XMLSERVICEPassword::Encrypt.decode(encoded)
+      cipher = OpenSSL::Cipher::Cipher.new(PWD_TYPE)
+      cipher.decrypt
+      cipher.key = @xml_pwdkey
+      cipher.iv = decoded.slice!(0,16) # Remove the IV from the encrypted data
+      decrypted = cipher.update(decoded) + cipher.final
+      decrypted 
+    end
+
+    # generate a pass key 
+    def self.gen_key()
+      XMLSERVICEPassword::Encrypt.establish_key("*DEFAULT");
+      cipher = OpenSSL::Cipher::Cipher.new(PWD_TYPE)
+      cipher.encrypt
+      cipher.key = @xml_pwdkey
+      all = " "
+      for i in 1..3
+        cipher.iv = iv = cipher.random_iv
+        raw = XMLSERVICEPassword::Encrypt.encode(iv)
+        all << raw.to_s
+      end
+      encode = all.slice!(1..32)
+      encode
+    end
+
+    # generate a encrypted password 
+    def self.gen_password(plaintext, key = "*DEFAULT")
+      XMLSERVICEPassword::Encrypt.establish_key(key);
+      cipher = OpenSSL::Cipher::Cipher.new(PWD_TYPE)
+      cipher.encrypt
+      cipher.key = @xml_pwdkey
+      cipher.iv = iv = cipher.random_iv
+      encrypted = cipher.update(plaintext) + cipher.final
+      encrypted = iv + encrypted # Send along the IV
+      encoded = XMLSERVICEPassword::Encrypt.encode(encrypted)
+      encoded
+    end
+
+    # ------------------
+    # helper function (maybe should be private)
+    # ------------------
+
+    # assure valid iv and key
+    def self.establish_key(key = "*DEFAULT")
+      if key && key != '*DEFAULT'
+        @xml_pwdkey = key
+      else
+        @xml_pwdkey = PWD_KEY
+      end
+    end
+
+    # base64 encode for web/yaml usage
+    def self.encode(item)
+      encrypted = Base64.encode64(item)
+      encoded = URI.escape(encrypted)
+      encoded
+    end
+
+    # base64 decode from web/yaml
+    def self.decode(item)
+      encrypted = URI.unescape(item)
+      decoded = Base64.decode64(encrypted)
+      decoded
+    end
+
+    # Converts all +config+ keys to symbols
+    def self.symbolize_keys(config)
+      # config = config.symbolize_keys
+      config.keys.each do |key|
+        config[(key.to_sym rescue key) || key] = config.delete(key)
+      end
+      config
+    end
+
+
+    # recursive *_yaml: /path/thing.yml
+    def self.nest_yaml(config,key,value)
+      if key.include? "_yaml" or (value != nil and value.instance_of? String and value.to_s.include? ".yml")
+        # recursive /path/password.yml
+        if value.include? "password.yml"
+          if !config.has_key?(:username)
+            if config.has_key?("username")
+              config[:username] = config["username"]
+            end
+          end
+          if config.has_key?(:username)
+            config = XMLSERVICEPassword::Encrypt.parse_yaml(config, value, config[:username])
+          end
+        # recursive *_yaml: /path/thing.yml
+        else
+          config = XMLSERVICEPassword::Encrypt.parse_yaml(config, value, "*ALL")
+        end
+      end
+      config
+    end
+
+    # parse nested yaml files
+    def self.parse_yaml(config, yaml_file, yaml_key)
+      rfile = Pathname.new(yaml_file)
+      if rfile
+        f = open(rfile.to_s)
+        doc = YAML::load_stream( f )
+        doc.each do |key, value|
+         key.each do |key0, value0|
+          # recursive *_yaml
+          config = XMLSERVICEPassword::Encrypt.nest_yaml(config,key0,value0)
+          # take everything
+          if yaml_key == "*ALL"
+            config[key0] = value0
+          # found target key="username"
+          elsif yaml_key == key0
+            value0.each do |key1, value1|
+              # recursive *_yaml
+              config = XMLSERVICEPassword::Encrypt.nest_yaml(config,key1,value1)
+              # take everything
+              config[key1] = value1
+            end
+          end
+         end
+        end
+      end
+      config
+    end
+  end # Encrypt
+end # XMLSERVICEPassword
+
+