satorix 0.0.1 → 1.5.3

data/lib/satorix/CI/test/shared/database.rb

@@ -0,0 +1,74 @@
+module Satorix
+  module CI
+    module Test
+      module Shared
+        module Database
+
+
+          include Satorix::Shared::Console
+
+
+          extend self
+
+
+          def host
+            ENV['DB_HOST'].to_s
+          end
+
+
+          def name
+            name_key.empty? ? '' : ENV[name_key].to_s
+          end
+
+
+          def name_key
+            {
+              mariadb: 'MYSQL_DATABASE',
+              mysql: 'MYSQL_DATABASE',
+              postgres: 'POSTGRES_DB'
+            }[host.to_sym].to_s
+          end
+
+
+          def password
+            password_key.empty? ? '' : ENV[password_key].to_s
+          end
+
+
+          def password_key
+            {
+              mariadb: 'MYSQL_ROOT_PASSWORD',
+              mysql: 'MYSQL_ROOT_PASSWORD',
+              postgres: 'POSTGRES_PASSWORD'
+            }[host.to_sym].to_s
+          end
+
+
+          def url
+            unset = [host, user, password, name].select(&:empty?)
+            if unset.empty?
+              "#{ host }://#{ user }:#{ password }@#{ host }/#{ name }"
+            else
+              log 'No database has been configured.'
+              log 'If you would like to use a database for this job, ensure that your gitlab-config.yml is configured.'
+              log 'Most databases require you to specify a type, host, database, username, and password.'
+              nil
+            end
+          end
+
+
+          def user
+            (ENV[user_key] || 'root').to_s
+          end
+
+
+          def user_key
+            "#{ host.upcase }_USER"
+          end
+
+
+        end
+      end
+    end
+  end
+end

data/lib/satorix/shared/console.rb

@@ -0,0 +1,157 @@
+module Satorix
+  module Shared
+    module Console
+
+
+      require 'benchmark'
+      require 'English' # http://ruby-doc.org/stdlib-2.0.0/libdoc/English/rdoc/English.html
+      require 'shellwords'
+
+
+      extend self
+
+
+      def colors
+        Hash.new(39).merge(red: '0;31', light_red: '1;31',
+                           green: '0;32', light_green: '1;32',
+                           yellow: '0;33', light_yellow: '1;33',
+                           blue: '0;34', light_blue: '1;34',
+                           magenta: '0;35', light_magenta: '1;35',
+                           cyan: '0;36', light_cyan: '1;36',
+                           white: '0;37', light_white: '1;37')
+      end
+
+
+      def colorize(text, color = nil)
+        "\033[#{ colors[color] }m#{ text }\033[0m"
+      end
+
+
+      def log(text, color = nil)
+        puts color ? colorize(text, color) : text
+      end
+
+
+      def log_command(text)
+        log text, :cyan
+      end
+
+
+      def log_duration(text)
+        log text, :light_cyan
+      end
+
+
+      def log_header(text)
+        log("\n#{ text }", :light_green)
+      end
+
+
+      def log_error(text)
+        log text, :light_red
+      end
+
+
+      def log_error_and_abort(text)
+        log_error text
+        abort text
+      end
+
+
+      def log_bench(message)
+        log_header message
+        result = nil
+        log_duration "Time elapsed: #{ humanize_time Benchmark.realtime { result = yield } }."
+        result
+      end
+
+
+      def humanize_time(seconds)
+        return 'less than 1 second' if seconds < 1
+        [[60, :second], [60, :minute], [24, :hour], [1000, :day]].map do |count, name|
+          if seconds > 0
+            seconds, n = seconds.divmod(count)
+            n = n.to_i
+            "#{ n } #{ name }#{ 's' if n > 1 }" if n > 0
+          end
+        end.compact.reverse.join(' ')
+      end
+
+
+      # This method is used *EVERYWHERE*.
+      # Seemingly small changes can have far-ranging and extreme consequences.
+      # Modify only with extreme caution.
+      #
+      # Note: Many applications (like echo and the Flynn CLI) append a newline to their output.
+      #       If you are using the command result, it may be desirable to chomp the trailing
+      #       newline. It is left to the implementing call to handle this, as it proved
+      #       cumbersome to handle in this method in a way that worked perfectly in all cases.
+      def run_command(command, filtered_text: [], quiet: false)
+        command = command.shelljoin if command.is_a?(Array)
+        logged_command = logged_command(command, filtered_text)
+        log_command(logged_command) unless quiet
+
+        ''.tap do |output|
+          IO.popen(bash(command)) do |io|
+            until io.eof?
+              line = io.gets
+              puts line unless quiet || line.empty?
+              $stdout.flush
+              output.concat line
+            end
+          end
+
+          handle_run_command_error(logged_command, quiet) unless $CHILD_STATUS.success?
+        end
+      end
+
+
+      # http://stackoverflow.com/questions/1197224/source-shell-script-into-environment-within-a-ruby-script
+      # TODO : reduce / consolidate?
+      # Find variables changed as a result of sourcing the given file, and update in ENV.
+      def source_env_from(file)
+        bash_source(file).each { |k, v| ENV[k] = v }
+      end
+
+
+      private ##########################################################################################################
+
+
+      def logged_command(command, filtered_text)
+        filtered_text = [filtered_text].flatten.delete_if { |text| text.nil? || text.strip.empty? }
+        command.gsub(Regexp.union(filtered_text), '[MASKED]')
+      end
+
+
+      def bash(command)
+        "bash -c #{ command.shellescape }"
+      end
+
+
+      # http://stackoverflow.com/questions/1197224/source-shell-script-into-environment-within-a-ruby-script
+      # TODO : reduce / consolidate?
+      # Read in the bash environment, after an optional command. Returns Array of key/value pairs.
+      def bash_env(cmd = nil)
+        env_cmd = bash("#{ cmd + ';' if cmd } printenv")
+        env = `#{ env_cmd }`
+        env.split(/\n/).map { |l| l.split(/=/, 2) }
+      end
+
+
+      # http://stackoverflow.com/questions/1197224/source-shell-script-into-environment-within-a-ruby-script
+      # TODO : reduce / consolidate?
+      # Source a given file, and compare environment before and after. Returns Hash of any keys that have changed.
+      def bash_source(file)
+        Hash[bash_env("source #{ File.realpath file }") - bash_env]
+      end
+
+
+      def handle_run_command_error(logged_command, quiet)
+        error_message = "\nAn error has occurred while running the following command:\n#{ logged_command }\n"
+        quiet ? abort : log_error_and_abort(error_message)
+      end
+
+
+    end
+  end
+end

data/lib/satorix/version.rb

@@ -1,3 +1,3 @@
 module Satorix
-  VERSION = '0.0.1'
+  VERSION = '1.5.3'.freeze
 end

data/lib/satorix.rb

@@ -1,5 +1,346 @@
-require "satorix/version"
+require 'airbrake-ruby'
+require 'English' # http://ruby-doc.org/stdlib-2.0.0/libdoc/English/rdoc/English.html
+require 'satorix/version'
+require 'etc'
 
 module Satorix
-  # Your code goes here...
+
+
+  module Shared
+    autoload :Console, 'satorix/shared/console'
+  end
+
+
+  module CI
+
+    module Deploy
+      autoload :Flynn, 'satorix/CI/deploy/flynn'
+    end
+
+    module Shared
+      autoload :BuildpackManager, 'satorix/CI/shared/buildpack_manager'
+      module BuildpackManager
+        autoload :Buildpack, 'satorix/CI/shared/buildpack_manager/buildpack'
+      end
+      autoload :YarnManager, 'satorix/CI/shared/yarn_manager'
+
+      module Ruby
+        autoload :GemManager, 'satorix/CI/shared/ruby/gem_manager'
+      end
+    end
+
+    module Test
+      module Python
+        autoload :DjangoTest, 'satorix/CI/test/python/django_test'
+        autoload :Safety, 'satorix/CI/test/python/safety'
+      end
+
+      module Ruby
+        autoload :Brakeman, 'satorix/CI/test/ruby/brakeman'
+        autoload :BundlerAudit, 'satorix/CI/test/ruby/bundler_audit'
+        autoload :Cucumber, 'satorix/CI/test/ruby/cucumber'
+        autoload :RailsTest, 'satorix/CI/test/ruby/rails_test'
+        autoload :Rspec, 'satorix/CI/test/ruby/rspec'
+        autoload :Rubocop, 'satorix/CI/test/ruby/rubocop'
+      end
+
+      module Shared
+        autoload :Database, 'satorix/CI/test/shared/database'
+      end
+    end
+
+  end
+
+
+  include Satorix::Shared::Console
+
+
+  extend self
+
+
+  def go
+    airbrake_start
+    prepare_app_environment
+
+    begin
+      log_header "Executing #{ ci_job_name } script for #{ ci_commit_ref_name }..."
+
+      execute_as_user 'satorix' do
+        Dir.chdir(build_dir)
+        unless skip_buildpack?
+          Satorix::CI::Shared::BuildpackManager.go
+          Dir.chdir(app_dir)
+        end
+        Satorix::CI::Shared::Ruby::GemManager.go if ruby_gem?
+        Satorix::CI::Shared::YarnManager.go if yarn?
+
+        job_class.go
+      end
+
+      log_header "\nDone executing #{ ci_job_name } script for #{ ci_commit_ref_name }.\n"
+    rescue Exception => e
+      # TODO: add link to issue tracker
+      log 'If you feel this failure was in error, please check the issue tracker for more information.'
+      Airbrake.notify(e) if airbrake_configured?
+      raise e
+    end
+  end
+
+
+  def add_user(username)
+    unless user_exists?(username)
+      run_command ['useradd', '--user-group', '--comment', "'#{ username } user'", '--shell', '/bin/bash', '--home', app_dir, username], quiet: true
+    end
+  end
+
+
+  def user_exists?(username)
+    Etc.getpwnam(username)
+  rescue
+  end
+
+
+  def airbrake_configured?
+    [airbrake_project_id, airbrake_project_key].all? { |var| !var.empty? }
+  end
+
+
+  def airbrake_project_id
+    ENV['SATORIX_CI_AIRBRAKE_PROJECT_ID'].to_s
+  end
+
+
+  def airbrake_project_key
+    ENV['SATORIX_CI_AIRBRAKE_PROJECT_KEY'].to_s
+  end
+
+
+  def airbrake_start
+    return unless airbrake_configured?
+
+    Airbrake.configure do |c|
+      c.project_id = airbrake_project_id
+      c.project_key = airbrake_project_key
+    end
+
+    at_exit do
+      Airbrake.notify_sync($ERROR_INFO) if $ERROR_INFO # https://github.com/airbrake/airbrake-ruby#reporting-critical-exceptions
+      Airbrake.close # https://github.com/airbrake/airbrake-ruby#airbrakeclose
+    end
+  end
+
+
+  def custom_loader_relative_path
+    File.join 'satorix', 'custom.rb'
+  end
+
+
+  def custom_loader_full_path
+    File.join build_dir, custom_loader_relative_path
+  end
+
+
+  def load_custom
+    log_bench "Looking for custom job definitions in #{ custom_loader_relative_path }....." do
+      if File.exist? custom_loader_full_path
+        log "Loading custom job definitions from #{ custom_loader_relative_path }."
+        require custom_loader_full_path
+        Satorix::Custom.available_jobs
+      else
+        # TODO : create this documentation and link to it in the message below
+        log 'No custom jobs found.'
+        log "You can define custom jobs by adding a #{ custom_loader_relative_path } file to your app root."
+        log 'For more information, please refer to https://www.satorix.com/docs/articles/custom_satorix_jobs.'
+        {}
+      end
+    end
+  end
+
+
+  def default_jobs
+    { deploy: { deploy_with_flynn: Satorix::CI::Deploy::Flynn },
+      test: { brakeman: Satorix::CI::Test::Ruby::Brakeman,
+              bundler_audit: Satorix::CI::Test::Ruby::BundlerAudit,
+              cucumber: Satorix::CI::Test::Ruby::Cucumber,
+              django_test: Satorix::CI::Test::Python::DjangoTest,
+              rails_test: Satorix::CI::Test::Ruby::RailsTest,
+              rspec: Satorix::CI::Test::Ruby::Rspec,
+              rubocop: Satorix::CI::Test::Ruby::Rubocop,
+              safety: Satorix::CI::Test::Python::Safety } }
+  end
+
+
+  def available_jobs
+    @_available_jobs ||= load_custom.tap do |jobs|
+      default_jobs.each do |stage, job_definitions|
+        jobs[stage] ||= {}
+        job_definitions.each { |job, target| jobs[stage][job] = target }
+      end
+    end
+  end
+
+
+  def ci_job_name
+    ENV['CI_JOB_NAME']
+  end
+
+
+  def ci_job_stage
+    ENV['CI_JOB_STAGE']
+  end
+
+
+  def ci_commit_ref_name
+    ENV['CI_COMMIT_REF_NAME']
+  end
+
+
+  def ci_commit_sha
+    ENV['CI_COMMIT_SHA']
+  end
+
+
+  def current_branch
+    @_current_branch ||= ci_commit_ref_name.to_s.upcase
+  end
+
+
+  def job_class
+    available_jobs[ci_job_stage.to_sym] && available_jobs[ci_job_stage.to_sym][ci_job_name.to_sym] || begin
+                                                                                                        log_error_and_abort "The #{ ci_job_name } job does not exist for the #{ ci_job_stage } stage!"
+                                                                                                      end
+  end
+
+
+  # https://stackoverflow.com/questions/4548151/run-ruby-block-as-specific-os-user/
+  def execute_as_user(user, &block)
+    u = (user.is_a? Integer) ? Etc.getpwuid(user) : Etc.getpwnam(user)
+
+    ENV['HOME'] = Satorix.app_dir
+
+    reader, writer = IO.pipe
+
+    Process.fork do
+      # the child process won't need to read from the pipe
+      reader.close
+
+      # use primary group ID of target user
+      # This needs to be done first as we won't have
+      # permission to change our group after changing EUID
+      Process.gid = Process.egid = u.gid
+
+      # set real and effective UIDs to target user
+      Process.uid = Process.euid = u.uid
+
+      # get the result and write it to the IPC pipe
+      result = block.call(user)
+      Marshal.dump(result, writer)
+      writer.close
+
+      # prevent shutdown hooks from running
+      Process.exit!(true)
+    end
+
+    # back to reality... we won't be writing anything
+    writer.close
+
+    # block until there's data to read
+    result = Marshal.load(reader)
+
+    # done with that!
+    reader.close
+
+    # return block result
+    result
+  rescue EOFError
+    log_error 'This job has failed.'
+    abort
+  end
+
+
+  def paths
+    ci_project_dir = ENV['CI_PROJECT_DIR'].to_s
+    { buildpacks: '/tmp/buildpacks',
+      app_dir: '/tmp/app',
+      build_dir: ci_project_dir,
+      cache: File.join(ci_project_dir, 'tmp', 'satorix', 'cache'),
+      env: '/tmp/env' }
+  end
+
+
+  def app_dir
+    paths[:app_dir]
+  end
+
+
+  def bin_dir
+    File.join app_dir, 'bin'
+  end
+
+
+  def build_dir
+    paths[:build_dir]
+  end
+
+
+  def prepare_app_environment
+    log_bench 'Preparing app environment...' do
+      add_user('satorix')
+      setup_directories
+    end
+  end
+
+
+  def project_name
+    ENV['CI_PROJECT_NAME']
+  end
+
+
+  def setup_directories
+    paths.values.each { |path| FileUtils.mkdir_p path }
+    paths.values.each { |path| FileUtils.chown_R 'satorix', 'satorix', path }
+    FileUtils.ln_s app_dir, '/app'
+  end
+
+
+  def skip_buildpack?
+    job_class.respond_to?(:skip_buildpack) && job_class.skip_buildpack
+  end
+
+
+  def yarn?
+    File.exist? yarn_lock_file
+  end
+
+
+  def yarn_lock_file
+    File.join(app_dir, 'yarn.lock')
+  end
+
+
+  def rails_app?
+    # This used to follow the Heroku buildpack, with:
+    # File.exist?(File.join(build_dir, 'Gemfile'))
+    # It has been adjusted to accommodate non-rails apps that use ruby gems.
+    # The config/application.rb file seems to be present in all rails applications.
+    # It may be useful to add additional checks, for increased precision, in the future.
+    File.exist?(File.join(build_dir, 'config', 'application.rb'))
+  end
+
+
+  def django_app?
+    # Satorix requires django apps be in a public directory.
+    # The manage.py file seems to be present in all django applications.
+    # It may be useful to add additional checks, for increased precision, in the future.
+    File.exist?(File.join(build_dir, 'public', 'manage.py'))
+  end
+
+
+  def ruby_gem?
+    # Checks for the presence of a *.gemspec file in the project root.
+    # It may be useful to add additional checks, for increased precision, in the future.
+    Dir[File.join(build_dir, '*.gemspec')].any?
+  end
+
+
 end

data/satorix/CI/deploy/ie_gem_server.rb

@@ -0,0 +1,80 @@
+module Satorix
+  module CI
+    module Deploy
+      module IeGemServer
+
+
+        require 'fileutils'
+
+
+        include Satorix::Shared::Console
+
+
+        extend self
+
+
+        def go
+          log_bench('Installing the geminabox gem...') { install_geminabox_gem }
+          log_bench('Preparing gem build directory...') { prepare_gem_build_directory }
+          log_bench('Building gem...') { build_gem }
+          built_gems.each { |gem| log_bench("Publishing #{ File.basename gem }...") { publish_gem gem } }
+        end
+
+
+        def build_gem
+          run_command 'rake build'
+        end
+
+
+        def built_gems
+          Dir.glob(File.join(gem_build_directory, '*.gem')).select { |e| File.file? e }
+        end
+
+
+        def gem_build_directory
+          File.join Satorix.app_dir, 'pkg'
+        end
+
+
+        def ie_gem_server_host
+          "https://#{ ie_gem_server_user_name }:#{ ie_gem_server_password }@gems.iexposure.com"
+        end
+
+
+        def install_geminabox_gem
+          run_command "gem install geminabox --source https://gems.iexposure.com --no-document --bindir #{ Satorix.bin_dir }"
+        end
+
+
+        def prepare_gem_build_directory
+          run_command "rm -rf #{ gem_build_directory }", quiet: true
+          FileUtils.mkdir_p gem_build_directory
+        end
+
+
+        def publish_gem(gem)
+          run_command "gem inabox #{ gem } --host #{ ie_gem_server_host }",
+                      filtered_text: [ie_gem_server_user_name, ie_gem_server_password]
+        rescue RuntimeError
+          # To prevent the display of an ugly stacktrace.
+          abort "\nGem was not published!"
+        end
+
+
+        private ########################################################################################################
+
+
+        def ie_gem_server_password
+          ENV['IE_GEM_SERVER_PASSWORD']
+        end
+
+
+        def ie_gem_server_user_name
+          ENV['IE_GEM_SERVER_USER_NAME']
+        end
+
+
+      end
+    end
+  end
+end