nucleus 0.1.0

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

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

@@ -0,0 +1,68 @@
+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)
+
+          # @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

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

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

@@ -0,0 +1,103 @@
+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 }
+          }
+
+          # @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

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

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

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

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