nucleus 0.1.0

data/lib/nucleus/adapters/v1/cloud_control/token.rb

@@ -0,0 +1,17 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudControl < Stub
+        # cloud control specific token, which requires a specific +cc_auth_token+ value in the +Authorization+ header.
+        class Token < Nucleus::Adapters::ExpiringTokenAuthClient
+          # @see Nucleus::Adapters::ExpiringTokenAuthClient#auth_header
+          def auth_header
+            # call super for error checks, but ignore returned header
+            super
+            { 'Authorization' => "cc_auth_token=\"#{api_token}\"" }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudControl < Stub
+        # cloud control, CRUD operations for the application's environment variable object,
+        # which is referred to as +config addon+ on the platform.
+        module Vars
+          # @see Stub#env_vars
+          def env_vars(application_id)
+            cc_vars = cc_vars(application_id)
+            cc_vars.collect do |key, value|
+              { id: key, key: key, value: value }
+            end
+          end
+
+          # @see Stub#env_var
+          def env_var(application_id, env_var_key)
+            cc_vars = cc_vars(application_id)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
+            { id: env_var_key, key: env_var_key, value: cc_vars[env_var_key.to_sym] }
+          end
+
+          # @see Stub#create_env_var
+          def create_env_var(application_id, env_var)
+            cc_vars = cc_vars(application_id)
+            fail Errors::SemanticAdapterRequestError,
+                 "Env. var key '#{env_var[:key]}' already taken" if env_var?(application_id, env_var[:key], cc_vars)
+            set_var(application_id, env_var[:key], env_var[:value])
+          end
+
+          # @see Stub#update_env_var
+          def update_env_var(application_id, env_var_key, env_var)
+            cc_vars = cc_vars(application_id)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
+            set_var(application_id, env_var_key, env_var[:value])
+          end
+
+          # @see Stub#delete_env_var
+          def delete_env_var(application_id, env_var_key)
+            cc_vars = cc_vars(application_id)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
+            set_var(application_id, env_var_key, nil)
+          end
+
+          private
+
+          def cc_vars(application_id)
+            cc_vars_response = get("app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/config.free")
+            cc_vars_response.body[:settings][:CONFIG_VARS]
+          end
+
+          # Set the variable value (create or update)
+          # @param [String] application_id id of the cloud control 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(application_id, key, value)
+            if value.nil?
+              # delete the var, set to 'null'
+              settings = "{\"#{key}\":null}"
+            else
+              settings = "{\"#{key}\":\"#{value}\"}"
+            end
+            response = put("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/config.free",
+                           body: { addon: 'config.free',
+                                   settings: settings,
+                                   force: true })
+            all_vars = response.body[:settings][:CONFIG_VARS]
+            { id: key, key: key, value: all_vars[key.to_sym] }
+          end
+
+          # Checks if a variable with the env_var_key already exists.
+          # @param [String] application_id id of the cloud control 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?(application_id, env_var_key, all_vars = nil)
+            all_vars = cc_vars(application_id) if all_vars.nil?
+            all_vars.key? env_var_key.to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        # AppStates for Cloud Foundry V2, or the logic to determine the current application state
+        module AppStates
+          private
+
+          def application_state(app_resource)
+            if app_resource[:entity][:state] == 'STARTED'
+              # 1: crashed
+              return Enums::ApplicationStates::CRASHED if app_resource[:entity][:package_state] == 'FAILED'
+              # 1: started
+              return Enums::ApplicationStates::RUNNING if app_resource[:entity][:package_state] == 'STAGED'
+            end
+
+            # 4: stopped if there is a detected buildpack
+            return Enums::ApplicationStates::STOPPED unless app_resource[:entity][:staging_task_id].nil?
+            # 3: deployed if stopped but no data can be downloaded
+            return Enums::ApplicationStates::DEPLOYED if deployed?(app_resource[:metadata][:guid])
+            # 2: created if stopped and no buildpack detected
+            Enums::ApplicationStates::CREATED
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        module Application
+          # @see Stub#applications
+          def applications
+            response = get('/v2/apps')
+            apps = []
+            response.body[:resources].each do |application_resource|
+              apps << to_nucleus_app(application_resource)
+            end
+            apps
+          end
+
+          # @see Stub#application
+          def application(application_name_or_id)
+            app_guid = app_guid(application_name_or_id)
+            get_response = get("/v2/apps/#{app_guid}")
+            to_nucleus_app(get_response.body)
+          end
+
+          # @see Stub#create_application
+          def create_application(application)
+            if application.key? :region
+              unless application[:region].casecmp('default') == 0
+                fail Errors::SemanticAdapterRequestError,
+                     "Region '#{application[:region]}' does not exist at the endpoint. "\
+                     'Please check which regions are actually available on this endpoint.'
+              end
+              # there is no region in Cloud Foundry --> remove from request
+              application.delete :region
+            end
+
+            apply_buildpack(application)
+
+            # apply default values, if not overridden by custom params
+            default_params = { space_guid: user_space_guid }
+            application = default_params.merge(application)
+
+            # WORKAROUND: requires numeric input, but rack-test provides characters :/
+            application['memory'] = application['memory'].to_i if application.key?('memory')
+
+            response = post('/v2/apps', body: application).body
+
+            # now create the default route (similar to when using an UI, e.g. Pivotal, Stackato or Bluemix) == web_url
+            create_cf_domain(response[:metadata][:guid], @endpoint_app_domain, response[:metadata][:guid])
+
+            # finally build the application response
+            application(response[:metadata][:guid])
+          end
+
+          # @see Stub#update_application
+          def update_application(application_name_or_id, application_form)
+            app_guid = app_guid(application_name_or_id)
+            apply_buildpack(application_form)
+            # update by guid
+            update_response = put("/v2/apps/#{app_guid}", body: application_form)
+            to_nucleus_app(update_response.body)
+          end
+
+          # @see Stub#delete_application
+          def delete_application(application_name_or_id)
+            app_guid = app_guid(application_name_or_id)
+            # first delete all service bindings
+            remove_all_services(app_guid)
+            # then delete the default route (otherwise it would remain as orphaned route)
+            routes = get("/v2/apps/#{app_guid}/routes?q=host:#{app_guid}&inline-relations-depth=1").body[:resources]
+            default_route = routes.find { |route| route[:entity][:domain][:entity][:name] == @endpoint_app_domain }
+            delete("/v2/routes/#{default_route[:metadata][:guid]}") if default_route
+            # and finally delete the app
+            delete("/v2/apps/#{app_guid}")
+          end
+
+          private
+
+          def apply_buildpack(application)
+            # handle desired runtime(s)
+            runtimes = application.delete(:runtimes)
+            return unless runtimes
+            fail_with(:only_one_runtime) if runtimes.length > 1
+
+            buildpack = find_runtime(runtimes[0])
+            # use the translated buildpack name if available, otherwise pass on the given runtime name
+            application[:buildpack] = buildpack ? buildpack : runtimes[0]
+          end
+
+          def to_nucleus_app(app_resource)
+            metadata = app_resource[:metadata]
+            app = app_resource[:entity]
+
+            app[:id] = metadata[:guid]
+            app[:created_at] = metadata[:created_at]
+            app[:updated_at] = metadata[:updated_at] || metadata[:created_at]
+            app[:state] = application_state(app_resource)
+            app[:web_url] = "http://#{app_web_url(metadata[:guid])}"
+            # route could have been deleted by the user
+            app[:web_url] = nil unless domain?(metadata[:guid], app[:web_url])
+            # Stackato does support autoscaling
+            app[:autoscaled] = app.delete(:autoscale_enabled) || false
+            app[:region] = 'default'
+            app[:active_runtime] = app[:detected_buildpack]
+            app[:runtimes] = app[:buildpack] ? [app[:buildpack]] : []
+            app[:release_version] = app.delete(:version)
+            app
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        # Authentication functionality to support the Cloud Foundry API
+        module Authentication
+          # @see Stub#auth_client
+          def auth_client
+            auth_endpoint = endpoint_info[:authorization_endpoint]
+            log.debug "Authenticate @ #{auth_endpoint}/oauth/token"
+            OAuth2AuthClient.new("#{auth_endpoint}/oauth/token", @check_certificates)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        module Buildpacks
+          include Nucleus::Adapters::BuildpackTranslator
+
+          # @see BuildpackTranslator#vendor_specific_runtimes
+          def vendor_specific_runtimes
+            {
+              'ruby' => 'ruby_buildpack',
+              'nodejs' => 'nodejs_buildpack',
+              'python' => 'python_buildpack',
+              'java' => 'java_buildpack',
+              'go' => 'go_buildpack',
+              'php' => 'php_buildpack'
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module Nucleus
+  module Adapters
+    module V1
+      # The {CloudFoundryV2} adapter is designed to support the Cloud Foundry API and uses only commands
+      # of the API version 2.<br>
+      # <br>
+      # Besides native Cloud Foundry installations, this adapter shall also work with forks, such as Stackato 3.4.2.<br>
+      # <br>
+      # The Nucleus API is fully supported, there are no known issues.
+      # @see http://apidocs.cloudfoundry.org The latest Cloud Foundry API documentation
+      class CloudFoundryV2 < Stub
+        include Nucleus::Logging
+        include Nucleus::Adapters::V1::CloudFoundryV2::Authentication
+        include Nucleus::Adapters::V1::CloudFoundryV2::AppStates
+        include Nucleus::Adapters::V1::CloudFoundryV2::Buildpacks
+        include Nucleus::Adapters::V1::CloudFoundryV2::Application
+        include Nucleus::Adapters::V1::CloudFoundryV2::Domains
+        include Nucleus::Adapters::V1::CloudFoundryV2::Data
+        include Nucleus::Adapters::V1::CloudFoundryV2::Lifecycle
+        include Nucleus::Adapters::V1::CloudFoundryV2::Logs
+        include Nucleus::Adapters::V1::CloudFoundryV2::Regions
+        include Nucleus::Adapters::V1::CloudFoundryV2::Scaling
+        include Nucleus::Adapters::V1::CloudFoundryV2::SemanticErrors
+        include Nucleus::Adapters::V1::CloudFoundryV2::Services
+        include Nucleus::Adapters::V1::CloudFoundryV2::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)
+          cf_error = error.body.is_a?(Hash) ? error.body[:code] : nil
+          case error.status
+          when 400
+            handle_400_error(error, cf_error)
+          when 404
+            fail Errors::AdapterResourceNotFoundError, error.body[:description] if cf_error > 10_000
+          else
+            if [1001].include? cf_error
+              fail Errors::AdapterRequestError, "#{error.body[:description]} (#{cf_error} - #{error.body[:error_code]})"
+            elsif [10_002].include?(cf_error) || error.status == 401
+              fail Errors::EndpointAuthenticationError, 'Endpoint authentication failed with OAuth2 token'
+            end
+          end
+          # error still unhandled, will result in a 500, server error
+          log.warn "Cloud Foundry error still unhandled: #{error}"
+        end
+
+        private
+
+        def handle_400_error(error, cf_error)
+          if cf_error == 150_001 || cf_error == 160_001 || cf_error > 100_000 && cf_error < 109_999
+            # Indicating semantically invalid parameters
+            fail Errors::SemanticAdapterRequestError, error.body[:description]
+          elsif cf_error == 170_002
+            fail_with(:build_in_progress)
+          elsif cf_error == 60_002
+            fail Errors::SemanticAdapterRequestError, 'Service is already assigned to the application'
+          end
+        end
+
+        def guid?(name_or_id)
+          Regexp::UUID_PATTERN.match(name_or_id) ? true : false
+        end
+
+        def default_organization_guid
+          get("/v2/spaces/#{user_space_guid}").body[:entity][:organization_guid]
+        end
+
+        def app_guid(app_name_or_id)
+          # app name is a UUID and therefore most likely the CF GUID
+          return app_name_or_id if guid?(app_name_or_id)
+          find_app_guid_by_name(app_name_or_id)
+        end
+
+        def find_app_guid_by_name(application_name)
+          filtered_list_response = get('/v2/apps', query: { q: "name:#{application_name}" })
+          if filtered_list_response.body[:resources].length == 0
+            fail Errors::AdapterResourceNotFoundError,
+                 "Couldn't find app with name '#{application_name}' on the platform"
+          end
+          # return the found guid
+          filtered_list_response.body[:resources][0][:metadata][:guid]
+        end
+
+        def find_app_id_by_name(application_name, previous_response)
+          filtered_list_response = get('/v2/apps', query: { q: "name:#{application_name}" })
+          # fail as expected if the app can also not be found by its name
+          fail Errors::AdapterResourceNotFoundError,
+               previous_response.body[:description] if filtered_list_response.body[:resources].length == 0
+          # return the found guid
+          filtered_list_response.body[:resources][0][:metadata][:guid]
+        end
+
+        def endpoint_info
+          get('/v2/info', headers: {}).body
+        end
+
+        def user_info
+          get("#{endpoint_info[:authorization_endpoint]}/userinfo").body
+        end
+
+        def user
+          get("/v2/users/#{user_info[:user_id]}").body
+        end
+
+        def user_space_guid
+          users_spaces = get('/v2/spaces').body[:resources]
+          # only once space accessible
+          return users_spaces[0][:metadata][:guid] if users_spaces.length == 1
+          # use default space (stackato feature)
+          default_space = users_spaces.detect { |space_resource| space_resource[:entity][:is_default] == true }
+          return default_space[:metadata][:guid] if default_space
+          # check the users spaces for default
+          user_default_space_guid = user[:entity][:default_space_guid]
+          return user_default_space_guid if user_default_space_guid
+          # TODO: find a more suitable approach to detect the right space !?
+          # multiple spaces and no default space (dammit), choose the first one...
+          return users_spaces[0][:metadata][:guid] if users_spaces
+          # user has no space assigned, fail since we cant determine a space guid
+          fail_with(:no_space_assigned)
+        end
+
+        def headers
+          super.merge('Basic' => 'Y2Y6', 'Content-Type' => 'application/json')
+        end
+
+        def deployed?(application_guid)
+          response = head("/v2/apps/#{application_guid}/download", follow_redirects: false, expects: [200, 302, 404])
+          return true if response.status == 200 || response.status == 302
+          return false if response.status == 404
+          # if the response is neither one of the codes, the call fails anyway...
+        end
+
+        def app_web_url(app_guid)
+          "#{app_guid}.#{@endpoint_app_domain}" if @endpoint_app_domain
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        module Data
+          # @see Stub#deploy
+          def deploy(application_name_or_id, file, file_compression_format)
+            # could be made async, too
+            # resources: [] says that no previous data shall be reused, see also:
+            # http://apidocs.cloudfoundry.org/202/apps/uploads_the_bits_for_an_app.html
+
+            app_guid = app_guid(application_name_or_id)
+            # deploy by guid
+            # deploy_response = put("/v2/apps/#{app_guid}/bits", body: { resources: [], application: file.read },
+            #                       headers: { 'Content-Type' => 'multipart/form-data; '\
+            #                       'boundary=nucleus-cloud-foundry-adapter-file-upload-boundary' })
+
+            begin
+              # convert all archives to .zip archives
+              converted_file = ArchiveConverter.convert(file, file_compression_format, 'zip', true)
+              unless converted_file.respond_to?(:path) && converted_file.respond_to?(:read)
+                tmpfile = Tempfile.new(["nucleus-cf-deploy-upload-#{app_guid}", '.zip'])
+                tmpfile.binmode
+                tmpfile.write converted_file.read
+                tmpfile.rewind
+                converted_file = tmpfile
+              end
+
+              # TODO: this is only a temporary solution until excon supports multipart requests
+              # See also: https://github.com/excon/excon/issues/353
+              url = "#{@endpoint_url}/v2/apps/#{app_guid}/bits"
+              request_body = { multipart: true, application: converted_file, async: false, resources: '[]' }
+              begin
+                RestClient::Request.execute(method: :put, url: url, payload: request_body,
+                                            headers: headers, verify_ssl: @check_certificates)
+              rescue RestClient::BadRequest => e
+                raise Errors::AdapterRequestError, e.http_body
+              end
+            ensure
+              if tmpfile
+                tmpfile.close
+                tmpfile.unlink # deletes this temporary file
+              end
+            end
+          end
+
+          # @see Stub#download
+          def download(application_name_or_id, compression_format)
+            app_guid = app_guid(application_name_or_id)
+            # fail if there is no deployment
+            unless deployed?(app_guid)
+              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before data can be downloaded'
+            end
+
+            download_response = get("/v2/apps/#{app_guid}/download", follow_redirects: false, expects: [200, 302])
+            if download_response.status == 200
+              data = download_response.body
+            else
+              download_location = download_response.headers[:Location]
+              # if IBM f*cked with the download URL, fix the address
+              download_location = download_location.gsub(/objectstorage.service.networklayer.com/, 'objectstorage.softlayer.net')
+              # omit_default_port: https://github.com/excon/excon/issues/475
+              data = Excon.new(download_location, omit_default_port: true).get.body
+            end
+
+            # write data to tmpfile so that it can be converted
+            downloaded_application_archive = Tempfile.new(["nucleus-cf-deployment-download-#{app_guid}", '.zip'])
+            downloaded_application_archive.binmode
+            downloaded_application_archive.write StringIO.new(data).read
+            downloaded_application_archive.rewind
+
+            # convert from current format (which is always a zip archive) to the destination format
+            ArchiveConverter.convert(downloaded_application_archive, 'zip', compression_format, false)
+          ensure
+            if downloaded_application_archive
+              downloaded_application_archive.close
+              downloaded_application_archive.unlink
+            end
+          end
+
+          # @see Stub#rebuild
+          def rebuild(application_name_or_id)
+            app_guid = app_guid(application_name_or_id)
+            # fail if there is no deployment
+            unless deployed?(app_guid)
+              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before it can be rebuild'
+            end
+
+            # rebuild by name or id
+            rebuild_response = post("/v2/apps/#{app_guid}/restage")
+            to_nucleus_app(rebuild_response.body)
+          end
+        end
+      end
+    end
+  end
+end