xamarin-test-cloud 2.0.0.pre1 → 2.0.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8ce3574021504d1c37d218b7816a8be26b0e958
-  data.tar.gz: 5eee5e4df2534d4b7e1211ff4b05863b2ce6b24c
+  metadata.gz: a5fb53a5aad5e3006ce408c5bcdc838fc9710b27
+  data.tar.gz: 08f838fe24bacc453b7b6b3479a3a23e467c376e
 SHA512:
-  metadata.gz: 879ebe1c1ce04963405374a2b5510eac9bb1e0ae8a8e902d7956242da95e47346df7874d18b5173d14876f774859ecd5eb9f870ec7d6fcd216fe1f1bb390c7cc
-  data.tar.gz: 3c936024d954fe9702e9617b733fc238ece5c777d5ee5f813b6b2d58523acd660f67b6c1485d5ee7a2876af51f6f1a036d63a2bc0535384a16f35c0c32ebc2a6
+  metadata.gz: 7715a00158c011e57f6671c25590577113bece273948659f9f01037147ab95a04d65546c7ee81515ad556a05a044412c65eca920598dc9cb6021aa35e87f3ed2
+  data.tar.gz: ff1dcb9dae040573210204b0dad1cc1a5343368b5148bceb477e9a1c9ea797ea836301715b9220d1c5327932ec91a15808524bb9195c62f9f681dcce429a9328

data/CHANGELOG.md

@@ -1,6 +1,7 @@
 ### 2.0.0
 
-* Set minimum ruby verision to 2.0
+* Replace RestClient with HTTPClient
+* Set minimum ruby version to 2.0
 * Gem does not work in Windows environment: ffi cannot be found. #34
 
 ### 1.1.2

data/README.md

@@ -10,9 +10,9 @@
 
 ```
 $ bundle update
-$ rake test         # All tests.
-$ rake unit         # Unit tests.
-$ rake integration  # Integration tests.
-$ rake spec         # rspec tests
+$ bundle exec rake test         # All tests.
+$ bundle exec rake unit         # Unit tests.
+$ bundle exec rake integration  # Integration tests.
+$ bundle exec rake spec         # rspec tests
 ```
 

data/lib/xamarin-test-cloud/cli.rb

@@ -4,7 +4,6 @@ require 'erb'
 require 'rubygems'
 require 'zip'
 require 'digest'
-require 'rest_client'
 require 'json'
 require 'rbconfig'
 require 'tmpdir'
@@ -12,6 +11,8 @@ require 'fileutils'
 require 'retriable'
 require 'xamarin-test-cloud/version'
 require 'xamarin-test-cloud/retriable_options'
+require 'xamarin-test-cloud/http/request'
+require 'xamarin-test-cloud/http/retriable_client'
 require 'securerandom'
 require 'open3'
 
@@ -391,7 +392,6 @@ module XamarinTestCloud
         if debug?
           log "Packaging gems in: #{tmpdir}"
         end
-        start_at = Time.now
 
         server = verify_app_and_extract_test_server
 
@@ -471,14 +471,13 @@ module XamarinTestCloud
           puts "Will upload to file path: #{self.endpoint_path}"
         end
 
-
-        response = http_post(endpoint_path, upload_data) do |response, request, result, &block|
+        response = http_post(endpoint_path, upload_data) do |response, request|
           if debug?
             puts "Request url: #{request.url}"
             puts "Response code: #{response.code}"
             puts "Response body: #{response.body}"
           end
-          case response.code
+          case response.status_code
             when 200..202
               response
             when 400
@@ -496,7 +495,7 @@ module XamarinTestCloud
           end
         end
 
-        return :status => response.code, :body => JSON.parse(response)
+        return :status => response.status_code, :body => JSON.parse(response.body)
 
       end
 
@@ -562,7 +561,6 @@ module XamarinTestCloud
 
         response = http_post('check_hash', out)
 
-
         cache_status = JSON.parse(response)
 
         log_header('Gathering files based on negotiation')
@@ -701,26 +699,27 @@ module XamarinTestCloud
       def http_post(address, args = {}, &block)
         args['uploader_version'] = XamarinTestCloud::VERSION
         args['session_id'] = session_id
-        exec_options = {}
+
+        request = XamarinTestCloud::HTTP::Request.new(address, args)
+
+        exec_options = {:header => { 'Content-Type' => 'application/x-www-form-urlencoded' }}
         if ENV['XTC_USERNAME'] && ENV['XTC_PASSWORD']
           exec_options[:user] = ENV['XTC_USERNAME']
           exec_options[:password] = ENV['XTC_PASSWORD']
         end
 
+        client = XamarinTestCloud::HTTP::RetriableClient.new("#{host}/")
+
         if block_given?
-          exec_options = exec_options.merge({:method => :post, :url => "#{host}/#{address}", :payload => args,
-                          :timeout => 90000000,
-                          :open_timeout => 15,
-                          :headers => {:content_type => 'multipart/form-data'}})
-          response = RestClient::Request.execute(exec_options) do |response, request, result, &other_block|
-            block.call(response, request, result, &other_block)
-          end
+          exec_options[:header] = {'Content-Type' => 'multipart/form-data'}
+          exec_options[:timeout] = 90000000
+          response = client.post(request, exec_options)
+          block.call(response, request)
+          response
         else
-          exec_options = exec_options.merge(:method => :post, :url => "#{host}/#{address}", :payload => args)
-          response = RestClient::Request.execute(exec_options)
+          response = client.post(request, exec_options)
+          response.body
         end
-
-        response.body
       end
 
       def is_windows?

data/lib/xamarin-test-cloud/http/payload.rb

@@ -0,0 +1,268 @@
+# Adapted from RestClient payload.rb and used under the following license:
+#
+# The MIT License (MIT)
+#
+# Copyright (c) 2008-2014 Rest Client Authors
+#
+# 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.
+
+require 'tempfile'
+require 'stringio'
+require 'mime/types'
+
+module XamarinTestCloud
+  module HTTP
+
+    # Copied from rest-client
+    module Payload
+      extend self
+
+
+      def generate(params)
+        if params.is_a?(String)
+          Base.new(params)
+        elsif params.is_a?(Hash)
+          if params.delete(:multipart) == true || has_file?(params)
+            Multipart.new(params)
+          else
+            UrlEncoded.new(params)
+          end
+        elsif params.respond_to?(:read)
+          Streamed.new(params)
+        else
+          nil
+        end
+      end
+
+      def has_file?(params)
+        params.any? do |_, v|
+          case v
+            when Hash
+              has_file?(v)
+            when Array
+              has_file_array?(v)
+            else
+              v.respond_to?(:path) && v.respond_to?(:read)
+          end
+        end
+      end
+
+      def has_file_array?(params)
+        params.any? do |v|
+          case v
+            when Hash
+              has_file?(v)
+            when Array
+              has_file_array?(v)
+            else
+              v.respond_to?(:path) && v.respond_to?(:read)
+          end
+        end
+      end
+
+      class Base
+        def initialize(params)
+          build_stream(params)
+        end
+
+        def build_stream(params)
+          @stream = StringIO.new(params)
+          @stream.seek(0)
+        end
+
+        def read(bytes=nil)
+          @stream.read(bytes)
+        end
+
+        alias :to_s :read
+
+        # Flatten parameters by converting hashes of hashes to flat hashes
+        # {keys1 => {keys2 => value}} will be transformed into [keys1[key2], value]
+        def flatten_params(params, parent_key = nil)
+          result = []
+          params.each do |key, value|
+            calculated_key = parent_key ? "#{parent_key}[#{handle_key(key)}]" : handle_key(key)
+            if value.is_a? Hash
+              result += flatten_params(value, calculated_key)
+            elsif value.is_a? Array
+              result += flatten_params_array(value, calculated_key)
+            else
+              result << [calculated_key, value]
+            end
+          end
+          result
+        end
+
+        def flatten_params_array(value, calculated_key)
+          result = []
+          value.each do |elem|
+            if elem.is_a? Hash
+              result += flatten_params(elem, calculated_key)
+            elsif elem.is_a? Array
+              result += flatten_params_array(elem, calculated_key)
+            else
+              result << ["#{calculated_key}[]", elem]
+            end
+          end
+          result
+        end
+
+        def headers
+          {'Content-Length' => size.to_s}
+        end
+
+        def size
+          @stream.size
+        end
+
+        alias :length :size
+
+        def close
+          @stream.close unless @stream.closed?
+        end
+
+        def inspect
+          result = to_s.inspect
+          @stream.seek(0)
+          result
+        end
+
+        def short_inspect
+          (size > 500 ? "#{size} byte(s) length" : inspect)
+        end
+
+      end
+
+      class Streamed < Base
+        def build_stream(params = nil)
+          @stream = params
+        end
+
+        def size
+          if @stream.respond_to?(:size)
+            @stream.size
+          elsif @stream.is_a?(IO)
+            @stream.stat.size
+          end
+        end
+
+        alias :length :size
+      end
+
+      class UrlEncoded < Base
+        def build_stream(params = nil)
+          @stream = StringIO.new(flatten_params(params).collect do |entry|
+            "#{entry[0]}=#{handle_key(entry[1])}"
+          end.join("&"))
+          @stream.seek(0)
+        end
+
+        # for UrlEncoded escape the keys
+        def handle_key key
+          Parser.escape(key.to_s, Escape)
+        end
+
+        def headers
+          super.merge({'Content-Type' => 'application/x-www-form-urlencoded'})
+        end
+
+        Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+        Escape = Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+      end
+
+      class Multipart < Base
+        EOL = "\r\n"
+
+        def build_stream(params)
+          b = "--#{boundary}"
+
+          @stream = Tempfile.new("RESTClient.Stream.#{rand(1000)}")
+          @stream.binmode
+          @stream.write(b + EOL)
+
+          if params.is_a? Hash
+            x = flatten_params(params)
+          else
+            x = params
+          end
+
+          last_index = x.length - 1
+          x.each_with_index do |a, index|
+            k, v = * a
+            if v.respond_to?(:read) && v.respond_to?(:path)
+              create_file_field(@stream, k, v)
+            else
+              create_regular_field(@stream, k, v)
+            end
+            @stream.write(EOL + b)
+            @stream.write(EOL) unless last_index == index
+          end
+          @stream.write('--')
+          @stream.write(EOL)
+          @stream.seek(0)
+        end
+
+        def create_regular_field(s, k, v)
+          s.write("Content-Disposition: form-data; name=\"#{k}\"")
+          s.write(EOL)
+          s.write(EOL)
+          s.write(v)
+        end
+
+        def create_file_field(s, k, v)
+          begin
+            s.write("Content-Disposition: form-data;")
+            s.write(" name=\"#{k}\";") unless (k.nil? || k=='')
+            s.write(" filename=\"#{v.respond_to?(:original_filename) ? v.original_filename : File.basename(v.path)}\"#{EOL}")
+            s.write("Content-Type: #{v.respond_to?(:content_type) ? v.content_type : mime_for(v.path)}#{EOL}")
+            s.write(EOL)
+            while (data = v.read(8124))
+              s.write(data)
+            end
+          ensure
+            v.close if v.respond_to?(:close)
+          end
+        end
+
+        def mime_for(path)
+          mime = MIME::Types.type_for path
+          mime.empty? ? 'text/plain' : mime[0].content_type
+        end
+
+        def boundary
+          @boundary ||= rand(1_000_000).to_s
+        end
+
+        # for Multipart do not escape the keys
+        def handle_key key
+          key
+        end
+
+        def headers
+          super.merge({'Content-Type' => %Q{multipart/form-data; boundary=#{boundary}}})
+        end
+
+        def close
+          @stream.close!
+        end
+      end
+
+    end
+  end
+end

data/lib/xamarin-test-cloud/http/request.rb

@@ -0,0 +1,46 @@
+module XamarinTestCloud
+  module HTTP
+
+    class RequestError < RuntimeError; ; end
+
+    # A representation of an HTTP request that can be passed passed to the HTTP
+    # client as an argument for `get` or `post`.
+    # @!visibility private
+    class Request
+      attr_reader :route, :params
+
+      def initialize(route, params={})
+        @route = route
+        @params = params
+      end
+
+      # Create a new Request from `route` and `parameters`.
+      #
+      # @param [String] route The http route for the new request.
+      # @param [Array, Hash] parameters An Array or Hash of parameters.
+      # @return [Request] A new Request for `route` with `parameters`.
+      # @raise [RequestError] Raises an error if the parameters cannot be
+      #   converted to JSON
+      def self.request(route, parameters)
+        Request.new(route, Request.data(parameters))
+      end
+
+      private
+
+      # Converts `parameters` to JSON.
+      #
+      # @param [Array, Hash] parameters An Array or Hash of parameters.
+      # @return [String] A JSON formatted string that represents the parameters.
+      # @raise [RequestError] Raises an error if the parameters cannot be
+      #   converted to JSON
+      def self.data(parameters)
+        begin
+          JSON.generate(parameters)
+        rescue *[TypeError, JSON::GeneratorError] => e
+          raise RequestError, "#{e}: could not generate JSON from '#{parameters}'"
+        end
+      end
+    end
+  end
+end
+

data/lib/xamarin-test-cloud/http/retriable_client.rb

@@ -0,0 +1,166 @@
+require 'httpclient'
+require 'xamarin-test-cloud/http/payload'
+
+module XamarinTestCloud
+  module HTTP
+
+    class Error < RuntimeError; ; end
+
+    # An HTTP client that retries its connection on errors and can time out.
+    # @!visibility private
+    class RetriableClient
+      attr_reader :client
+
+      # @!visibility private
+       RETRY_ON =
+        [
+          # Raised for indicating a connection timeout error
+          HTTPClient::ConnectTimeoutError,
+
+          # Raised for indicating a request sending timeout error
+          HTTPClient::SendTimeoutError,
+
+          # Raised for indicating a response receiving timeout error.
+          HTTPClient::ReceiveTimeoutError,
+
+          Errno::ECONNREFUSED,
+
+          # The server sent a partial response
+          # Errno::ECONNRESET,
+          #
+          # Client sent TCP reset (RST) before server has accepted the
+          # connection requested by client.
+          Errno::ECONNABORTED,
+        ]
+
+      # @!visibility private
+      HEADER =
+            {
+                  'Content-Type' => 'application/json;charset=utf-8'
+            }
+
+      # Creates a new retriable client.
+      #
+      # This initializer takes multiple options.  If the option is not
+      # documented, it should be considered _private_. You use undocumented
+      # options at your own risk.
+      #
+      # @param [String] endpoint The server to make the HTTP request
+      #  on.
+      # @param [Hash] options Control the retry, timeout, and interval.
+      # @option options [Number] :retries (5) How often to retry.
+      # @option options [Number] :timeout (5) How long to wait for a response
+      #  before timing out.
+      # @option options [Number] :interval (0.5) How long to sleep between
+      #  retries.
+      def initialize(endpoint, options = {})
+        @client = options[:client] || ::HTTPClient.new
+        @endpoint = endpoint
+        @retries = options.fetch(:retries, 3)
+        @timeout = options.fetch(:timeout, 15)
+        @connect_timeout = options.fetch(:connect_timeout, 15)
+        @interval = options.fetch(:interval, 0.5)
+        @on_error = {}
+      end
+
+      # @!visibility private
+      def on_error(type, &block)
+        @on_error[type] = block
+      end
+
+      # Make an HTTP get request.
+      #
+      # This method takes multiple options.  If the option is not documented,
+      # it should be considered _private_.  You use undocumented options at
+      # your own risk.
+      #
+      # @param [Calabash::HTTP::Request] request The request.
+      # @param [Hash] options Control the retry, timeout, and interval.
+      # @option options [Number] :retries (5) How often to retry.
+      # @option options [Number] :timeout (5) How long to wait for a response
+      #  before timing out.
+      # @option options [Number] :interval (0.5) How long to sleep between
+      #  retries.
+      def get(request, options={})
+        request(request, :get, options)
+      end
+
+      # Make an HTTP post request.
+      #
+      # This method takes multiple options.  If the option is not documented,
+      # it should be considered _private_.  You use undocumented options at
+      # your own risk.
+      #
+      # @param [Calabash::HTTP::Request] request The request.
+      # @param [Hash] options Control the retry, timeout, and interval.
+      # @option options [Number] :retries (3) How many times to retry.
+      # @option options [Number] :timeout (15) How long to wait for a response
+      #  before timing out.
+      # @option options [Number] :connect_timeout (15) How long to wait for a
+      # connection.
+      # @option options [Number] :interval (0.5) How long to sleep between
+      #  retries.
+      def post(request, options={})
+        request(request, :post, options)
+      end
+
+      private
+
+      def request(request, request_method, options={})
+        retries = options.fetch(:retries, @retries)
+        timeout = options.fetch(:timeout, @timeout)
+        connect_timeout = options.fetch(:timeout, @connect_timeout)
+        interval = options.fetch(:interval, @interval)
+        header = options.fetch(:header, HEADER)
+
+        start_time = Time.now
+        last_error = nil
+
+        client = @client.dup
+        client.receive_timeout = timeout
+        client.connect_timeout = connect_timeout
+
+        if options.fetch(:user, nil) && options.fetch(:password, nil)
+          client.set_auth(options.fetch(:user), options.fetch(:password))
+        end
+
+        retries.times do |i|
+          first_try = i == 0
+
+          # Subtract the aggregate time we've spent thus far to make sure we're
+          # not exceeding the request timeout across retries.
+          time_diff = start_time + timeout - Time.now
+
+
+          if time_diff <= 0
+            raise HTTP::Error, 'Timeout exceeded'
+          end
+
+          client.receive_timeout = [time_diff, client.receive_timeout].min
+
+          payload = Payload.generate(request.params)
+
+          header.merge!(payload.headers) if payload
+
+          begin
+            return client.send(request_method, @endpoint + request.route,
+                               payload.to_s, header)
+          rescue *RETRY_ON => e
+
+            if first_try
+              if @on_error[e.class]
+                @on_error[e.class].call(@endpoint)
+              end
+            end
+
+            last_error = e
+            sleep interval
+          end
+        end
+
+        raise HTTP::Error, last_error
+      end
+    end
+  end
+end
+

data/lib/xamarin-test-cloud/version.rb

@@ -1,3 +1,3 @@
 module XamarinTestCloud
-  VERSION = "2.0.0.pre1"
+  VERSION = "2.0.0.pre2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xamarin-test-cloud
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre1
+  version: 2.0.0.pre2
 platform: ruby
 authors:
 - Karl Krukow
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-24 00:00:00.000000000 Z
+date: 2016-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -79,20 +79,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: rest-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: retriable
   requirement: !ruby/object:Gem::Requirement
@@ -113,6 +99,34 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.99'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -259,6 +273,9 @@ files:
 - README.md
 - bin/test-cloud
 - lib/xamarin-test-cloud/cli.rb
+- lib/xamarin-test-cloud/http/payload.rb
+- lib/xamarin-test-cloud/http/request.rb
+- lib/xamarin-test-cloud/http/retriable_client.rb
 - lib/xamarin-test-cloud/retriable_options.rb
 - lib/xamarin-test-cloud/version.rb
 homepage: http://xamarin.com/test-cloud