nucleus 0.2.0 → 0.3.1

data/lib/nucleus/adapters/v1/heroku/app_states.rb

@@ -1,57 +1,57 @@
-module Nucleus
-  module Adapters
-    module V1
-      class Heroku < Stub
-        # AppStates for Heroku, or the logic to determine the current application state
-        module AppStates
-          private
-
-          def application_state(app, retrieved_dynos = nil)
-            # 1: created, both repo and slug are nil
-            return Enums::ApplicationStates::CREATED unless repo_or_slug_content?(app)
-
-            # all subsequent states require dynos to be determined
-            dynos = retrieved_dynos ? retrieved_dynos : dynos(app[:id])
-
-            # 2: deployed if no dynos assigned
-            return Enums::ApplicationStates::DEPLOYED if dynos.empty?
-
-            # 3: stopped if maintenance
-            return Enums::ApplicationStates::STOPPED if app[:maintenance] || dynos_not_running?(dynos)
-
-            # 4: running if no maintenance (checked above) and at least ony dyno is up
-            return Enums::ApplicationStates::RUNNING if dyno_states(dynos).include?('up')
-
-            # 5: idle if all dynos are idling
-            return Enums::ApplicationStates::IDLE if dynos_idle?(dynos)
-
-            # arriving here the above states do not catch all states of the Heroku app, which should not happen ;-)
-            log.debug("Faild to determine state for: #{app}, #{dynos}")
-            fail Errors::UnknownAdapterCallError, 'Could not determine app state. Please verify the Heroku adapter'
-          end
-
-          def repo_or_slug_content?(app)
-            return true if !app[:repo_size].nil? && app[:repo_size].to_i > 0
-            return true if !app[:slug_size].nil? && app[:slug_size].to_i > 0
-            false
-          end
-
-          def dyno_states(dynos)
-            dynos.collect { |dyno| dyno[:state] }.compact.uniq
-          end
-
-          def dynos_idle?(dynos)
-            dyno_states = dyno_states(dynos)
-            dyno_states.length == 1 && dyno_states[0] == 'idle'
-          end
-
-          def dynos_not_running?(dynos)
-            dynos.empty? || dyno_states(dynos).reject do |state|
-              %w(crashed down starting).include?(state)
-            end.empty?
-          end
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        # AppStates for Heroku, or the logic to determine the current application state
+        module AppStates
+          private
+
+          def application_state(app, retrieved_dynos = nil)
+            # 1: created, both repo and slug are nil
+            return Enums::ApplicationStates::CREATED unless repo_or_slug_content?(app)
+
+            # all subsequent states require dynos to be determined
+            dynos = retrieved_dynos ? retrieved_dynos : dynos(app[:id])
+
+            # 2: deployed if no dynos assigned
+            return Enums::ApplicationStates::DEPLOYED if dynos.empty?
+
+            # 3: stopped if maintenance
+            return Enums::ApplicationStates::STOPPED if app[:maintenance] || dynos_not_running?(dynos)
+
+            # 4: running if no maintenance (checked above) and at least ony dyno is up
+            return Enums::ApplicationStates::RUNNING if dyno_states(dynos).include?('up')
+
+            # 5: idle if all dynos are idling
+            return Enums::ApplicationStates::IDLE if dynos_idle?(dynos)
+
+            # arriving here the above states do not catch all states of the Heroku app, which should not happen ;-)
+            log.debug("Faild to determine state for: #{app}, #{dynos}")
+            raise Errors::UnknownAdapterCallError, 'Could not determine app state. Please verify the Heroku adapter'
+          end
+
+          def repo_or_slug_content?(app)
+            return true if !app[:repo_size].nil? && app[:repo_size].to_i > 0
+            return true if !app[:slug_size].nil? && app[:slug_size].to_i > 0
+            false
+          end
+
+          def dyno_states(dynos)
+            dynos.collect { |dyno| dyno[:state] }.compact.uniq
+          end
+
+          def dynos_idle?(dynos)
+            dyno_states = dyno_states(dynos)
+            dyno_states.length == 1 && dyno_states[0] == 'idle'
+          end
+
+          def dynos_not_running?(dynos)
+            dynos.empty? || dyno_states(dynos).reject do |state|
+              %w(crashed down starting).include?(state)
+            end.empty?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,78 +1,78 @@
-module Nucleus
-  module Adapters
-    module V1
-      class Heroku < Stub
-        module Data
-          # @see Stub#deploy
-          def deploy(application_id, file, file_compression_format)
-            app = get("/apps/#{application_id}").body
-            account = get('/account').body
-            repo_name = "nucleus.app.repo.heroku.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
-
-            return unless application_state(app) == Enums::ApplicationStates::CREATED
-            # instantly remove all initially added dynos to keep the 'deployed' state on first deployment
-            log.debug 'state before deployment was \'created\', scale web to 0'
-            scale_web(application_id, 0)
-          end
-
-          # @see Stub#download
-          def download(application_id, compression_format)
-            # Only possible with git, not with HTTP builds
-            app = get("/apps/#{application_id}").body
-            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.heroku.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 = get("/apps/#{application_id}").body
-            if application_state(app) == Enums::ApplicationStates::CREATED
-              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before data can be rebuild'
-            end
-
-            account = get('/account').body
-            repo_name = "nucleus.app.repo.heroku.rebuild.#{application_id}.#{SecureRandom.uuid}"
-
-            with_ssh_key do
-              GitDeployer.new(repo_name, app[:git_url], account[:email]).trigger_build
-            end
-
-            # return with updated application
-            application(application_id)
-          end
-
-          private
-
-          def with_ssh_key
-            # load ssh key into cloud control
-            matches = nucleus_config.ssh.handler.public_key.match(/(.*)\s{1}(.*)\s{1}(.*)/)
-            key_id = register_key(matches[1], matches[2])
-            return yield
-          ensure
-            # unload ssh key, allow 404 if the key couldn't be registered at first
-            delete("/account/keys/#{key_id}") if key_id
-          end
-
-          def register_key(type, key)
-            # skip if the key is already registered
-            installed_keys = get('/account/keys').body
-            return nil if installed_keys.any? { |installed_key| installed_key[:public_key].include?(key) }
-
-            key_name = "nucleus-#{SecureRandom.uuid}"
-            post('/account/keys', body: { public_key: [type, key, key_name].join(' ') }).body[:id]
-          end
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Data
+          # @see Stub#deploy
+          def deploy(application_id, file, file_compression_format)
+            app = get("/apps/#{application_id}").body
+            account = get('/account').body
+            repo_name = "nucleus.app.repo.heroku.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
+
+            return unless application_state(app) == Enums::ApplicationStates::CREATED
+            # instantly remove all initially added dynos to keep the 'deployed' state on first deployment
+            log.debug 'state before deployment was \'created\', scale web to 0'
+            scale_web(application_id, 0)
+          end
+
+          # @see Stub#download
+          def download(application_id, compression_format)
+            # Only possible with git, not with HTTP builds
+            app = get("/apps/#{application_id}").body
+            if application_state(app) == Enums::ApplicationStates::CREATED
+              raise 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.heroku.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 = get("/apps/#{application_id}").body
+            if application_state(app) == Enums::ApplicationStates::CREATED
+              raise Errors::SemanticAdapterRequestError, 'Application must be deployed before data can be rebuild'
+            end
+
+            account = get('/account').body
+            repo_name = "nucleus.app.repo.heroku.rebuild.#{application_id}.#{SecureRandom.uuid}"
+
+            with_ssh_key do
+              GitDeployer.new(repo_name, app[:git_url], account[:email]).trigger_build
+            end
+
+            # return with updated application
+            application(application_id)
+          end
+
+          private
+
+          def with_ssh_key
+            # load ssh key into cloud control
+            matches = nucleus_config.ssh.handler.public_key.match(/(.*)\s{1}(.*)\s{1}(.*)/)
+            key_id = register_key(matches[1], matches[2])
+            return yield
+          ensure
+            # unload ssh key, allow 404 if the key couldn't be registered at first
+            delete("/account/keys/#{key_id}") if key_id
+          end
+
+          def register_key(type, key)
+            # skip if the key is already registered
+            installed_keys = get('/account/keys').body
+            return nil if installed_keys.any? { |installed_key| installed_key[:public_key].include?(key) }
+
+            key_name = "nucleus-#{SecureRandom.uuid}"
+            post('/account/keys', body: { public_key: [type, key, key_name].join(' ') }).body[:id]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,146 +1,146 @@
-module Nucleus
-  module Adapters
-    module V1
-      # The {Heroku} adapter is designed to support the Heroku platform API.<br>
-      # <br>
-      # The Nucleus API is fully supported, there are no known issues.
-      # @see https://devcenter.heroku.com/articles/platform-api-reference Heroku Platform API
-      class Heroku < Stub
-        include Nucleus::Logging
-        include Nucleus::Adapters::V1::Heroku::Authentication
-        include Nucleus::Adapters::V1::Heroku::Application
-        include Nucleus::Adapters::V1::Heroku::AppStates
-        include Nucleus::Adapters::V1::Heroku::Buildpacks
-        include Nucleus::Adapters::V1::Heroku::Data
-        include Nucleus::Adapters::V1::Heroku::Domains
-        include Nucleus::Adapters::V1::Heroku::Logs
-        include Nucleus::Adapters::V1::Heroku::Lifecycle
-        include Nucleus::Adapters::V1::Heroku::Regions
-        include Nucleus::Adapters::V1::Heroku::Scaling
-        include Nucleus::Adapters::V1::Heroku::Services
-        include Nucleus::Adapters::V1::Heroku::SemanticErrors
-        include Nucleus::Adapters::V1::Heroku::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)
-          handle_422(error_response)
-          if error_response.status == 404 && error_response.body[:id] == 'not_found'
-            fail Errors::AdapterResourceNotFoundError, error_response.body[:message]
-          elsif error_response.status == 503
-            fail Errors::PlatformUnavailableError, 'The Heroku API is currently not responding'
-          end
-          # error still unhandled, will result in a 500, server error
-          log.warn "Heroku error still unhandled: #{error_response}"
-        end
-
-        def handle_422(error_response)
-          return unless error_response.status == 422
-          if error_response.body[:id] == 'invalid_params'
-            fail Errors::SemanticAdapterRequestError, error_response.body[:message]
-          elsif error_response.body[:id] == 'verification_required'
-            fail_with(:need_verification, [error_response.body[:message]])
-          end
-        end
-
-        private
-
-        def install_runtimes(application_id, runtimes)
-          runtime_instructions = runtimes.collect { |buildpack_url| { buildpack: buildpack_url } }
-          log.debug "Install runtimes: #{runtime_instructions}"
-          buildpack_instructions = { updates: runtime_instructions }
-          put("/apps/#{application_id}/buildpack-installations", body: buildpack_instructions)
-        end
-
-        def runtimes_to_install(application)
-          return [] unless application[:runtimes]
-          runtimes_to_install = []
-          application[:runtimes].each do |runtime_identifier|
-            # we do not need to install native buildpacks
-            # TODO: 2 options for heroku runtime handling
-            # a) skip native, fails when native required and not in list
-            # b) (current) use native, fails when others (additional) are in the list
-            # next if native_runtime?(runtime_identifier)
-            runtime_is_url = runtime_identifier =~ /\A#{URI.regexp}\z/
-            runtime_url = find_runtime(runtime_identifier)
-            runtime_is_valid = runtime_url || runtime_is_url
-            fail_with(:invalid_runtime, [runtime_identifier]) unless runtime_is_valid
-            # if runtime identifier is valid, we need to install the runtime
-            runtimes_to_install.push(runtime_is_url ? runtime_identifier : runtime_url)
-          end
-          # heroku does not know the 'runtimes' property and would crash if present
-          application.delete :runtimes
-          runtimes_to_install
-        end
-
-        def heroku_api
-          ::Heroku::API.new(headers: headers)
-        end
-
-        def headers
-          super.merge(
-            'Accept' => 'application/vnd.heroku+json; version=3',
-            'Content-Type' => 'application/json'
-          )
-        end
-
-        def installed_buildpacks(application_id)
-          buildpacks = get("/apps/#{application_id}/buildpack-installations").body
-          return [] if buildpacks.empty?
-          buildpacks.collect do |buildpack|
-            buildpack[:buildpack][:url]
-          end
-        end
-
-        def application_instances(application_id)
-          formations = get("/apps/#{application_id}/formation").body
-          web_formation = formations.find { |formation| formation[:type] == 'web' }
-          return web_formation[:quantity] unless web_formation.nil?
-          # if no web formation was detected, there is no instance available
-          0
-        end
-
-        def dynos(application_id)
-          get("/apps/#{application_id}/dynos").body
-        end
-
-        def web_dynos(application_id, retrieved_dynos = nil)
-          all_dynos = retrieved_dynos ? retrieved_dynos : dynos(application_id)
-          all_dynos.find_all do |dyno|
-            dyno[:type] == 'web'
-          end.compact
-        end
-
-        def latest_release(application_id, retrieved_dynos = nil)
-          dynos = web_dynos(application_id, retrieved_dynos)
-          if dynos.nil? || dynos.empty?
-            log.debug 'no dynos for build detection, fallback to latest release version'
-            # this approach might be wrong if the app is rolled-back to a previous release
-            # However, if no dyno is active, this is the only option to identify the current release
-            latest_version = 0
-            latest_version_id = nil
-            get("/apps/#{application_id}/releases").body.each do |release|
-              if release[:version] > latest_version
-                latest_version = release[:version]
-                latest_version_id = release[:id]
-              end
-            end
-          else
-            latest_version = 0
-            latest_version_id = nil
-            dynos.each do |dyno|
-              if dyno[:release][:version] > latest_version
-                latest_version = dyno[:release][:version]
-                latest_version_id = dyno[:release][:id]
-              end
-            end
-          end
-
-          latest_version_id
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      # The {Heroku} adapter is designed to support the Heroku platform API.<br>
+      # <br>
+      # The Nucleus API is fully supported, there are no known issues.
+      # @see https://devcenter.heroku.com/articles/platform-api-reference Heroku Platform API
+      class Heroku < Stub
+        include Nucleus::Logging
+        include Nucleus::Adapters::V1::Heroku::Authentication
+        include Nucleus::Adapters::V1::Heroku::Application
+        include Nucleus::Adapters::V1::Heroku::AppStates
+        include Nucleus::Adapters::V1::Heroku::Buildpacks
+        include Nucleus::Adapters::V1::Heroku::Data
+        include Nucleus::Adapters::V1::Heroku::Domains
+        include Nucleus::Adapters::V1::Heroku::Logs
+        include Nucleus::Adapters::V1::Heroku::Lifecycle
+        include Nucleus::Adapters::V1::Heroku::Regions
+        include Nucleus::Adapters::V1::Heroku::Scaling
+        include Nucleus::Adapters::V1::Heroku::Services
+        include Nucleus::Adapters::V1::Heroku::SemanticErrors
+        include Nucleus::Adapters::V1::Heroku::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)
+          handle_422(error_response)
+          if error_response.status == 404 && error_response.body[:id] == 'not_found'
+            raise Errors::AdapterResourceNotFoundError, error_response.body[:message]
+          elsif error_response.status == 503
+            raise Errors::PlatformUnavailableError, 'The Heroku API is currently not responding'
+          end
+          # error still unhandled, will result in a 500, server error
+          log.warn "Heroku error still unhandled: #{error_response}"
+        end
+
+        def handle_422(error_response)
+          return unless error_response.status == 422
+          if error_response.body[:id] == 'invalid_params'
+            raise Errors::SemanticAdapterRequestError, error_response.body[:message]
+          elsif error_response.body[:id] == 'verification_required'
+            fail_with(:need_verification, [error_response.body[:message]])
+          end
+        end
+
+        private
+
+        def install_runtimes(application_id, runtimes)
+          runtime_instructions = runtimes.collect { |buildpack_url| { buildpack: buildpack_url } }
+          log.debug "Install runtimes: #{runtime_instructions}"
+          buildpack_instructions = { updates: runtime_instructions }
+          put("/apps/#{application_id}/buildpack-installations", body: buildpack_instructions)
+        end
+
+        def runtimes_to_install(application)
+          return [] unless application[:runtimes]
+          runtimes_to_install = []
+          application[:runtimes].each do |runtime_identifier|
+            # we do not need to install native buildpacks
+            # TODO: 2 options for heroku runtime handling
+            # a) skip native, fails when native required and not in list
+            # b) (current) use native, fails when others (additional) are in the list
+            # next if native_runtime?(runtime_identifier)
+            runtime_is_url = runtime_identifier =~ /\A#{URI.regexp}\z/
+            runtime_url = find_runtime(runtime_identifier)
+            runtime_is_valid = runtime_url || runtime_is_url
+            fail_with(:invalid_runtime, [runtime_identifier]) unless runtime_is_valid
+            # if runtime identifier is valid, we need to install the runtime
+            runtimes_to_install.push(runtime_is_url ? runtime_identifier : runtime_url)
+          end
+          # heroku does not know the 'runtimes' property and would crash if present
+          application.delete :runtimes
+          runtimes_to_install
+        end
+
+        def heroku_api
+          ::Heroku::API.new(headers: headers)
+        end
+
+        def headers
+          super.merge(
+            'Accept' => 'application/vnd.heroku+json; version=3',
+            'Content-Type' => 'application/json'
+          )
+        end
+
+        def installed_buildpacks(application_id)
+          buildpacks = get("/apps/#{application_id}/buildpack-installations").body
+          return [] if buildpacks.empty?
+          buildpacks.collect do |buildpack|
+            buildpack[:buildpack][:url]
+          end
+        end
+
+        def application_instances(application_id)
+          formations = get("/apps/#{application_id}/formation").body
+          web_formation = formations.find { |formation| formation[:type] == 'web' }
+          return web_formation[:quantity] unless web_formation.nil?
+          # if no web formation was detected, there is no instance available
+          0
+        end
+
+        def dynos(application_id)
+          get("/apps/#{application_id}/dynos").body
+        end
+
+        def web_dynos(application_id, retrieved_dynos = nil)
+          all_dynos = retrieved_dynos ? retrieved_dynos : dynos(application_id)
+          all_dynos.find_all do |dyno|
+            dyno[:type] == 'web'
+          end.compact
+        end
+
+        def latest_release(application_id, retrieved_dynos = nil)
+          dynos = web_dynos(application_id, retrieved_dynos)
+          if dynos.nil? || dynos.empty?
+            log.debug 'no dynos for build detection, fallback to latest release version'
+            # this approach might be wrong if the app is rolled-back to a previous release
+            # However, if no dyno is active, this is the only option to identify the current release
+            latest_version = 0
+            latest_version_id = nil
+            get("/apps/#{application_id}/releases").body.each do |release|
+              if release[:version] > latest_version
+                latest_version = release[:version]
+                latest_version_id = release[:id]
+              end
+            end
+          else
+            latest_version = 0
+            latest_version_id = nil
+            dynos.each do |dyno|
+              if dyno[:release][:version] > latest_version
+                latest_version = dyno[:release][:version]
+                latest_version_id = dyno[:release][:id]
+              end
+            end
+          end
+
+          latest_version_id
+        end
+      end
+    end
+  end
+end