scooter 3.2.19 → 4.1.0

data/lib/scooter/httpdispatchers/consoledispatcher.rb

@@ -83,7 +83,7 @@ module Scooter
           if !host.is_a?(Unix::Host)
             raise 'Can only acquire SSL certs if the host is a Unix::Host'
           end
-         acquire_ca_cert(host)
+          acquire_ca_cert(host)
         end
       end
 
@@ -93,28 +93,14 @@ module Scooter
           request.body = "username=#{login}&password=#{CGI.escape(password)}"
           connection.port = 443
         end
-        #return the response if the status code was not 200
         return response if response.status != 200
-        # try to be helpful and acquire the xcsrf; catch any error that occurs
-        # in the acquire_xcsrf method
-        begin
-          acquire_xcsrf
-        rescue
-          # do nothing in the rescue
-        end
+        # This just had to be a string...*sigh*
+        header_array = response.headers['Set-Cookie'].split(';')
+        pl_ssti = header_array.select{|s| s =~ /pl_ssti/}
+        pl_ssti_value = pl_ssti[0].partition('pl_ssti=').last
+        @connection.headers['Cookie'] = response.headers['Set-Cookie']
+        @connection.headers['X-Authentication'] = pl_ssti_value
         # Reset the connection port, since we have to hardcode it to 443 signin
-        # here
-        set_url_prefix
-      end
-
-      def acquire_xcsrf
-        # This simply makes a call to the base_uri and extracts out an
-        # anti-forgery-token and adds that token to the headers for the
-        # connection object
-        response_body = @connection.get('/') { |req| connection.port = 443 }.env.body
-        parsed_body = Nokogiri::HTML(response_body)
-        token = parsed_body.css("meta[name='__anti-forgery-token']")[0].attributes['content'].value
-        @connection.headers['X-CSRF-Token'] = token
         set_url_prefix
       end
 

data/lib/scooter/httpdispatchers/httpdispatcher.rb

@@ -11,10 +11,10 @@ module Scooter
     # low level functionality. Otherwise, the primary function of this class
     # is to allow more specific Dispatchers, such as the ConsoleDispatcher, to
     # extend it and write higher level functionality.
-    class HttpDispatcher
+    class HttpDispatcher < Beaker::Http::Connection
 
 
-      attr_accessor :connection, :host, :ssl, :token, :send_auth_token_as_query_param, :faraday_logger
+      attr_accessor :connection, :host, :token, :send_auth_token_as_query_param, :faraday_logger
       # The only required parameter for the HttpDispatcher is the host, which
       # could either be a beaker Unix::Host or a String. HttpDispatchers offer
       # support for automatically generating the required SSL components for the
@@ -30,17 +30,20 @@ module Scooter
       # @param log_level(Int) The desired log level
       # @param log_body(Boolean) Whether to log the body of responses
       def initialize(host, log_level=Logger::DEBUG, log_body=true)
+        @connection = create_default_connection(host.options, log_body)
         @log_body = log_body
-        @ssl = {}
         @host = host
-        if @host.is_a?(Unix::Host)
-          @connection = create_default_connection_with_beaker_host
-        elsif @host.is_a?(String)
-          @connection = create_default_connection(log_level)
-          set_url_prefix
-        else
-          raise "Argument host must be Unix::Host or String"
+        configure_private_key_and_cert_with_puppet(host)
+
+        set_url_prefix
+        # In this conditional, if we are unable to resolve the hostname, we get the public IP address;
+        # because public IP addresses will fail ssl verification, we explicitly turn that off. There
+        # should be a better solution, but this has worked so far...
+        if !is_resolvable
+          connection.url_prefix.host = Scooter::Utilities::BeakerUtilities.get_public_ip(host)
+          connection.ssl['verify'] = false
         end
+
         # The http-cookie library that the cookie-jar wraps requires that a
         # URI object be specifically a URI::HTTPS object. This changes the
         # default url_prefix in Faraday to be sub-classed from HTTPS, not plain
@@ -49,20 +52,7 @@ module Scooter
         @connection.url_prefix = URI.parse(@connection.url_prefix.to_s)
       end
 
-      def initialize_connection
-        if @host.is_a?(Unix::Host)
-          @connection = create_default_connection_with_beaker_host
-        elsif @host.is_a?(String)
-          @connection = create_default_connection
-          set_url_prefix
-          add_ssl_components_to_connection
-        else
-          raise "Argument host must be Unix::Host or String"
-        end
-
-      end
-
-      def create_default_connection(log_level=Logger::DEBUG)
+      def create_default_connection(options, log_body)
         Faraday.new do |conn|
           conn.request :rbac_auth_token, self
           conn.request :json
@@ -70,10 +60,7 @@ module Scooter
           conn.response :follow_redirects
           conn.response :raise_error
           conn.response :json, :content_type => /\bjson$/
-          @faraday_logger ||= Logger.new $stderr
-          # If log level is not set by Beaker, set faraday log level to debug.
-          @faraday_logger.level ||= log_level if defined? @faraday_logger.level
-          conn.response :logger, @faraday_logger, bodies: @log_body
+          conn.response :faraday_beaker_logger, options[:logger], { :bodies => log_body }
 
           conn.use :cookie_jar
 
@@ -89,21 +76,6 @@ module Scooter
         end
       end
 
-      def create_default_connection_with_beaker_host
-        if host.logger
-          log_level = Logger::ERROR if host.logger.log_level == :error
-          log_level = Logger.WARN if host.logger.log_level == :warn
-          log_level = Logger::INFO if (host.logger.log_level == :info || host.logger.log_level == :notify)
-          log_level ||= Logger::DEBUG
-        end
-
-        connection = create_default_connection(log_level)
-        set_url_prefix(connection)
-        acquire_ssl_components if ssl.empty?
-        add_ssl_components_to_connection(connection)
-        connection
-      end
-
       # See if we can reach the host by hostname
       def is_resolvable(host=self.host)
         begin
@@ -113,56 +85,6 @@ module Scooter
           false
         end
       end
-
-      # If you would like to run tests that expect 400 or even 500 responses,
-      # apply this method to remove the <tt>:raise_error</tt> middleware.
-      def remove_error_checking(connection=self.connection)
-        connection.builder.delete(Faraday::Response::RaiseError)
-      end
-
-      def acquire_ssl_components(host=self.host)
-        if !host.is_a?(Unix::Host)
-          raise 'Can only acquire SSL certs if the host is a Unix::Host'
-        end
-        acquire_ca_cert(host)
-        acquire_cert_and_key(host)
-      end
-
-      def acquire_ca_cert(host=self.host)
-        @ssl['ca_file'] = Scooter::Utilities::BeakerUtilities.pe_ca_cert_file(host)
-      end
-
-      def acquire_cert_and_key(host=self.host)
-        client_key = Scooter::Utilities::BeakerUtilities.pe_private_key(host)
-        client_cert = Scooter::Utilities::BeakerUtilities.pe_hostcert(host)
-        @ssl['client_key']  = OpenSSL::PKey.read(client_key)
-        @ssl['client_cert'] = OpenSSL::X509::Certificate.new(client_cert)
-      end
-
-      def add_ssl_components_to_connection(connection=self.connection)
-        # return immediately if the ssl object is empty
-        if ssl.empty?
-          warn 'no ssl keys defined, the connection object will not be modified'
-          return
-        end
-        # enforce the scheme to be https, since we are adding ssl components to
-        # the connection object
-        connection.url_prefix.scheme = 'https'
-
-        @ssl.each do |k, v|
-          connection.ssl[k] = v
-        end
-
-        if host.is_a?(Unix::Host)
-          if connection.url_prefix.host == Scooter::Utilities::BeakerUtilities.get_public_ip(host) && connection.ssl['verify'] == nil
-            # Because we are connecting to the dashboard by IP address, SSL verification
-            # against the CA will fail. Disable verifying against it for now until a better
-            # fix can be found.
-            connection.ssl['verify'] = false
-          end
-        end
-      end
-
     end
   end
 end

data/lib/scooter/httpdispatchers/orchestrator/v1/v1.rb

@@ -10,9 +10,13 @@ module Scooter
         end
 
         #jobs endpoints
-        def get_last_jobs(n_jobs)
-          @connection.get("#{@version}/jobs") do |req|
-            req.body = {:limit => n_jobs} if n_jobs
+        def get_last_jobs(limit=nil, offset=nil, order_by=nil, order=nil)
+          path = "#{@version}/jobs"
+          @connection.get(path) do |request|
+            request.params['limit'] = limit if limit
+            request.params['offset'] = offset if offset
+            request.params['order_by'] = order_by if order_by
+            request.params['order'] = order if order
           end
         end
 
@@ -33,6 +37,10 @@ module Scooter
         end
 
         #environments endpoints
+        def get_environments
+          @connection.get("v1/environments")
+        end
+
         def get_environment(environment)
           @connection.get("#{@version}/environments/#{environment}")
         end

data/lib/scooter/httpdispatchers/puppetdbdispatcher.rb

@@ -14,62 +14,28 @@ module Scooter
         connection.url_prefix.port = 8081
       end
 
-      # Used to compare replica puppetdb to master. Raises exception if it does not match.
-      # @param [BeakerHost] host_name
-      def database_matches_self?(host_name)
-        original_host_name = self.host
-        begin
-          self.host = host_name
-          initialize_connection
-          other_nodes    = query_nodes.body
-          other_catalogs = query_catalogs.body
-          other_facts    = query_facts.body
-          other_reports  = query_reports.body
-        ensure
-          self.host = original_host_name
-          initialize_connection
-        end
-
-        self_nodes    = query_nodes.body
-        self_catalogs = query_catalogs.body
-        self_facts    = query_facts.body
-        self_reports  = query_reports.body
-
-        nodes_match    = nodes_match?(other_nodes, self_nodes)
-        catalogs_match = catalogs_match?(other_catalogs, self_catalogs)
-        facts_match    = facts_match?(other_facts, self_facts)
-        reports_match  = reports_match?(other_reports, self_reports)
-
-        errors = ''
-        errors << "Nodes do not match\r\n" unless nodes_match
-        errors << "Catalogs do not match\r\n" unless catalogs_match
-        errors << "Facts do not match\r\n" unless facts_match
-        errors << "Reports do not match\r\n" unless reports_match
-
-        @faraday_logger.warn(errors.chomp) unless errors.empty?
-        errors.empty?
-      end
-
       # Compares Replica PuppetDB with Master PuppetDB, to make sure Master PuppetDB has synced to Replica PuppetDB.
       #
       # N.B.: this uses a weird definition of "synced". We're NOT making sure the two PuppetDBs are exactly the same.
       # We're just checking that the replica DB doesn't contain any records that aren't also in the master, and that
       # the replica has at least one report from each node. We do this because there's a race condition-y window where
       # an agent may have delivered a report to the Master PuppetDB, but the Replica PuppetDB hasn't picked it up yet.
-      # @param [BeakerHost] replica_host_name
+      # @param [BeakerHost] replica_host
       # @param [Array] agents all the agents in the SUT, in the form of BeakerHost instances
-      def replica_db_synced_with_master_db?(replica_host_name, agents)
-        master_host_name = self.host
+      def replica_db_synced_with_master_db?(replica_host, agents)
+        # Save a beaker host_hash[:vmhostname], set it to the supplied host_name param,
+        # and then set it back to the original at the end of the ensure. The :vmhostname
+        #overrides the host.hostname, and nothing should win out over it.
+        original_host_name = host.host_hash[:vmhostname]
         begin
-          self.host = replica_host_name
-          initialize_connection
+          host.host_hash[:vmhostname] = replica_host.hostname
+
           replica_nodes    = query_nodes.body
           replica_catalogs = query_catalogs.body
           replica_facts    = query_facts.body
           replica_reports  = query_reports.body
         ensure
-          self.host = master_host_name
-          initialize_connection
+          host.host_hash[:vmhostname] = original_host_name
         end
         master_nodes    = query_nodes.body
         master_catalogs = query_catalogs.body
@@ -87,7 +53,7 @@ module Scooter
         errors << "Facts not synced\r\n" unless facts_synced
         errors << "Reports not synced\r\n" unless reports_synced
 
-        @faraday_logger.warn(errors.chomp) unless errors.empty?
+        host.logger.warn(errors.chomp) unless errors.empty?
         errors.empty?
       end
 
@@ -289,7 +255,7 @@ module Scooter
         master_facts.each do |master_fact|
           return true if ['certname', 'name', 'environment'].all? { |key| replica_fact[key] == master_fact[key] }
         end
-        @faraday_logger.warn("*** fact sync failure: no Master fact matches Replica fact: #{replica_fact}")
+        host.logger.warn("*** fact sync failure: no Master fact matches Replica fact: #{replica_fact}")
         false
       end
 
@@ -321,7 +287,7 @@ module Scooter
       # @return [Boolean]
       def master_has_catalog?(replica_catalog, master_catalogs)
         master_catalogs.each { |master_catalog| return true if replica_catalog['certname'] == master_catalog['certname'] }
-        @faraday_logger.warn("master doesn't have catalog with hash '#{replica_catalog['certname']}', which is on replica")
+        host.logger.warn("master doesn't have catalog with hash '#{replica_catalog['certname']}', which is on replica")
         false
       end
 
@@ -337,7 +303,7 @@ module Scooter
       # @return [Boolean]
       def master_has_node?(replica_node, master_nodes)
         master_nodes.each { |master_node| return true if replica_node['certname'] == master_node['certname'] }
-        @faraday_logger.warn("master doesn't have node with certname '#{replica_node['certname']}', which is on replica")
+        host.logger.warn("master doesn't have node with certname '#{replica_node['certname']}', which is on replica")
         false
       end
 
@@ -352,7 +318,7 @@ module Scooter
           same_contents = same_contents?(replica_report, master_report, keys_with_expected_diffs)
           return true if same_hash && same_contents
         end
-        @faraday_logger.warn("master doesn't have report with hash '#{replica_report['hash']}', which is on replica")
+        host.logger.warn("master doesn't have report with hash '#{replica_report['hash']}', which is on replica")
         false
       end
 
@@ -362,7 +328,7 @@ module Scooter
       # @return [Boolean]
       def replica_has_node_for_agent?(replica_nodes, agent)
         replica_nodes.each { |replica_node| return true if replica_node['certname'] == agent.hostname }
-        @faraday_logger.warn("replica doesn't have any nodes for certname '#{agent.hostname}'")
+        host.logger.warn("replica doesn't have any nodes for certname '#{agent.hostname}'")
         false
       end
 
@@ -372,7 +338,7 @@ module Scooter
       # @return [Boolean]
       def replica_has_report_for_agent?(replica_reports, agent)
         replica_reports.each { |replica_report| return true if replica_report['certname'] == agent.hostname }
-        @faraday_logger.warn("replica doesn't have any reports for certname '#{agent.hostname}'")
+        host.logger.warn("replica doesn't have any reports for certname '#{agent.hostname}'")
         false
       end
 
@@ -382,7 +348,7 @@ module Scooter
       # @return [Boolean]
       def replica_has_catalog_for_agent?(replica_catalogs, agent)
         replica_catalogs.each { |replica_catalog| return true if replica_catalog['certname'] == agent.hostname }
-        @faraday_logger.warn("replica doesn't have any catalogs for certname '#{agent.hostname}'")
+        host.logger.warn("replica doesn't have any catalogs for certname '#{agent.hostname}'")
         false
       end
     end

data/lib/scooter/httpdispatchers/rbac.rb

@@ -170,17 +170,19 @@ module Scooter
         @token = acquire_token(credentials.login, credentials.password, lifetime)
       end
 
-      def rbac_database_matches_self?(host_name)
-        original_host_name = self.host
+      def rbac_database_matches_self?(replica_host)
+        # Save a beaker host_hash[:vmhostname], set it to the supplied host_name param,
+        # and then set it back to the original at the end of the ensure. The :vmhostname
+        #overrides the host.hostname, and nothing should win out over it.
+        original_host_name = host.host_hash[:vmhostname]
         begin
-          self.host = host_name.to_s
-          initialize_connection
+          host.host_hash[:vmhostname] = replica_host.hostname
+
           other_users  = get_list_of_users
           other_groups = get_list_of_groups
           other_roles  = get_list_of_roles
         ensure
-          self.host = original_host_name
-          initialize_connection
+          host.host_hash[:vmhostname] = original_host_name
         end
 
         self_users  = get_list_of_users
@@ -192,7 +194,7 @@ module Scooter
         errors << "Groups do not match\r\n" unless groups_match?(self_groups, other_groups)
         errors << "Roles do not match\r\n" unless roles_match?(self_roles, other_roles)
 
-        @faraday_logger.warn(errors.chomp) unless errors.empty?
+        host.logger.warn(errors.chomp) unless errors.empty?
         errors.empty?
       end
 

data/lib/scooter/version.rb

@@ -1,5 +1,5 @@
 module Scooter
   module Version
-    STRING = '3.2.19'
+    STRING = '4.1.0'
   end
 end

data/scooter.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'activesupport', '4.2.6'
 
   #Run time dependencies
+  spec.add_runtime_dependency 'beaker-http', '~> 0.1'
   spec.add_runtime_dependency 'json', '~> 1.8'
   spec.add_runtime_dependency 'test-unit'
   spec.add_runtime_dependency 'net-ldap', '~> 0.6', '>= 0.6.1', '<= 0.12.1'
@@ -36,5 +37,4 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'faraday', '~> 0.9', '>= 0.9.1'
   spec.add_runtime_dependency 'faraday_middleware', '~> 0.9'
   spec.add_runtime_dependency 'faraday-cookie_jar', '~> 0.0', '>= 0.0.6'
-  spec.add_runtime_dependency 'nokogiri', '~> 1.5', '>= 1.5.10'
 end

data/spec/scooter/httpdispatchers/activity/activity_spec.rb

@@ -127,15 +127,22 @@ module Scooter
 
     context 'with a beaker host passed in' do
 
+      let(:logger) { double('logger')}
       unixhost = { roles:     ['test_role'],
                    'platform' => 'debian-7-x86_64' }
-      let(:host) { Beaker::Host.create('test.com', unixhost, {}) }
+      let(:host) { Beaker::Host.create('test.com', unixhost, {:logger => logger}) }
+      let(:host2) { Beaker::Host.create('test2.com', unixhost, {:logger => logger}) }
       let(:credentials) { { login: 'Ziggy', password: 'Stardust' } }
 
       before do
-        expect(Scooter::Utilities::BeakerUtilities).to receive(:pe_ca_cert_file).and_return('cert file')
-        expect(Scooter::Utilities::BeakerUtilities).to receive(:get_public_ip).and_return('public_ip')
-        expect(subject).not_to be_nil
+        allow_any_instance_of(Beaker::Http::FaradayBeakerLogger).to receive(:info) { true }
+        allow_any_instance_of(Beaker::Http::FaradayBeakerLogger).to receive(:debug) { true }
+        allow_any_instance_of(HttpDispatchers::ConsoleDispatcher).to receive(:configure_private_key_and_cert_with_puppet) { true }
+        # Since we mocked the cert configuration action, we need to fixup the url_prefix
+        # to be the proper scheme and object class, HTTPS instead of HTTP
+        subject.url_prefix.scheme = 'https'
+        subject.url_prefix = URI.parse(subject.connection.url_prefix.to_s)
+        expect(subject).to be_kind_of(HttpDispatchers::ConsoleDispatcher)
       end
 
       describe '.get_classifier_events' do
@@ -195,22 +202,23 @@ module Scooter
           subject.connection.builder.swap(index, Faraday::Adapter::Test) do |stub|
             stub.get('activity-api/v1/events?service_id=rbac') { |env| env[:url].to_s == "https://test.com:4433/activity-api/v1/events?service_id=rbac" ?
                 [200, [], rbac_events] :
-                [200, [], rbac_events.dup["commits"].push('another_array_item')] }
+                [200, [], rbac_events['commits'].dup.push('another_array_item')] }
             stub.get('activity-api/v1/events?service_id=classifier') { |env| env[:url].to_s == "https://test.com:4433/activity-api/v1/events?service_id=classifier" ?
                 [200, [], classifier_events] :
                 [200, [], classifier_events.dup["commits"].push('another_array_item')] }
           end
-          expect(subject).to receive(:create_default_connection).with(any_args).twice.and_return(subject.connection)
-          expect(Scooter::Utilities::BeakerUtilities).to receive(:get_public_ip).and_return('public_ip')
+          expect(subject).to receive(:is_resolvable).exactly(4).times.and_return(true)
+          # expect(subject).to receive(:create_default_connection).with(any_args).twice.and_return(subject.connection)
+          # expect(Scooter::Utilities::BeakerUtilities).to receive(:get_public_ip).and_return('public_ip')
         end
 
         it 'compare with self' do
-          expect(subject.activity_database_matches_self?('test.com')).to be_truthy
+          expect(subject.activity_database_matches_self?(host)).to be_truthy
         end
 
         it 'compare with different' do
-          expect(subject.faraday_logger).to receive(:warn).with /Rbac events do not match/
-          expect(subject.activity_database_matches_self?('test2.com')).to be_falsey
+          expect(subject.host.logger).to receive(:warn).with /Rbac events do not match/
+          expect(subject.activity_database_matches_self?(host2)).to be_falsey
         end
       end
     end