nucleus 0.1.0 → 0.2.0

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

@@ -1,103 +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
+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/vars.rb

@@ -1,88 +1,88 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudControl < Stub
-        # cloud control, CRUD operations for the application's environment variable object,
-        # which is referred to as +config addon+ on the platform.
-        module Vars
-          # @see Stub#env_vars
-          def env_vars(application_id)
-            cc_vars = cc_vars(application_id)
-            cc_vars.collect do |key, value|
-              { id: key, key: key, value: value }
-            end
-          end
-
-          # @see Stub#env_var
-          def env_var(application_id, env_var_key)
-            cc_vars = cc_vars(application_id)
-            fail Errors::AdapterResourceNotFoundError,
-                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
-            { id: env_var_key, key: env_var_key, value: cc_vars[env_var_key.to_sym] }
-          end
-
-          # @see Stub#create_env_var
-          def create_env_var(application_id, env_var)
-            cc_vars = cc_vars(application_id)
-            fail Errors::SemanticAdapterRequestError,
-                 "Env. var key '#{env_var[:key]}' already taken" if env_var?(application_id, env_var[:key], cc_vars)
-            set_var(application_id, env_var[:key], env_var[:value])
-          end
-
-          # @see Stub#update_env_var
-          def update_env_var(application_id, env_var_key, env_var)
-            cc_vars = cc_vars(application_id)
-            fail Errors::AdapterResourceNotFoundError,
-                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
-            set_var(application_id, env_var_key, env_var[:value])
-          end
-
-          # @see Stub#delete_env_var
-          def delete_env_var(application_id, env_var_key)
-            cc_vars = cc_vars(application_id)
-            fail Errors::AdapterResourceNotFoundError,
-                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
-            set_var(application_id, env_var_key, nil)
-          end
-
-          private
-
-          def cc_vars(application_id)
-            cc_vars_response = get("app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/config.free")
-            cc_vars_response.body[:settings][:CONFIG_VARS]
-          end
-
-          # Set the variable value (create or update)
-          # @param [String] application_id id of the cloud control application
-          # @param [Symbol] key variable key name
-          # @param [String, Integer, Float, Double] value value to apply to the variable
-          # @return [Hash] Nucleus representation of the modified variable
-          def set_var(application_id, key, value)
-            if value.nil?
-              # delete the var, set to 'null'
-              settings = "{\"#{key}\":null}"
-            else
-              settings = "{\"#{key}\":\"#{value}\"}"
-            end
-            response = put("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/config.free",
-                           body: { addon: 'config.free',
-                                   settings: settings,
-                                   force: true })
-            all_vars = response.body[:settings][:CONFIG_VARS]
-            { id: key, key: key, value: all_vars[key.to_sym] }
-          end
-
-          # Checks if a variable with the env_var_key already exists.
-          # @param [String] application_id id of the cloud control application
-          # @param [Symbol] env_var_key key name that shall be checked for existence
-          # @param [Hash] all_vars collection of currently existing variables for the application
-          # @return [Boolean] true if there is a variable with the env_var_key, otherwise false
-          def env_var?(application_id, env_var_key, all_vars = nil)
-            all_vars = cc_vars(application_id) if all_vars.nil?
-            all_vars.key? env_var_key.to_sym
-          end
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      class CloudControl < Stub
+        # cloud control, CRUD operations for the application's environment variable object,
+        # which is referred to as +config addon+ on the platform.
+        module Vars
+          # @see Stub#env_vars
+          def env_vars(application_id)
+            cc_vars = cc_vars(application_id)
+            cc_vars.collect do |key, value|
+              { id: key, key: key, value: value }
+            end
+          end
+
+          # @see Stub#env_var
+          def env_var(application_id, env_var_key)
+            cc_vars = cc_vars(application_id)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
+            { id: env_var_key, key: env_var_key, value: cc_vars[env_var_key.to_sym] }
+          end
+
+          # @see Stub#create_env_var
+          def create_env_var(application_id, env_var)
+            cc_vars = cc_vars(application_id)
+            fail Errors::SemanticAdapterRequestError,
+                 "Env. var key '#{env_var[:key]}' already taken" if env_var?(application_id, env_var[:key], cc_vars)
+            set_var(application_id, env_var[:key], env_var[:value])
+          end
+
+          # @see Stub#update_env_var
+          def update_env_var(application_id, env_var_key, env_var)
+            cc_vars = cc_vars(application_id)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
+            set_var(application_id, env_var_key, env_var[:value])
+          end
+
+          # @see Stub#delete_env_var
+          def delete_env_var(application_id, env_var_key)
+            cc_vars = cc_vars(application_id)
+            fail Errors::AdapterResourceNotFoundError,
+                 "Env. var key '#{env_var_key}' does not exist" unless env_var?(application_id, env_var_key, cc_vars)
+            set_var(application_id, env_var_key, nil)
+          end
+
+          private
+
+          def cc_vars(application_id)
+            cc_vars_response = get("app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/config.free")
+            cc_vars_response.body[:settings][:CONFIG_VARS]
+          end
+
+          # Set the variable value (create or update)
+          # @param [String] application_id id of the cloud control application
+          # @param [Symbol] key variable key name
+          # @param [String, Integer, Float, Double] value value to apply to the variable
+          # @return [Hash] Nucleus representation of the modified variable
+          def set_var(application_id, key, value)
+            settings = if value.nil?
+                         # delete the var, set to 'null'
+                         "{\"#{key}\":null}"
+                       else
+                         "{\"#{key}\":\"#{value}\"}"
+                       end
+            response = put("/app/#{application_id}/deployment/#{NUCLEUS_DEPLOYMENT}/addon/config.free",
+                           body: { addon: 'config.free',
+                                   settings: settings,
+                                   force: true })
+            all_vars = response.body[:settings][:CONFIG_VARS]
+            { id: key, key: key, value: all_vars[key.to_sym] }
+          end
+
+          # Checks if a variable with the env_var_key already exists.
+          # @param [String] application_id id of the cloud control application
+          # @param [Symbol] env_var_key key name that shall be checked for existence
+          # @param [Hash] all_vars collection of currently existing variables for the application
+          # @return [Boolean] true if there is a variable with the env_var_key, otherwise false
+          def env_var?(application_id, env_var_key, all_vars = nil)
+            all_vars = cc_vars(application_id) if all_vars.nil?
+            all_vars.key? env_var_key.to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,149 +1,149 @@
-module Nucleus
-  module Adapters
-    module V1
-      class CloudFoundryV2 < Stub
-        # Application domain / route functionality to support the Cloud Foundry API.<br>
-        module Domains
-          # @see Stub#domains
-          def domains(domain_id)
-            app_guid = app_guid(domain_id)
-            assigned_routes = get("/v2/apps/#{app_guid}/routes").body
-            domains = []
-            assigned_routes[:resources].each do |assigned_route|
-              nucleus_domain = route_to_nucleus_domain(assigned_route)
-              domains.push(nucleus_domain) unless nucleus_domain[:name] == app_web_url(app_guid)
-            end
-            domains
-          end
-
-          # @see Stub#domain
-          def domain(application_name_or_id, domain_id)
-            app_guid = app_guid(application_name_or_id)
-            assigned_routes = get("/v2/apps/#{app_guid}/routes").body
-            assigned_routes[:resources].each do |assigned_route|
-              return route_to_nucleus_domain(assigned_route) if assigned_route[:metadata][:guid] == domain_id
-            end
-          end
-
-          # @see Stub#create_domain
-          def create_domain(application_name_or_id, domain)
-            domains(application_name_or_id).each do |existing_domain|
-              if existing_domain[:name] == domain[:name]
-                fail Errors::SemanticAdapterRequestError,
-                     "Domain '#{domain[:name]}' is already assigned to the application"
-              end
-            end
-
-            app_guid = app_guid(application_name_or_id)
-            # extract the hostname and the domain name from the FQDN
-            /(?<domain_host>([-\w]+\.)*)(?<domain_name>([-\w]+\.[-\w]+))/ =~ domain[:name]
-            domain_host.chomp!('.') unless domain_host.nil?
-
-            # finally build the response
-            route_to_nucleus_domain(create_cf_domain(app_guid, domain_name, domain_host))
-          end
-
-          # @see Stub#delete_domain
-          def delete_domain(application_name_or_id, route_id)
-            app_guid = app_guid(application_name_or_id)
-            # remove route from the app
-            delete_response = delete("/v2/apps/#{app_guid}/routes/#{route_id}", expects: [201, 400])
-            if delete_response.status == 400
-              cf_error = delete_response.body[:code]
-              if cf_error == 1002
-                fail Errors::AdapterResourceNotFoundError, 'Domain not found. '\
-                  'CF context specific: Route does not exist or is not assigned with this application'
-              else
-                # delete failed with 400, but not due to invalid domain
-                fail Errors::AdapterRequestError,
-                     "#{delete_response.body[:description]} (#{cf_error} - #{delete_response.body[:error_code]})"
-              end
-            end
-
-            # check route usage
-            route_in_apps = get("/v2/routes/#{route_id}/apps").body
-            return unless route_in_apps[:total_results] == 0
-
-            # route is no longer needed, delete
-            delete("/v2/routes/#{route_id}")
-          end
-
-          private
-
-          def domain?(application_name_or_id, domain_name)
-            app_guid = app_guid(application_name_or_id)
-            domain_without_protocol = %r{([a-zA-Z]+://)?([-\.\w]*)}.match(domain_name)[2]
-            assigned_routes = get("/v2/apps/#{app_guid}/routes").body
-            assigned_routes[:resources].each do |route|
-              route_domain = get(route[:entity][:domain_url]).body
-              return true if "#{route[:entity][:host]}.#{route_domain[:entity][:name]}" == domain_without_protocol
-            end
-            false
-          end
-
-          def route_to_nucleus_domain(route_resource)
-            route_entity = route_resource[:entity]
-            route_metadata = route_resource[:metadata]
-            assigned_domain = get(route_entity[:domain_url]).body
-            domain = { id: route_metadata[:guid], created_at: route_metadata[:created_at] }
-            if route_metadata[:updated_at].to_s == ''
-              domain[:updated_at] = route_metadata[:created_at]
-            else
-              domain[:updated_at] = route_metadata[:updated_at]
-            end
-
-            if route_entity[:host].to_s == ''
-              domain[:name] = assigned_domain[:entity][:name]
-            else
-              domain[:name] = "#{route_entity[:host]}.#{assigned_domain[:entity][:name]}"
-            end
-            domain
-          end
-
-          def cf_domain(domain_name)
-            %w(private shared).each do |domain_type|
-              response = get("/v2/#{domain_type}_domains").body
-              response[:resources].each do |domain|
-                return domain if domain[:entity][:name] == domain_name
-              end
-            end
-            nil
-          end
-
-          def cf_route(domain_guid, domain_host)
-            # There is no way to check if a root domain (empty hostname) is already taken.
-            # Therefore we must iterate through all routes and find matches...
-            all_routes = get('/v2/routes').body[:resources]
-            all_routes.each do |route|
-              return route if route[:entity][:domain_guid] == domain_guid && route[:entity][:host] == domain_host
-            end
-            nil
-          end
-
-          def create_cf_domain(app_guid, domain_name, domain_host)
-            created_domain = cf_domain(domain_name)
-            unless created_domain
-              # domain does not exist, create!
-              domain_request_body = { name: domain_name, owning_organization_guid: default_organization_guid }
-              created_domain = post('/v2/private_domains', body: domain_request_body).body
-            end
-
-            created_route = cf_route(created_domain[:metadata][:guid], domain_host)
-            unless created_route
-              # route does not exist, create!
-              route_request_body = { domain_guid: created_domain[:metadata][:guid],
-                                     host: domain_host, space_guid: user_space_guid }
-              created_route = post('/v2/routes', body: route_request_body).body
-            end
-
-            # assign the route to the application
-            put("/v2/apps/#{app_guid}/routes/#{created_route[:metadata][:guid]}").body
-
-            # return the actual route, not the association response
-            created_route
-          end
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  module Adapters
+    module V1
+      class CloudFoundryV2 < Stub
+        # Application domain / route functionality to support the Cloud Foundry API.<br>
+        module Domains
+          # @see Stub#domains
+          def domains(domain_id)
+            app_guid = app_guid(domain_id)
+            assigned_routes = get("/v2/apps/#{app_guid}/routes").body
+            domains = []
+            assigned_routes[:resources].each do |assigned_route|
+              nucleus_domain = route_to_nucleus_domain(assigned_route)
+              domains.push(nucleus_domain) unless nucleus_domain[:name] == app_web_url(app_guid)
+            end
+            domains
+          end
+
+          # @see Stub#domain
+          def domain(application_name_or_id, domain_id)
+            app_guid = app_guid(application_name_or_id)
+            assigned_routes = get("/v2/apps/#{app_guid}/routes").body
+            assigned_routes[:resources].each do |assigned_route|
+              return route_to_nucleus_domain(assigned_route) if assigned_route[:metadata][:guid] == domain_id
+            end
+          end
+
+          # @see Stub#create_domain
+          def create_domain(application_name_or_id, domain)
+            domains(application_name_or_id).each do |existing_domain|
+              if existing_domain[:name] == domain[:name]
+                fail Errors::SemanticAdapterRequestError,
+                     "Domain '#{domain[:name]}' is already assigned to the application"
+              end
+            end
+
+            app_guid = app_guid(application_name_or_id)
+            # extract the hostname and the domain name from the FQDN
+            /(?<domain_host>([-\w]+\.)*)(?<domain_name>([-\w]+\.[-\w]+))/ =~ domain[:name]
+            domain_host.chomp!('.') unless domain_host.nil?
+
+            # finally build the response
+            route_to_nucleus_domain(create_cf_domain(app_guid, domain_name, domain_host))
+          end
+
+          # @see Stub#delete_domain
+          def delete_domain(application_name_or_id, route_id)
+            app_guid = app_guid(application_name_or_id)
+            # remove route from the app
+            delete_response = delete("/v2/apps/#{app_guid}/routes/#{route_id}", expects: [201, 400])
+            if delete_response.status == 400
+              cf_error = delete_response.body[:code]
+              if cf_error == 1002
+                fail Errors::AdapterResourceNotFoundError, 'Domain not found. '\
+                  'CF context specific: Route does not exist or is not assigned with this application'
+              else
+                # delete failed with 400, but not due to invalid domain
+                fail Errors::AdapterRequestError,
+                     "#{delete_response.body[:description]} (#{cf_error} - #{delete_response.body[:error_code]})"
+              end
+            end
+
+            # check route usage
+            route_in_apps = get("/v2/routes/#{route_id}/apps").body
+            return unless route_in_apps[:total_results] == 0
+
+            # route is no longer needed, delete
+            delete("/v2/routes/#{route_id}")
+          end
+
+          private
+
+          def domain?(application_name_or_id, domain_name)
+            app_guid = app_guid(application_name_or_id)
+            domain_without_protocol = %r{([a-zA-Z]+://)?([-\.\w]*)}.match(domain_name)[2]
+            assigned_routes = get("/v2/apps/#{app_guid}/routes").body
+            assigned_routes[:resources].each do |route|
+              route_domain = get(route[:entity][:domain_url]).body
+              return true if "#{route[:entity][:host]}.#{route_domain[:entity][:name]}" == domain_without_protocol
+            end
+            false
+          end
+
+          def route_to_nucleus_domain(route_resource)
+            route_entity = route_resource[:entity]
+            route_metadata = route_resource[:metadata]
+            assigned_domain = get(route_entity[:domain_url]).body
+            domain = { id: route_metadata[:guid], created_at: route_metadata[:created_at] }
+            domain[:updated_at] = if route_metadata[:updated_at].to_s == ''
+                                    route_metadata[:created_at]
+                                  else
+                                    route_metadata[:updated_at]
+                                  end
+
+            domain[:name] = if route_entity[:host].to_s == ''
+                              assigned_domain[:entity][:name]
+                            else
+                              "#{route_entity[:host]}.#{assigned_domain[:entity][:name]}"
+                            end
+            domain
+          end
+
+          def cf_domain(domain_name)
+            %w(private shared).each do |domain_type|
+              response = get("/v2/#{domain_type}_domains").body
+              response[:resources].each do |domain|
+                return domain if domain[:entity][:name] == domain_name
+              end
+            end
+            nil
+          end
+
+          def cf_route(domain_guid, domain_host)
+            # There is no way to check if a root domain (empty hostname) is already taken.
+            # Therefore we must iterate through all routes and find matches...
+            all_routes = get('/v2/routes').body[:resources]
+            all_routes.each do |route|
+              return route if route[:entity][:domain_guid] == domain_guid && route[:entity][:host] == domain_host
+            end
+            nil
+          end
+
+          def create_cf_domain(app_guid, domain_name, domain_host)
+            created_domain = cf_domain(domain_name)
+            unless created_domain
+              # domain does not exist, create!
+              domain_request_body = { name: domain_name, owning_organization_guid: default_organization_guid }
+              created_domain = post('/v2/private_domains', body: domain_request_body).body
+            end
+
+            created_route = cf_route(created_domain[:metadata][:guid], domain_host)
+            unless created_route
+              # route does not exist, create!
+              route_request_body = { domain_guid: created_domain[:metadata][:guid],
+                                     host: domain_host, space_guid: user_space_guid }
+              created_route = post('/v2/routes', body: route_request_body).body
+            end
+
+            # assign the route to the application
+            put("/v2/apps/#{app_guid}/routes/#{created_route[:metadata][:guid]}").body
+
+            # return the actual route, not the association response
+            created_route
+          end
+        end
+      end
+    end
+  end
+end