heighliner 0.9.0

data/lib/heighliner/config.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Heighliner
+  class Config
+    class << self
+      attr_accessor :out,
+                    :info_out
+
+      attr_reader :work_dir,
+                  :config_dir,
+                  :config_file,
+                  :steerfile,
+                  :config
+
+      def load(work_dir, use_steerfile: true)
+        @work_dir = work_dir
+        @config_dir = "#{ENV['HOME']}/.heighliner"
+
+        migrate_dotted_config_files
+
+        FileUtils.mkdir_p @config_dir
+        @config_file = "#{@config_dir}/config.yml"
+
+        @config = {
+          envnames: {},
+          envs: {},
+          networkname: 'heighliner_net',
+          shared_names: {
+            nginx: 'heighliner-nginx',
+            chrome: 'heighliner-chrome',
+            dns: 'heighliner-dns',
+            certs: 'heighliner-certs'
+          },
+          largest_port: 9000,
+          always_verbose: false
+        }
+
+        load_config
+
+        if use_steerfile
+          POSSIBLE_STEERFILES.each do |x|
+            @fname = x if File.exist?(x)
+          end
+
+          Optimist.die <<~ERROR if @fname.nil?
+            No Steerfile in current directory.
+            Possible names are #{POSSIBLE_STEERFILES.join(', ')}"
+          ERROR
+
+          @steerfile = Steerfile.new("#{@work_dir}/#{@fname}")
+        end
+
+        @config
+      end
+
+      POSSIBLE_STEERFILES = %w[
+        Steerfile
+        Heighliner.config
+        heighliner.config
+      ].freeze
+
+      def always_verbose?
+        @config[:always_verbose]
+      end
+
+      # Up until version 0.5.1, heighliner used dotfiles for all of it configuration.
+      # It makes sense of hide the configuration directory itself but hiding the files
+      # inside of it just causes confusion.
+      #
+      # Heighliner 0.5.2 started using non-dotted files instead. This method renames the old
+      # files in case you have just upgraded from an older version.
+      def migrate_dotted_config_files
+        return unless File.exist?("#{@config_dir}/.config.yml")
+
+        Dir["#{@config_dir}/**/.*"].each do |x|
+          dest = x.sub(%r{/\.([a-z.]+)$}, '/\1')
+          FileUtils.mv x, dest
+        end
+      end
+
+      def load_config
+        loaded = YAML.load_file(@config_file) if File.exist?(@config_file)
+
+        config_shared_names = @config[:shared_names] if @config
+        loaded_shared_names = loaded[:shared_names] if loaded
+
+        @config = {
+          **(@config || {}),
+          **(loaded || {}),
+          shared_names: { **(config_shared_names || {}), **(loaded_shared_names || {}) }
+        }
+      end
+    end
+  end
+end

data/lib/heighliner/databases/mysql.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Databases
+    class Mysql
+      def initialize(options)
+        @options = options
+      end
+
+      def options_hash
+        testpass = @options[:root_password] || 'testpassword'
+        parameters = @options[:parameters] || ''
+        port = @options[:port] || 3306
+
+        {
+          port: port,
+          data_dir: '/var/lib/mysql',
+          params: "-e MYSQL_ROOT_PASSWORD=#{testpass}",
+          commands: parameters,
+          waitscript_params: "
+            -e MYSQL_ADDR=<%= db_container_name %>
+            -e MYSQL_PORT=#{port}
+            -e MYSQL_ROOT_PASSWORD=#{testpass}",
+          waitscript: <<~SCRIPT
+            #!/bin/bash
+
+            echo "Waiting for mysql to start."
+            until mysql -h"$MYSQL_ADDR" -P"$MYSQL_PORT" -uroot -p"$MYSQL_ROOT_PASSWORD" -e "SELECT 1"
+            do
+              printf "."
+              sleep 1
+            done
+
+            echo -e "\nmysql started."
+          SCRIPT
+        }
+      end
+
+      def image_name
+        version = @options[:version] || '5.6'
+        "mysql:#{version}"
+      end
+    end
+  end
+end

data/lib/heighliner/databases/postgres.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Databases
+    class Postgres
+      def initialize(options)
+        @options = options
+      end
+
+      def options_hash
+        testpass = @options[:root_password] || 'testpassword'
+        parameters = @options[:parameters] || ''
+        port = @options[:port] || 3306
+        platform = @options[:platform] || 'linux/amd64'
+
+        {
+          port: port,
+          data_dir: '/var/lib/postgresql/data',
+          params: "-e POSTGRES_PASSWORD=#{testpass}",
+          commands: parameters,
+          platform: platform,
+          waitscript_params: "
+            -e PG_HOST=<%= db_container_name %>
+            -e PG_USER=postgres
+            -e PGPASSWORD=#{testpass}
+            -e PG_DATABASE=postgres",
+          waitscript: <<~SCRIPT
+            #!/bin/sh
+
+            RETRIES=5
+
+            until psql -h $PG_HOST -U $PG_USER -d $PG_DATABASE -c "select 1" > /dev/null 2>&1 || [ $RETRIES -eq 0 ]; do
+             echo "Waiting for postgres server, $((RETRIES--)) remaining attempts..."
+             sleep 1
+            done
+          SCRIPT
+        }
+      end
+
+      def image_name
+        version = @options[:version] || 'alpine'
+        "postgres:#{version}"
+      end
+    end
+  end
+end

data/lib/heighliner/docker_control.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Heighliner
+  # Docker control
+  class DockerControl
+    def initialize
+      @docker
+    end
+  end
+end

data/lib/heighliner/dotter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Heighliner
+  # Prints dots for every line printed
+  class Dotter
+    attr_accessor :dotted
+
+    def method_missing(name, *value)
+      $stderr.print '.'
+      @dotted = true
+      super unless @dotted
+    end
+
+    # rubocop:disable Lint/UselessMethodDefinition
+    # If we remove this method rubocop complains about it not existing instead.
+    def respond_to_missing?(name)
+      super
+    end
+    # rubocop:enable Lint/UselessMethodDefinition
+  end
+end

data/lib/heighliner/error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Heighliner
+  # Base class for Heighliner-related errors.
+  class Error < StandardError
+  end
+
+  # Raised when a command exits with non-zero exit status.
+  class CmdError < Error
+    def initialize(cmd, status)
+      super "ERROR\n#{cmd}\n- exited with code #{status}"
+    end
+  end
+end

data/lib/heighliner/plugin.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Heighliner
+  # To implement a Heighliner plugin you must inherit from this class.
+  # For example,
+  #
+  #   class MyPlugin < Plugin
+  #     def on_init
+  #       puts 'My plugin is loaded!'
+  #     end
+  #   end
+  #
+  # Then in your Kasierfile
+  #
+  #   plugin :my_plugin
+  #
+  # Plugins has access the Steerfile DSL. For example,
+  #
+  #   class Ruby < Plugin
+  #     def on_init
+  #       attach_mount 'Gemfile', '/usr/app/Gemfile'
+  #       attach_mount 'Gemfile.lock', '/usr/app/Gemfile.lock'
+  #     end
+  #   end
+  #
+  class Plugin
+    def initialize(steerfile)
+      @steerfile = steerfile
+    end
+
+    def self.loaded?(name)
+      Plugin.all_plugins.key?(name)
+    end
+
+    def self.inherited(plugin)
+      super
+
+      puts "INHERITED #{plugin}"
+
+      # underscore class name
+      name = plugin.to_s.split('::').last
+                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                   .gsub(/([a-z])(\d)/, '\1_\2')
+                   .tr('-', '_').downcase
+
+      Plugin.all_plugins[name.to_sym] = plugin
+    end
+
+    def self.all_plugins
+      @all_plugins ||= {}
+    end
+
+    def on_init
+      raise 'Please implement #on_init'
+    end
+
+    def method_missing(method_sym, *arguments, &block) # rubocop:disable all
+      @steerfile.send(method_sym, *arguments, &block)
+    end
+  end
+end
+
+# Little stub to initialize the namespace
+module Heighliner
+  module Plugins
+  end
+end

data/lib/heighliner/plugins/database.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module Heighliner
+  module Plugins
+    class Database < Plugin
+      def on_init
+        @steerfile.define_singleton_method :def_db do |*args|
+          args[0] = { args.first => {} } unless args.first.is_a? Hash
+
+          option = args.first
+
+          driver_name = option.keys.first.to_s
+
+          begin
+            require "heighliner/databases/#{driver_name}"
+          rescue LoadError
+            raise "Unknown database '#{driver_name}'"
+          end
+
+          driver_class = Heighliner::Databases.const_get(driver_name.camelize)
+          db_driver = driver_class.new(option.values.first)
+
+          db(db_driver.image_name, **db_driver.options_hash)
+        end
+      end
+    end
+  end
+end

data/lib/heighliner/plugins/git_submodule.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Plugins
+    class GitSubmodule < Plugin
+      def on_init
+        `git submodule status`.lines.each do |line|
+          # The git-submodule man page says uninitialized submodules are prefixed with a -
+          # but I found this unreliable. While testing I pressed Control-C in the middle of
+          # the update command so some submodule would be initialized and others wouldn't.
+          # After that, the status command had removed the - for every submodule.
+          # Therefore we just check if there's files in the directory instead.
+          dir = line.strip.split(' ')[1]
+          if !Dir.exist?(dir) || Dir.empty?(dir) # rubocop:disable Style/Next
+            puts "Found uninitialized git submodule '#{dir}'"
+            puts "please run 'git submodule update --init --recursive'"
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/heighliner/service.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Heighliner
+  # This class describes an app-specific service
+  class Service
+    attr_reader :name
+
+    def initialize(envname, name, service_info)
+      @envname = envname
+      @name = name
+      @service_info = service_info
+    end
+
+    def shared_name
+      "#{@envname}-#{name}"
+    end
+
+    def image
+      @service_info[:image]
+    end
+
+    def command
+      @service_info[:command].to_s
+    end
+
+    def binds
+      @service_info[:binds] || {}
+    end
+
+    def env
+      @service_info[:env] || {}
+    end
+
+    def start_docker_command
+      envstring = env.map do |k, v|
+        "-e #{k}=#{v}"
+      end.join(' ')
+
+      bindstring = binds.map do |k, v|
+        "-v #{k}:#{v}"
+      end.join(' ')
+
+      commandstring = command
+
+      cmd_array = [
+        'docker run -d',
+        "--name #{shared_name}",
+        "--network #{Config.config[:networkname]}",
+        envstring,
+        bindstring,
+        image,
+        commandstring
+      ]
+
+      cmd_array.filter! { |x| !x.empty? }
+
+      cmd_array.join(' ')
+    end
+  end
+end

data/lib/heighliner/steerfile.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Heighliner
+  # This class is responsible for parsing the Steerfile
+  class Steerfile
+    attr_accessor :docker_file_contents,
+                  :docker_build_args,
+                  :database,
+                  :platform,
+                  :port,
+                  :database_reset_command,
+                  :attach_mounts,
+                  :server_type,
+                  :services
+
+    def initialize(filename)
+      Optimist.die 'No Steerfile in current directory' unless File.exist? filename
+
+      @database = {
+        image: 'none',
+        platform: '',
+        port: 1234,
+        data_dir: '/tmp/data',
+        params: '',
+        commands: 'echo "no db"',
+        waitscript: 'echo "no dbwait"',
+        waitscript_params: ''
+      }
+      @attach_mounts = []
+      @params_array = []
+      @server_type = :unknown
+      @database_reset_command = 'echo "no db to reset"'
+      @port = 1234
+      @services = {}
+
+      instance_eval File.read(filename), filename
+    end
+
+    def validate!
+      raise 'No dockerfile specified.' if @docker_file_contents.nil?
+    end
+
+    def plugin(name)
+      require "heighliner/plugins/#{name}"
+      raise "Plugin #{name} is not loaded." unless Plugin.loaded?(name)
+
+      Plugin.all_plugins[name].new(self).on_init
+    end
+
+    def dockerfile(name, options = {})
+      @docker_file_contents = File.read(name)
+      @docker_build_args = options[:args] || {}
+    end
+
+    def attach_mount(from, to)
+      attach_mounts << [from, to]
+    end
+
+    def db(image,
+           data_dir:,
+           port:,
+           platform: '',
+           params: '',
+           commands: '',
+           waitscript: nil,
+           waitscript_params: '')
+      @database = {
+        image: image,
+        platform: platform,
+        port: port,
+        data_dir: data_dir,
+        params: params,
+        commands: commands,
+        waitscript: waitscript,
+        waitscript_params: waitscript_params
+      }
+    end
+
+    def force_platform(platform_name)
+      @platform = platform_name
+    end
+
+    def expose(port)
+      @port = port
+    end
+
+    def app_params(value)
+      @params_array << value
+    end
+
+    def params
+      @params_array.join(' ')
+    end
+
+    def db_reset_command(value)
+      @database_reset_command = value
+    end
+
+    def type(value)
+      raise 'Valid server types are: [:http]' if value != :http
+
+      @server_type = value
+    end
+
+    def service(name,
+                image: name,
+                command: nil,
+                binds: {},
+                env: {})
+      raise "duplicate service #{name.inspect}" if @services.key?(name)
+
+      @services[name] = {
+        image: image,
+        command: command,
+        binds: binds,
+        env: env
+      }
+    end
+  end
+end

data/lib/heighliner/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Heighliner
+  VERSION = '0.9.0'
+end

data/lib/heighliner.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'heighliner/error'
+require 'heighliner/version'
+require 'heighliner/steerfile'
+require 'heighliner/cli_options'
+require 'heighliner/cli'
+require 'heighliner/after_dotter'
+require 'heighliner/dotter'
+
+require 'heighliner/config'
+
+require 'heighliner/cmds/init'
+require 'heighliner/cmds/deinit'
+require 'heighliner/cmds/up'
+require 'heighliner/cmds/down'
+require 'heighliner/cmds/shutdown'
+require 'heighliner/cmds/db_save'
+require 'heighliner/cmds/db_load'
+require 'heighliner/cmds/db_reset'
+require 'heighliner/cmds/db_reset_hard'
+require 'heighliner/cmds/logs'
+require 'heighliner/cmds/attach'
+require 'heighliner/cmds/login'
+require 'heighliner/cmds/show'
+require 'heighliner/cmds/set'
+require 'heighliner/cmds/root'
+
+require 'heighliner/plugin'
+
+require 'heighliner/service'
+
+# Heighliner
+module Heighliner
+  SUB_COMMANDS = {
+    init: Heighliner::Cmds::Init,
+    deinit: Heighliner::Cmds::Deinit,
+    up: Heighliner::Cmds::Up,
+    down: Heighliner::Cmds::Down,
+    shutdown: Heighliner::Cmds::Shutdown,
+    db_save: Heighliner::Cmds::DbSave,
+    db_load: Heighliner::Cmds::DbLoad,
+    db_reset: Heighliner::Cmds::DbReset,
+    db_reset_hard: Heighliner::Cmds::DbResetHard,
+    logs: Heighliner::Cmds::Logs,
+    attach: Heighliner::Cmds::Attach,
+    login: Heighliner::Cmds::Login,
+    show: Heighliner::Cmds::Show,
+    set: Heighliner::Cmds::Set,
+    root: Heighliner::Cmds::Root
+  }.freeze
+end