nucleus 0.2.0 → 0.3.1

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

@@ -1,65 +1,65 @@
-module Nucleus
-  module Adapters
-    module V1
-      class Heroku < Stub
-        module Vars
-          # @see Stub#env_vars
-          def env_vars(application_id)
-            all_vars = get("/apps/#{application_id}/config-vars").body
-            formatted_vars = []
-            all_vars.each do |key, value|
-              formatted_vars.push(id: key, key: key, value: value)
-            end
-            formatted_vars
-          end
-
-          # @see Stub#env_var
-          def env_var(application_id, env_var_key)
-            all_vars = get("/apps/#{application_id}/config-vars").body
-            fail Errors::AdapterResourceNotFoundError,
-                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, all_vars)
-
-            { id: env_var_key, key: env_var_key, value: all_vars[env_var_key.to_sym] }
-          end
-
-          # @see Stub#create_env_var
-          def create_env_var(application_id, env_var)
-            fail Errors::SemanticAdapterRequestError,
-                 "Env. var key '#{env_var[:key]}' already taken" if env_var?(application_id, env_var[:key])
-
-            request_body = { env_var[:key] => env_var[:value] }
-            all_vars = patch("/apps/#{application_id}/config-vars", body: request_body).body
-            { id: env_var[:key], key: env_var[:key], value: all_vars[env_var[:key].to_sym] }
-          end
-
-          # @see Stub#update_env_var
-          def update_env_var(application_id, env_var_key, env_var)
-            fail Errors::AdapterResourceNotFoundError,
-                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key)
-
-            request_body = { env_var_key => env_var[:value] }
-            updated_vars = patch("/apps/#{application_id}/config-vars", body: request_body).body
-            { id: env_var_key, key: env_var_key, value: updated_vars[env_var_key.to_sym] }
-          end
-
-          # @see Stub#delete_env_var
-          def delete_env_var(application_id, env_var_key)
-            fail Errors::AdapterResourceNotFoundError,
-                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key)
-
-            # vars can be deleted by setting them to null / nil
-            request_body = { env_var_key => nil }
-            patch("/apps/#{application_id}/config-vars", body: request_body).body
-          end
-
-          private
-
-          def env_var?(application_id, env_var_key, all_vars = nil)
-            all_vars = get("/apps/#{application_id}/config-vars").body if all_vars.nil?
-            all_vars.key? env_var_key.to_sym
-          end
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Vars
+          # @see Stub#env_vars
+          def env_vars(application_id)
+            all_vars = get("/apps/#{application_id}/config-vars").body
+            formatted_vars = []
+            all_vars.each do |key, value|
+              formatted_vars.push(id: key, key: key, value: value)
+            end
+            formatted_vars
+          end
+
+          # @see Stub#env_var
+          def env_var(application_id, env_var_key)
+            all_vars = get("/apps/#{application_id}/config-vars").body
+            raise Errors::AdapterResourceNotFoundError,
+                  "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, all_vars)
+
+            { id: env_var_key, key: env_var_key, value: all_vars[env_var_key.to_sym] }
+          end
+
+          # @see Stub#create_env_var
+          def create_env_var(application_id, env_var)
+            raise Errors::SemanticAdapterRequestError,
+                  "Env. var key '#{env_var[:key]}' already taken" if env_var?(application_id, env_var[:key])
+
+            request_body = { env_var[:key] => env_var[:value] }
+            all_vars = patch("/apps/#{application_id}/config-vars", body: request_body).body
+            { id: env_var[:key], key: env_var[:key], value: all_vars[env_var[:key].to_sym] }
+          end
+
+          # @see Stub#update_env_var
+          def update_env_var(application_id, env_var_key, env_var)
+            raise Errors::AdapterResourceNotFoundError,
+                  "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key)
+
+            request_body = { env_var_key => env_var[:value] }
+            updated_vars = patch("/apps/#{application_id}/config-vars", body: request_body).body
+            { id: env_var_key, key: env_var_key, value: updated_vars[env_var_key.to_sym] }
+          end
+
+          # @see Stub#delete_env_var
+          def delete_env_var(application_id, env_var_key)
+            raise Errors::AdapterResourceNotFoundError,
+                  "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key)
+
+            # vars can be deleted by setting them to null / nil
+            request_body = { env_var_key => nil }
+            patch("/apps/#{application_id}/config-vars", body: request_body).body
+          end
+
+          private
+
+          def env_var?(application_id, env_var_key, all_vars = nil)
+            all_vars = get("/apps/#{application_id}/config-vars").body if all_vars.nil?
+            all_vars.key? env_var_key.to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,68 +1,68 @@
-module Nucleus
-  module Adapters
-    module V1
-      class OpenshiftV2 < Stub
-        module AppStates
-          # Determine the current state of the application in the Nucleus lifecycle.
-          # @return [Symbol] application state according to {Nucleus::Enums::ApplicationStates}
-          def application_state(app, gear_groups = nil, deployments = nil)
-            deployments = load_deployments(app[:id]) unless deployments
-            gear_groups = load_gears(app[:id]) unless gear_groups
-
-            return :created if state_created?(app, gear_groups, deployments)
-            return :deployed if state_deployed?(app, gear_groups, deployments)
-            return :running if gear_groups[0][:gears].any? { |gear| gear[:state] == 'started' }
-            return :stopped if gear_groups[0][:gears].all? { |gear| gear[:state] == 'stopped' }
-            return :idle if gear_groups[0][:gears].all? { |gear| gear[:state] == 'idle' }
-
-            log.debug("Failed to determine state for: #{app}")
-            fail Errors::UnknownAdapterCallError,
-                 'Could not determine app state. Please verify the Openshift V2 adapter'
-          end
-
-          private
-
-          def state_created?(app, gear_groups, deployments)
-            # this state exists, but only within the first seconds before the original deployment is applied
-            return true if gear_groups[0][:gears].all? { |gear| gear[:state] == 'new' }
-
-            if app[:keep_deployments].to_i > 1
-              if deployments.length == 1
-                original_os_deployment = original_deployment(app, deployments)
-                currently_activated = active_deployment(app, deployments)
-                # if the current deployment still is the default, the state must be :created
-                return true if original_os_deployment && original_os_deployment[:id] == currently_activated[:id]
-              end
-              # if there is more than 1 deployment, state can't be :created
-            else
-              # app was not created with nucleus or has recently been modified :/
-              diff = Time.parse(deployments[0][:created_at]).to_i - Time.parse(app[:creation_time]).to_i
-              # we can analyse if the deployment was created within 15 seconds after the application,
-              # then there can't possibly be an actual code deployment
-              return true if diff.abs < 15
-            end
-            # does not seem to be in state :created
-            false
-          end
-
-          def state_deployed?(app, gear_groups, deployments)
-            # Gears must all be stopped
-            return false unless gear_groups[0][:gears].all? { |gear| gear[:state] == 'stopped' }
-
-            deployments = load_deployments(app[:id]) unless deployments
-
-            # If there still is the initial deployment, then the state can be deployed.
-            original_os_deployment = original_deployment(app, deployments) unless original_os_deployment
-            return false unless original_os_deployment
-
-            activations = deployments.inject(0) { |a, e| a + e[:activations].length }
-            # deduct the activations of the original deployment
-            activations -= original_os_deployment[:activations].length
-            return false if activations > 1
-            true
-          end
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      class OpenshiftV2 < Stub
+        module AppStates
+          # Determine the current state of the application in the Nucleus lifecycle.
+          # @return [Symbol] application state according to {Nucleus::Enums::ApplicationStates}
+          def application_state(app, gear_groups = nil, deployments = nil)
+            deployments = load_deployments(app[:id]) unless deployments
+            gear_groups = load_gears(app[:id]) unless gear_groups
+
+            return :created if state_created?(app, gear_groups, deployments)
+            return :deployed if state_deployed?(app, gear_groups, deployments)
+            return :running if gear_groups[0][:gears].any? { |gear| gear[:state] == 'started' }
+            return :stopped if gear_groups[0][:gears].all? { |gear| gear[:state] == 'stopped' }
+            return :idle if gear_groups[0][:gears].all? { |gear| gear[:state] == 'idle' }
+
+            log.debug("Failed to determine state for: #{app}")
+            raise Errors::UnknownAdapterCallError,
+                  'Could not determine app state. Please verify the Openshift V2 adapter'
+          end
+
+          private
+
+          def state_created?(app, gear_groups, deployments)
+            # this state exists, but only within the first seconds before the original deployment is applied
+            return true if gear_groups[0][:gears].all? { |gear| gear[:state] == 'new' }
+
+            if app[:keep_deployments].to_i > 1
+              if deployments.length == 1
+                original_os_deployment = original_deployment(app, deployments)
+                currently_activated = active_deployment(app, deployments)
+                # if the current deployment still is the default, the state must be :created
+                return true if original_os_deployment && original_os_deployment[:id] == currently_activated[:id]
+              end
+              # if there is more than 1 deployment, state can't be :created
+            else
+              # app was not created with nucleus or has recently been modified :/
+              diff = Time.parse(deployments[0][:created_at]).to_i - Time.parse(app[:creation_time]).to_i
+              # we can analyse if the deployment was created within 15 seconds after the application,
+              # then there can't possibly be an actual code deployment
+              return true if diff.abs < 15
+            end
+            # does not seem to be in state :created
+            false
+          end
+
+          def state_deployed?(app, gear_groups, deployments)
+            # Gears must all be stopped
+            return false unless gear_groups[0][:gears].all? { |gear| gear[:state] == 'stopped' }
+
+            deployments = load_deployments(app[:id]) unless deployments
+
+            # If there still is the initial deployment, then the state can be deployed.
+            original_os_deployment = original_deployment(app, deployments) unless original_os_deployment
+            return false unless original_os_deployment
+
+            activations = deployments.inject(0) { |a, e| a + e[:activations].length }
+            # deduct the activations of the original deployment
+            activations -= original_os_deployment[:activations].length
+            return false if activations > 1
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module Nucleus
           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
+            fail_with(:must_have_runtime) if application_entity[:runtimes].empty?
             application_entity[:cartridge] = cartridge(application_entity.delete(:runtimes)[0])
 
             # updates the application with a valid region identity

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

@@ -1,96 +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
+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
+              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.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
+              raise 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