nucleus 0.2.0 → 0.3.1

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

@@ -1,76 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        # cloud control data management operations
-        module Data
-          # @see Stub#deploy
-          def deploy(application_id, file, compression_format)
-            # get deployment, also serves as 404 check for application
-            deployment = default_deployment(application_id)
-            current_state = application_state(deployment)
-
-            user = get('/user').body[0]
-            name = "nucleus.app.repo.cloudControl.deploy.#{application_id}.#{SecureRandom.uuid}"
-            # push to the deployment branch, here: nucleus
-            with_ssh_key do
-              deployer = GitDeployer.new(name, deployment[:branch], user[:email], NUCLEUS_DEPLOYMENT)
-              deployer.deploy(file, compression_format)
-            end
-
-            return if current_state == Enums::ApplicationStates::CREATED ||
-                      current_state == Enums::ApplicationStates::DEPLOYED
-
-            # Deploy via the API, use version identifier -1 to refer a new build,
-            # but ONLY (!) if the application is not in the CREATED or DEPLOYED state
-            put("app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}", body: { version: '-1' })
-          end
-
-          # @see Stub#download
-          def download(application_id, compression_format)
-            # get deployment, also serves as 404 check for application
-            deployment = default_deployment(application_id)
-            if application_state(deployment) == 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
-            name = "nucleus.app.repo.cloudControl.download.#{application_id}.#{SecureRandom.uuid}"
-            with_ssh_key do
-              GitDeployer.new(name, deployment[:branch], nil, NUCLEUS_DEPLOYMENT).download(compression_format, true)
-            end
-          end
-
-          # @see Stub#rebuild
-          def rebuild(application_id)
-            # get deployment, also serves as 404 check for application
-            deployment = default_deployment(application_id)
-            if application_state(deployment) == Enums::ApplicationStates::CREATED
-              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before data can be rebuild'
-            end
-
-            user = get('/user').body[0]
-            name = "nucleus.app.repo.cloudControl.rebuild.#{application_id}.#{SecureRandom.uuid}"
-
-            with_ssh_key do
-              GitDeployer.new(name, deployment[:branch], user[:email], NUCLEUS_DEPLOYMENT).trigger_build
-            end
-
-            # now deploy via the API, use version identifier -1 to refer a new build
-            put("app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}", body: { version: '-1' })
-
-            # return with updated application
-            application(application_id)
-          end
-
-          private
-
-          def register_key(user, type, key)
-            key_name = "nucleus-#{SecureRandom.uuid}"
-            post("/user/#{user}/key", body: { key: [type, key, key_name].join(' ') }).body[:key_id]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        # cloud control, CRUD operations for the application's domain object
-        module Domains
-          # cloud control URLs that are automatically assigned to applications as domain but can't be managed
-          CC_URLS = %w(cloudcontrolapp.com cloudcontrolled.com).freeze
-
-          # @see Stub#domains
-          def domains(application_id)
-            # no conversion needed, cc domains already have :name value
-            cc_domains = get("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/alias").body
-            # the domain shall NOT be a CC system domain
-            cc_domains = cc_domains.find_all do |domain|
-              !CC_URLS.any? { |cc_domain| domain[:name].include? cc_domain }
-            end
-            # the list does not include the timestamps, fetch all
-            cc_domains.compact.collect { |domain| domain(application_id, domain[:name]) }
-          end
-
-          # @see Stub#domain
-          def domain(application_id, alias_name)
-            # no conversion needed, cc domains already have :name value
-            cc_domain = get("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/alias/#{alias_name}").body
-            to_nucleus_domain(cc_domain)
-          end
-
-          # @see Stub#create_domain
-          def create_domain(application_id, domain)
-            # check if name is available
-            if domain?(application_id, domain[:name])
-              fail Errors::SemanticAdapterRequestError,
-                   "Domain '#{domain[:name]}' is already assigned to the application"
-            end
-
-            # no conversion needed, cc domains already have :name value
-            cc_domain = post("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/alias",
-                             body: { name: domain[:name] }).body
-            log.info("Please use this code to verify your custom application domain: #{cc_domain[:verification_code]}")
-            log.info('More information about the domain verification can be found at: '\
-              'https://www.cloudcontrol.com/dev-center/add-on-documentation/alias')
-            to_nucleus_domain(cc_domain)
-          end
-
-          # @see Stub#delete_domain
-          def delete_domain(application_id, alias_name)
-            delete("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/alias/#{alias_name}")
-          end
-
-          private
-
-          def domain?(application_id, alias_name)
-            cc_domains = get("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/alias").body
-            cc_domains.any? { |domain| domain[:name] == alias_name }
-          end
-
-          def to_nucleus_domain(domain)
-            domain[:id] = domain[:name]
-            domain[:created_at] = domain.delete(:date_created)
-            domain[:updated_at] = domain.delete(:date_modified)
-            domain
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        module Lifecycle
-          # @see Stub#start
-          def start(application_id)
-            deployment = default_deployment(application_id)
-            # fail if there is no deployment
-            unless data_uploaded?(deployment)
-              fail Errors::SemanticAdapterRequestError, 'Application must be deployed before it can be started'
-            end
-
-            # if no cloudControl deployment has been made, trigger it
-            if deployment[:version] == '-1'
-              # deploy via the API, use version identifier -1 to refer a new build
-              put("app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}", body: { version: '-1' })
-            end
-
-            # return the application object
-            to_nucleus_app(get("/app/#{application_id}").body, default_deployment(application_id))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        # cloud control application's log management operations
-        module Logs
-          class LogPoller
-            # Initialize a new instance
-            # @param [BaseAdapter] adapter the adapter that needs the {LogPoller}
-            # @param [Hash] headers_to_use adapter headers, e.g. containing the authentication, that shall be used
-            #   for requests when the headers can't be resolved line in deferred actions
-            def initialize(adapter, headers_to_use)
-              @adapter = adapter
-              @headers_to_use = headers_to_use
-              @last_log_entry = {}
-            end
-
-            # Start the continuous polling of the logs.
-            # @param [String] application_name the name (the ID) of the application
-            # @param [Array<String>] logs_to_poll IDs of the logs to poll
-            # @param [StreamCallback] stream stream callback to push messages
-            # @return [void]
-            def start(application_name, logs_to_poll, stream)
-              @polling_active = true
-              # 1 log: wait 4 seconds between polls
-              # 4 logs: 1 seconds
-              timeout = logs_to_poll.length == 1 ? 4 : 1
-              logs_to_poll.each { |log_to_poll| @last_log_entry[log_to_poll] = nil }
-
-              fetch_action = lambda do
-                update_log(application_name, logs_to_poll, stream)
-                # start next iteration if we are still supposed to be active
-                EM.add_timer(timeout) { fetch_action.call } if @polling_active
-              end
-              # start the loop to poll the logs
-              EM.add_timer(timeout) { fetch_action.call }
-            end
-
-            # Stop the polling at the next shot
-            def stop
-              @polling_active = false
-            end
-
-            private
-
-            def update_log(application_name, logs_to_poll, stream)
-              logs_to_poll.each do |log_to_poll|
-                # check again if we are still supposed to be active
-                break unless @polling_active
-                lines = @adapter.send(:cc_log_entries, application_name, log_to_poll,
-                                      @last_log_entry[log_to_poll], @headers_to_use)
-                next if lines.empty?
-                send_lines(lines, log_to_poll, stream)
-              end
-            end
-
-            def send_lines(lines, log_to_poll, stream)
-              # now sort by time
-              lines.sort_by! { |line| line[:time].to_f }
-              @last_log_entry[log_to_poll] = lines.last[:time] if lines
-              lines.each do |line|
-                line[:nucleus_origin] = log_to_poll
-                stream.send_message(@adapter.send(:format_log_entry, line[:nucleus_origin], line))
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,103 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        # cloud control application's log management operations
-        module Logs
-          # Cloud control log types. The +key+ and +id+ shall match the Nucleus definitions of log files,
-          # whereas the +name+ shall match the cloud control log id.
-          LOG_TYPES = {
-            all: { id: 'all', name: 'all', type: Enums::ApplicationLogfileType::OTHER },
-            request: { id: 'request', name: 'access', type: Enums::ApplicationLogfileType::REQUEST },
-            application: { id: 'application', name: 'error', type: Enums::ApplicationLogfileType::APPLICATION },
-            api: { id: 'api', name: 'deploy', type: Enums::ApplicationLogfileType::API },
-            system: { id: 'system', name: 'worker', type: Enums::ApplicationLogfileType::SYSTEM }
-          }.freeze
-
-          # @see Stub#logs
-          def logs(application_name)
-            # fails with 404 if application is not available and serves for timestamps
-            app = get("/app/#{application_name}").body
-
-            LOG_TYPES.values.collect do |log|
-              log[:created_at] = app[:date_created]
-              log[:updated_at] = app[:date_modified]
-              log
-            end
-          end
-
-          # @see Stub#log?
-          def log?(application_name, log_id)
-            # fails with 404 if application is not available
-            get("/app/#{application_name}")
-
-            LOG_TYPES.key? log_id.to_sym
-          end
-
-          # cloud control shows the last 500 log messages if applicable
-          # @see Stub#tail
-          def tail(application_name, log_id, stream)
-            # cache headers as they are bound to a request and could be lost with the next tick
-            headers_to_use = headers
-            logs_to_poll = log_id == 'all' ? LOG_TYPES.keys - [:all] : [log_id]
-            poller = LogPoller.new(self, headers_to_use)
-            poller.start(application_name, logs_to_poll, stream)
-            TailStopper.new(poller, :stop)
-          end
-
-          # cloud control shows the last 500 log messages if applicable
-          # @see Stub#log_entries
-          def log_entries(application_name, log_id)
-            unless log?(application_name, log_id)
-              fail Errors::AdapterResourceNotFoundError,
-                   "Invalid log file '#{log_id}', not available for application '#{application_name}'"
-            end
-            if log_id == 'all'
-              fetched_lines = []
-              (LOG_TYPES.keys - [:all]).each do |current_log_id|
-                cc_log_entries(application_name, current_log_id).each do |line|
-                  line[:nucleus_origin] = current_log_id
-                  fetched_lines.push(line)
-                end
-              end
-              fetched_lines.sort_by! { |line| line[:time] }
-              fetched_lines.collect { |line| format_log_entry(line[:nucleus_origin], line) }
-            else
-              cc_log_entries(application_name, log_id).collect { |line| format_log_entry(log_id, line) }
-            end
-          end
-
-          private
-
-          def cc_log_entries(app_name, log_id, time = nil, headers_to_use = nil)
-            log_name = LOG_TYPES[log_id.to_sym][:name]
-            # Hack, do not create fresh headers (which would fail) when in a deferred action
-            headers_to_use = headers unless headers_to_use
-            if time
-              get("/app/#{app_name}/deployment/#{NUCLEUS_DEPLOYMENT}/log/#{log_name}?timestamp=#{time}",
-                  headers: headers_to_use).body
-            else
-              get("/app/#{app_name}/deployment/#{NUCLEUS_DEPLOYMENT}/log/#{log_name}", headers: headers_to_use).body
-            end
-          end
-
-          def format_log_entry(log_id, line)
-            # format according to: https://github.com/cloudControl/cctrl/blob/master/cctrl/output.py
-            case log_id.to_sym
-            when :request
-              "#{line[:remote_host]} #{line[:remote_user]} #{line[:remote_logname]} [#{Time.at(line[:time]).iso8601}] "\
-                "#{line[:first_request_line]} #{line[:status]} #{line[:response_size_CLF]} #{line[:referer]} "\
-                "#{line[:user_agent]}"
-            when :system
-              "#{line[:time]} #{line[:wrk_id]} #{line[:message]}"
-            when :build
-              "#{Time.at(line[:time]).iso8601} [#{line[:hostname]}/#{line[:depl_id]}] #{line[:level]} #{line[:message]}"
-            when :error
-              "#{line[:time]} #{line[:type]} #{line[:message]}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        module Regions
-          # @see Stub#regions
-          def regions
-            [default_region]
-          end
-
-          # @see Stub#region
-          def region(region_name)
-            fail Errors::AdapterResourceNotFoundError,
-                 "Region '#{region_name}' does not exist at the endpoint" unless region_name.casecmp('default') == 0
-            default_region
-          end
-
-          private
-
-          def default_region
-            {
-              id: 'default',
-              description: 'Default region, cloudControl 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_control/scaling.rb

@@ -1,17 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        module Scaling
-          # @see Stub#scale
-          def scale(application_id, instances)
-            # update the number of instances on the application's deployment
-            scale_response = put("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}",
-                                 body: { min_boxes: instances }).body
-            to_nucleus_app(get("/app/#{application_id}").body, scale_response)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        # Semantic error messages that are specific for cloudControl
-        module SemanticErrors
-          # Get all cloudControl 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
-            {
-              # Error code '300_1': Only one runtime is allowed per cloudControl application
-              only_one_runtime: { code: 422_300_1, message: 'cloudControl only allows 1 runtime per application' },
-              # Error code '300_2': Billing details required
-              billing_required: { code: 422_300_2,
-                                  message: 'cloudControl requires a billing account to allow this action: %s' },
-              # Error code '300_3': Malformed name, please follow the requirements of cloudControl app names
-              bad_name: { code: 422_300_3, message: '%s' },
-              # Error code '300_3': Malformed name, please follow the requirements of cloudControl app names
-              ambiguous_deployments: { code: 422_300_4, message: 'Unable to identify the deployment that shall be '\
-                'used. Nucleus require to find: a) exactly one deployment, b) a "default" deployment or '\
-                'c) a "nucleus" deployment' },
-              no_deployment: { code: 422_300_5, message: 'No deployment found. Nucleus requires to find: a) '\
-                'exactly one deployment, b) a "default" deployment or c) a "nucleus" deployment' }
-            }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        # cloud control, operations for the application's addons
-        module Services
-          # @see Stub#services
-          def services
-            get('/addon').body.collect { |cc_service| to_nucleus_service(cc_service) }
-          end
-
-          # @see Stub#service
-          def service(service_name)
-            to_nucleus_service(get("/addon/#{service_name}").body)
-          end
-
-          # @see Stub#service_plans
-          def service_plans(service_name)
-            get("/addon/#{service_name}").body[:options].collect { |plan| to_nucleus_plan(plan) }
-          end
-
-          # @see Stub#service_plan
-          def service_plan(service_name, plan_name)
-            plan_name = plan_name?(plan_name) ? plan_name : "#{service_name}.#{plan_name}"
-            plan = get("/addon/#{service_name}").body[:options].find do |cc_plan|
-              cc_plan[:name] == plan_name
-            end
-            fail Errors::AdapterResourceNotFoundError,
-                 "No such plan '#{plan_name}' for service '#{service_name}'" unless plan
-            to_nucleus_plan(plan)
-          end
-
-          # @see Stub#installed_services
-          def installed_services(application_id)
-            load_installed_addons(application_id).collect do |assignment|
-              # ignore config and alias addons, for us they are core parts of the application
-              next if %w(config.free alias.free).include?(assignment[:addon_option][:name])
-              service = service(parse_service_name(assignment[:addon_option][:name]))
-              to_nucleus_installed_service(service, assignment)
-            end.compact
-          end
-
-          # @see Stub#installed_service
-          def installed_service(application_id, service_name)
-            # we also require the installed plan to retrieve the service, the list does not include all properties :(
-            plan_name = active_plan(application_id, service_name)
-            assignment = get("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/#{plan_name}").body
-            installed_service = service(parse_service_name(assignment[:addon_option][:name]))
-            to_nucleus_installed_service(installed_service, assignment)
-          end
-
-          # @see Stub#add_service
-          def add_service(application_id, service_entity, plan_entity)
-            plan_name = plan_name?(plan_entity[:id]) ? plan_entity[:id] : "#{service_entity[:id]}.#{plan_entity[:id]}"
-            created = post("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon",
-                           body: { addon: plan_name }).body
-            to_nucleus_installed_service(service(service_entity[:id]), created)
-          end
-
-          # @see Stub#change_service
-          def change_service(application_id, service_id, plan_entity)
-            plan_name = active_plan(application_id, service_id)
-            fail Errors::SemanticAdapterRequestError,
-                 "Plan '#{plan_entity[:id]}' is already active for service '#{service_id}' of application "\
-                 "'#{application_id}'" if plan_name == plan_entity[:id]
-
-            updated = put("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/#{plan_name}",
-                          body: { addon: plan_entity[:id] }).body
-            to_nucleus_installed_service(service(service_id), updated)
-          end
-
-          # @see Stub#remove_service
-          def remove_service(application_id, service_id)
-            plan_name = active_plan(application_id, service_id)
-            delete("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/#{plan_name}")
-          end
-
-          private
-
-          def plan_name?(plan_name)
-            parts = plan_name.split('.')
-            # must have 2 parts and both must not be empty
-            parts.length == 2 && parts.all { |part| part.length > 0 }
-          end
-
-          def parse_service_name(plan_name)
-            parts = plan_name.split('.')
-            fail Errors::SemanticAdapterRequestError, 'Invalid service plan name: Name must contain only one dot, '\
-              "which separates the service and plan, e.g. 'mysql.free'" if parts.length != 2
-            parts[0]
-          end
-
-          def load_installed_addons(application_id)
-            get("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon").body
-          end
-
-          def active_plan(application_id, service_id)
-            all_installed = load_installed_addons(application_id)
-            installed_service = all_installed.find do |service|
-              service[:addon_option][:name].start_with?("#{service_id}.") || service[:addon_option][:name] == service_id
-            end
-            fail Errors::AdapterResourceNotFoundError,
-                 "No such service '#{service_id}' for application '#{application_id}'" unless installed_service
-            installed_service[:addon_option][:name]
-          end
-
-          def free_plan?(service)
-            service[:options].any? { |plan| plan[:thirty_days_price].to_i == 0 }
-          end
-
-          # The currency that is used for the prices is not stored within the API.
-          # However, we can identify the currency based on a list of known providers.
-          # As fallback, we assume the currency is EURO.
-          def currency
-            return 'USD' if endpoint_url.to_s.include?('dotcloudapp.com')
-            return 'CHF' if endpoint_url.to_s.include?('app.exo.io')
-            # EUR used for cloudControl, CLOUD & HEAT and as fallback
-            'EUR'
-          end
-
-          def to_nucleus_plan(plan)
-            plan[:id] = plan[:name]
-            plan[:free] = plan[:thirty_days_price].to_i == 0
-            plan[:description] = nil
-            # TODO: extract payment period to enum
-            plan[:costs] = [{ period: 'month', per_instance: plan[:price_is_per_box],
-                             price: [amount: plan[:thirty_days_price].to_f, currency: currency] }]
-            plan[:created_at] = nil
-            plan[:updated_at] = nil
-            plan
-          end
-
-          def to_nucleus_service(service)
-            service[:id] = service[:name]
-            service[:release] = service.delete(:stage)
-            # the API does not contain any information, but the homepage does
-            service[:documentation_url] = "https://www.cloudcontrol.com/add-ons/#{service[:name]}"
-            service[:description] = nil
-            service[:created_at] = nil
-            service[:updated_at] = nil
-            service[:required_services] = []
-            service[:free_plan] = free_plan?(service)
-            service
-          end
-
-          def to_nucleus_installed_service(service, installed_service)
-            # settings ? ? ?
-            service[:active_plan] = installed_service[:addon_option][:name]
-            if installed_service[:settings] && !installed_service[:settings].empty?
-              properties = installed_service[:settings].collect do |key, value|
-                { key: key, value: value, description: nil }
-              end
-            end
-            service[:properties] = properties ? properties : []
-            service[:web_url] = nil
-            service
-          end
-        end
-      end
-    end
-  end
-end