scooter 0.0.0 → 3.2.19

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

@@ -0,0 +1,99 @@
+module Scooter
+  module HttpDispatchers
+    module Classifier
+      # Methods here are generally representative of endpoints, and depending
+      # on the method, return either a Faraday response object or some sort of
+      # instance of the object created/modified.
+      module V1
+
+        def create_node_group(options)
+          set_classifier_path
+          if options['id']
+            @connection.put("v1/groups/#{options['id']}") do |request|
+              request.body = options
+            end
+          else
+            @connection.post('v1/groups') do |request|
+              request.body = options
+            end
+          end
+        end
+
+        def get_list_of_node_groups
+          set_classifier_path
+          @connection.get('v1/groups').env.body
+        end
+
+        def get_node_group(uuid)
+          set_classifier_path
+          @connection.get("v1/groups/#{uuid}").env.body
+        end
+
+        def delete_node_group(uuid)
+          set_classifier_path
+          @connection.delete("v1/groups/#{uuid}")
+        end
+
+        def replace_node_group(node_group_id, node_group_model)
+          set_classifier_path
+          @connection.put("v1/groups/#{node_group_id}") do |request|
+            request.body = node_group_model
+          end
+        end
+
+        def update_node_group(node_group_id, update_hash)
+          set_classifier_path
+          @connection.post("v1/groups/#{node_group_id}") do |request|
+            request.body = update_hash
+          end
+        end
+
+        def import_hierarchy(hierarchy)
+          set_classifier_path
+          @connection.post('v1/import-hierarchy') do |request|
+            request.body = hierarchy
+          end
+        end
+
+        def update_classes(environment=nil)
+          set_classifier_path
+          @connection.post('v1/update-classes') do |request|
+            unless environment.nil?
+              request.params['environment'] = environment
+            end
+          end
+        end
+
+        def pin_nodes(node_group_id, nodes)
+          set_classifier_path
+          @connection.post("v1/groups/#{node_group_id}/pin") do |request|
+            request.body = nodes
+          end
+        end
+
+        def unpin_nodes(node_group_id, nodes)
+          set_classifier_path
+          @connection.post("v1/groups/#{node_group_id}/unpin") do |request|
+            request.body = nodes
+          end
+        end
+
+        def get_list_of_classes
+          set_classifier_path
+          @connection.get('v1/classes').env.body
+        end
+
+        def get_list_of_nodes
+          set_classifier_path
+          @connection.get('v1/nodes').env.body
+        end
+
+        def get_list_of_environments
+          set_classifier_path
+          @connection.get('v1/environments').env.body
+        end
+
+      end
+    end
+  end
+end

data/lib/scooter/httpdispatchers/code_manager.rb

@@ -0,0 +1,31 @@
+%w( v1 ).each do |lib|
+  require "scooter/httpdispatchers/code_manager/v1/#{lib}"
+end
+
+module Scooter
+  module HttpDispatchers
+    # Currently there is no httpdispatcher built for the CodeManager module
+    # it is necessary to create one and extend this module onto it
+    #
+    # Example:
+    # api = Scooter::HttpDispatchers::HttpDispatcher.new(master)
+    # api.extend(Scooter::HttpDispatchers::CodeManager)
+    # api.deploy_environments(['environment_one', 'environment_two'])
+    module CodeManager
+
+      include Scooter::HttpDispatchers::CodeManager::V1
+
+      def deploy_environments(environment_array, wait=true)
+        raise ArgumentError.new('wait must be TrueClass or FalseClass') unless !!wait == wait
+        payload = {:environments => environment_array, 'wait' => wait}
+        deploys(payload)
+      end
+
+      def deploy_all_environments(wait=true)
+        raise ArgumentError.new('wait must be TrueClass or FalseClass') unless !!wait == wait
+        payload = {'deploy-all' => true, 'wait' => wait}
+        deploys(payload)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Scooter
+  module HttpDispatchers
+    module CodeManager
+      # Methods here are generally representative of endpoints
+      module V1
+
+        def deploys(environments_payload_hash)
+          @connection.url_prefix.port = 8170
+          @connection.post('/code-manager/v1/deploys') do |req|
+            req.body = environments_payload_hash
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/scooter/httpdispatchers/consoledispatcher.rb

@@ -0,0 +1,132 @@
+%w( rbac classifier activity).each do |lib|
+  require "scooter/httpdispatchers/#{lib}"
+end
+
+module Scooter
+
+  module HttpDispatchers
+
+    # == Quick-start guide
+    # === example creating a ConsoleDispatcher with certificates and credentials
+    #
+    #  require 'scooter'
+    #
+    #  include Scooter::HttpDispatcher
+    #
+    #  console_dispatcher = ConsoleDispatcher.new(dashboard)
+    #
+    #  # creates a new user and returns a new ConsoleDispatcher
+    #  new_user = console_dispatcher.generate_local_user('login' => 'Chuck')
+    #
+    #  # because the new_user has credentials, it can signin
+    #  new_user.signin
+    #
+    #  # this will trigger the middleware error handler, because you cannot
+    #  # create two users with the same login
+    #  console_dispatcher.create_local_user('login' => 'Chuck')
+    #
+    #  # this will return Chuck's data
+    #  certificate_dispatcher.get_console_dispatcher_data(new_user)
+    #
+    #  # this will trigger a middleware error handler, because Chuck has no
+    #  # privilege to create new users
+    #  new_user.generate_local_user
+    #
+    #  # this will delete Chuck from RBAC
+    #  certificate_dispatcher.delete_local_console_dispatcher(new_user)
+    #
+    #  # this method will now return nil because new_user is deleted
+    #  certificate_dispatcher.get_console_dispatcher_data(new_guy)
+    class ConsoleDispatcher < HttpDispatcher
+
+      include Scooter::HttpDispatchers::Rbac
+      include Scooter::HttpDispatchers::Classifier
+      include Scooter::HttpDispatchers::Activity
+      attr_accessor :credentials
+      Credentials = Struct.new(:login, :password)
+
+      # This class is designed to interact with any of the pe-console-services:
+      # RBAC, Node Classifier, and the Activity Service. The most common use
+      # case will be for tests executed with beaker, for which you will want
+      # to pass in the dashboard for initialization. The other parameter that
+      # you can pass in optionally is credentials, if you wish to get a web
+      # session and use that to talk to various other parts of PE.
+      #
+      # If you are using this class outside of beaker, you can initialize an
+      # object without any parameters and supply your own dashboard as a String,
+      # credentials, Faraday connection object, and ssl parameters. Note that
+      # this is largely untested. Use outside of a Beaker test run at your own
+      # risk.
+      #
+      # @param credentials(Hash optional) Provide credentials if you wish to
+      #   communicate through the UI proxy.
+      def initialize(host, credentials=nil, log_level=Logger::DEBUG, log_body=true)
+        @credentials = Credentials.new(credentials[:login],
+                                       credentials[:password]) if credentials
+        super(host, log_level, log_body)
+      end
+
+      def set_url_prefix(connection=self.connection)
+        connection.url_prefix.port = 4433
+        super(connection)
+      end
+
+      # This is overridden from the parent class; in the case of
+      # ConsoleDispatcher objects, there are often cases where the Dispatcher is
+      # not a certificate dispatcher, but representing an LDAP or local user. If
+      # credentials are supplied during initialization, then this overrides the
+      # parent class and only acquires a ca_cert.
+      def acquire_ssl_components(host=self.host)
+        if credentials == nil
+          super(host)
+        else
+          if !host.is_a?(Unix::Host)
+            raise 'Can only acquire SSL certs if the host is a Unix::Host'
+          end
+         acquire_ca_cert(host)
+        end
+      end
+
+      def signin(login=self.credentials.login, password=self.credentials.password)
+        response = @connection.post "/auth/login" do |request|
+          request.headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8'
+          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
+        # 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
+
+      def reset_local_user_password(token, new_password)
+        @connection.post "https://#{host}/auth/reset" do |request|
+          request.headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8'
+          request.body = "password=#{new_password}&token=#{token}"
+          connection.port = 443
+        end
+        set_url_prefix
+      end
+
+    end
+  end
+end

data/lib/scooter/httpdispatchers/httpdispatcher.rb

@@ -0,0 +1,168 @@
+module Scooter
+  module HttpDispatchers
+
+    require 'scooter/httpdispatchers/code_manager'
+    require 'scooter/middleware/rbac_auth_token'
+
+    # <i>HttpDispatcher</i> is the base class to extend when constructing
+    # service specific objects. It contains specific logic to extract out
+    # certificates from Beaker hosts provided as the host argument.
+    # You can directly instantiate from this class if you would like only this
+    # 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
+
+
+      attr_accessor :connection, :host, :ssl, :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
+      # Dispatcher if it is passed a Unix Host.
+      #
+      # If it is only passed a String, than it is up to the caller to correctly
+      # configure the connection object to be configured correctly. Support for
+      # Strings is experimental for now; it may be deprecated if there is no
+      # feedback indicating that this functionality is being used.
+      #
+      # @param host(Unix::Host) The beaker host object you wish to communicate
+      #   with.
+      # @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)
+        @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"
+        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
+        # old HTTP. This should have no effect on any other middleware, as HTTPS
+        # is just HTTP subclassed with different defaults.
+        @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)
+        Faraday.new do |conn|
+          conn.request :rbac_auth_token, self
+          conn.request :json
+
+          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.use :cookie_jar
+
+          conn.adapter :net_http
+        end
+      end
+
+      def set_url_prefix(connection=self.connection)
+        if host.is_a?(Unix::Host)
+          connection.url_prefix.host = is_resolvable ? host.hostname : Scooter::Utilities::BeakerUtilities.get_public_ip(host)
+        else
+          connection.url_prefix.host = host
+        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
+          Resolv.getaddress(host.hostname)
+          true
+        rescue Resolv::ResolvError
+          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