nucleus 0.1.0

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

@@ -0,0 +1,108 @@
+module Nucleus
+  module Adapters
+    module V1
+      class OpenshiftV2 < Stub
+        module Application
+          # @see Stub#applications
+          def applications
+            get('/applications').body[:data].collect { |application| to_nucleus_app(application) }
+          end
+
+          # @see Stub#application
+          def application(application_id)
+            to_nucleus_app(get("/application/#{app_id_by_name(application_id)}").body[:data])
+          end
+
+          # Creates the Openshift application and enables scaling by default.
+          # @see Stub#create_application
+          def create_application(application_entity)
+            # handle runtimes / cartridges
+            fail_with(:only_one_runtime) if application_entity[:runtimes].length > 1
+            fail_with(:must_have_runtime) if application_entity[:runtimes].length == 0
+            application_entity[:cartridge] = cartridge(application_entity.delete(:runtimes)[0])
+
+            # updates the application with a valid region identity
+            retrieve_region(application_entity) if application_entity.key?(:region)
+
+            # enable application scaling by default
+            application_entity[:scale] = true unless application_entity.key?(:scale)
+            created_application = post("/domains/#{app_domain}/applications", body: application_entity).body
+            # now make sure we keep at least 2 deployments, allows proper identification of application state
+            updated_application = put("/application/#{created_application[:data][:id]}",
+                                      body: { keep_deployments: 2, auto_deploy: false }).body
+            to_nucleus_app(updated_application[:data])
+          end
+
+          # @see Stub#delete_application
+          def delete_application(application_id)
+            delete("/applications/#{app_id_by_name(application_id)}")
+          end
+
+          private
+
+          def app_id_by_name(application_name_or_id)
+            unless application_name_or_id.length == 24 && application_name_or_id.match(/[0-9a-f]{24}/)
+              response = get("/domains/#{app_domain}/applications/#{application_name_or_id}", expects: [200, 404])
+              return response.body[:data][:id] if response.status == 200
+            end
+            # presumably already is an application id
+            application_name_or_id
+          end
+
+          def cartridge(runtime)
+            cartridges = get('/cartridges').body[:data]
+            matched_cartridges, partial_matches = matching_cartridges(cartridges, runtime)
+
+            fail_with(:ambiguous_runtime, [runtime, matched_cartridges]) if matched_cartridges.length > 1
+            return matched_cartridges[0][:name] unless matched_cartridges.empty?
+            fail_with(:invalid_runtime, [runtime]) if partial_matches.empty?
+
+            latest = -1
+            partial_matches.each { |v| latest = v if v.to_f > latest.to_f }
+            matched_cartridges.push(cartridges.find { |cartridge| cartridge[:name] == "#{runtime}-#{latest}" })
+            log.info("Selected cartridge '#{matched_cartridges.last[:name]}' to match '#{runtime}'")
+            matched_cartridges.last[:name]
+          end
+
+          def matching_cartridges(cartridges, runtime)
+            partial_matches = []
+            matches = cartridges.find_all do |cartridge|
+              if cartridge[:type] != 'standalone'
+                false
+              elsif cartridge[:name] == runtime
+                true
+              else
+                # is the name partially valid?
+                matches = cartridge[:name].match(/(\w+)-([\.\d]+)/)
+                # push the version so that we can finally choose the latest version
+                partial_matches.push(matches[2]) if matches[1] == runtime
+                # nevertheless at first the cartridge is invalid
+                false
+              end
+            end
+            [matches, partial_matches]
+          end
+
+          def to_nucleus_app(app, gear_groups = nil, deployments = nil)
+            gear_groups = load_gears(app[:id]) unless gear_groups
+            deployments = load_deployments(app[:id]) unless deployments
+
+            app[:release_version] = active_deployment(app, deployments)[:sha1]
+            app[:state] = application_state(app, gear_groups, deployments)
+            app[:web_url] = app.delete :app_url
+            app[:autoscaled] = app.delete :scalable
+            app[:region] = gear_groups[0][:gears][0][:region]
+            app[:instances] = app.delete :gear_count
+            app[:created_at] = app.delete :creation_time
+            # applications can't be updated, use creation timestamp
+            app[:updated_at] = app[:created_at]
+            app[:active_runtime] = app.delete :framework
+            # no additional runtimes, only one fixed (active) runtime per application
+            app[:runtimes] = [app[:active_runtime]]
+            app
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Nucleus
+  module Adapters
+    module V1
+      class OpenshiftV2 < Stub
+        # Authentication functionality to support the Openshift V2 API
+        module Authentication
+          # @see Stub#auth_client
+          def auth_client
+            HttpBasicAuthClient.new @check_certificates do |verify_ssl, headers|
+              # auth verification block
+              headers['Accept'] = 'application/json; version=1.7'
+              result = Excon.new("#{@endpoint_url}/user", ssl_verify_peer: verify_ssl).get(headers: headers)
+              # Openshift returns 401 for invalid credentials --> auth failed, return false
+              result.status != 401
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module Nucleus
+  module Adapters
+    module V1
+      class OpenshiftV2 < Stub
+        module Data
+          # @see Stub#deploy
+          def deploy(application_id, file, file_compression_format)
+            app_id = app_id_by_name(application_id)
+            app = get("/application/#{app_id}").body[:data]
+            app_state = application_state(app)
+            account = get('/user').body[:data]
+            repo_name = "nucleus.app.repo.openshift_v2.deploy.#{application_id}.#{SecureRandom.uuid}"
+            # clone, extract, push and finally delete cloned repository (sync)
+            with_ssh_key do
+              GitDeployer.new(repo_name, app[:git_url], account[:email]).deploy(file, file_compression_format)
+            end
+
+            # auto deployment could be active for applications not created with Nucleus
+            return if app[:auto_deploy]
+
+            build_deployment(app_id)
+
+            return unless app_state == Enums::ApplicationStates::CREATED
+
+            # and finally stop so we don't get to see the sample application and switch to the deployed state
+            send_event(application_id, 'stop')
+          end
+
+          # @see Stub#download
+          def download(application_id, compression_format)
+            # Only possible with git
+            app = get("/application/#{app_id_by_name(application_id)}").body[:data]
+            if application_state(app) == Enums::ApplicationStates::CREATED
+              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before data can be downloaded'
+            end
+            # compress files to archive but exclude the .git repo
+            repo_name = "nucleus.app.repo.openshift_v2.download.#{application_id}.#{SecureRandom.uuid}"
+            with_ssh_key do
+              GitDeployer.new(repo_name, app[:git_url], nil).download(compression_format, true)
+            end
+          end
+
+          # @see Stub#rebuild
+          def rebuild(application_id)
+            app_id = app_id_by_name(application_id)
+            app = get("/application/#{app_id}").body[:data]
+            if application_state(app) == Enums::ApplicationStates::CREATED
+              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before data can be rebuild'
+            end
+
+            account = get('/user').body[:data]
+            repo_name = "nucleus.app.repo.openshift_v2.rebuild.#{application_id}.#{SecureRandom.uuid}"
+
+            with_ssh_key do
+              GitDeployer.new(repo_name, app[:git_url], account[:email]).trigger_build
+            end
+
+            # if auto deployment ist disabled, we must also trigger a clean build
+            build_deployment(app_id) unless app[:auto_deploy]
+
+            # return with updated application
+            application(application_id)
+          end
+
+          private
+
+          def build_deployment(app_id)
+            # deploy
+            post("/application/#{app_id}/deployments", body: { force_clean_build: true })
+          end
+
+          def with_ssh_key
+            # 409 Conflict:
+            # - 120: SSH key with name #{name} already exists. Use a different name or delete conflicting key and retry
+            # - 121: Given public key is already in use. Use different key or delete conflicting key and retry.
+
+            # load ssh key into Openshift
+            matches = nucleus_config.ssh.handler.public_key.match(/(.*)\s{1}(.*)\s{1}(.*)/)
+            key_name = register_key(matches[1], matches[2])
+            return yield
+          ensure
+            # unload ssh key, allow 404 if the key couldn't be registered at first
+            delete("/user/keys/#{key_name}", expects: [200, 204, 404]) if key_name
+          end
+
+          def register_key(type, key)
+            key_name = "nucleus-#{SecureRandom.uuid}"
+            # ignore if the key was already assigned to a different name (status == 409 && exit_code == 121)
+            post('/user/keys', body: { name: key_name, type: type, content: key }, expects: [201, 409])
+            key_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Nucleus
+  module Adapters
+    module V1
+      class OpenshiftV2 < Stub
+        module Domains
+          # @see Stub#domains
+          def domains(application_id)
+            domains = get("/application/#{app_id_by_name(application_id)}/aliases").body[:data]
+            domains.collect { |domain| to_nucleus_domain(domain) }
+          end
+
+          # @see Stub#domain
+          def domain(application_id, domain_id)
+            to_nucleus_domain get("/application/#{app_id_by_name(application_id)}/alias/#{domain_id}").body[:data]
+          end
+
+          # @see Stub#create_domain
+          def create_domain(application_id, domain_entity)
+            to_nucleus_domain post("/application/#{app_id_by_name(application_id)}/aliases",
+                                   body: { id: domain_entity[:name] }).body[:data]
+          end
+
+          # @see Stub#delete_domain
+          def delete_domain(application_id, domain_id)
+            delete("/application/#{app_id_by_name(application_id)}/alias/#{domain_id}")
+          end
+
+          private
+
+          def to_nucleus_domain(domain)
+            { id: domain[:id], name: domain[:id], created_at: nil, updated_at: nil }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +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

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

@@ -0,0 +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

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

@@ -0,0 +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