nucleus 0.2.0 → 0.3.1

data/lib/nucleus/adapters/v1/openshift_v2/lifecycle.rb

@@ -1,60 +1,60 @@
-module Nucleus
-  module Adapters
-    module V1
-      class OpenshiftV2 < Stub
-        module Lifecycle
-          # @see Stub#start
-          def start(application_id)
-            # if app is only deployed, we must first restore the latest deployment
-            id = app_id_by_name(application_id)
-            validate_start_requirements(id, 'start')
-            to_nucleus_app(send_event(id, 'start'))
-          end
-
-          # @see Stub#stop
-          def stop(application_id)
-            id = app_id_by_name(application_id)
-            unless deployed?(id)
-              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before it can be stopped'
-            end
-            to_nucleus_app(send_event(id, 'stop'))
-          end
-
-          # @see Stub#restart
-          def restart(application_id)
-            id = app_id_by_name(application_id)
-            validate_start_requirements(id, 'restart')
-            to_nucleus_app(send_event(id, 'restart'))
-          end
-
-          private
-
-          def validate_start_requirements(id, action)
-            state = application_state(get("/application/#{id}").body[:data])
-            if state == Enums::ApplicationStates::DEPLOYED
-              activate(id, latest_deployment(id)[:id])
-            elsif state == Enums::ApplicationStates::CREATED
-              fail Errors::SemanticAdapterRequestError, "Application must be deployed before it can be #{action}ed"
-            end
-          end
-
-          def deployed?(application_id)
-            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
-            application_state(app) != Enums::ApplicationStates::CREATED
-          end
-
-          # Send the event and trigger an action.
-          # @return [Hash] Openshift application data
-          def send_event(application_id, event, options = {})
-            options[:event] = event
-            post("/application/#{app_id_by_name(application_id)}/events", body: options).body[:data]
-          end
-
-          def activate(application_id, deployment_id)
-            send_event(application_id, 'activate', deployment_id: deployment_id)
-          end
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      class OpenshiftV2 < Stub
+        module Lifecycle
+          # @see Stub#start
+          def start(application_id)
+            # if app is only deployed, we must first restore the latest deployment
+            id = app_id_by_name(application_id)
+            validate_start_requirements(id, 'start')
+            to_nucleus_app(send_event(id, 'start'))
+          end
+
+          # @see Stub#stop
+          def stop(application_id)
+            id = app_id_by_name(application_id)
+            unless deployed?(id)
+              raise Errors::SemanticAdapterRequestError, 'Application must be deployed before it can be stopped'
+            end
+            to_nucleus_app(send_event(id, 'stop'))
+          end
+
+          # @see Stub#restart
+          def restart(application_id)
+            id = app_id_by_name(application_id)
+            validate_start_requirements(id, 'restart')
+            to_nucleus_app(send_event(id, 'restart'))
+          end
+
+          private
+
+          def validate_start_requirements(id, action)
+            state = application_state(get("/application/#{id}").body[:data])
+            if state == Enums::ApplicationStates::DEPLOYED
+              activate(id, latest_deployment(id)[:id])
+            elsif state == Enums::ApplicationStates::CREATED
+              raise Errors::SemanticAdapterRequestError, "Application must be deployed before it can be #{action}ed"
+            end
+          end
+
+          def deployed?(application_id)
+            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
+            application_state(app) != Enums::ApplicationStates::CREATED
+          end
+
+          # Send the event and trigger an action.
+          # @return [Hash] Openshift application data
+          def send_event(application_id, event, options = {})
+            options[:event] = event
+            post("/application/#{app_id_by_name(application_id)}/events", body: options).body[:data]
+          end
+
+          def activate(application_id, deployment_id)
+            send_event(application_id, 'activate', deployment_id: deployment_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nucleus/adapters/v1/openshift_v2/logs.rb

@@ -1,106 +1,106 @@
-require 'time'
-require 'net/ssh'
-
-module Nucleus
-  module Adapters
-    module V1
-      class OpenshiftV2 < Stub
-        module Logs
-          # @see Stub#logs
-          def logs(application_id)
-            # fails with 404 if application is not available
-            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
-            # ssh uri
-            uri = ssh_uri(app)
-
-            with_ssh_key do
-              remote_log_files(uri, app[:creation_time])
-            end
-          end
-
-          # @see Stub#log?
-          def log?(application_id, log_id)
-            # fails with 404 if application is not available
-            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
-            # ssh uri
-            uri = ssh_uri(app)
-
-            with_ssh_key do
-              remote_log_file?(uri)
-            end
-          end
-
-          # @see Stub#tail
-          def tail(application_id, log_id, stream)
-            # TODO: implement me
-            # remote_cmd = "tail#{options.opts ? ' --opts ' + Base64::encode64(options.opts).chomp : ''} #{file_glob}"
-            # ssh_cmd = "ssh -t #{uuid}@#{host} '#{remote_cmd}'"
-            fail NOT_IMPLEMENTED_ERROR
-          end
-
-          # @see Stub#log_entries
-          def log_entries(application_id, log_id)
-            # fails with 404 if application is not available
-            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
-            # ssh uri
-            uri = ssh_uri(app)
-
-            with_ssh_key do
-              remote_log_entries(uri, application_id, log_id)
-            end
-          end
-
-          private
-
-          def ssh_uri(application)
-            URI.parse(application[:ssh_url])
-          end
-
-          def remote_log_files(uri, app_creation_time)
-            available_log_files = []
-            # ssh into main instance
-            Net::SSH.start(uri.host, uri.user, keys: [nucleus_config.ssh.handler.key_file]) do |ssh|
-              # https://developers.openshift.com/en/managing-log-files.html#log-location
-              log_files = ssh.exec!('ls $OPENSHIFT_LOG_DIR')
-
-              log_files.split("\n").each do |file|
-                updated_at = ssh.exec!("date -r $OPENSHIFT_LOG_DIR/#{file}")
-                updated_at = Time.parse(updated_at).utc.iso8601
-                # TODO: no unified naming among cartridges: ApplicationLogfileType::APPLICATION by default.
-                available_log_files.push(id: File.basename(file, '.*'), name: file,
-                                         type: Enums::ApplicationLogfileType::APPLICATION,
-                                         created_at: app_creation_time, updated_at: updated_at)
-              end
-            end
-            available_log_files
-          end
-
-          def remote_log_file?(uri)
-            Net::SSH.start(uri.host, uri.user, keys: [nucleus_config.ssh.handler.key_file]) do |ssh|
-              remote_file_exists?(ssh, "#{log_id}.log")
-            end
-          end
-
-          def remote_log_entries(uri, app_id, log_id)
-            Net::SSH.start(uri.host, uri.user, keys: [nucleus_config.ssh.handler.key_file]) do |ssh|
-              # log exists?
-              unless remote_file_exists?(ssh, "#{log_id}.log")
-                fail Errors::AdapterResourceNotFoundError,
-                     "Invalid log file '#{log_id}', not available for application '#{app_id}'"
-              end
-              # process log
-              log = ssh.exec!("cat $OPENSHIFT_LOG_DIR/#{log_id}.log")
-              log.split("\n")
-            end
-          end
-
-          def remote_file_exists?(connection, file)
-            # file exists? 1 : 0
-            exists = connection.exec!("[ ! -f $OPENSHIFT_LOG_DIR/#{file} ]; echo $?").strip
-            exists == '1'
-          end
-        end
-      end
-    end
-  end
-end
+require 'time'
+require 'net/ssh'
+
+module Nucleus
+  module Adapters
+    module V1
+      class OpenshiftV2 < Stub
+        module Logs
+          # @see Stub#logs
+          def logs(application_id)
+            # fails with 404 if application is not available
+            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
+            # ssh uri
+            uri = ssh_uri(app)
+
+            with_ssh_key do
+              remote_log_files(uri, app[:creation_time])
+            end
+          end
+
+          # @see Stub#log?
+          def log?(application_id, log_id)
+            # fails with 404 if application is not available
+            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
+            # ssh uri
+            uri = ssh_uri(app)
+
+            with_ssh_key do
+              remote_log_file?(uri)
+            end
+          end
+
+          # @see Stub#tail
+          def tail(application_id, log_id, stream)
+            # TODO: implement me
+            # remote_cmd = "tail#{options.opts ? ' --opts ' + Base64::encode64(options.opts).chomp : ''} #{file_glob}"
+            # ssh_cmd = "ssh -t #{uuid}@#{host} '#{remote_cmd}'"
+            raise NOT_IMPLEMENTED_ERROR
+          end
+
+          # @see Stub#log_entries
+          def log_entries(application_id, log_id)
+            # fails with 404 if application is not available
+            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
+            # ssh uri
+            uri = ssh_uri(app)
+
+            with_ssh_key do
+              remote_log_entries(uri, application_id, log_id)
+            end
+          end
+
+          private
+
+          def ssh_uri(application)
+            URI.parse(application[:ssh_url])
+          end
+
+          def remote_log_files(uri, app_creation_time)
+            available_log_files = []
+            # ssh into main instance
+            Net::SSH.start(uri.host, uri.user, keys: [nucleus_config.ssh.handler.key_file]) do |ssh|
+              # https://developers.openshift.com/en/managing-log-files.html#log-location
+              log_files = ssh.exec!('ls $OPENSHIFT_LOG_DIR')
+
+              log_files.split("\n").each do |file|
+                updated_at = ssh.exec!("date -r $OPENSHIFT_LOG_DIR/#{file}")
+                updated_at = Time.parse(updated_at).utc.iso8601
+                # TODO: no unified naming among cartridges: ApplicationLogfileType::APPLICATION by default.
+                available_log_files.push(id: File.basename(file, '.*'), name: file,
+                                         type: Enums::ApplicationLogfileType::APPLICATION,
+                                         created_at: app_creation_time, updated_at: updated_at)
+              end
+            end
+            available_log_files
+          end
+
+          def remote_log_file?(uri)
+            Net::SSH.start(uri.host, uri.user, keys: [nucleus_config.ssh.handler.key_file]) do |ssh|
+              remote_file_exists?(ssh, "#{log_id}.log")
+            end
+          end
+
+          def remote_log_entries(uri, app_id, log_id)
+            Net::SSH.start(uri.host, uri.user, keys: [nucleus_config.ssh.handler.key_file]) do |ssh|
+              # log exists?
+              unless remote_file_exists?(ssh, "#{log_id}.log")
+                raise Errors::AdapterResourceNotFoundError,
+                      "Invalid log file '#{log_id}', not available for application '#{app_id}'"
+              end
+              # process log
+              log = ssh.exec!("cat $OPENSHIFT_LOG_DIR/#{log_id}.log")
+              log.split("\n")
+            end
+          end
+
+          def remote_file_exists?(connection, file)
+            # file exists? 1 : 0
+            exists = connection.exec!("[ ! -f $OPENSHIFT_LOG_DIR/#{file} ]; echo $?").strip
+            exists == '1'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nucleus/adapters/v1/openshift_v2/openshift_v2.rb

@@ -1,125 +1,125 @@
-module Nucleus
-  module Adapters
-    module V1
-      # @see https://access.redhat.com/documentation/en-US/OpenShift/2.0/html/REST_API_Guide The Openshift V2
-      #   API documentation
-      class OpenshiftV2 < Stub
-        include Nucleus::Logging
-        include Nucleus::Adapters::V1::OpenshiftV2::Authentication
-        include Nucleus::Adapters::V1::OpenshiftV2::Application
-        include Nucleus::Adapters::V1::OpenshiftV2::AppStates
-        include Nucleus::Adapters::V1::OpenshiftV2::Data
-        include Nucleus::Adapters::V1::OpenshiftV2::Domains
-        include Nucleus::Adapters::V1::OpenshiftV2::Lifecycle
-        include Nucleus::Adapters::V1::OpenshiftV2::Logs
-        include Nucleus::Adapters::V1::OpenshiftV2::Regions
-        include Nucleus::Adapters::V1::OpenshiftV2::Scaling
-        include Nucleus::Adapters::V1::OpenshiftV2::SemanticErrors
-        include Nucleus::Adapters::V1::OpenshiftV2::Services
-        include Nucleus::Adapters::V1::OpenshiftV2::Vars
-
-        def initialize(endpoint_url, endpoint_app_domain = nil, check_certificates = true)
-          super(endpoint_url, endpoint_app_domain, check_certificates)
-        end
-
-        def handle_error(error_response)
-          # some error messages do not have the proper error message format
-          errors = openshift_errors(error_response)
-          if error_response.status == 404 && errors.any? { |e| e[:text].include?('not found') }
-            fail Errors::AdapterResourceNotFoundError, errors.collect { |e| e[:text] }.join(' ')
-          elsif error_response.status == 422
-            fail Errors::SemanticAdapterRequestError, errors.collect { |e| e[:text] }.join(' ')
-          elsif error_response.status == 503
-            fail Errors::PlatformUnavailableError, 'The Openshift API is currently not available'
-          elsif error_response.status == 504
-            fail Errors::PlatformTimeoutError, 'The Openshift API did not receive information from it\'s slaves. '\
-              'Most likely the request is still being executed. Please make sure to analyse whether the request '\
-              'was successful before invoking further actions.'
-          end
-          # error still unhandled, will result in a 500, server error
-          log.warn "Openshift error still unhandled: #{error_response}"
-        end
-
-        def openshift_errors(error_response)
-          if error_response.body.is_a?(Hash) && error_response.body.key?(:messages)
-            error_response.body[:messages].collect { |error| { field: error[:field], text: error[:text] } }
-          else
-            []
-          end
-        end
-
-        private
-
-        def headers
-          super.merge('Accept' => 'application/json; version=1.7', 'Content-Type' => 'application/json')
-        end
-
-        def app_domain
-          # A user always has only 1 domain as described on:
-          # https://access.redhat.com/documentation/en-US/OpenShift/2.0/html/REST_API_Guide/chap-API_Guide-Domains.html
-          user_domains = get('/domains').body[:data]
-          fail_with(:no_user_domain) if user_domains.empty?
-          user_domains.first[:name]
-        end
-
-        def original_deployment(app, deployments = nil)
-          # TODO: this is actually quite scary, could easily fail with wrong timing
-          # What are the alternatives?
-          # 1) Clone git repo and lookup commits --> insanely slow
-          # 2) Identify initial commits by sha1 key --> would require collection of allowed values, which may change!
-          deployments = load_deployments(app[:id]) unless deployments
-          deployments.find do |deployment|
-            diff = (Time.parse(deployment[:created_at]).to_i - Time.parse(app[:creation_time]).to_i).abs
-            log.debug "OS deployment time diff: #{diff}"
-            diff < 20 && deployment[:force_clean_build] == false &&
-              deployment[:hot_deploy] == false && deployment[:ref] == 'master'
-          end
-        end
-
-        def latest_deployment(application_id, deployments = nil)
-          deployments = load_deployments(application_id) unless deployments
-          latest = nil
-          latest_ts = nil
-          deployments.each do |deployment|
-            ts = Time.parse(deployment[:created_at]).to_i
-            if latest.nil? || ts > latest_ts
-              latest = deployment
-              latest_ts = ts
-            end
-          end
-          latest
-        end
-
-        def active_deployment(app, deployments = nil)
-          deployments = load_deployments(app[:id]) unless deployments
-          active = nil
-          active_ts = nil
-          deployments.each do |deployment|
-            ts = Time.parse(last_activation(deployment[:activations])).to_i
-            if active.nil? || ts > active_ts
-              active = deployment
-              active_ts = ts
-            end
-          end
-          active
-        end
-
-        def last_activation(activations)
-          latest = nil
-          activations.each do |activation|
-            latest = activation if latest.nil? || Time.parse(activation).to_i > Time.parse(latest).to_i
-          end
-          latest
-        end
-
-        def load_deployments(application_id)
-          get("/application/#{application_id}/deployments").body[:data]
-        end
-
-        def load_gears(application_id)
-          get("/application/#{application_id}/gear_groups").body[:data]
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      # @see https://access.redhat.com/documentation/en-US/OpenShift/2.0/html/REST_API_Guide The Openshift V2
+      #   API documentation
+      class OpenshiftV2 < Stub
+        include Nucleus::Logging
+        include Nucleus::Adapters::V1::OpenshiftV2::Authentication
+        include Nucleus::Adapters::V1::OpenshiftV2::Application
+        include Nucleus::Adapters::V1::OpenshiftV2::AppStates
+        include Nucleus::Adapters::V1::OpenshiftV2::Data
+        include Nucleus::Adapters::V1::OpenshiftV2::Domains
+        include Nucleus::Adapters::V1::OpenshiftV2::Lifecycle
+        include Nucleus::Adapters::V1::OpenshiftV2::Logs
+        include Nucleus::Adapters::V1::OpenshiftV2::Regions
+        include Nucleus::Adapters::V1::OpenshiftV2::Scaling
+        include Nucleus::Adapters::V1::OpenshiftV2::SemanticErrors
+        include Nucleus::Adapters::V1::OpenshiftV2::Services
+        include Nucleus::Adapters::V1::OpenshiftV2::Vars
+
+        def initialize(endpoint_url, endpoint_app_domain = nil, check_certificates = true)
+          super(endpoint_url, endpoint_app_domain, check_certificates)
+        end
+
+        def handle_error(error_response)
+          # some error messages do not have the proper error message format
+          errors = openshift_errors(error_response)
+          if error_response.status == 404 && errors.any? { |e| e[:text].include?('not found') }
+            raise Errors::AdapterResourceNotFoundError, errors.collect { |e| e[:text] }.join(' ')
+          elsif error_response.status == 422
+            raise Errors::SemanticAdapterRequestError, errors.collect { |e| e[:text] }.join(' ')
+          elsif error_response.status == 503
+            raise Errors::PlatformUnavailableError, 'The Openshift API is currently not available'
+          elsif error_response.status == 504
+            raise Errors::PlatformTimeoutError, 'The Openshift API did not receive information from it\'s slaves. '\
+              'Most likely the request is still being executed. Please make sure to analyse whether the request '\
+              'was successful before invoking further actions.'
+          end
+          # error still unhandled, will result in a 500, server error
+          log.warn "Openshift error still unhandled: #{error_response}"
+        end
+
+        def openshift_errors(error_response)
+          if error_response.body.is_a?(Hash) && error_response.body.key?(:messages)
+            error_response.body[:messages].collect { |error| { field: error[:field], text: error[:text] } }
+          else
+            []
+          end
+        end
+
+        private
+
+        def headers
+          super.merge('Accept' => 'application/json; version=1.7', 'Content-Type' => 'application/json')
+        end
+
+        def app_domain
+          # A user always has only 1 domain as described on:
+          # https://access.redhat.com/documentation/en-US/OpenShift/2.0/html/REST_API_Guide/chap-API_Guide-Domains.html
+          user_domains = get('/domains').body[:data]
+          fail_with(:no_user_domain) if user_domains.empty?
+          user_domains.first[:name]
+        end
+
+        def original_deployment(app, deployments = nil)
+          # TODO: this is actually quite scary, could easily fail with wrong timing
+          # What are the alternatives?
+          # 1) Clone git repo and lookup commits --> insanely slow
+          # 2) Identify initial commits by sha1 key --> would require collection of allowed values, which may change!
+          deployments = load_deployments(app[:id]) unless deployments
+          deployments.find do |deployment|
+            diff = (Time.parse(deployment[:created_at]).to_i - Time.parse(app[:creation_time]).to_i).abs
+            log.debug "OS deployment time diff: #{diff}"
+            diff < 20 && deployment[:force_clean_build] == false &&
+              deployment[:hot_deploy] == false && deployment[:ref] == 'master'
+          end
+        end
+
+        def latest_deployment(application_id, deployments = nil)
+          deployments = load_deployments(application_id) unless deployments
+          latest = nil
+          latest_ts = nil
+          deployments.each do |deployment|
+            ts = Time.parse(deployment[:created_at]).to_i
+            if latest.nil? || ts > latest_ts
+              latest = deployment
+              latest_ts = ts
+            end
+          end
+          latest
+        end
+
+        def active_deployment(app, deployments = nil)
+          deployments = load_deployments(app[:id]) unless deployments
+          active = nil
+          active_ts = nil
+          deployments.each do |deployment|
+            ts = Time.parse(last_activation(deployment[:activations])).to_i
+            if active.nil? || ts > active_ts
+              active = deployment
+              active_ts = ts
+            end
+          end
+          active
+        end
+
+        def last_activation(activations)
+          latest = nil
+          activations.each do |activation|
+            latest = activation if latest.nil? || Time.parse(activation).to_i > Time.parse(latest).to_i
+          end
+          latest
+        end
+
+        def load_deployments(application_id)
+          get("/application/#{application_id}/deployments").body[:data]
+        end
+
+        def load_gears(application_id)
+          get("/application/#{application_id}/gear_groups").body[:data]
+        end
+      end
+    end
+  end
+end