sem4r 0.1.2 → 0.1.3

data/lib/sem4r_cli.rb

@@ -23,16 +23,14 @@
 # -------------------------------------------------------------------
 
 require 'optparse'
-require 'ostruct'
-# require "highline/import" # to ask password on command line
+require "highline/import" # to ask password on command line
 
 require 'sem4r'
-require 'sem4r/cli/cli_sem'
-require 'sem4r/cli/cli_common_args'
-require 'sem4r/cli/cli_command'
-require 'sem4r/cli/cli_helpers'
+require 'sem4r_cli/cli_mini_framework'
+require 'sem4r_cli/cli_sem'
+require 'sem4r_cli/cli_helpers'
 
 # commands
-Dir[File.join( File.dirname(__FILE__), "sem4r", "cli", "commands", "*.rb" )].each do |f|
+Dir[File.join( File.dirname(__FILE__), "sem4r_cli", "commands", "*.rb" )].each do |f|
   require f
 end

data/lib/sem4r_soap/http_connector.rb

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+# -------------------------------------------------------------------------
+# Copyright (c) 2009-2010 Sem4r sem4ruby@gmail.com
+# 
+# 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.
+# 
+# -------------------------------------------------------------------------
+
+module Sem4rSoap
+
+  module HttpConnector
+
+    def self.get(logger = nil, type = :http_client)
+      case type
+        when :http_client
+          ConnectorHttpClient.new(logger)
+        when :net_http
+          ConnectorNetHttp.new(logger)
+        else
+          raise "unknow connector type"
+      end
+    end
+
+    #
+    # use Net::HTTP standard library http client
+    #
+    class ConnectorNetHttp
+      include SoapDumper
+
+      def initialize(logger = nil)
+        @logger = logger
+      end
+
+      def logger=(log)
+        @logger = log
+      end
+
+      #
+      # Send a soap request
+      # 
+      # @raise [URI::InvalidURIError] when service_url is incorrect
+      #
+      def send(service_url, soap_action, soap_request_xml)
+        uri     = URI.parse(service_url) # might raise URI::InvalidURIError
+
+        headers = {
+            "Content-Type"   => "text/xml; charset=utf-8",
+            "Content-Length" => soap_request_xml.length.to_s,
+            "SOAPAction"     => soap_action}
+
+        @logger.info("Post to #{uri.path} (#{soap_action})") if @logger
+        dump_soap_request(service_url, soap_request_xml)
+        response = post(uri, soap_request_xml, headers)
+        unless response
+          raise Sem4rError, "Connection Error"
+        end
+        response_xml = response.body
+        dump_soap_response(service_url, response_xml)
+        response_xml
+      end
+
+      #
+      # Downloads content at url in path_name
+      #
+      def download(url, path_name)
+        uri     = URI.parse(url)
+        http    = Net::HTTP.new(uri.host, uri.port)
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request.initialize_http_header({"User-Agent" => "My Ruby Script"})
+        response = http.request(request)
+        File.open(path_name, "w") { |f| f.write(response.body) }
+      end
+
+      def post(uri, str, headers)
+        unless uri.respond_to? :path
+          uri     = URI.parse(uri) # might raise URI::InvalidURIError
+        end
+        retries = 0; response = nil
+        while retries <= MAXRETRIES and response.nil?
+          retries += 1
+          begin
+            client   = client_for_uri(uri)
+            response = client.post(uri.path, str, headers)
+            status   = response.code.to_i
+            # pp response.class.to_s
+            # pp "status: #{status}"
+          rescue StandardError => e
+            @logger.warn("request_post retries!!! #{e.to_s}") if @logger
+            invalidate_client_for_uri(uri)
+            sleep(1 * retries) # wait
+          end
+        end
+
+        unless response
+          raise "Connection Error, Network is down?? :-((("
+        end
+        response
+      end
+
+      private
+
+      MAXRETRIES = 2
+
+      def client_for_uri(uri)
+        @clients ||= {}
+        key      = uri.scheme + "://" + uri.host
+        client   = @clients[key]
+        unless client
+          client = Net::HTTP.new(uri.host, uri.port)
+          if uri.scheme == "https"
+            client.use_ssl     = (uri.scheme == "https")
+            client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+          @clients[key] = client
+        end
+        client
+      end
+
+      def invalidate_client_for_uri(uri)
+        key = uri.scheme + "://" + uri.host
+        @clients[uri.host] = nil if  @clients[key]
+      end
+
+    end
+
+    class ConnectorHttpClient
+      include SoapDumper
+
+      def initialize(logger = nil)
+        @logger = logger
+      end
+
+      def logger=(log)
+        @logger = log
+      end
+
+      #
+      # Send a soap request
+      # @return [String] soap xml response
+      # @raise [URI::InvalidURIError] when service_url is incorrect
+      #
+      def send(service_url, soap_action, request_xml)
+        uri     = URI.parse(service_url)
+
+        headers = {
+            "Content-Type"   => "text/xml; charset=utf-8",
+            "Content-Length" => request_xml.length.to_s,
+            "SOAPAction"     => soap_action}
+
+        @logger.info("Post to #{uri.path} (#{soap_action})") if @logger
+        dump_soap_request(service_url, request_xml)
+        response = post(service_url, request_xml, headers)
+        unless response
+          raise Sem4rError, "Connection Error"
+        end
+        response_xml = response.content
+        dump_soap_response(service_url, response_xml)
+        response_xml
+      end
+
+      #
+      # Downloads content at url in path_name
+      #
+      def download(url, path_name)
+        client = HTTPClient.new(:agent_name => 'Ruby') # agentname
+        File.open(path_name, "w") do |file|
+          client.get_content(url) do |chunk|
+            file.write chunk
+          end
+        end
+      end
+
+      #
+      # @return [Object] must respond to :status and :body
+      #
+      def post(service_url, body, headers)
+        client   = HTTPClient.new(:agent_name => 'Ruby') # agentname
+        response = client.post(service_url, body, headers)
+        unless response
+          raise "Connection Error, Network is down?? :-((("
+        end
+        response.instance_eval { def body; content; end}
+        response
+      end
+    end
+
+  end
+
+end # module Sem4rSoap

data/lib/{soap_helpers → sem4r_soap}/soap_attributes.rb

@@ -22,7 +22,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 # -------------------------------------------------------------------
 
-module Sem4r
+module Sem4rSoap
 
   class MetaSoapAttribute
     attr_reader :name, :xpath
@@ -31,7 +31,7 @@ module Sem4r
       if xpath
         @xpath = xpath
       else
-        @xpath = name.to_s.camel_case 
+        @xpath = name.to_s.camel_case
       end
     end
 
@@ -68,6 +68,12 @@ module Sem4r
       self
     end
 
+    def _to_s
+      self.class.attributes.map do |a|
+        if a.enum? then "" else self.send(a.name) end
+      end.join(' ')
+    end
+
     module ClassMethods
 
       def enum(set, values)
@@ -91,7 +97,6 @@ module Sem4r
         attr_reader name
       end
 
-
       #
       # constraints
       #   :values_in

data/lib/{sem4r/services → sem4r_soap}/soap_dumper.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # -------------------------------------------------------------------------
 # Copyright (c) 2009-2010 Sem4r sem4ruby@gmail.com
 # 
@@ -22,27 +23,36 @@
 # 
 # -------------------------------------------------------------------------
 
-module Sem4r
+module Sem4rSoap
 
   module SoapDumper
 
     def initialize
-      @soap_dump = false
+      @soap_dump     = false
       @soap_dump_log = nil
     end
 
-    def dump_soap_options( dump_options )
-      @soap_dump = true
+    #
+    # set the options for the dumping soap message
+    #
+    # @param [Hash] options
+    # @option options [String] :directory
+    # @option options [String] :file
+    # @option options [String] :format
+    # @option options [String] :interceptor
+    #
+    def dump_soap_options(options)
+      @soap_dump     = true
       @soap_dump_log = nil
 
-      if dump_options[:directory]
-        @soap_dump_dir = dump_options[:directory]
+      if options[:directory]
+        @soap_dump_dir = options[:directory]
       else
-        @soap_dump_log = File.open( dump_options[:file], "w" )
+        @soap_dump_log = File.open(options[:file], "w")
       end
-      @soap_dump_format = false || dump_options[:format]
+      @soap_dump_format = false || options[:format]
 
-      @soap_dump_interceptor = dump_options[:interceptor] if dump_options[:interceptor]
+      @soap_dump_interceptor = options[:interceptor] if options[:interceptor]
     end
 
     def dump_soap_request(service_url, request_xml)
@@ -60,9 +70,9 @@ module Sem4r
       return unless @soap_dump
       response_xml.gsub(/<email[^>]*>.+<\/email>/, "<email>**censured**</email>")
       str = ""
-      str <<  "<!-- response -->\n" unless @soap_dump_dir
+      str << "<!-- response -->\n" unless @soap_dump_dir
       str << xml_to_s(response_xml) << "\n"
-      str <<  "<!-- end -->" unless @soap_dump_dir
+      str << "<!-- end -->" unless @soap_dump_dir
       dump(service_url, "res", str)
     end
 
@@ -73,12 +83,12 @@ module Sem4r
       @soap_dump_interceptor.call(service_url, type, str) if @soap_dump_interceptor
 
       if @soap_dump_dir
-        service = service_url.match(/\/([^\/]*)$/)[1]
+        service  = service_url.match(/\/([^\/]*)$/)[1]
         filename = Time.now.strftime "%Y%m%d-%H%M%S-%L-#{service}-#{type}.xml"
 
         FileUtils.mkdir_p(@soap_dump_dir) unless File.directory?(@soap_dump_dir)
         pathname = File.join(@soap_dump_dir, filename)
-        File.open(pathname, "w") {|f|
+        File.open(pathname, "w") { |f|
           f.puts str
         }
       else
@@ -93,13 +103,19 @@ module Sem4r
       else
         # TODO: using nokogiri also for pretty print xml ?
         require 'rexml/document'
-        xml_document = REXML::Document.new(xml)
-        f = REXML::Formatters::Pretty.new
-        out = String.new
-        f.write(xml_document, out)
-        # remove xml directive
-        out.gsub("<?xml version='1.0' encoding='UTF-8'?>","")
+        begin
+          xml_document = REXML::Document.new(xml)
+          f            = REXML::Formatters::Pretty.new
+          out          = String.new
+          f.write(xml_document, out)
+          # remove xml directive
+          out.gsub("<?xml version='1.0' encoding='UTF-8'?>", "")
+        rescue
+          puts xml
+          raise
+        end
       end
     end
   end
-end
+
+end # module Sem4rSoap

data/lib/{sem4r/services → sem4r_soap}/soap_error.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # -------------------------------------------------------------------
 # Copyright (c) 2009-2010 Sem4r sem4ruby@gmail.com
 #
@@ -21,8 +22,9 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 # -------------------------------------------------------------------
 
-module Sem4r
-  class SoapError < Sem4rError
+module Sem4rSoap
+
+  class SoapError # < Sem4r::Sem4rError
     #    attr_reader :fault_code
     #    attr_reader :fault_string
     #
@@ -35,4 +37,5 @@ module Sem4r
     #      "#{@fault_code}: '#{@fault_string}'"
     #    end
   end
+
 end

data/lib/sem4r_soap/soap_response.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# -------------------------------------------------------------------------
+# Copyright (c) 2009-2010 Sem4r sem4ruby@gmail.com
+# 
+# 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.
+# 
+# -------------------------------------------------------------------------
+
+module Sem4rSoap
+  class SoapResponse
+
+    attr_reader :response
+    attr_reader :counters
+
+    def parse_response(response_xml)
+      # erase namespace so it more simple parsing the xml
+      response_xml.gsub!(/\b(ns\d:|xsi:|s:|soapenv:|env:|soap:)/, "")
+      response_xml.gsub!(/xmlns=["'].*?['"]/, '')
+      @response = Nokogiri::XML::Document.parse(response_xml)
+
+      #
+      # extract information from header
+      #
+      header    = @response.at_xpath("/Envelope/Header/ResponseHeader") # v2010xx
+      if header
+        @counters = {
+            :operations    => header.at_xpath("operations").text.to_i,
+            :response_time => header.at_xpath("responseTime").text.to_i,
+            :units         => header.at_xpath("units").text.to_i
+        }
+      else
+        header = @response.at_xpath("/Envelope/Header") # v13
+        if header
+          @counters = {
+              :operations    => header.at_xpath("operations").text.to_i,
+              :response_time => header.at_xpath("responseTime").text.to_i,
+              :units         => header.at_xpath("units").text.to_i
+          }
+        end
+      end
+      #
+      # check soap fault
+      #
+      fault_el = @response.at_xpath("//Fault")
+      if fault_el
+        # fault_code   = fault_el.at_xpath('faultcode').text
+        # fault_string = fault_el.at_xpath('faultstring').text
+        # raise SoapError,  "#{fault_code}: '#{fault_string}'"
+
+        fault_string = fault_el.at_xpath('faultstring').text
+        @logger.error("soap error: #{fault_string}") if @logger
+        raise fault_string
+      end
+      self
+    end
+
+  end
+end

data/lib/sem4r_soap/soap_service.rb

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+# -------------------------------------------------------------------
+# Copyright (c) 2009-2010 Sem4r sem4ruby@gmail.com
+#
+# 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.
+# -------------------------------------------------------------------
+
+module Sem4rSoap
+
+  class SoapService
+
+    def initialize
+      @soap_namespaces = {}
+    end
+
+    def init(header_namespace, service_namespace)
+      @soap_namespaces = {}
+
+      @header_namespace = header_namespace
+      @soap_namespaces['xmlns'] = header_namespace if header_namespace
+
+      @service_namespace = service_namespace
+      @soap_namespaces['xmlns:s'] = service_namespace if service_namespace
+    end
+
+    def build_soap_message(soap_header, soap_body)
+      soap_message = '<?xml version="1.0" encoding="utf-8" ?>'
+      soap_message +=<<-EOFS
+      <env:Envelope
+         xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
+      EOFS
+
+      @soap_namespaces.each do |name, value|
+        soap_message += " #{name}=\"#{value}\""
+      end
+      soap_message += ">"
+
+      soap_message += soap_header
+      soap_message += "<env:Body>"
+      soap_message += soap_body
+      soap_message += "</env:Body>"
+
+      soap_message += "</env:Envelope>"
+      soap_message
+    end
+
+    def helper_call(api_version, credentials, soap_body)
+      soap_action = ""
+
+      case api_version
+        when "v13"
+          match_data = soap_body.match(/<(\w+)/m)
+          if match_data
+            soap_action = match_data[1]
+          else
+            raise "Soapaction not found in #{soap_body}"
+          end
+        when "v2010"
+        else
+          raise "unkwnow api version #{api_version}"
+      end
+
+      soap_xml = build_soap_message(build_soap_header(credentials), soap_body)
+      if credentials.sandbox?
+        _send(@sandbox_service_url, soap_action, soap_xml)
+      else
+        _send(@production_service_url, soap_action, soap_xml)
+      end
+    end
+
+    def helper_call_raw(credentials, xml_message)
+      soap_message = SoapMessageV2010.new(@connector, credentials)
+      soap_message.init( @header_namespace, @service_namespace )
+      if credentials.sandbox?
+        soap_message.send_raw(@sandbox_service_url, xml_message)
+      else
+        soap_message.send_raw(@production_service_url, xml_message)
+      end
+    end
+
+    def self._soap_call(api_version, method, options = {})
+      options.assert_valid_keys(:mutate)
+      mutate = options.delete :mutate
+      if mutate.nil? or mutate
+        smutate = "credentials.mutable?"
+      else
+        smutate = "true"
+      end
+      rubystr =<<-EOFS
+          define_method :#{method.to_sym} do |*args|
+            credentials = args.shift
+            if #{smutate}
+              soap_body = send("_#{method}", *args)
+              helper_call('#{api_version}', credentials, soap_body)
+            else
+              raise "mutate methods '#{method}' cannot be called on read_only profile"
+            end
+          end
+      EOFS
+      eval rubystr
+
+      rubystr =<<-EOFS
+          define_method :#{(method.to_s + "_raw").to_sym} do |*args|
+            credentials = args.shift
+            soap_message = args.shift
+            if #{smutate}
+              helper_call_raw('#{api_version}', credentials, soap_message)
+            else
+              raise "mutate methods '#{method}' cannot be called on read_only profile"
+            end
+          end
+      EOFS
+      eval rubystr
+    end
+
+  end
+
+end # module Sem4rSoap

data/lib/{sem4r/cli/cli_sem.rb → sem4r_soap/soap_service_v13.rb}

@@ -22,42 +22,41 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 # -------------------------------------------------------------------
 
-# stdlib
+module Sem4rSoap
 
-module Sem4r
+  class SoapServiceV13 < SoapService
 
-  class CliSem
-
-    def self.run
-      cli = self.new
-      cli.parse_and_run(ARGV)
+    def initialize
+      super
     end
 
-    def parse_and_run( argv )
-      common_args, command, command_args = CliCommand.split_args(argv)
-
-      #      $stderr.puts "debug -------------------"
-      #      $stderr.puts "common_args:  #{common_args}"
-      #      $stderr.puts "command:      #{command}"
-      #      $stderr.puts "command_args: #{command_args}"
-      #      $stderr.puts "debug -------------------"
+    def self.soap_call(method, options = {})
+      _soap_call("v13", method, options)
+    end
 
-      cli_common_args = CliCommonArgs.new
-      success = cli_common_args.parse_and_run(common_args)
-      return false unless success
+    private
+    
+    def build_soap_header(credentials)
+      str= <<-EOFS
+      <env:Header>
+        <email env:mustUnderstand="0">#{credentials.email}</email>
+        <password env:mustUnderstand="0">#{credentials.password}</password>
+        <useragent env:mustUnderstand="0">#{credentials.useragent}</useragent>
+        <developerToken env:mustUnderstand="0">#{credentials.developer_token}</developerToken>
+      EOFS
 
-      if command.nil?
-        puts "missing command try sem -h for help"
-        return false
+      if credentials.client_email
+        str += "<clientEmail env:mustUnderstand=\"0\">#{credentials.client_email}</clientEmail>"
       end
 
-      begin
-        cmd = CliCommand.commands[command].new(cli_common_args)
-        return cmd.parse_and_run(command_args)
-      rescue Sem4rError
-        puts "I am so sorry! Something went wrong! (exception #{$!.to_s})"
-        return false
-      end
+      str += "</env:Header>"
+      str
+    end
+
+    def _send(service_url, soap_action, soap_xml)
+      response_xml = @connector.send(service_url, soap_action, soap_xml)
+      soap_response = SoapResponse.new.parse_response(response_xml)
+      soap_response
     end
 
   end