noms-command 0.5.0 → 2.1.1

data/lib/noms/command/useragent/requester/httpclient.rb

@@ -0,0 +1,61 @@
+#!ruby
+
+require 'noms/command/version'
+
+require 'httpclient'
+
+require 'noms/command/base'
+require 'noms/command/useragent/requester'
+require 'noms/command/useragent/response/httpclient'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::UserAgent < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Requester < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Requester::HTTPClient < NOMS::Command::Base
+
+    def initialize(opt={})
+        @log = opt[:logger] || default_logger
+        @log.debug "Creating #{self.class} with options: #{opt.inspect}"
+        @client_opts = opt
+        @client = ::HTTPClient.new :agent_name => "noms/#{NOMS::Command::VERSION} httpclient/#{::HTTPClient::VERSION}"
+        @cookies = opt.has_key?(:cookies) ? opt[:cookies] : true
+        if @cookies
+            cookie_jar = File.join(NOMS::Command.home, 'cookies.txt')
+            @client.set_cookie_store(cookie_jar)
+        else
+            @client.cookie_manager = nil
+        end
+        @client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    def request(opt={})
+        response = @client.request(opt[:method].to_s.upcase, opt[:url], '', opt[:body], opt[:headers])
+        noms_response = NOMS::Command::UserAgent::Response::HTTPClient.new(response)
+        if @cookies
+            # @client.save_cookie_store - There is a bug where
+            # it thinks @is_saved is satisfied all the time and
+            # the file isn't written, which is why we call
+            # cookie manager directly.
+            @client.cookie_manager.save_all_cookies(true)
+        end
+        noms_response
+    end
+
+    def set_auth(domain, username, password)
+        @client.set_auth(domain, username, password)
+    end
+
+end

data/lib/noms/command/useragent/requester/typhoeus.rb

@@ -0,0 +1,73 @@
+#!ruby
+
+require 'noms/command/version'
+
+require 'uri'
+require 'typhoeus'
+
+require 'noms/command/base'
+require 'noms/command/useragent/requester'
+require 'noms/command/useragent/response/typhoeus'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::UserAgent < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Requester < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Requester::Typhoeus < NOMS::Command::Base
+
+    def initialize(opt={})
+        @log = opt[:logger] || default_logger
+        @log.debug "Creating #{self.class} with options: #{opt.inspect}"
+        @agent_name = "noms/#{NOMS::Command::VERSION} typhoeus/#{::Typhoeus::VERSION}"
+        @auth = { }
+        @client_opts = {
+            :ssl_verifypeer => false
+        }
+        cookies = opt.has_key?(:cookies) ? opt[:cookies] : true
+
+        if cookies
+            cookie_jar = File.join(NOMS::Command.home, 'cookies.txt')
+            @client_opts = @client_opts.merge({
+                                                  :cookiefile => cookie_jar,
+                                                  :cookiejar => cookie_jar
+                                              })
+        end
+    end
+
+    def get_auth(url)
+        url = URI.parse(url) unless url.respond_to? :scheme
+        domain = url.scheme + '://' + url.host + ':' + url.port.to_s + '/'
+        @auth[domain] || { }
+    end
+
+    def request(opt={})
+        url = opt[:url]
+        spec = @client_opts.merge({
+                                      :method => opt[:method] || opt[:get],
+                                      :headers => {
+                                          'User-Agent' => @agent_name
+                                      }.merge(opt[:headers]),
+                                      :body => opt[:body]
+                                  }).merge(get_auth(url))
+        request = ::Typhoeus::Request.new(opt[:url], spec)
+        response = request.run
+        NOMS::Command::UserAgent::Response::Typhoeus.new(response)
+    end
+
+    def set_auth(domain, username, password)
+        @auth[domain] = { :userpwd => [username, password].join(':') }
+    end
+
+end

data/lib/noms/command/useragent/response.rb

@@ -0,0 +1,202 @@
+#!ruby
+
+require 'noms/command/version'
+
+require 'time'
+
+require 'noms/command'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::UserAgent < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Response < NOMS::Command::Base
+
+    attr_reader :expires, :cache_control, :etag, :last_modified
+    attr_accessor :auth_hash, :from_cache, :date, :original_date
+
+    def self.from_cache(cache_text, opts={})
+        unless cache_text.nil? or cache_text.empty?
+            self.from_json(cache_text, opts)
+        end
+    end
+
+    def self.from_json(json_text, opts={})
+        return self.new(JSON.parse(json_text), opts)
+    end
+
+    # Constructor, pass in HTTP response subclass object
+    # In the base clase (which is what gets unfrozen)
+    # This is a hash.
+    def initialize(httpresponse, opts={})
+        @log = opts[:logger] || default_logger
+        @response = httpresponse
+        self.from_cache = false
+        self.auth_hash = nil
+
+        if httpresponse.respond_to? :[]
+            self.from_cache = httpresponse['from_cache']
+            self.auth_hash = httpresponse['auth_hash']
+            self.original_date = Time.httpdate(httpresponse['original_date'])
+            self.date = Time.httpdate(httpresponse['date'])
+        end
+
+        @cache_control = self.header 'Cache-Control'
+        @date = get_header_time('Date') || Time.now
+        @original_date ||= @date
+        @expires = get_expires
+        @etag = self.header 'Etag'
+        @last_modified = get_header_time 'Last-modified'
+    end
+
+    # The response body
+    def body
+        @response['body']
+    end
+
+    # The success status
+    def success?
+        # We created this object explicitly, so it's always successful
+        true
+    end
+
+    # A hash or headers, or specific header
+    def header(hdr=nil)
+        if hdr.nil?
+            @response['header']
+        else
+            Hash[@response['header'].map { |h, v| [h.downcase, v] }][hdr.downcase] unless @response.nil?
+        end
+    end
+
+    # An integer status code
+    def status
+        @response['status']
+    end
+
+    # The status message including code
+    def statusText
+        @response['statusText']
+    end
+
+    # MIME Type of content
+    def content_type
+        self.header 'Content-Type'
+    end
+
+    def header_params(s)
+        Hash[s.split(';').map do |field|
+                param, value = field.split('=', 2)
+                value ||= ''
+                [param.strip, value.strip]
+            end]
+    end
+
+    def content_encoding
+        if self.content_type
+            header_params(self.content_type)['charset']
+        end
+    end
+
+    def to_json
+        self.to_hash.to_json
+    end
+
+    def to_cache
+        self.to_json
+    end
+
+    def to_hash
+        {
+            'body' => self.body,
+            'header' => self.header,
+            'status' => self.status,
+            'statusText' => self.statusText,
+            'auth_hash' => self.auth_hash,
+            'from_cache' => self.from_cache,
+            'date' => self.date.httpdate,
+            'original_date' => self.original_date.httpdate
+        }
+    end
+
+    def auth_hash=(hvalue)
+        @auth_hash = hvalue
+    end
+
+    def get_expires
+
+        expires = [ ]
+
+        if @cache_control and (m = /max-age=(\d+)/.match(@cache_control))
+            expires << (@date + m[1].to_i)
+        end
+
+        if self.header('Expires')
+            begin
+                expires << Time.httpdate(self.header('Expires'))
+            rescue ArgumentError => e
+                @log.debug "Response had 'Expires' header but could not parse (#{e.class}): #{e.message}"
+            end
+        end
+
+        return nil if expires.empty?
+
+        expires.empty? ? nil : expires.min
+    end
+
+    def get_header_time(hdr)
+        value = self.header hdr
+        if value
+            begin
+                Time.httpdate(value)
+            rescue ArgumentError => e
+                @log.debug "Response has a '#{hdr}' but could not parse (#{e.class}): #{e.message}"
+            end
+        end
+    end
+
+    def cacheable?
+        return false unless self.status == 200
+        return false unless @expires
+        return false if self.from_cache?
+        return false if /no-cache/.match @cache_control
+        return false if /no-store/.match @cache_control
+        return false if self.header 'Pragma' and /no-cache/.match self.header('Pragma')
+
+        true
+    end
+
+    def cached!
+        @from_cache = true
+    end
+
+    def from_cache?
+        @from_cache
+    end
+
+    def current?
+        return false if (@cache_control and /must-revalidate/.match @cache_control)
+        return false unless @expires
+        return false if Time.now > @expires
+        true
+    end
+
+    def age
+        Time.now - self.original_date
+    end
+
+    def cacheable_copy
+        other = self.dup
+        other.logger = nil
+        other
+    end
+
+end

data/lib/noms/command/useragent/response/httpclient.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'noms/command/version'
+
+require 'httpclient'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::UserAgent < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Response < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Response::HTTPClient < NOMS::Command::UserAgent::Response
+
+    def initialize(httpresponse, opts={})
+        super
+        @log = opts[:logger] || default_logger
+        @response = httpresponse
+    end
+
+    def body
+        @response.content
+    end
+
+    def success?
+        @response.ok?
+    end
+
+    def header(hdr=nil)
+        if hdr.nil?
+            @response.headers
+        else
+            @response.header[hdr.downcase].first
+        end
+    end
+
+    def status
+        @response.status.to_i unless @response.status.nil?
+    end
+
+    def statusText
+        @response.status.to_s + ' ' + @response.reason unless @response.status.nil?
+    end
+
+    def content_type
+        @response.contenttype
+    end
+
+end

data/lib/noms/command/useragent/response/typhoeus.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'noms/command/version'
+
+require 'typhoeus'
+
+class NOMS
+
+end
+
+class NOMS::Command
+
+end
+
+class NOMS::Command::UserAgent < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Response < NOMS::Command::Base
+
+end
+
+class NOMS::Command::UserAgent::Response::Typhoeus < NOMS::Command::UserAgent::Response
+
+    def initialize(httpresponse, opts={})
+        super
+        if @response.return_code != :ok
+            raise NOMS::Command::Error.new "Client error[#{@response.return_code.inspect}]: #{@response.return_message}"
+        end
+        content_encoding = self.content_encoding || 'utf-8'
+        @body = @response.body
+
+        if @body
+
+            begin
+                @log.debug "Forcing body string encoding to #{content_encoding}"
+                @body.force_encoding(content_encoding)
+            rescue Encoding::UndefinedConversionError
+                @log.debug "   (coercing 'binary' to '#{content_encoding}')"
+                @body = @body.encode('utf8', 'binary', :undef => :replace, :invalid => :replace)
+            end
+
+        end
+    end
+
+    def body
+        @body || @response.body
+    end
+
+    def success?
+        @response.success?
+    end
+
+    def header(hdr=nil)
+        if hdr.nil?
+            @response.headers
+        else
+            Hash[@response.headers.map { |h, v| [h.downcase, v] }][hdr.downcase]
+        end
+    end
+
+    def status
+        @response.code.to_i
+    end
+
+    def statusText
+        @response.code.to_s + ' ' + @response.status_message
+    end
+
+    def content_type
+        @response.headers['Content-Type']
+    end
+
+end