satorix 0.0.1 → 1.5.3

data/lib/satorix/CI/deploy/flynn/routes.rb

@@ -0,0 +1,267 @@
+module Satorix
+  module CI
+    module Deploy
+      module Flynn
+        module Routes
+
+
+          def find_or_create_route(domain)
+            route_ids = route_ids(domain)
+            if route_ids.empty?
+              log "Adding route for #{ domain }..."
+              route_ids << fc_route_add(domain)
+              log "Route for #{ domain } added with the ID of #{ route_ids.first }."
+            else
+              multiple = route_ids.length > 1
+              log "Route#{ 's' if multiple } already exist#{ 's' unless multiple } for #{ domain }."
+            end
+
+            route_ids
+          end
+
+
+          def configure_routes
+            defined_and_internal_routes.each do |ddev_id, domain|
+              route_ids = find_or_create_route(domain)
+              route_ids.each do |route_id|
+                add_tls_to_route(route_id: route_id, ddev_id: ddev_id)
+              end
+            end
+          end
+
+
+          def add_tls_to_route(route_id:, ddev_id:)
+            domain = defined_and_internal_routes[ddev_id]
+            if use_tls?(ddev_id)
+              if use_lets_encrypt?(ddev_id)
+                log "Using Let's Encrypt for #{ domain }."
+                log_error_and_abort "Let's Encrypt support is not implemented, yet!"
+              else
+                log "Using #{ user_defined_tls?(ddev_id) ? 'custom' : 'default' } certificate details for #{ domain } (#{ service_for_route_id(route_id) } service)."
+                File.open('crt', 'w') { |f| f.write(crt_for_ddev_id(ddev_id)) }
+                File.open('key', 'w') { |f| f.write(key_for_ddev_id(ddev_id)) }
+                fc_route_update(route_id)
+              end
+            else
+              log "Skipping TLS configuration for #{ domain }."
+              log "Environment variables #{ env_var_crt_prefix }#{ ddev_id } and #{ env_var_key_prefix }#{ ddev_id } have not been specified."
+              log 'For more information, please refer to https://www.satorix.com/docs/user/projects#certificates'
+            end
+            log ''
+          end
+
+
+          def canonical_domain
+            ENV["AEEV_#{ current_branch }_SATORIX_CANONICAL_URI_HOST"]
+          end
+
+
+          def canonical_domain_information
+            "\nThe above routes will all be redirected to the default URL:\n\n\t#{ canonical_uri }\n\n" if canonical_uri?
+          end
+
+
+          def canonical_domain_protocol
+            ENV["AEEV_#{ current_branch }_SATORIX_CANONICAL_URI_PROTOCOL"]
+          end
+
+
+          def canonical_uri
+            "#{ canonical_domain_protocol }://#{ canonical_domain }" if canonical_uri?
+          end
+
+
+          def canonical_uri?
+            [canonical_domain, canonical_domain_protocol].all? { |x| x.to_s !~ only_whitespace }
+          end
+
+
+          def crt_for_ddev_id(ddev_id)
+            ENV["#{ env_var_crt_prefix }#{ user_defined_tls?(ddev_id) ? ddev_id : 'DEFAULT' }"]
+          end
+
+
+          def custom_crt_for_ddev_id?(ddev_id)
+            ENV["#{ env_var_crt_prefix }#{ ddev_id }"].to_s !~ only_whitespace
+          end
+
+
+          def custom_key_for_ddev_id?(ddev_id)
+            ENV["#{ env_var_key_prefix }#{ ddev_id }"].to_s !~ only_whitespace
+          end
+
+
+          def defined_and_internal_routes
+            defined_routes.merge flynn_internal_routes
+          end
+
+
+          def defined_routes
+            {}.tap do |routes|
+              invalid_keys = flynn_internal_routes.keys
+              ENV.each do |key, value|
+                next unless key.start_with?(env_var_domain_prefix)
+                renamed_key = key.sub(env_var_domain_prefix, '')
+                message = "The user-defined route #{ key } conflicts with an internal route."
+                log_error_and_abort message if invalid_keys.include?(renamed_key)
+                routes[renamed_key] = value
+              end
+            end
+          end
+
+
+          def display_routing_information
+            log 'All application routes...'
+            log ''
+            log urlified_routes_for_display.map { |r| "\t#{ r }" }
+            log canonical_domain_information if canonical_uri?
+          end
+
+
+          def env_var_crt_prefix
+            "CRT_#{ current_branch }_"
+          end
+
+
+          def env_var_domain_prefix
+            "DDEV_#{ current_branch }_"
+          end
+
+
+          def env_var_key_prefix
+            "KEY_#{ current_branch }_"
+          end
+
+
+          def fc_route
+            run_command("flynn -a #{ project_name } route", quiet: true).chomp
+          end
+
+
+          def fc_route_add(domain)
+            run_command("flynn route add http #{ domain } --sticky").chomp
+          end
+
+
+          def fc_route_remove(route_id)
+            run_command "flynn route remove #{ route_id }"
+          end
+
+
+          def fc_route_update(route_id)
+            run_command "flynn route update #{ route_id } --tls-cert=crt --tls-key=key --sticky", quiet: true
+          end
+
+
+          def flynn_internal_routes
+            { 'FLYNN_INTERNAL' => "#{ project_name }.#{ domain_for_web_host }" }
+          end
+
+
+          def key_for_ddev_id(ddev_id)
+            ENV["#{ env_var_key_prefix }#{ user_defined_tls?(ddev_id) ? ddev_id : 'DEFAULT' }"]
+          end
+
+
+          def only_whitespace
+            /\A\s*\z/m
+          end
+
+
+          def remove_undefined_routes
+            routes_to_remove.each do |route|
+              log_header "Removing undefined route #{ route[routes_legend['ROUTE']] }..."
+              fc_route_remove route[routes_legend['ID']]
+            end
+          end
+
+
+          def route_ids(route)
+            [].tap do |route_ids|
+              routes_all_of('ROUTE').map { |r| r.sub(/https??:/i, '') }.each_with_index do |r, i|
+                route_ids << routes_all_of('ID')[i] if r == route
+              end
+            end
+          end
+
+
+          def routes
+            routes_with_legend.drop(1)
+          end
+
+
+          def routes_all_of(field)
+            routes.map { |a| a[routes_legend[field]] }
+          end
+
+
+          def routes_legend
+            {}.tap { |h| routes_with_legend.first.each_with_index { |route, index| h[route] = index } }
+          end
+
+
+          def routes_to_remove
+            routes.reject do |route|
+              defined_and_internal_routes.values.include? route[routes_legend['ROUTE']].partition(':').last
+            end
+          end
+
+
+          def routes_with_legend
+            fc_route.split("\n").map(&:split)
+          end
+
+
+          def service_for_route_id(route_id)
+            index = routes_all_of('ID').index(route_id)
+            routes_all_of('SERVICE')[index]
+          end
+
+
+          def setup_routes
+            configure_routes
+            remove_undefined_routes
+            display_routing_information
+          end
+
+
+          def urlified_routes
+            routes_all_of('ROUTE').map { |r| urlify_route r }
+          end
+
+
+          def urlified_routes_for_display
+            urlified_routes.map { |route| urlify_route_for_display route }.sort
+          end
+
+
+          def urlify_route(route)
+            route.sub(':', '://')
+          end
+
+
+          def urlify_route_for_display(route)
+            route =~ /^http:/ ? route : "#{ route.sub 'https', 'http' }, #{ route }"
+          end
+
+
+          def use_lets_encrypt?(ddev_id)
+            crt_for_ddev_id(ddev_id).to_s.gsub(/\W+/, '').casecmp('letsencrypt').zero? &&
+              key_for_ddev_id(ddev_id).to_s.gsub(/\W+/, '').casecmp('letsencrypt').zero?
+          end
+
+
+          def use_tls?(ddev_id)
+            [crt_for_ddev_id(ddev_id), key_for_ddev_id(ddev_id)].all? { |x| x.to_s !~ only_whitespace }
+          end
+
+
+          def user_defined_tls?(ddev_id)
+            custom_crt_for_ddev_id?(ddev_id) && custom_key_for_ddev_id?(ddev_id)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/satorix/CI/deploy/flynn/scale.rb

@@ -0,0 +1,52 @@
+module Satorix
+  module CI
+    module Deploy
+      module Flynn
+        module Scale
+
+
+          def adjust_scale
+            cached_scale_options_to_set = scale_options_to_set
+            log "No scale specified in #{ defined_scale_key }. Displaying current scale:" if cached_scale_options_to_set.empty?
+            fc_scale cached_scale_options_to_set
+          end
+
+
+          def current_scale
+            scale_string_to_hash fc_scale
+          end
+
+
+          def defined_scale
+            scale_string_to_hash ENV[defined_scale_key].to_s
+          end
+
+
+          def defined_scale_key
+            "FLYNN_#{ current_branch }_SCALE"
+          end
+
+
+          def fc_scale(scale_options_to_set = nil)
+            run_command "flynn scale#{ " #{ scale_options_to_set }" unless scale_options_to_set.nil? || scale_options_to_set.empty? }".chomp
+          end
+
+
+          def scale_options_to_set
+            [].tap do |scale|
+              defined_scale.each { |job, workers| scale << "#{ job }=#{ workers }" }
+              (current_scale.keys - defined_scale.keys).each { |job| scale << "#{ job }=0" } unless defined_scale.empty?
+            end.join(' ')
+          end
+
+
+          def scale_string_to_hash(scale_string)
+            {}.tap { |jobs| scale_string.split.map { |x| x.partition('=') }.each { |x| jobs[x.first.to_sym] = x.last } }
+          end
+
+
+        end
+      end
+    end
+  end
+end

data/lib/satorix/CI/deploy/flynn.rb

@@ -0,0 +1,132 @@
+module Satorix
+  module CI
+    module Deploy
+      module Flynn
+
+
+        include Satorix
+        include Satorix::Shared::Console
+
+        require_relative 'flynn/environment_variables'
+        include EnvironmentVariables
+
+        require_relative 'flynn/resources'
+        include Resources
+
+        require_relative 'flynn/routes'
+        include Routes
+
+        require_relative 'flynn/scale'
+        include Scale
+
+
+        extend self
+
+
+        def go
+          log_bench('Adding a local reference to the remote Flynn cluster...') { add_cluster }
+          log_bench('Creating Flynn project...') { create_project }
+          log_bench('Adding Flynn remote to CI local git...') { add_remote }
+          log_bench('Adjusting Flynn environment variables...') { adjust_env_vars }
+          log_bench('Configuring Flynn inactive slug release count...') { configure_inactive_slug_releases }
+          log_bench('Setting resources...') { set_resources }
+          log_bench('Deploying to Flynn...') { deploy }
+          log_bench('Running Database migrations...') { run_database_migrations } if run_database_migrations?
+          log_bench('Scaling application processes...') { adjust_scale }
+          log_bench('Setting up routes...') { setup_routes }
+        end
+
+
+        def skip_buildpack
+          true
+        end
+
+
+        def add_cluster
+          run_command "flynn cluster add --force --default --tls-pin=#{ tls_pin } #{ cluster_name } #{ domain_for_cluster } #{ key }", filtered_text: [tls_pin, key]
+        end
+
+
+        def add_remote
+          run_command "flynn -a #{ project_name } remote add #{ cluster_name } -y"
+        end
+
+
+        def cluster_name
+          domain_for_cluster
+        end
+
+
+        def configure_inactive_slug_releases
+          run_command 'flynn meta set gc.max_inactive_slug_releases=2'
+        end
+
+
+        def create_project
+          if project_exists?
+            log "Skipping - Flynn project '#{ project_name }' already exists."
+          else
+            run_command "flynn create --remote=#{ cluster_name } -y #{ project_name }"
+          end
+        end
+
+
+        def deploy
+          run_command "git push #{ cluster_name } HEAD:refs/heads/master"
+        end
+
+
+        def domain_for_cluster
+          ENV["FLYNN_#{ current_branch }_DOMAIN"]
+        end
+
+
+        def domain_for_web_host
+          "#{ current_branch.downcase }.#{ hosting_namespace }"
+        end
+
+
+        def hosting_namespace
+          if ENV['SATORIX_HOSTING_NAMESPACE'].to_s !~ only_whitespace
+            ENV['SATORIX_HOSTING_NAMESPACE']
+          else
+            log_error_and_abort("Satorix configuration error: Missing SATORIX_HOSTING_NAMESPACE.\n\nPlease contact support.\n")
+          end
+
+        end
+
+
+        def key
+          ENV["FLYNN_#{ current_branch }_KEY"]
+        end
+
+
+        def project_exists?
+          `flynn apps`.split(/\R/).map { |a| a.split.last }.include? project_name
+        end
+
+
+        def run_database_migrations?
+          [rails_app?, django_app?].any?
+        end
+
+
+        def run_database_migrations
+          if desired_resource_provider_names.nil? || desired_resource_provider_names.empty?
+            log 'Skipping migrations, no database has been defined. Please see the resources section of this log for more information.'
+          else
+            run_command('flynn run --enable-log bundle exec rake db:migrate') if rails_app?
+            run_command('flynn run --enable-log python public/manage.py migrate') if django_app?
+          end
+        end
+
+
+        def tls_pin
+          ENV["FLYNN_#{ current_branch }_TLSPIN"]
+        end
+
+
+      end
+    end
+  end
+end

data/lib/satorix/CI/shared/buildpack_manager/buildpack.rb

@@ -0,0 +1,159 @@
+module Satorix
+  module CI
+    module Shared
+      module BuildpackManager
+
+
+        class Buildpack
+
+
+          require 'fileutils'
+          require 'uri'
+
+
+          include Satorix::Shared::Console
+
+
+          attr_accessor :commit_sha_short,
+                        :url
+
+
+          def go
+            log_error_and_abort 'Buildpack.go should not be called directly - use BuildpackManager.go.'
+          end
+
+
+          def initialize(initialization_url)
+            self.url, self.commit_sha_short = initialization_url.to_s.strip.split('#')
+          end
+
+
+          def compile
+            log_bench "Building application using the #{ name } buildpack..." do
+              run_command [compile_binary_path,
+                           Satorix.build_dir,
+                           Satorix.paths[:cache],
+                           Satorix.paths[:env]]
+            end
+          end
+
+
+          def compile_binary_path
+            bin_path = File.join(path, 'bin')
+            test_compile_path = File.join(bin_path, 'test-compile')
+            compile_path = File.join(bin_path, 'compile')
+            File.exist?(test_compile_path) ? test_compile_path : compile_path
+          end
+
+
+          def detected?
+            if BuildpackManager.custom_buildpacks?
+              log "Custom Buildpack: #{ name }."
+            else
+              command = [File.join(path, 'bin', 'detect'), Satorix.build_dir]
+              buildpack_name = run_command(command, quiet: true).chomp
+              log "Detected Framework: #{ buildpack_name }."
+            end
+            true
+          rescue SystemExit
+            # By design, buildpacks return a non-zero exit code
+            # (which raises a SystemExit exception) when not detected.
+            # This is not particularly exceptional, so we just return false.
+            false
+          end
+
+
+          def name
+            File.basename(URI.parse(url).path, ".git")
+          end
+
+
+          def path
+            File.join Satorix.paths[:buildpacks], name
+          end
+
+
+          def ensure_correctness
+            unless correct_version?
+              delete!
+              checkout
+            end
+          end
+
+
+          def delete!
+            FileUtils.rm_rf path
+          end
+
+
+          def exist?
+            Dir.exist? path
+          end
+
+
+          def checkout
+            log "Downloading Buildpack: #{ url }."
+            commit_sha_short ? checkout_specific_version : checkout_newest_version
+          end
+
+
+          def checkout_specific_version
+            run_command ['git', 'clone', '--quiet', '--no-checkout', url, path], quiet: true
+            Dir.chdir(path) { run_command ['git', 'checkout', '--quiet', commit_sha_short], quiet: true }
+            Dir.chdir(path) { run_command ['git', 'submodule', 'update', '--init', '--recursive'], quiet: true }
+          end
+
+
+          def checkout_newest_version
+            run_command ['git', 'clone', '--quiet', '--recursive', '--depth', '1', url, path], quiet: true
+          end
+
+
+          def correct_version?
+            exist? &&
+              commit_sha_short &&
+              commit_sha_short == current_commit_sha_short_on_disk
+          end
+
+
+          def commit_sha_length
+            commit_sha_short ? commit_sha_short.to_s.length : 7
+          end
+
+
+          def satorix_distrib_sha_version
+            IO.binread(satorix_distrib_sha_path).strip if satorix_distrib_sha?
+          end
+
+
+          def satorix_distrib_sha?
+            File.exist? satorix_distrib_sha_path
+          end
+
+
+          def satorix_distrib_sha_path
+            File.join(path, '.distrib-sha')
+          end
+
+
+          def git_sha_short
+            Dir.chdir(path) do
+              # Also works: `git show -s --format=%h`.strip
+              run_command(['git', 'rev-parse', "--short=#{ commit_sha_length }", 'HEAD'], quiet: true).strip
+            end
+          end
+
+
+          def current_commit_sha_short_on_disk
+            return '' unless exist?
+            satorix_distrib_sha_version || git_sha_short
+          end
+
+
+        end
+
+
+      end
+    end
+  end
+end