nucleus 0.1.0

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

@@ -0,0 +1,108 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Logs
+          # Carriage return (newline in Mac OS) + line feed (newline in Unix) == CRLF (newline in Windows)
+          CRLF = "\r\n"
+
+          # @see Stub#logs
+          def logs(application_id)
+            # fails with 404 if application is not available and serves for timestamps
+            app = get("/apps/#{application_id}").body
+
+            available_log_files = []
+            available_log_types.keys.each do |type|
+              # TODO: right now, we always assume the log has recently been updated
+              available_log_files.push(id: type, name: type, type: type,
+                                       created_at: app[:created_at], updated_at: Time.now.utc.iso8601)
+            end
+            available_log_files
+          end
+
+          # @see Stub#log?
+          def log?(application_id, log_id)
+            # fails with 404 if application is not available
+            get("/apps/#{application_id}")
+
+            return true if log_id.to_sym == :all
+            return true if log_id.to_sym == :build
+            available_log_types.key? log_id.to_sym
+          end
+
+          # @see Stub#log_entries
+          def log_entries(application_id, log_id)
+            unless log?(application_id, log_id)
+              fail Errors::AdapterResourceNotFoundError,
+                   "Invalid log file '#{log_id}', not available for application '#{application_id}'"
+            end
+
+            return build_log_entries(application_id) if log_id.to_sym == Enums::ApplicationLogfileType::BUILD
+
+            request_body = request_body(log_id.to_sym).merge(tail: false)
+            log = post("/apps/#{application_id}/log-sessions", body: request_body).body
+            logfile = get(log[:logplex_url], headers: {}).body
+            # process to entries
+            entries = []
+            # skip empty logs, which are detected as Hash by the http client
+            logfile.split(CRLF).each { |logfile_line| entries.push logfile_line } unless logfile == {}
+            entries
+          end
+
+          # @see Stub#tail
+          def tail(application_id, log_id, stream)
+            # Currently no tailing for build log possible
+            if log_id == Enums::ApplicationLogfileType::BUILD
+              entries = build_log_entries(application_id)
+              entries.each { |entry| stream.send_message(entry) }
+              stream.close
+            else
+              request_body = request_body(log_id.to_sym).merge(tail: true)
+              log = post("/apps/#{application_id}/log-sessions", body: request_body).body
+              tail_http_response(log[:logplex_url], stream)
+            end
+          end
+
+          private
+
+          def available_log_types
+            log_types = {}
+            log_types[Enums::ApplicationLogfileType::API] = { source: 'heroku', dyno: 'api' }
+            log_types[Enums::ApplicationLogfileType::APPLICATION] = { source: 'app' }
+            log_types[Enums::ApplicationLogfileType::REQUEST] = { source: 'heroku', dyno: 'router' }
+            # TODO: filter only for web and worker dynos (must be merged manually :/)
+            log_types[Enums::ApplicationLogfileType::SYSTEM] = { source: 'heroku' }
+            log_types
+          end
+
+          def request_body(log_id)
+            return {} if log_id == :all
+            available_log_types[log_id]
+          end
+
+          def build_log_entries(application_id)
+            build_list = get("/apps/#{application_id}/builds").body
+            # limitation: show only the last 3 builds
+            entries = []
+            build_list.last(3).each do |build|
+              entries.push(*build_result_entries(application_id, build[:id]))
+            end
+            entries
+          end
+
+          def build_result_entries(application_id, build_id)
+            build_result = get("/apps/#{application_id}/builds/#{build_id}/result").body
+            entries = []
+            build_result[:lines].each do |line_entry|
+              # skip all blank lines
+              next if line_entry[:line].strip.empty?
+              # push and remove all trailing newline characters
+              entries.push line_entry[:line].chomp('')
+            end
+            entries
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Regions
+          # @see Stub#regions
+          def regions
+            response = get('/regions').body
+            response.each do |region|
+              region[:id] = region.delete(:name).upcase
+            end
+            response
+          end
+
+          # @see Stub#region
+          def region(region_name)
+            found_region = native_region(region_name)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Region '#{region_name}' does not exist at the endpoint" if found_region.nil?
+            found_region[:id] = found_region.delete(:name).upcase
+            found_region
+          end
+
+          private
+
+          def retrieve_region(application)
+            return unless application.key?(:region)
+            found_region = native_region(application[:region])
+            fail Errors::SemanticAdapterRequestError,
+                 "Region '#{application[:region]}' does not exist at the endpoint" if found_region.nil?
+            application[:region] = found_region[:id]
+          end
+
+          def native_region(region_name)
+            response = get('/regions').body
+            response.find { |region| region[:name].casecmp(region_name) == 0 }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Scaling
+          # @see Stub#scale
+          def scale(application_id, instances)
+            scale_web(application_id, instances)
+            # return the updated application object
+            application(application_id)
+          end
+
+          private
+
+          def scale_web(application_id, instances)
+            patch("/apps/#{application_id}/formation", body: { updates: [{ process: 'web', quantity: instances }] })
+          end
+
+          def scale_worker(application_id, instances)
+            patch("/apps/#{application_id}/formation", body: { updates: [{ process: 'worker', quantity: instances }] },
+                  # raises 404 if no worker is defined in the Procfile
+                  expects: [404])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        # Semantic error messages that are specific for Heroku
+        module SemanticErrors
+          # Get all Heroku specific semantic error definitions.
+          # @return [Hash<Symbol,Hash<Symbol,String>>] the error message definitions, including the error +code+,
+          #   e.g. +422_200_1+ and the +message+ that shall be formatted when used.
+          def semantic_error_messages
+            {
+              need_verification: { code: 422_100_1,
+                                   message: 'Heroku requires a billing account to allow this action: %s' },
+              no_autoscale: { code: 422_100_2, message: 'Can\'t use \'autoscale\' on Heroku' },
+              invalid_runtime: { code: 422_100_3,
+                                 message: 'Invalid runtime: %s is neither a known runtime, nor a buildpack URL' }
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Services
+          # @see Stub#services
+          def services
+            get('/addon-services').body.collect { |service| to_nucleus_service(service) }
+          end
+
+          # @see Stub#service
+          def service(service_id)
+            to_nucleus_service(get("/addon-services/#{service_id}").body)
+          end
+
+          # @see Stub#service_plans
+          def service_plans(service_id)
+            load_plans(service_id).collect { |plan| to_nucleus_plan(plan) }.sort_by do |plan|
+              # only compare the first cost, covers most cases and sorting for all costs would be far too complex
+              plan[:costs][0][:price].first[:amount].to_f
+            end
+          end
+
+          # @see Stub#service_plan
+          def service_plan(service_id, plan_id)
+            to_nucleus_plan(get("/addon-services/#{service_id}/plans/#{plan_id}").body)
+          end
+
+          # @see Stub#installed_services
+          def installed_services(application_id)
+            get("/apps/#{application_id}/addons").body.collect { |service| to_nucleus_installed_service(service) }
+          end
+
+          # @see Stub#installed_service
+          def installed_service(application_id, service_id)
+            assigned_service = raw_installed_service(application_id, service_id)
+            to_nucleus_installed_service(assigned_service)
+          end
+
+          # @see Stub#add_service
+          def add_service(application_id, service_entity, plan_entity)
+            begin
+              # make sure plan belongs to this service, throws 404 if no such plan
+              # the service plan itself requires the name, e.g. 'sandbox' or the UUID
+              service_plan(service_entity[:id], plan_entity[:id])
+            rescue Errors::AdapterResourceNotFoundError => e
+              # convert to 422
+              raise Errors::SemanticAdapterRequestError, e.message
+            end
+            # the plan to choose requires the UUID of the plan OR the combination of both names
+            plan_id = service_plan_identifier(service_entity[:id], plan_entity[:id])
+            created = post("/apps/#{application_id}/addons", body: { plan: plan_id }).body
+            to_nucleus_installed_service(created)
+          end
+
+          # @see Stub#change_service
+          def change_service(application_id, service_id, plan_entity)
+            # make sure service is bound to the application
+            assignment_id = raw_installed_service(application_id, service_id)[:id]
+            begin
+              # make sure plan belongs to this service, throws 404 if no such plan
+              # the service plan itself requires the name, e.g. 'sandbox' or the UUID
+              service_plan(service_id, plan_entity[:id])
+            rescue Errors::AdapterResourceNotFoundError => e
+              # convert to 422
+              raise Errors::SemanticAdapterRequestError, e.message
+            end
+            # the plan to choose requires the UUID of the plan OR the combination of both names
+            plan_id = service_plan_identifier(service_id, plan_id)
+            updated = patch("/apps/#{application_id}/addons/#{assignment_id}", body: { plan: plan_id }).body
+            to_nucleus_installed_service(updated)
+          end
+
+          # @see Stub#remove_service
+          def remove_service(application_id, service_id)
+            # make sure service is bound to the application
+            assignment_id = raw_installed_service(application_id, service_id)[:id]
+            delete("/apps/#{application_id}/addons/#{assignment_id}")
+          end
+
+          private
+
+          def service_plan_identifier(service_id, plan_id)
+            # process plan id_or_name to build the unique identifier
+            # a) is a UUID
+            return plan_id if Regexp::UUID_PATTERN =~ plan_id
+            # b) is valid identifier, contains ':'
+            return plan_id if /^[-\w]+:[-\w]+$/i =~ plan_id
+            # c) fetch id for name
+            return "#{service_id}:#{plan_id}" unless Regexp::UUID_PATTERN =~ service_id
+            # arriving here, service_id is UUID but plan_id is the name --> DOH!
+            # we return the plan_id and the request will presumably fail
+            plan_id
+          end
+
+          def raw_installed_service(application_id, service_id)
+            # here we probably receive the ID of the service, not the service assignment ID itself
+            installed = get("/apps/#{application_id}/addons/#{service_id}", expects: [200, 404])
+            if installed.status == 404
+              assignment_id = service_assignment_id(application_id, service_id)
+              fail Errors::AdapterResourceNotFoundError,
+                   "Service #{service_id} is not assigned to application #{application_id}" unless assignment_id
+              return get("/apps/#{application_id}/addons/#{assignment_id}").body
+            end
+            installed.body
+          end
+
+          def service_assignment_id(application_id, service_id)
+            all_services = get("/apps/#{application_id}/addons").body
+            match = all_services.find do |addon|
+              addon[:addon_service][:id] == service_id || addon[:addon_service][:name] == service_id
+            end
+            return match[:id] if match
+            nil
+          end
+
+          def to_nucleus_service(service)
+            service[:description] = service.delete(:human_name)
+            service[:release] = service.delete(:state)
+            service[:required_services] = []
+            service[:free_plan] = free_plan?(service[:id])
+            service[:documentation_url] = "https://addons.heroku.com/#{service[:name]}"
+            service
+          end
+
+          def to_nucleus_installed_service(installed_service)
+            service = service(installed_service[:addon_service][:id])
+            # get all variables and reject all that do not belong to the addon
+            unless installed_service[:config_vars].nil? && installed_service[:config_vars].empty?
+              vars = get("/apps/#{installed_service[:app][:id]}/config-vars").body
+              # ignore all vars that do not belong to the service
+              vars = vars.delete_if { |k| !installed_service[:config_vars].include?(k.to_s) }
+              # format to desired format
+              vars = vars.collect { |k, v| { key: k, value: v, description: nil } }
+            end
+            service[:properties] = vars ? vars : []
+            service[:active_plan] = installed_service[:plan][:id]
+            service[:web_url] = installed_service[:web_url]
+            service
+          end
+
+          def to_nucleus_plan(plan)
+            # TODO: extract payment period to enum
+            plan[:costs] = [{ price: [amount: plan[:price][:cents] / 100.0, currency: 'USD'],
+                             period: plan[:price][:unit], per_instance: false }]
+            plan[:free] = plan[:price][:cents] == 0
+            plan
+          end
+
+          def load_plans(service_id)
+            get("/addon-services/#{service_id}/plans").body
+          end
+
+          # Memoize this detection.
+          # The information is not critical, but takes some time to evaluate.
+          # Values are not expected to change often.
+          def free_plan?(service_id, plans = nil)
+            @free_plans ||= {}
+            return @free_plans[service_id] if @free_plans.key?(service_id)
+            plans = load_plans(service_id) unless plans
+            @free_plans[service_id] = plans.any? { |plan| plan[:price][:cents] == 0 }
+            @free_plans[service_id]
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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