shiplane 0.1.1

data/lib/shiplane/checkout_artifact.rb

@@ -0,0 +1,121 @@
+require 'fileutils'
+
+module Shiplane
+  class CheckoutArtifact
+    extend Forwardable
+    attr_accessor :sha
+
+    delegate %i(build_config project_config) => :shiplane_config
+
+    def initialize(sha)
+      @sha = sha
+
+      # call this before changing directories.
+      # This prevents race conditions where the config file is accessed before being downloaded
+      shiplane_config
+    end
+
+    def appname
+      @appname ||= project_config['appname']
+    end
+
+    def shiplane_config
+      @shiplane_config ||= Shiplane::Configuration.new
+    end
+
+    def github_token
+      @github_token ||= ENV['GITHUB_TOKEN']
+    end
+
+    def git_url
+      "https://#{github_token ? "#{github_token}@" : ''}github.com/#{project_config['origin']}"
+    end
+
+    def app_directory
+      @app_directory ||= File.join(Dir.pwd, 'docker_builds', appname)
+    end
+
+    def build_directory
+      @build_directory ||= File.join(app_directory, "#{appname}-#{sha}")
+    end
+
+    def make_directory
+      FileUtils.mkdir_p build_directory
+    end
+
+    def checkout!
+      return if File.exist?(File.join(build_directory, Shiplane::SHIPLANE_CONFIG_FILENAME))
+
+      puts "Checking out Application #{appname}[#{sha}]..."
+      make_directory
+
+      success = true
+      FileUtils.cd app_directory do
+        success = success && system("echo 'Downloading #{git_url}/archive/#{sha}.tar.gz --output #{appname}-#{sha}.tar.gz'")
+        success = success && system("curl -L #{git_url}/archive/#{sha}.tar.gz --output #{appname}-#{sha}.tar.gz")
+        success = success && system("tar -xzf #{appname}-#{sha}.tar.gz -C .")
+      end
+
+      raise "Errors encountered while downloading archive" unless success
+      puts "Finished checking out Application"
+      tasks.each(&method(:send))
+    end
+
+    def tasks
+      [:make_directories, :copy_env_files, :copy_insert_on_build_files, :unignore_required_directories]
+    end
+
+    def make_directories
+      FileUtils.cd build_directory do
+        required_directories.each do |directory|
+          FileUtils.mkdir_p directory
+        end
+      end
+    end
+
+    def copy_env_files
+      puts "Copying in environment files..."
+      FileUtils.cp File.join(Dir.pwd, build_config.fetch('environment_file', '.env')), File.join(build_directory, '.env')
+      puts "Environment Files Copied"
+    end
+
+    def copy_insert_on_build_files
+      puts "Copying application configuration files..."
+
+      if Dir.exist? File.join(build_config.fetch('settings_folder', '.shiplane'), "insert_on_build")
+        FileUtils.cd File.join(build_config.fetch('settings_folder', '.shiplane'), "insert_on_build") do
+          Dir["*/**"].each do |filepath|
+            if File.extname(filepath) == ".erb"
+              copy_erb_file(filepath)
+            else
+              FileUtils.cp filepath, File.join(build_directory, filepath)
+            end
+          end
+        end
+      end
+      puts "Configuration Files Copied"
+    end
+
+    def copy_erb_file(filepath)
+      File.write(File.join(build_directory, filepath.gsub(".erb","")), ERB.new(File.read(filepath)).result, mode: 'w')
+    end
+
+    def unignore_required_directories
+      puts "Adding Required Directories as explicit inclusions in ignore file..."
+      File.open(File.join(build_directory, '.dockerignore'), 'a') do |file|
+        required_directories.each do |directory|
+          file.puts "!#{directory}/*"
+        end
+      end
+      puts "Finished including required directories..."
+    end
+
+    def required_directories
+      ['vendor']
+    end
+
+    def self.checkout!(sha)
+      new(sha).checkout!
+    end
+  end
+end

data/lib/shiplane/compose_hash.rb

@@ -0,0 +1,38 @@
+require_relative 'extensions'
+
+module Shiplane
+  class ComposeHash
+    attr_accessor :compose_file, :production_config
+
+    def initialize(compose_file, production_config)
+      @compose_file = compose_file
+      @production_config = production_config
+    end
+
+    def production_yml
+      blacklisted_nodes.inject(whitelisted_hash){ |acc, node| acc.blacklist(node) }
+    end
+
+    def compose_hash
+      @compose_hash ||= YAML.load(compose_file)
+    end
+
+    def whitelisted_hash
+      @whitelisted_hash ||= compose_hash.whitelist(*default_whitelisted_nodes, *whitelisted_nodes)
+    end
+
+    def blacklisted_nodes
+      @blacklisted_nodes ||= production_config.fetch('blacklist', [])
+    end
+
+    def whitelisted_nodes
+      @whitelisted_nodes ||= production_config.fetch('whitelist', [])
+    end
+
+    def default_whitelisted_nodes
+      [
+        "version",
+      ]
+    end
+  end
+end

data/lib/shiplane/configuration.rb

@@ -0,0 +1,37 @@
+module Shiplane
+  class Configuration
+    attr_accessor :project_folder
+
+    def initialize(project_folder = nil)
+      @project_folder = project_folder || Dir.pwd
+    end
+
+    def shiplane_config_file
+      @shiplane_config_file ||= File.join(project_folder, Shiplane::SHIPLANE_CONFIG_FILENAME)
+    end
+
+    def config
+      @config ||= YAML.load_file(shiplane_config_file)
+    end
+
+    def build_config
+      @build_config ||= config.fetch('build', {})
+    end
+
+    def bootstrap_config
+      @bootstrap_config ||= config.fetch('bootstrap', {})
+    end
+
+    def deploy_config
+      @deploy_config ||= config.fetch('deploy', {})
+    end
+
+    def project_config
+      @project_config ||= config.fetch('project', {})
+    end
+
+    def self.config(project_folder = nil)
+      new(project_folder).config
+    end
+  end
+end

data/lib/shiplane/convert_compose_file.rb

@@ -0,0 +1,59 @@
+require 'facets/hash/traverse'
+require_relative 'configuration'
+require_relative 'compose_hash'
+
+module Shiplane
+  class ConvertComposeFile
+    extend Forwardable
+    attr_accessor :project_folder, :sha
+
+    delegate %i(build_config) => :shiplane_config
+
+    def initialize(project_folder, sha)
+      @project_folder = project_folder
+      @sha = sha
+    end
+
+    def shiplane_config
+      @shiplane_config ||= Shiplane::Configuration.new
+    end
+
+    def compose_config
+      @compose_config ||= build_config.fetch('compose', {})
+    end
+
+    def compose_filepath
+      @compose_filepath ||= File.join(project_folder, build_config.fetch('compose_filepath', Shiplane::DEFAULT_COMPOSEFILE_FILEPATH))
+    end
+
+    def converted_compose_hash
+      @converted_compose_hash ||= Shiplane::ComposeHash.new(File.new(compose_filepath), compose_config).production_yml
+    end
+
+    def converted_output
+      @converted_output ||= converted_compose_hash.dup.tap do |hash|
+        build_config.fetch('artifacts', {}).each do |(appname, config)|
+          hash.deep_merge!({ 'services' => { appname => { 'image' => "#{config['repo']}:#{sha}" } } })
+        end
+
+        hash.traverse! do |key, value|
+          if (key == 'env_file' && value == '.env.development')
+            [key, '.env.production']
+          else
+            [key, value]
+          end
+        end
+      end
+    end
+
+    def convert_output!
+      puts "Converting Compose File..."
+      File.write(compose_filepath, converted_output.to_yaml)
+      puts "Compose File Converted..."
+    end
+
+    def self.convert_output!(project_folder, sha)
+      new(project_folder, sha).convert_output!
+    end
+  end
+end

data/lib/shiplane/convert_dockerfile.rb

@@ -0,0 +1,60 @@
+require_relative 'configuration'
+
+module Shiplane
+  class ConvertDockerfile
+    extend Forwardable
+    attr_accessor :artifact_context, :compose_context, :project_folder
+
+    delegate %i(build_config project_config) => :shiplane_config
+
+    def initialize(project_folder, artifact_context, compose_context)
+      @project_folder = project_folder
+      @artifact_context = artifact_context
+      @compose_context = compose_context
+    end
+
+    def appname
+      @appname ||= project_config['appname']
+    end
+
+    def shiplane_config
+      @shiplane_config ||= Shiplane::Configuration.new
+    end
+
+    def dockerfile_name
+      @dockerfile_name ||= compose_context.fetch('build', {}).fetch('context', '.').tap do |filename|
+        filename.gsub!(/^\.$/, 'Dockerfile')
+      end
+    end
+
+    def dockerfile_filepath
+      @dockerfile_filepath ||= File.join(project_folder, dockerfile_name)
+    end
+
+    def dockerfile_production_stages_filepath
+      @dockerfile_production_stages_filepath ||= File.join(Dir.pwd, build_config.fetch('settings_folder', '.shiplane'), Shiplane::DEFAULT_PRODUCTION_DOCKERFILE_STAGES_FILEPATH)
+    end
+
+    def entrypoint
+      @entrypoint ||= artifact_context.fetch('command', compose_context.fetch('command', "bin/rails s"))
+    end
+
+    def converted_output
+      @converted_output ||= [
+        File.read(dockerfile_filepath),
+        File.read(dockerfile_production_stages_filepath),
+        # "ENTRYPOINT #{entrypoint}",
+      ].join("\n\n")
+    end
+
+    def convert_output!
+      puts "Converting Dockerfile..."
+      File.write(dockerfile_filepath, converted_output)
+      puts "Dockerfile Converted..."
+    end
+
+    def self.convert_output!(project_folder, artifact_context, compose_context)
+      new(project_folder, artifact_context, compose_context).convert_output!
+    end
+  end
+end

data/lib/shiplane/deploy/configuration.rb

@@ -0,0 +1,17 @@
+module Shiplane
+  module Deploy
+    class Configuration
+      attr_accessor :env, :name, :options
+
+      def initialize(name, options, env)
+        @name = name
+        @options = options
+        @env = env
+      end
+
+      def docker_command(role)
+        role.requires_sudo? ? "sudo docker" : "docker"
+      end
+    end
+  end
+end

data/lib/shiplane/deploy/container_configuration.rb

@@ -0,0 +1,93 @@
+require_relative 'configuration'
+
+module Shiplane
+  module Deploy
+    class ContainerConfiguration < Configuration
+      def network_alias
+        @network_alias ||= options.fetch(:alias, container_name)
+      end
+
+      def volumes
+        @volumes ||= options.fetch(:volumes, [])
+      end
+
+      def published_ports
+        @published_ports ||= [options.fetch(:publish, [])].flatten
+      end
+
+      def exposed_ports
+        @exposed_ports ||= [options.fetch(:expose, [])].flatten - published_ports
+      rescue => e
+        binding.pry
+      end
+
+      def container_name
+        @container_name ||= "#{env.fetch(:application)}_#{name}_#{env.fetch(:sha)}"
+      end
+
+      def image_name
+        @image_name ||= "#{options.fetch(:repo)}:#{image_tag}"
+      end
+
+      def image_tag
+        @image_tag ||= options.fetch(:tag, "#{env.fetch(:stage)}-#{env.fetch(:sha)}")
+      end
+
+      def virtual_host
+        @virtual_host ||= options[:virtual_host]
+      end
+
+      def letsencrypt_host
+        @letsencrypt_host ||= options.fetch(:letsencrypt_host, virtual_host)
+      end
+
+      def letsencrypt_email
+        @letsencrypt_email ||= options[:letsencrypt_email]
+      end
+
+      def networks
+        @networks ||= options.fetch(:networks, [])
+      end
+
+      def startup_command
+        @startup_command ||= options[:command]
+      end
+
+      def network_connect_commands(role)
+        @network_commands ||= networks.map do |network|
+          [
+            docker_command(role),
+            "network connect",
+            "--alias #{network_alias}",
+            network,
+            container_name,
+            "|| true",
+          ].flatten.compact.join(" ")
+        end
+      end
+
+      def run_command(role)
+        @command ||= [
+          docker_command(role),
+          "run -d",
+          volumes.map{|volume_set| "-v #{volume_set}" },
+          published_ports.map{|port| "--expose #{port} -p #{port}" },
+          exposed_ports.map{|port| "--expose #{port}" },
+          "--name #{container_name}",
+          virtual_host ? "-e VIRTUAL_HOST=#{virtual_host}" : nil,
+          letsencrypt_host ? "-e LETSENCRYPT_HOST=#{letsencrypt_host}" : nil,
+          letsencrypt_email ? "-e LETSENCRYPT_EMAIL=#{letsencrypt_email}" : nil,
+          image_name,
+          startup_command ? startup_command : nil,
+        ].flatten.compact.join(" ")
+      end
+
+      def run_commands(role)
+        @run_commands ||= [
+          run_command(role),
+          network_connect_commands(role),
+        ].flatten
+      end
+    end
+  end
+end

data/lib/shiplane/deploy/network_configuration.rb

@@ -0,0 +1,40 @@
+require_relative 'configuration'
+
+module Shiplane
+  module Deploy
+    class NetworkConfiguration < Configuration
+      def connections
+        @connections ||= options.fetch(:connections, [])
+      end
+
+      def connect_commands(role)
+        @connect_commands ||=
+        connections.map do |connection|
+          [
+            docker_command(role),
+            "network connect",
+            name,
+            connection,
+            "|| true",
+          ].flatten.compact.join(" ")
+        end
+      end
+
+      def create_command(role)
+        @create_command ||= [
+          docker_command(role),
+          "network create",
+          name,
+          "|| true",
+        ].flatten.compact.join(" ")
+      end
+
+      def create_commands(role)
+        [
+          create_command(role),
+          connect_commands(role),
+        ].flatten
+      end
+    end
+  end
+end

data/lib/shiplane/extensions.rb

@@ -0,0 +1,49 @@
+require 'facets/hash/deep_merge'
+
+class Hash
+  def whitelist(*keymaps)
+    self.dup.whitelist!(*keymaps)
+  end
+
+  def whitelist!(*keymaps)
+    keymaps.map do |map|
+      deep_subset(map)
+    end.inject(&:deep_merge)
+  end
+
+  def deep_subset(keymap)
+    self.dup.deep_subset!(keymap)
+  end
+
+  def deep_subset!(keymap)
+    keypath_keys = keymap.split('.')
+    return {} unless keypath_keys.size >= 1
+
+    deepest_subset = { keypath_keys.last => dig(*keypath_keys) }
+
+    keypath_keys[0..-2].reverse.inject(deepest_subset)do |accum, key|
+      accum = { key => accum }
+    end
+  end
+
+  def blacklist(keymap)
+    self.dup.blacklist!(keymap)
+  end
+
+  def blacklist!(keymap, parentparts = nil)
+    keypart, *rest = keymap.split(".")
+    keychain = [parentparts, keypart].compact.join(".")
+
+    self.each do |k, v|
+      v.blacklist!(Array(rest).join("."), keychain) if v.is_a?(Hash) && k.to_s == keypart.to_s
+      self.delete(k) if k.to_s == keypart.to_s && rest.empty?
+    end
+  end
+end
+
+class Array
+  def pad(pad_length, character = nil)
+    return self if size >= pad_length
+    self + [character] * (pad_length - size)
+  end
+end

data/lib/shiplane/host.rb

@@ -0,0 +1,96 @@
+require 'sshkit'
+require 'sshkit/dsl'
+
+module Shiplane
+  class Host
+    extend Forwardable
+    include SSHKit::DSL
+
+    attr_accessor :env, :host, :role
+    def_delegators :env, :servers
+    def_delegators :role, :hostname
+
+    SSHKIT_PROPERTIES = %i(user password keys hostname port ssh_options)
+
+    def initialize(role, env)
+      @role = role
+      @env = env
+    end
+
+    def host
+      @host ||= SSHKit::Host.new(sshkit_options)
+    end
+
+    def capistrano_role
+      @capistrano_role ||= role.dup.tap do |r|
+        r.properties.set(:ssh_options, ssh_options)
+      end
+    end
+
+    def sshkit_values
+      {
+        interaction_handler: { "[sudo] password for #{user}: " => "#{password}\n" }
+      }
+    end
+
+    def requires_sudo?
+      @requires_sudo ||= config.fetch('requires_sudo', false)
+    end
+
+    private
+
+    def user
+      ssh_options.fetch("user", "")
+    end
+
+    def password
+      ssh_options.fetch("password", "")
+    end
+
+    def sshkit_options
+      @sshkit_options ||= options.merge(hostname: hostname).slice(*SSHKIT_PROPERTIES)
+    end
+
+    def options
+      @options ||= role.properties.to_h.symbolize_keys.merge(ssh_options: ssh_options)
+    end
+
+    def ssh_options
+      @ssh_options ||= config.fetch('ssh_options', {}).symbolize_keys
+    end
+
+    def config
+      self.class.config.fetch('deploy', {}).fetch('servers', {}).fetch(hostname, {})
+    end
+
+    def with_context(&block)
+      set(:shiplane_sshkit_values, sshkit_values)
+      yield
+      set(:shiplane_sshkit_values, nil)
+    end
+
+    def sshkit_output
+      @sshkit_output ||= SSHKit.config.output
+    end
+
+    def write_message(verbosity, message)
+      sshkit_output.write(SSHKit::LogMessage.new(verbosity, message))
+    end
+
+    def self.env_file
+      config.fetch("bootstrap", {}).fetch('env_file', '.env')
+    end
+
+    def self.config
+      @config ||= YAML.load(File.read(config_filepath))
+    end
+
+    def self.config_filepath
+      File.join("shiplane.yml")
+    end
+
+    def self.bootstrap!(host, env)
+      new(host, env).bootstrap!
+    end
+  end
+end

data/lib/shiplane/railtie.rb

@@ -0,0 +1,5 @@
+class Shiplane::Railtie < Rails::Railtie
+  rake_tasks do
+    load 'shiplane/tasks/install.rake'
+  end
+end