nucleus 0.1.0

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

@@ -0,0 +1,93 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Application
+          # @see Stub#applications
+          def applications
+            response = get('/apps')
+            apps = []
+            response.body.each do |application|
+              apps << to_nucleus_app(application)
+            end
+            apps
+          end
+
+          # @see Stub#application
+          def application(application_id)
+            response = get("/apps/#{application_id}")
+            to_nucleus_app response.body
+          end
+
+          # @see Stub#delete_application
+          def delete_application(application_id)
+            # returns the application, but we do not want any output
+            delete("/apps/#{application_id}")
+          end
+
+          # @see Stub#create_application
+          def create_application(application)
+            # updates the application with a valid region identity
+            retrieve_region(application)
+
+            # Heroku does not support autoscale
+            fail_with(:no_autoscale) if application[:autoscaled]
+            application.delete :autoscaled
+
+            # can fail if runtime URLs are invalid or names do not exist on this platform
+            runtimes = runtimes_to_install(application)
+
+            # create the actual application
+            created_app = post('/apps', body: application).body
+
+            # when application has been created, process runtime information if applicable
+            unless runtimes.nil? || runtimes.empty?
+              begin
+                install_runtimes(created_app[:id], runtimes)
+              rescue
+                # if buildpack fails, make sure app gets deleted (!)
+                log.debug 'Runtime installation failed, rollback...'
+                delete_application(created_app[:id])
+                log.debug '...application successfully rolled back'
+                raise Errors::AdapterRequestError,
+                      'Heroku requires a buildpack URL when the runtime shall be specified manually.'
+              end
+            end
+            to_nucleus_app(created_app)
+          end
+
+          # TODO: make update transactional in case sub-task (app, buildpacks) fails
+          # @see Stub#update_application
+          def update_application(application_id, application)
+            # start updating the buildpacks
+            if application.key? :runtimes
+              # can fail if runtime URLs are invalid or names do not exist on this platform
+              runtimes = runtimes_to_install(application)
+              install_runtimes(application_id, runtimes)
+            end
+
+            # now change the app name and all other direct properties, which are in the body
+            response = patch("/apps/#{application_id}", body: application)
+            to_nucleus_app(response.body)
+          end
+
+          private
+
+          def to_nucleus_app(heroku_application)
+            # load dynos only once
+            dynos = dynos(heroku_application[:id])
+            # add missing fields to the application representation
+            heroku_application[:autoscaled] = false
+            heroku_application[:state] = application_state(heroku_application, dynos)
+            heroku_application[:instances] = application_instances(heroku_application[:id])
+            heroku_application[:active_runtime] = heroku_application.delete(:buildpack_provided_description)
+            heroku_application[:runtimes] = installed_buildpacks(heroku_application[:id])
+            heroku_application[:release_version] = latest_release(heroku_application[:id], dynos)
+            heroku_application[:region] = heroku_application[:region][:name]
+            heroku_application
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        # Authentication functionality to support the Heroku API
+        module Authentication
+          # @see Stub#auth_client
+          def auth_client
+            log.debug "Authenticate @ #{@endpoint_url}"
+            TokenAuthClient.new @check_certificates do |verify_ssl, username, password|
+              response = Excon.post("#{@endpoint_url}/login", query: { username: username, password: password },
+                                   ssl_verify_peer: verify_ssl)
+              # Heroku returns 404 for invalid credentials, then we do not return an API token
+              if response.status == 404
+                nil
+              else
+                # extract the token
+                response_parsed = JSON.parse(response.body)
+                response_parsed['api_key']
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Buildpacks
+          include Nucleus::Adapters::BuildpackTranslator
+
+          # @see BuildpackTranslator#vendor_specific_runtimes
+          def vendor_specific_runtimes
+            {
+              'ruby' => 'https://github.com/heroku/heroku-buildpack-ruby',
+              'nodejs' => 'https://github.com/heroku/heroku-buildpack-nodejs',
+              'clojure' => 'https://github.com/heroku/heroku-buildpack-clojure',
+              'python' => 'https://github.com/heroku/heroku-buildpack-python',
+              'java' => 'https://github.com/heroku/heroku-buildpack-java',
+              'gradle' => 'https://github.com/heroku/heroku-buildpack-gradle',
+              'grails' => 'https://github.com/heroku/heroku-buildpack-grails',
+              'scala' => 'https://github.com/heroku/heroku-buildpack-scala',
+              'play' => 'https://github.com/heroku/heroku-buildpack-play',
+              'php' => 'https://github.com/heroku/heroku-buildpack-php'
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Data
+          # @see Stub#deploy
+          def deploy(application_id, file, file_compression_format)
+            app = get("/apps/#{application_id}").body
+            account = get('/account').body
+            repo_name = "nucleus.app.repo.heroku.deploy.#{application_id}.#{SecureRandom.uuid}"
+            # clone, extract, push and finally delete cloned repository (sync)
+            with_ssh_key do
+              GitDeployer.new(repo_name, app[:git_url], account[:email]).deploy(file, file_compression_format)
+            end
+
+            return unless application_state(app) == Enums::ApplicationStates::CREATED
+            # instantly remove all initially added dynos to keep the 'deployed' state on first deployment
+            log.debug 'state before deployment was \'created\', scale web to 0'
+            scale_web(application_id, 0)
+          end
+
+          # @see Stub#download
+          def download(application_id, compression_format)
+            # Only possible with git, not with HTTP builds
+            app = get("/apps/#{application_id}").body
+            if application_state(app) == Enums::ApplicationStates::CREATED
+              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before data can be downloaded'
+            end
+            # compress files to archive but exclude the .git repo
+            repo_name = "nucleus.app.repo.heroku.download.#{application_id}.#{SecureRandom.uuid}"
+            with_ssh_key do
+              GitDeployer.new(repo_name, app[:git_url], nil).download(compression_format, true)
+            end
+          end
+
+          # @see Stub#rebuild
+          def rebuild(application_id)
+            app = get("/apps/#{application_id}").body
+            if application_state(app) == Enums::ApplicationStates::CREATED
+              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before data can be rebuild'
+            end
+
+            account = get('/account').body
+            repo_name = "nucleus.app.repo.heroku.rebuild.#{application_id}.#{SecureRandom.uuid}"
+
+            with_ssh_key do
+              GitDeployer.new(repo_name, app[:git_url], account[:email]).trigger_build
+            end
+
+            # return with updated application
+            application(application_id)
+          end
+
+          private
+
+          def with_ssh_key
+            # load ssh key into cloud control
+            matches = nucleus_config.ssh.handler.public_key.match(/(.*)\s{1}(.*)\s{1}(.*)/)
+            key_id = register_key(matches[1], matches[2])
+            return yield
+          ensure
+            # unload ssh key, allow 404 if the key couldn't be registered at first
+            delete("/account/keys/#{key_id}") if key_id
+          end
+
+          def register_key(type, key)
+            # skip if the key is already registered
+            installed_keys = get('/account/keys').body
+            return nil if installed_keys.any? { |installed_key| installed_key[:public_key].include?(key) }
+
+            key_name = "nucleus-#{SecureRandom.uuid}"
+            post('/account/keys', body: { public_key: [type, key, key_name].join(' ') }).body[:id]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Domains
+          # As of now, there is no update functionality on Heroku as on most other platforms (!)
+
+          # @see Stub#domains
+          def domains(application_id)
+            domains = get("/apps/#{application_id}/domains").body
+            # exclude web_url by domain, otherwise we would need to fire an additional query and get the application
+            domains.delete_if { |domain| domain[:hostname].end_with? ".#{@endpoint_app_domain}" }
+            domains.collect { |domain| to_nucleus_domain(domain) }
+          end
+
+          # @see Stub#domain
+          def domain(application_id, domain_id)
+            domain = get("/apps/#{application_id}/domains/#{domain_id}").body
+            to_nucleus_domain(domain)
+          end
+
+          # @see Stub#create_domain
+          def create_domain(application_id, domain)
+            domain = post("/apps/#{application_id}/domains", body: { hostname: domain[:name] }).body
+            to_nucleus_domain(domain)
+          end
+
+          # @see Stub#delete_domain
+          def delete_domain(application_id, domain_id)
+            delete("/apps/#{application_id}/domains/#{domain_id}")
+          end
+
+          private
+
+          def to_nucleus_domain(domain)
+            domain[:name] = domain.delete :hostname
+            domain
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+module Nucleus
+  module Adapters
+    module V1
+      # The {Heroku} adapter is designed to support the Heroku platform API.<br>
+      # <br>
+      # The Nucleus API is fully supported, there are no known issues.
+      # @see https://devcenter.heroku.com/articles/platform-api-reference Heroku Platform API
+      class Heroku < Stub
+        include Nucleus::Logging
+        include Nucleus::Adapters::V1::Heroku::Authentication
+        include Nucleus::Adapters::V1::Heroku::Application
+        include Nucleus::Adapters::V1::Heroku::AppStates
+        include Nucleus::Adapters::V1::Heroku::Buildpacks
+        include Nucleus::Adapters::V1::Heroku::Data
+        include Nucleus::Adapters::V1::Heroku::Domains
+        include Nucleus::Adapters::V1::Heroku::Logs
+        include Nucleus::Adapters::V1::Heroku::Lifecycle
+        include Nucleus::Adapters::V1::Heroku::Regions
+        include Nucleus::Adapters::V1::Heroku::Scaling
+        include Nucleus::Adapters::V1::Heroku::Services
+        include Nucleus::Adapters::V1::Heroku::SemanticErrors
+        include Nucleus::Adapters::V1::Heroku::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_response)
+          handle_422(error_response)
+          if error_response.status == 404 && error_response.body[:id] == 'not_found'
+            fail Errors::AdapterResourceNotFoundError, error_response.body[:message]
+          elsif error_response.status == 503
+            fail Errors::PlatformUnavailableError, 'The Heroku API is currently not responding'
+          end
+          # error still unhandled, will result in a 500, server error
+          log.warn "Heroku error still unhandled: #{error_response}"
+        end
+
+        def handle_422(error_response)
+          return unless error_response.status == 422
+          if error_response.body[:id] == 'invalid_params'
+            fail Errors::SemanticAdapterRequestError, error_response.body[:message]
+          elsif error_response.body[:id] == 'verification_required'
+            fail_with(:need_verification, [error_response.body[:message]])
+          end
+        end
+
+        private
+
+        def install_runtimes(application_id, runtimes)
+          runtime_instructions = runtimes.collect { |buildpack_url| { buildpack: buildpack_url } }
+          log.debug "Install runtimes: #{runtime_instructions}"
+          buildpack_instructions = { updates: runtime_instructions }
+          put("/apps/#{application_id}/buildpack-installations", body: buildpack_instructions)
+        end
+
+        def runtimes_to_install(application)
+          return [] unless application[:runtimes]
+          runtimes_to_install = []
+          application[:runtimes].each do |runtime_identifier|
+            # we do not need to install native buildpacks
+            # TODO: 2 options for heroku runtime handling
+            # a) skip native, fails when native required and not in list
+            # b) (current) use native, fails when others (additional) are in the list
+            # next if native_runtime?(runtime_identifier)
+            runtime_is_url = runtime_identifier =~ /\A#{URI.regexp}\z/
+            runtime_url = find_runtime(runtime_identifier)
+            runtime_is_valid = runtime_url || runtime_is_url
+            fail_with(:invalid_runtime, [runtime_identifier]) unless runtime_is_valid
+            # if runtime identifier is valid, we need to install the runtime
+            runtimes_to_install.push(runtime_is_url ? runtime_identifier : runtime_url)
+          end
+          # heroku does not know the 'runtimes' property and would crash if present
+          application.delete :runtimes
+          runtimes_to_install
+        end
+
+        def heroku_api
+          ::Heroku::API.new(headers: headers)
+        end
+
+        def headers
+          super.merge(
+            'Accept' => 'application/vnd.heroku+json; version=3',
+            'Content-Type' => 'application/json'
+          )
+        end
+
+        def installed_buildpacks(application_id)
+          buildpacks = get("/apps/#{application_id}/buildpack-installations").body
+          return [] if buildpacks.empty?
+          buildpacks.collect do |buildpack|
+            buildpack[:buildpack][:url]
+          end
+        end
+
+        def application_instances(application_id)
+          formations = get("/apps/#{application_id}/formation").body
+          web_formation = formations.find { |formation| formation[:type] == 'web' }
+          return web_formation[:quantity] unless web_formation.nil?
+          # if no web formation was detected, there is no instance available
+          0
+        end
+
+        def dynos(application_id)
+          get("/apps/#{application_id}/dynos").body
+        end
+
+        def web_dynos(application_id, retrieved_dynos = nil)
+          all_dynos = retrieved_dynos ? retrieved_dynos : dynos(application_id)
+          all_dynos.find_all do |dyno|
+            dyno[:type] == 'web'
+          end.compact
+        end
+
+        def latest_release(application_id, retrieved_dynos = nil)
+          dynos = web_dynos(application_id, retrieved_dynos)
+          if dynos.nil? || dynos.empty?
+            log.debug 'no dynos for build detection, fallback to latest release version'
+            # this approach might be wrong if the app is rolled-back to a previous release
+            # However, if no dyno is active, this is the only option to identify the current release
+            latest_version = 0
+            latest_version_id = nil
+            get("/apps/#{application_id}/releases").body.each do |release|
+              if release[:version] > latest_version
+                latest_version = release[:version]
+                latest_version_id = release[:id]
+              end
+            end
+            latest_version_id
+          else
+            latest_version = 0
+            latest_version_id = nil
+            dynos.each do |dyno|
+              if dyno[:release][:version] > latest_version
+                latest_version = dyno[:release][:version]
+                latest_version_id = dyno[:release][:id]
+              end
+            end
+            latest_version_id
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Nucleus
+  module Adapters
+    module V1
+      class Heroku < Stub
+        module Lifecycle
+          # Lifecycle:
+          # A) via maintenance - workers are still active
+          # B) via formation - loose scaling information
+
+          # @see Stub#start
+          def start(application_id)
+            log.debug "Start @ #{@endpoint_url}"
+
+            app = application(application_id)
+            if app[:state] == Enums::ApplicationStates::DEPLOYED
+              # add web dyno if there currently are no dynos (state == deployed)
+              scale_web(application_id, 1)
+            elsif app[:state] == Enums::ApplicationStates::CREATED
+              # fail if there is no deployment
+              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before it can be started'
+            end
+
+            scale_worker(application_id, 1)
+            update_application(application_id, maintenance: false)
+          end
+
+          # @see Stub#stop
+          def stop(application_id)
+            log.debug "Stop @ #{@endpoint_url}"
+
+            # fail if there is no deployment
+            app = application(application_id)
+            if app[:state] == Enums::ApplicationStates::CREATED
+              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before it can be stopped'
+            end
+
+            scale_worker(application_id, 0)
+            update_application(application_id, maintenance: true)
+          end
+
+          # @see Stub#restart
+          def restart(application_id)
+            log.debug "Restart @ #{@endpoint_url}"
+            stop(application_id)
+            start(application_id)
+          end
+        end
+      end
+    end
+  end
+end