cide 0.7.0 → 0.8.0

data/lib/cide/config_file.rb

@@ -0,0 +1,101 @@
+require 'virtus'
+
+require 'erb'
+require 'yaml'
+
+require 'cide/config_file_loader'
+
+module CIDE
+  class ConfigFile
+    DOCKERFILE_TEMPLATE =
+      File.expand_path('../dockerfile_template.erb', __FILE__)
+
+    module NiceInspect
+      def inspect
+        out = []
+        attributes.each_pair do |key, value|
+          out << "#{key}=#{value.inspect}"
+        end
+        "<#{out.join(' ')}>"
+      end
+    end
+
+    class FileAdd
+      include Virtus.model(strict: true)
+      include NiceInspect
+      attribute :src, Array[String], default: []
+      attribute :dest, String
+    end
+
+    class Step
+      include Virtus.model(strict: true)
+      include NiceInspect
+      attribute :add, Array[FileAdd], default: []
+      attribute :env, Hash[String, String], default: {}
+      attribute :run, Array[String], default: []
+    end
+
+    class Link
+      include Virtus.model
+      include NiceInspect
+      attribute :name, String
+      attribute :image, String
+      attribute :env, Hash[String, String], default: {}
+      attribute :run, String
+      # Container ID added after the fact
+      attr_accessor :id
+    end
+
+    include Virtus.model(strict: true)
+    include NiceInspect
+    attribute :from, String, default: 'ubuntu'
+    attribute :as_root, Step, required: false
+    attribute :use_ssh, Boolean, default: false
+    attribute :before, Step, required: false
+    attribute :env, Hash[String, String], default: {}
+    attribute :export_dir, String, required: false
+    attribute :links, Array[Link], default: []
+    attribute :run, Array[String], default: ['script/ci']
+
+    attr_reader :warnings, :errors
+
+    def initialize(*)
+      super
+      @warnings = []
+      @errors = []
+    end
+
+    def to_dockerfile
+      ERB.new(File.read(DOCKERFILE_TEMPLATE), nil, '<>-').result(binding)
+    end
+
+    def self.load(dir, output = $stderr)
+      file_path = find_config(dir)
+      load_file(file_path, output)
+    end
+
+    def self.load_file(file_path, output = $stderr)
+      obj = new
+      loader = ConfigFileLoader.new(obj)
+      loader.load YAML.load_file(file_path)
+
+      obj.warnings.each do |warn|
+        output.puts "WARN: #{warn}"
+      end
+
+      obj.errors.each do |error|
+        output.puts "ERROR: #{error}"
+      end
+
+      return obj if obj.errors.empty?
+      nil
+    end
+
+    def self.find_config(dir)
+      paths = CONFIG_FILES.map { |name| File.expand_path(name, dir) }
+      paths
+        .find { |path| File.exist?(path) } ||
+        fail("Config not found among these paths: #{paths.inspect}")
+    end
+  end
+end

data/lib/cide/config_file_loader.rb

@@ -0,0 +1,305 @@
+module CIDE
+  class ConfigFileLoader
+    class Path
+      attr_reader :to_s
+      def initialize(str)
+        @to_s = str.to_s
+      end
+
+      def append(value)
+        self.class.new(
+          @to_s + (value.is_a?(Integer) ? "[#{value}]" : ".#{value}"),
+        )
+      end
+    end
+
+    def initialize(config)
+      @config = config
+    end
+
+    def load(data)
+      data.each_pair do |key, value|
+        key = key.to_s
+        path = Path.new(key)
+        case key
+        when 'from', 'image' then
+          wanted_key(path, 'from', key)
+          @config.from = expect_string(path, value)
+        when 'as_root' then
+          @config.as_root = maybe_step(path, value)
+        when 'use_ssh' then
+          @config.use_ssh = expect_boolean(path, value)
+        when 'before' then
+          @config.before = maybe_step(path, value)
+        when 'env', 'forward_env' then
+          wanted_key(path, 'env', key)
+          @config.env = expect_env_hash(path, value)
+        when 'export_dir' then
+          @config.export_dir = maybe_string(path, value)
+        when 'link', 'links' then
+          @config.links = expect_links(path, value)
+        when 'run', 'command' then
+          wanted_key(path, 'run', key)
+          @config.run = expect_run(path, value)
+        else
+          unknown_key(path)
+        end
+      end
+      @config
+    end
+
+    protected
+
+    def warn(message)
+      @config.warnings << message
+    end
+
+    def error(message)
+      @config.errors << message
+    end
+
+    def wanted_key(path, wanted_key, key)
+      return if key == wanted_key
+      warn "#{path} is deprecated. use '#{wanted_key}' instead."
+    end
+
+    def unknown_key(path)
+      warn "Unknown key #{path}"
+    end
+
+    def type_error(path, wanted_type, value)
+      error "expected #{path} to be a #{wanted_type} but got a #{value.class}"
+    end
+
+    def expect_string(path, value)
+      case value
+      when String, Symbol, Integer
+        value.to_s
+      else
+        type_error(path, 'string', value)
+        ''
+      end
+    end
+
+    def maybe_string(path, value)
+      case value
+      when String, Symbol, Integer
+        value.to_s
+      when nil
+        nil
+      else
+        type_error(path, 'string or nil', value)
+        nil
+      end
+    end
+
+    def maybe_step(path, value)
+      case value
+      when String, Symbol, Integer, Array then
+        load_step(path, run: value)
+      when Hash then
+        load_step(path, value)
+      when nil then
+        nil
+      else
+        type_error(path, 'string, array, hash or nil', value)
+        nil
+      end
+    end
+
+    def load_step(path, data)
+      step = ConfigFile::Step.new
+      data.each_pair do |key, value|
+        key = key.to_s
+        path_ = path.append(key)
+        case key
+        when 'run' then
+          step.run = expect_array(path_, value)
+        when 'env', 'forward_env' then
+          wanted_key(path_, 'env', key)
+          step.env = expect_env_hash(path_, value)
+        when 'add' then
+          step.add = expect_adds(path_, value)
+        else
+          unknown_key(path_)
+        end
+      end
+      step
+    end
+
+    def expect_links(path, value)
+      array = []
+      case value
+      when String, Symbol, Integer, Hash then
+        array << expect_link(path, value)
+      when Array then
+        value.compact.each_with_index do |value_, i|
+          array << expect_link(path.append(i), value_)
+        end
+      when nil then
+        # nothing to do
+      else
+        type_error(path, 'string, array of links, hash or nil', value)
+      end
+      array.compact
+    end
+
+    def expect_link(path, value)
+      case value
+      when String, Symbol, Integer then
+        load_link(path, image: value)
+      when Hash
+        load_link(path, value)
+      else
+        type_error(path, 'string or hash expected', value)
+      end
+    end
+
+    def load_link(path, data)
+      link = ConfigFile::Link.new
+      data.each_pair do |key, value|
+        key = key.to_s
+        path_ = path.append(key)
+        case key
+        when 'name' then
+          link.name = expect_string(path_, value)
+        when 'image', 'from' then
+          wanted_key(path_, 'image', key)
+          link.image = expect_string(path_, value)
+        when 'env' then
+          link.env = expect_env_hash(path_, value)
+        when 'run' then
+          link.run = maybe_string(path_, value)
+        else
+          unknown_key(path_)
+        end
+      end
+      link.name ||= link.image.split(':').first.split('/').last if link.image
+      link.image ||= link.name
+      if link.name.nil?
+        type_error(
+          path,
+          'expected hash to either declare the name or image',
+          data,
+        )
+        return nil
+      end
+      link
+    end
+
+    def expect_boolean(path, value)
+      case value
+      when true then
+        true
+      when false then
+        false
+      else
+        type_error(path, 'boolean', value)
+        false
+      end
+    end
+
+    def expect_array(path, value)
+      array = []
+      case value
+      when Array then
+        value.compact.each_with_index do |value_, i|
+          array << expect_string(path.append(i), value_)
+        end
+      when String, Symbol, Integer then
+        array << value.to_s
+      when nil then
+        # nothing to do
+      else
+        type_error(path, 'array of string, string or nil', value)
+      end
+      array.compact
+    end
+
+    def expect_adds(path, value)
+      array = []
+      case value
+      when Array then
+        value.compact.each_with_index do |value_, i|
+          str = expect_string(path.append(i), value_)
+          array << load_add_str(str)
+        end
+      when Hash then
+        value.each_pair do |key_, value_|
+          src = expect_array(path.append(key_), value_)
+          array << ConfigFile::FileAdd.new(src: src, dest: key_.to_s)
+        end
+      when String, Symbol, Integer then
+        array << load_add_str(value.to_s)
+      when nil then
+        # nothing to do
+      else
+        type_error(path, 'arrays of string, hash, string or nil', value)
+      end
+      array.compact
+    end
+
+    def load_add_str(str)
+      ConfigFile::FileAdd.new(
+        src: [str],
+        dest: str,
+      )
+    end
+
+    def expect_env(path, key)
+      str = expect_string(path, key)
+      return nil if str == ''
+      value = ENV[str]
+      error "Missing environment variable #{key} in #{path}" if value.nil?
+      value
+    end
+
+    def expect_env_hash(path, value)
+      hash = {}
+      case value
+      when String, Symbol, Integer
+        key1 = value
+        value1 = expect_env(path, key1)
+        hash[key1] = value1 if value1
+      when Array then
+        value.compact.each_with_index do |key, i|
+          value_ = expect_env(path.append(i), key)
+          hash[key.to_s] = value_ if value_
+        end
+      when Hash then
+        value.each_pair do |key, value_|
+          key = key.to_s
+          path_ = path.append(key)
+          if value_.nil?
+            value_ = expect_env(path_, key)
+          else
+            value_ = expect_string(path_, value_)
+          end
+          hash[key.to_s] = value_ if value_
+        end
+      else
+        type_error(path, 'hash or array of keys or just a string', value)
+      end
+      hash
+    end
+
+    def expect_run(path, value)
+      array = []
+      has_error = false
+      case value
+      when Array
+        value.compact.each_with_index do |key, i|
+          array << expect_string(path.append(i), key)
+        end
+      when String, Symbol, Integer
+        array.push('sh', '-e', '-c', value.to_s)
+      when nil then
+      else
+        has_error = true
+        type_error(path, 'string or array of string', value)
+      end
+      error("#{path} shouldn't be empty") if array.empty? && !has_error
+      array
+    end
+  end
+end

data/lib/cide/docker.rb

@@ -1,4 +1,4 @@
-require 'shellwords'
+require 'thor'
 
 module CIDE
   # Simple docker client helper
@@ -19,32 +19,30 @@ module CIDE
 
     class VersionError < StandardError; end
 
-    def docker(*args, **opts)
-      setup_docker
+    def docker(*args, verbose: false, capture: false)
+      cmd = (['docker'] + args).map(&:to_s)
+      p cmd if verbose
 
-      ret = run Shellwords.join(['docker'] + args), opts
+      if capture
+        r, w = IO.pipe
+        pid = Process.spawn(*cmd, out: w)
+        w.close
+        return r.read
+      else
+        pid = Process.spawn(*cmd)
+
+        return 0
+      end
+    ensure
+      Process.wait(pid)
       exitstatus = $?.exitstatus
       fail Error, exitstatus if exitstatus > 0
-      ret
     end
 
     protected
 
     def setup_docker
       @setup_docker ||= (
-        if `uname`.strip == 'Darwin' && !ENV['DOCKER_HOST']
-          unless system('which boot2docker >/dev/null 2>&1')
-            puts 'make sure boot2docker is installed and running'
-            puts
-            puts '> brew install boot2docker'
-            exit 1
-          end
-
-          `boot2docker shellinit 2>/dev/null`
-            .lines
-            .grep(/export (\w+)=(.*)/) { ENV[$1] = $2.strip }
-        end
-
         # Check docker version
         docker_version = nil
         case `docker version 2>/dev/null`