nucleus 0.1.0

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

@@ -0,0 +1,33 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        module Regions
+          # @see Stub#regions
+          def regions
+            [default_region]
+          end
+
+          # @see Stub#region
+          def region(region_name)
+            unless region_name.casecmp('default') == 0
+              fail Errors::AdapterResourceNotFoundError, "Region '#{region_name}' does not exist at the endpoint"
+            end
+            default_region
+          end
+
+          private
+
+          def default_region
+            {
+              id: 'default',
+              description: 'Default region, Cloud Foundry does not support multi regions yet.',
+              created_at: Time.at(0).to_datetime,
+              updated_at: Time.at(0).to_datetime
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        module Scaling
+          # @see Stub#scale
+          def scale(application_name_or_id, instances)
+            # update the number of instances on the application
+            update_application(application_name_or_id, instances: instances)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        # Semantic error messages that are specific for Cloud Foundry V2
+        module SemanticErrors
+          # Get all Cloud Foundry V2 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
+            {
+              only_one_runtime: { code: 422_200_1, message: 'Cloud Foundry V2 only allows 1 runtime per application' },
+              build_in_progrss: { code: 422_200_2, message: 'Application build is still in progress' },
+              no_space_assigned: { code: 422_200_3, message: 'User is not assigned to any space' },
+              service_not_bindable: { code: 422_200_4, message: "Can't add service '%s' to the application: "\
+                'The service does not allow to be bound to applications.' },
+              service_not_active: { code: 422_200_5, message: "Can't add service '%s' to the application: "\
+                'The service does is not active, thus does not allow to create a new instance to bind to the app.' },
+              service_not_updateable: { code: 422_200_6, message: "Can't change service '%s' to the new plan: "\
+                'The service does not allow to update the plan.' }
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,286 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        # Cloud Foundry, operations for the application's addons
+        module Services
+          # @see Stub#services
+          def services
+            get('/v2/services?inline-relations-depth=1').body[:resources].collect do |service|
+              # show only services that are both, active and bindable
+              next unless service[:entity][:active] && service[:entity][:bindable]
+              to_nucleus_service(service)
+            end.compact
+          end
+
+          # @see Stub#service
+          def service(service_id_or_name)
+            service_guid = service_guid(service_id_or_name)
+            to_nucleus_service(get("/v2/services/#{service_guid}?inline-relations-depth=1").body)
+          end
+
+          # @see Stub#service_plans
+          def service_plans(service_id_or_name)
+            service_guid = service_guid(service_id_or_name)
+            load_plans(service_guid).collect { |plan| to_nucleus_plan(plan) }
+          end
+
+          # @see Stub#service_plan
+          def service_plan(service_id_or_name, plan_id)
+            service_guid = service_guid(service_id_or_name)
+            plan_guid = plan_guid(service_guid, plan_id, Errors::AdapterResourceNotFoundError)
+            to_nucleus_plan(get("/v2/service_plans/#{plan_guid}").body)
+          end
+
+          # @see Stub#installed_services
+          def installed_services(application_name_or_id)
+            app_guid = app_guid(application_name_or_id)
+            get("/v2/apps/#{app_guid}/service_bindings?inline-relations-depth=1").body[:resources].collect do |binding|
+              to_nucleus_installed_service(binding)
+            end
+          end
+
+          # @see Stub#installed_service
+          def installed_service(application_name_or_id, service_id_or_name)
+            app_guid = app_guid(application_name_or_id)
+            service_guid = service_guid(service_id_or_name)
+            cf_binding = binding(app_guid, service_guid)
+            # make sure there is a binding
+            fail Errors::AdapterResourceNotFoundError,
+                 "No such service '#{service_id_or_name}' for application '#{application_name_or_id}'" unless cf_binding
+            to_nucleus_installed_service(cf_binding)
+          end
+
+          # @see Stub#add_service
+          def add_service(application_name_or_id, service_entity, plan_entity)
+            app_guid = app_guid(application_name_or_id)
+            service_guid = service_guid(service_entity[:id], Errors::SemanticAdapterRequestError)
+            cf_service = load_allowed_service(service_entity, service_guid)
+
+            # get the plan, throws 422 if the plan could not be found
+            plan_guid = plan_guid(service_guid, plan_entity[:id])
+
+            # create new service instance
+            instance_request_body = { space_guid: user_space_guid, service_plan_guid: plan_guid,
+                                      name: "#{cf_service[:entity][:label]}-#{application_name_or_id}-nucleus" }
+            cf_instance = post('/v2/service_instances', body: instance_request_body).body
+
+            # bind the created service instance to the application
+            binding_request_body = { service_instance_guid: cf_instance[:metadata][:guid], app_guid: app_guid }
+            cf_binding = post('/v2/service_bindings', body: binding_request_body).body
+
+            # created service presentation
+            to_nucleus_installed_service(cf_binding, cf_service, cf_instance)
+          end
+
+          # @see Stub#change_service
+          def change_service(application_name_or_id, service_id, plan_entity)
+            app_guid = app_guid(application_name_or_id)
+            service_guid = service_guid(service_id)
+            cf_service = get("/v2/services/#{service_guid}").body
+            fail_with(:service_not_updateable, [service_id]) unless cf_service[:entity][:plan_updateable]
+
+            cf_binding = binding(app_guid, service_guid)
+
+            # get the plan, throws 422 if the plan could not be found
+            plan_guid = plan_guid(service_guid, plan_entity[:id])
+            cf_instance = put("/v2/service_instances/#{cf_binding[:entity][:service_instance_guid]}",
+                              body: { service_plan_guid: plan_guid }).body
+            to_nucleus_installed_service(cf_binding, cf_service, cf_instance)
+          end
+
+          # @see Stub#remove_service
+          def remove_service(application_name_or_id, service_id)
+            app_guid = app_guid(application_name_or_id)
+            service_guid = service_guid(service_id)
+            # sadly we can't resolve the binding and instance from the service_id with ease
+            # we therefore setup a chain to resolve the binding and instance from the active pla
+            binding = binding(app_guid, service_guid)
+
+            # now remove the binding from the application
+            delete("/v2/apps/#{app_guid}/service_bindings/#{binding[:metadata][:guid]}", expects: [201])
+            # and finally delete the service instance
+            delete("/v2/service_instances/#{binding[:entity][:service_instance_guid]}")
+          end
+
+          private
+
+          def load_allowed_service(service_entity, service_guid)
+            begin
+              cf_service = get("/v2/services/#{service_guid}").body
+            rescue Errors::AdapterResourceNotFoundError
+              # convert to semantic error with the service being a body, not a path entity
+              raise Errors::SemanticAdapterRequestError,
+                    "Invalid service: Could not find service with the ID '#{service_entity[:id]}'"
+            end
+
+            # must be active and bindable?
+            # currently we focus only on bindable services
+            fail_with(:service_not_bindable, [service_entity[:id]]) unless cf_service[:entity][:bindable]
+            # service must be active, otherwise we can't create the instance
+            fail_with(:service_not_active, [service_entity[:id]]) unless cf_service[:entity][:active]
+            # service seems to be valid, return
+            cf_service
+          end
+
+          def remove_all_services(app_guid)
+            get("/v2/apps/#{app_guid}/service_bindings").body[:resources].collect do |binding|
+              # remove the binding from the application
+              delete("/v2/apps/#{app_guid}/service_bindings/#{binding[:metadata][:guid]}", expects: [201])
+              # and delete the service instance to prevent orphans
+              delete("/v2/service_instances/#{binding[:entity][:service_instance_guid]}")
+            end
+          end
+
+          def service_guid(service_id_or_name, error_class = Errors::AdapterResourceNotFoundError)
+            return service_id_or_name if guid?(service_id_or_name)
+            # list all available services
+            services = get('/v2/services').body[:resources]
+            # find a match and use the service's guid
+            service_match = services.find { |service| service[:entity][:label] == service_id_or_name }
+            fail error_class,
+                 "Invalid service: Could not find service with name '#{service_id_or_name}'" unless service_match
+            service_match[:metadata][:guid]
+          end
+
+          def binding(app_guid, service_id)
+            service_plans = get("/v2/services/#{service_id}/service_plans").body[:resources]
+            service_plan_ids = service_plans.collect { |plan| plan[:metadata][:guid] }
+            app_bindings = get("/v2/apps/#{app_guid}/service_bindings?inline-relations-depth=1").body[:resources]
+            # the plan must be bound to the app via an instance
+            app_bindings.find do |binding|
+              service_plan_ids.include?(binding[:entity][:service_instance][:entity][:service_plan_guid])
+            end
+          end
+
+          def plan_guid(service_id, plan_name_or_id, error_class = Errors::SemanticAdapterRequestError)
+            return plan_name_or_id if guid?(plan_name_or_id)
+            # list all plans for the service
+            plans = get("/v2/services/#{service_id}/service_plans").body[:resources]
+            # find a match and use the plan's guid
+            plan_match = plans.find { |plan| plan[:entity][:name] == plan_name_or_id }
+            fail error_class,
+                 "Invalid plan: No such plan '#{plan_name_or_id}' for service '#{service_id}'" unless plan_match
+            plan_match[:metadata][:guid]
+          end
+
+          def load_plans(service_id)
+            get("/v2/services/#{service_id}/service_plans").body[:resources]
+          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[:entity][:free] }
+            @free_plans[service_id]
+          end
+
+          def to_nucleus_plan(cf_plan)
+            plan = cf_plan[:entity]
+            plan[:id] = cf_plan[:metadata][:guid]
+            plan[:created_at] = cf_plan[:metadata][:created_at]
+            plan[:updated_at] = cf_plan[:metadata][:updated_at]
+            plan[:costs] = []
+            plan
+
+            # TODO: determine prices for CF services
+            # we know how IBM handles the costs, but can't determine the country
+            # we know how Pivotal IO handles the costs
+            # but what do the others???
+
+            # extra = Oj.load(plan[:extra])
+            # if plan[:free]
+            #   plan[:costs] = { period: '', per_instance: false, price: { amount: 0.00, currency: nil} }
+            # elsif endpoint_url.include?('pivotal.io')
+            #   # show prices for Pivotal Web Services
+            #   # see for an explanation: http://docs.pivotal.io/pivotalcf/services/catalog-metadata.html
+            #   plan[:costs] = extra[:costs].collect do |cost|
+            #     prices = cost[:amount].collect { |currency, amount| { currency: currency, amount: amount } }
+            #     { per_instance: false, period: cost[:unit], price: prices }
+            #   end
+            # elsif endpoint_url.include?('bluemix.net')
+            #   # show prices for IBM Bluemix
+            # else
+            #   # fallback, unknown CF system
+            # end
+          end
+
+          def to_nucleus_service(cf_service)
+            service = cf_service[:entity]
+            service = apply_metadata(service, cf_service)
+            service[:name] = service.delete(:label)
+            service[:release] = service.delete(:version)
+            if cf_service[:entity].key?(:service_plans)
+              # use preloaded plans if available
+              service[:free_plan] = free_plan?(service[:id], cf_service[:entity][:service_plans])
+            else
+              service[:free_plan] = free_plan?(service[:id])
+            end
+            # CF does not have service dependencies
+            service[:required_services] = service.delete(:requires)
+            # description and documentation_url should already be set
+            service
+          end
+
+          # Show the installed service. Therefore we need:<br>
+          # <ul>
+          # <li>the classic service for the basic information (version, name, ...)</li>
+          # <li>the binding for the properties and metadata (id, timestamps, ...)</li>
+          # <li>the bound instance for the active plan and web_url</li>
+          # </ul>
+          def to_nucleus_installed_service(cf_binding, cf_service = nil, cf_instance = nil)
+            # load if not provided
+            cf_instance = load_instance(cf_binding) unless cf_instance
+            cf_service = load_service(cf_instance) unless cf_service
+            # load if not provided
+            unless cf_service
+              cf_service = get("/v2/service_plans/#{cf_instance[:entity][:service_plan_guid]}"\
+                '?inline-relations-depth=1').body[:entity][:service]
+            end
+
+            # active_plan, web_url, properties
+            service = to_nucleus_service(cf_service)
+            # use the metadata of the binding, is more future proof than instance metadata
+            apply_metadata(service, cf_binding)
+            service[:active_plan] = cf_instance[:entity][:service_plan_guid]
+            service[:web_url] = cf_instance[:entity][:dashboard_url]
+            service[:properties] = binding_properties(cf_binding)
+            service
+          end
+
+          def load_instance(cf_binding)
+            if cf_binding[:entity].key?(:service_instance)
+              # use if nested property is available
+              cf_binding[:entity][:service_instance]
+            else
+              get("/v2/service_instances/#{cf_binding[:entity][:service_instance_guid]}").body
+            end
+          end
+
+          def load_service(cf_instance)
+            get("/v2/service_plans/#{cf_instance[:entity][:service_plan_guid]}"\
+              '?inline-relations-depth=1').body[:entity][:service]
+          end
+
+          def binding_properties(binding)
+            # in the credentials there are information such as: hostname, username, password, license keys, ...
+            binding[:entity][:credentials].collect do |key, value|
+              { key: key, value: value, description: nil }
+            end
+          end
+
+          def apply_metadata(apply_to, cf_object)
+            apply_to[:id] = cf_object[:metadata][:guid]
+            apply_to[:created_at] = cf_object[:metadata][:created_at]
+            apply_to[:updated_at] = cf_object[:metadata][:updated_at]
+            apply_to
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        module Vars
+          # @see Stub#env_vars
+          def env_vars(application_name_or_id)
+            app_guid = app_guid(application_name_or_id)
+            app_vars = get("/v2/apps/#{app_guid}/env").body[:environment_json]
+            formatted_vars = []
+            app_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_name_or_id, env_var_key)
+            app_guid = app_guid(application_name_or_id)
+            all_vars = get("/v2/apps/#{app_guid}/env").body[:environment_json]
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(app_guid, 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_name_or_id, env_var)
+            app_guid = app_guid(application_name_or_id)
+            fail Errors::SemanticAdapterRequestError,
+                 "Env. var key '#{env_var[:key]}' already taken" if env_var?(app_guid, env_var[:key])
+            set_var(app_guid, env_var[:key].to_sym, env_var[:value])
+          end
+
+          # @see Stub#update_env_var
+          def update_env_var(application_name_or_id, env_var_key, env_var)
+            app_guid = app_guid(application_name_or_id)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(app_guid, env_var_key)
+            set_var(app_guid, env_var_key.to_sym, env_var[:value])
+          end
+
+          # @see Stub#delete_env_var
+          def delete_env_var(application_name_or_id, env_var_key)
+            app_guid = app_guid(application_name_or_id)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(app_guid, env_var_key)
+            request_body = get("/v2/apps/#{app_guid}/env").body[:environment_json]
+            request_body.delete(env_var_key.to_sym)
+            put("/v2/apps/#{app_guid}", body: { environment_json: request_body }).body[:entity][:environment_json]
+          end
+
+          private
+
+          # Set the variable value (create or update) and include all already existing variables
+          # to protect them from being deleted.
+          # @param [String] app_guid GUID of the CF application
+          # @param [Symbol] key variable key name
+          # @param [String, Integer, Float, Double] value value to apply to the variable
+          # @return [Hash] Nucleus representation of the modified variable
+          def set_var(app_guid, key, value)
+            request_body = get("/v2/apps/#{app_guid}/env").body[:environment_json]
+            request_body[key] = value
+            vars = put("/v2/apps/#{app_guid}", body: { environment_json: request_body }).body[:entity]
+            { id: key, key: key, value: vars[:environment_json][key] }
+          end
+
+          # Checks if a variable with the env_var_key already exists.
+          # @param [String] app_guid GUID of the CF application
+          # @param [Symbol] env_var_key key name that shall be checked for existence
+          # @param [Hash] all_vars collection of currently existing variables for the application
+          # @return [Boolean] true if there is a variable with the env_var_key, otherwise false
+          def env_var?(app_guid, env_var_key, all_vars = nil)
+            all_vars = get("/v2/apps/#{app_guid}/env").body[:environment_json] if all_vars.nil?
+            all_vars.key? env_var_key.to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

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