nucleus 0.1.0

data/lib/nucleus/adapters/base_adapter.rb

@@ -0,0 +1,109 @@
+module Nucleus
+  # The {Adapters} module combines all application logic to communicate with the different vendor platforms
+  # and created the unified API.
+  module Adapters
+    # The {BaseAdapter} is an abstract class that shall be extended by all actual Adapters.
+    # It provides methods to common functionality:<br>
+    # * authentication (+cache)
+    # * http client with general error handling
+    # * native platform API calls
+    # @abstract
+    class BaseAdapter
+      include HttpClient
+      include HttpTailClient
+      include Logging
+
+      attr_reader :endpoint_url
+
+      def initialize(endpoint_url, endpoint_app_domain = nil, check_certificates = true)
+        fail ArgumentError, "'endpoint_url' must be a valid URL" unless endpoint_url =~ /\A#{URI.regexp(['https'])}\z/
+        @endpoint_url = endpoint_url
+        @endpoint_app_domain = endpoint_app_domain
+        @check_certificates = check_certificates
+      end
+
+      # thread-based cache for the api authorization headers
+      thread_config_accessor :auth_objects_cache, default: {}
+
+      # Cache the auth information.
+      # @param [String] key cache key
+      # @param [Nucleus::Adapters::AuthClient] auth_object authentication client to be cached
+      # @return [void]
+      def cache(key, auth_object)
+        auth_objects_cache[key] = auth_object
+      end
+
+      # Are there cached information for this key?
+      # @param [String] key cache key
+      # @return [true, false] true if has cached auth info, else false
+      def cache?(key)
+        auth_objects_cache.key? key
+      end
+
+      # Get the currently cached authentication object.
+      # @param [String] key cache key
+      # @return [Hash<String,String>, Nucleus::Adapters::AuthClient] cached authentication client
+      def cached(key)
+        return nil unless cache?(key)
+        auth_objects_cache[key]
+      end
+
+      # Create the cache key for the username / password combination and save it in the {::RequestStore} to make it
+      # available throughout the current request.
+      # @param [String] username the username for the authentication
+      # @param [String] password the password for the authentication
+      # @return [String] calculated hash key for the input values
+      def cache_key(username, password)
+        # calculate the cache only once per request
+        return RequestStore.store[:cache_key] if RequestStore.exist?(:cache_key)
+        key = Digest::SHA256.hexdigest "#{endpoint_url}#{username}:#{password}"
+        RequestStore.store[:cache_key] = key
+        key
+      end
+
+      # Get the cached authentication object and retrieve the presumably valid authentication header.
+      # @return [Hash<String,String>] hash including a valid authentication header
+      def headers
+        auth_object = auth_objects_cache[RequestStore.store[:cache_key]]
+        # AuthClient, generates the header for us
+        auth_object.auth_header
+      end
+
+      # Execute an API call, targeted directly against the vendors API.
+      # @param [Symbol] method http method to use, one of: [:GET, :POST, :DELETE, :PUT, :PATCH]
+      # @param [String] path url path to append to the endpoint's URL
+      # @param [Hash] params body params to use for PATCH, :PUT and :POST requests
+      # @return [Object] the actual response body of the vendor platform
+      def endpoint_call(method, path, params)
+        case method
+        when :GET
+          get(path, native_call: true).body
+        when :POST
+          post(path, native_call: true, body: params).body
+        when :DELETE
+          delete(path, native_call: true).body
+        when :PUT
+          put(path, native_call: true, body: params).body
+        when :PATCH
+          patch(path, native_call: true, body: params).body
+        else
+          fail AdapterRequestError, 'Unsupported adapter call method. Allowed are: GET, POST, PATCH, PUT, DELETE'
+        end
+      end
+
+      # Fail with a {Errors::PlatformSpecificSemanticError} error and format the error message to include the values
+      # that are passed in the params. Requires the adapter to provide a +semantic_error_messages+ method, which shall
+      # return a Hash with the platform specific semantic errors.
+      # @param [Symbol] error_name error that shall be returned
+      # @param [Array<String>] params values that are to be included in the error message template
+      # @raise [Errors::PlatformSpecificSemanticError]
+      def fail_with(error_name, params = nil)
+        unless respond_to?(:semantic_error_messages)
+          fail StandardError 'Invalid adapter implementation, no :semantic_error_messages method provided'
+        end
+        error = semantic_error_messages[error_name]
+        fail Errors::PlatformSpecificSemanticError.new(error[:message] % params, error[:code])
+      end
+    end
+  end
+end

data/lib/nucleus/adapters/buildpack_translator.rb

@@ -0,0 +1,79 @@
+module Nucleus
+  module Adapters
+    # The {BuildpackTranslator} provides convenience methods for the user to handle the installation
+    # of application runtimes. Common runtime names can be applied and are automatically translated to a
+    # platform native runtime name / url (if applicable).
+    module BuildpackTranslator
+      # List of common buildpacks that are available GitHub.
+      # However, they are not guaranteed to work with every platform that utilized buildpacks.
+      PUBLIC_BUILDPACKS = {
+        'c' => 'https://github.com/atris/heroku-buildpack-c',
+        'common_lisp' => 'https://github.com/mtravers/heroku-buildpack-cl',
+        'core_data' => 'https://github.com/heroku/heroku-buildpack-core-data',
+        'dart' => 'https://github.com/igrigorik/heroku-buildpack-dart',
+        'eiffel' => 'https://github.com/mbustosorg/heroku-buildpack-eiffel',
+        'elixir' => 'https://github.com/hashnuke/heroku-buildpack-elixir',
+        'emacs' => 'https://github.com/technomancy/heroku-buildpack-emacs',
+        'embedded_proxy' => 'https://github.com/ryanbrainard/heroku-buildpack-embedded-proxy',
+        'erlang' => 'https://github.com/archaelus/heroku-buildpack-erlang',
+        'factor' => 'https://github.com/ryanbrainard/heroku-buildpack-factor',
+        'fakesu' => 'https://github.com/fabiokung/heroku-buildpack-fakesu',
+        'geodjango' => 'https://github.com/cirlabs/heroku-buildpack-geodjango',
+        'go' => 'https://github.com/kr/heroku-buildpack-go',
+        'haskell' => 'https://github.com/mietek/haskell-on-heroku',
+        'inline' => 'https://github.com/kr/heroku-buildpack-inline',
+        'java_ant' => 'https://github.com/dennisg/heroku-buildpack-ant',
+        # introduced by IBM Bluemix, shall also work in Heroku
+        'java_liberty' => 'https://github.com/cloudfoundry/ibm-websphere-liberty-buildpack',
+        'jekyll' => 'https://github.com/mattmanning/heroku-buildpack-ruby-jekyll',
+        'lua' => 'https://github.com/leafo/heroku-buildpack-lua',
+        'luvit' => 'https://github.com/skomski/heroku-buildpack-luvit',
+        'meteor' => 'https://github.com/jordansissel/heroku-buildpack-meteor',
+        'middleman' => 'https://github.com/hashicorp/heroku-buildpack-middleman',
+        'monit' => 'https://github.com/k33l0r/monit-buildpack',
+        'multi' => 'https://github.com/heroku/heroku-buildpack-multi',
+        'nanoc' => 'https://github.com/bobthecow/heroku-buildpack-nanoc',
+        'dot_net' => 'https://github.com/friism/heroku-buildpack-mono',
+        'null' => 'https://github.com/ryandotsmith/null-buildpack',
+        'opa' => 'https://github.com/tsloughter/heroku-buildpack-opa',
+        'perl' => 'https://github.com/miyagawa/heroku-buildpack-perl',
+        'phantomjs' => 'https://github.com/stomita/heroku-buildpack-phantomjs',
+        'phing' => 'https://github.com/ryanbrainard/heroku-buildpack-phing',
+        'r' => 'https://github.com/virtualstaticvoid/heroku-buildpack-r',
+        'rust' => 'https://github.com/emk/heroku-buildpack-rust',
+        'redline' => 'https://github.com/will/heroku-buildpack-redline',
+        'silex' => 'https://github.com/klaussilveira/heroku-buildpack-silex',
+        'sphinx' => 'https://github.com/kennethreitz/sphinx-buildpack',
+        'test' => 'https://github.com/ddollar/buildpack-test',
+        'testing' => 'https://github.com/ryanbrainard/heroku-buildpack-testrunner'
+      }
+
+      # Search the list of known buildpacks, both vendor specific and public, to match the desires runtime name.
+      # @param [String] name of the runtime to look out for
+      # @return [Boolean] returns true if a vendor specific or public buildpack was found for the runtime
+      def find_runtime(name)
+        if respond_to? :vendor_specific_runtimes
+          runtime = vendor_specific_runtimes[name.downcase.underscore]
+          return runtime unless runtime.nil?
+        end
+
+        # if no vendor specific runtime was found, use the general definitions
+        PUBLIC_BUILDPACKS[name.downcase.underscore]
+      end
+
+      # Checks if the name of the runtime is matching a vendor specific runtime / buildpack.
+      # @param [String] name of the runtime for which to check if it matches a vendor specific runtime
+      # @return [Boolean] returns true if the name matches a vendor specific runtime, false otherwise
+      def native_runtime?(name)
+        if respond_to? :vendor_specific_runtimes
+          # case A: name is a key
+          return true if vendor_specific_runtimes.keys.include? name
+          # case B: name is a specific runtime name or a URL and one of the values
+          return vendor_specific_runtimes.values.include? name
+        end
+        # cant be native if there are no vendor specific runtimes
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudControl < Stub
+        # cloud control, CRUD operations for the application object
+        module Application
+          # @see Stub#applications
+          def applications
+            response = get('/app')
+            apps = []
+            response.body.each do |application|
+              apps << to_nucleus_app(application, default_deployment(application[:name]))
+            end
+            apps
+          end
+
+          # @see Stub#application
+          def application(application_id)
+            response = get("/app/#{application_id}").body
+            to_nucleus_app(response, default_deployment(response[:name]))
+          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 cloudControl --> remove from request
+              application.delete :region
+            end
+
+            apply_buildpack(application)
+
+            # force the use of repository type 'git', unless overridden by the params
+            default_params = { repository_type: 'git' }
+            cc_application = default_params.merge(application)
+
+            create_app_response = post('/app', body: cc_application).body
+
+            # create the default deployment, name will automatically become 'default'
+            created_deployment = post("/app/#{create_app_response[:name]}/deployment", body: { name: 'nucleus' }).body
+
+            # activate the variables addon. However, the activation explicitly requires an initial key value pair...
+            post("/app/#{create_app_response[:name]}/deployment/#{NUCLEUS_DEPLOYMENT}/addon",
+                 body: { addon: 'config.free', options: "{\"nucleus-initialized\": \"true\"}" }).body
+            # ...now delete the initial key value pair to have the desired clean setup
+            delete_env_var(create_app_response[:name], 'nucleus-initialized')
+
+            to_nucleus_app(create_app_response, created_deployment)
+          end
+
+          # @see Stub#delete_application
+          def delete_application(application_id)
+            # delete all deployments first
+            deployments = get("/app/#{application_id}/deployment").body
+            deployments.each do |deployment|
+              deployment_name = %r{(\w+)\/(\w+)}.match(deployment[:name])[2]
+              delete("/app/#{application_id}/deployment/#{deployment_name}")
+            end
+            delete("/app/#{application_id}")
+          end
+
+          private
+
+          def apply_buildpack(application)
+            runtimes = application.delete(:runtimes)
+            return unless runtimes
+            fail_with(:only_one_runtime) if runtimes.length > 1
+            buildpack = find_runtime(runtimes[0])
+            if native_runtime?(buildpack)
+              application[:type] = buildpack
+            elsif buildpack
+              application[:type] = 'custom'
+              application[:buildpack_url] = buildpack
+            else
+              # 3rd party buildpack must be a valid URL
+              unless Regexp::PERFECT_URL_PATTERN =~ runtimes[0]
+                fail Errors::SemanticAdapterRequestError,
+                     "Invalid buildpack: '#{runtimes[0]}'. Please provide a valid buildpack URL for all "\
+                      'custom buildpacks that are not provided by cloud control.'
+              end
+              application[:type] = 'custom'
+              application[:buildpack_url] = runtimes[0]
+            end
+          end
+
+          def to_nucleus_app(app, deployment)
+            app[:id] = app[:name]
+            app[:created_at] = app.delete :date_created
+            app[:updated_at] = app.delete :date_modified
+            app[:state] = application_state(deployment)
+            app[:web_url] = "http://#{deployment[:default_subdomain]}"
+            app[:autoscaled] = false
+            app[:region] = 'default'
+            app[:instances] = deployment[:min_boxes]
+            app[:active_runtime] = app[:type][:name] == 'custom' ? app[:buildpack_url] : app[:type][:name]
+            app[:runtimes] = [app[:active_runtime]]
+            app[:release_version] = deployment[:version] != '-1' ? deployment[:version] : nil
+            app
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudControl < Stub
+        # Authentication functionality to support the cloudControl API
+        module Authentication
+          # @see Stub#auth_client
+          def auth_client
+            Token.new @check_certificates do |_verify_ssl, username, password|
+              auth_headers = { 'Authorization' => 'Basic ' + ["#{username}:#{password}"].pack('m*').gsub(/\n/, '') }
+              begin
+                # ssl verification is implemented by the HttpClient itself
+                response = post('/token', headers: auth_headers)
+                # parse to retrieve the token and expiration date
+                expires = Time.parse(response.body[:expires])
+                [response.body[:token], expires]
+              rescue Errors::AdapterError
+                # ignore the error, return nil for failed authentication
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Nucleus
+  module Adapters
+    module V1
+      class CloudControl < Stub
+        # cloud control specific buildpacks
+        module Buildpacks
+          include Nucleus::Adapters::BuildpackTranslator
+
+          # @see BuildpackTranslator#vendor_specific_runtimes
+          def vendor_specific_runtimes
+            {
+              'java' => 'java',
+              'nodejs' => 'nodejs',
+              'ruby' => 'ruby',
+              'php' => 'php',
+              'python' => 'python'
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+require 'net/ssh'
+
+module Nucleus
+  module Adapters
+    module V1
+      class CloudControl < Stub
+        include Nucleus::Logging
+        include Nucleus::Adapters::V1::CloudControl::Authentication
+        include Nucleus::Adapters::V1::CloudControl::Application
+        include Nucleus::Adapters::V1::CloudControl::Buildpacks
+        include Nucleus::Adapters::V1::CloudControl::Domains
+        include Nucleus::Adapters::V1::CloudControl::Data
+        include Nucleus::Adapters::V1::CloudControl::Lifecycle
+        include Nucleus::Adapters::V1::CloudControl::Logs
+        include Nucleus::Adapters::V1::CloudControl::Regions
+        include Nucleus::Adapters::V1::CloudControl::Scaling
+        include Nucleus::Adapters::V1::CloudControl::SemanticErrors
+        include Nucleus::Adapters::V1::CloudControl::Services
+        include Nucleus::Adapters::V1::CloudControl::Vars
+
+        # The default deployment name of cloud control applications that is used by Nucleus
+        NUCLEUS_DEPLOYMENT = 'nucleus'
+        # Error messages of semantic errors that are platform specific
+        CC_EXCLUSIVE_SEMANTIC_ERROR_MSGS = ['cannot use this name', 'may only contain', 'this field has no more than']
+        # Error messages of common semantic errors
+        CC_SEMANTIC_ERROR_MSGS = ['must be unique', 'already exists',
+                                  'not a valid addon name', 'not a valid addon option']
+        CC_CONFLICT_ERROR_MSGS = ['Addon already exists']
+
+        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)
+          message = error_response.body.match(/{(.*?)}/)
+          message = message[1] if message
+
+          # cloud control responds almost every time with 400...
+          if error_response.status == 400
+            handle_400(message)
+          elsif error_response.status == 409 && CC_CONFLICT_ERROR_MSGS.any? { |msg| message.include? msg }
+            fail Errors::SemanticAdapterRequestError, message
+          elsif error_response.status == 410
+            fail Errors::AdapterResourceNotFoundError, 'Resource not found'
+          elsif error_response.status == 503
+            fail Errors::PlatformUnavailableError, 'The cloudControl API is currently not available'
+          end
+          # error still unhandled, will result in a 500, server error
+          log.warn "cloudControl error still unhandled: #{error_response}"
+        end
+
+        private
+
+        def handle_400(message)
+          fail Errors::AdapterResourceNotFoundError, 'Resource not found' if message.nil?
+
+          if message.include?('Billing account required')
+            fail_with(:billing_required, [message])
+          elsif CC_EXCLUSIVE_SEMANTIC_ERROR_MSGS.any? { |msg| message.include? msg }
+            # all these errors are limited to cloud control, e.g. the allowed name characters and max name length
+            fail_with(:bad_name, [message])
+          elsif CC_SEMANTIC_ERROR_MSGS.any? { |msg| message.include? msg }
+            fail Errors::SemanticAdapterRequestError, message
+          end
+          fail Errors::AdapterRequestError, message
+        end
+
+        def username
+          get('/user').body.first[:username]
+        end
+
+        def data_uploaded?(deployment)
+          application_id = deployment[:name].split(%r{/})[0]
+          repo_host = URI.parse(deployment[:branch]).host
+          repo_path = URI.parse(deployment[:branch]).path.gsub(%r{^/}, '').chomp('.git')
+          attempts = 0
+          with_ssh_key do
+            loop do
+              begin
+                return GitRepoAnalyzer.any_branch?(repo_host, repo_path, application_id)
+              rescue Net::SSH::AuthenticationFailed => e
+                attempts += 1
+                # wait up to 30 seconds
+                raise e if attempts >= 15
+                log.debug('SSH authentication failed, sleep and repeat')
+                # authentication is not yet ready, wait a short time
+                sleep(2.0)
+              end
+            end
+          end
+        end
+
+        def application_state(deployment)
+          # With cloud control not supporting the Nucleus application lifecycle, only 3 actual states remain:<br>
+          # * created, when no data deployment (not to confuse with cloud control deployment object) has been made yet
+          # * deployed, when only the data has been pushed into the repository (no build)
+          # * running, if a data deployment was pushed
+          if deployment[:version] == '-1'
+            return Enums::ApplicationStates::DEPLOYED if data_uploaded?(deployment)
+            return Enums::ApplicationStates::CREATED
+          end
+          return Enums::ApplicationStates::IDLE if deployment[:state] == 'idle'
+          Enums::ApplicationStates::RUNNING
+          # return Enums::ApplicationStates::STOPPED
+
+          # arriving here the above states do not catch all states of the cloudControl app, which should not happen ;-)
+          # fail Errors::UnknownAdapterCallError, 'Could not determine application state. '\
+          #   'Please verify the cloudControl adapter'
+        end
+
+        def default_deployment(application_id)
+          # get and return nucleus deployment, but catch arising 404 errors
+          return get("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}").body
+        rescue Errors::AdapterResourceNotFoundError
+          # if 404, list all deployments
+          all_deployments = get("/app/#{application_id}/deployment").body
+
+          # fail 422 (platform specific) if no deployment is available at all
+          fail_with(:no_deployment) if all_deployments.length == 0
+
+          # return deployment[0] if collection size is 1
+          return all_deployments[0] if all_deployments.length == 1
+
+          # return 'default' if more than 1 deployment and 'default' is included
+          def_deployment = all_deployments.find { |d| d[:name].split(%r{/})[1].downcase == 'default' }
+          return def_deployment if def_deployment
+
+          # return 'nucleus' if more than 1 deployment, but no 'default' is included
+          nucleus_deployment = all_deployments.find { |d| d[:name].split(%r{/})[1].downcase == 'nucleus' }
+          return nucleus_deployment if nucleus_deployment
+
+          # fail 422 if no 'default', no 'nucleus', and more than 1 deployment is available (could not identify default)
+          fail_with(:ambiguous_deployments)
+        end
+
+        def headers
+          super.merge('Content-Type' => 'application/json')
+        end
+
+        def with_ssh_key
+          user = username
+          # load ssh key into cloud control
+          matches = nucleus_config.ssh.handler.public_key.match(/(.*)\s{1}(.*)\s{1}(.*)/)
+          key_id = register_key(user, matches[1], matches[2])
+          return yield
+        ensure
+          # unload ssh key, allow 404 if the key couldn't be registered at first
+          delete("/user/#{user}/key/#{key_id}") if key_id
+        end
+      end
+    end
+  end
+end