rascal 0.1.0

data/lib/rascal/docker/container.rb

@@ -0,0 +1,121 @@
+module Rascal
+  module Docker
+    class Container
+      include IOHelper
+
+      def initialize(name, image)
+        @name = name
+        @prefixed_name = "#{NAME_PREFIX}#{name}"
+        @image = image
+      end
+
+      def download_missing
+        unless image_exists?
+          say "Downloading image for #{@name}"
+          Docker.interface.run(
+            'pull',
+            @image,
+            stdout: stdout,
+          )
+        end
+      end
+
+      def running?
+        if id
+          container_info = Docker.interface.run(
+            'container',
+            'inspect',
+            id,
+            output: :json
+          ).first
+          !!container_info.dig('State', 'Running')
+        else
+          false
+        end
+      end
+
+      def exists?
+        !!id
+      end
+
+      def start(network: nil, network_alias: nil)
+        say "Starting container for #{@name}"
+        create(network: network, network_alias: network_alias) unless exists?
+        Docker.interface.run(
+          'container',
+          'start',
+          id,
+        )
+      end
+
+      def create(network: nil, network_alias: nil)
+        @id = Docker.interface.run(
+          'container',
+          'create',
+          '--name', @prefixed_name,
+          *(['--network', network.id] if network),
+          *(['--network-alias', network_alias] if network_alias),
+          @image,
+          output: :id
+        )
+      end
+
+      def run_and_attach(*command, env: {}, network: nil, volumes: [], working_dir: nil, allow_failure: false)
+        Docker.interface.run_and_attach(@image, *command,
+          env: env,
+          stdout: stdout,
+          stderr: stderr,
+          stdin: stdin,
+          network: network&.id,
+          volumes: volumes,
+          working_dir: working_dir,
+          allow_failure: allow_failure
+        )
+      end
+
+      def clean
+        stop_container if running?
+        remove_container if exists?
+      end
+
+      private
+
+      def id
+        @id ||= Docker.interface.run(
+          'container',
+          'ps',
+          '--all',
+          '--quiet',
+          '--filter', "name=^/#{@prefixed_name}$",
+          output: :id
+        )
+      end
+
+      def image_exists?
+        Docker.interface.run(
+          'image',
+          'inspect',
+          @image,
+          output: :json,
+          allow_failure: true,
+        ).first
+      end
+
+      def stop_container
+        Docker.interface.run(
+          'container',
+          'stop',
+          id,
+        )
+      end
+
+      def remove_container
+        Docker.interface.run(
+          'container',
+          'rm',
+          id,
+        )
+      end
+    end
+  end
+end

data/lib/rascal/docker/interface.rb

@@ -0,0 +1,111 @@
+require 'json'
+require 'open3'
+
+module Rascal
+  module Docker
+    class Interface
+      class Error < Rascal::Error; end
+
+      def run(*command, output: :ignore, stdout: nil, redirect_io: {}, allow_failure: false)
+        save_stdout = ''
+        save_stderr = ''
+        exit_status = nil
+        popen3('docker', *stringify_command(command)) do |docker_stdin, docker_stdout, docker_stderr, wait_thr|
+          docker_stdin.close
+          output_threads = [
+            read_lines(docker_stdout, save_stdout, stdout),
+            read_lines(docker_stderr, save_stderr),
+          ]
+          exit_status = wait_thr.value
+          output_threads.each(&:join)
+        end
+        unless allow_failure || exit_status.success?
+          raise Error, "docker command '#{command.join(' ')}' failed with error:\n#{save_stderr}"
+        end
+        case output
+        when :json
+          begin
+            JSON.parse(save_stdout)
+          rescue JSON::ParserError
+            raise Error, "could not parse output of docker command '#{command.join(' ')}':\n#{save_stdout}"
+          end
+        when :id
+          save_stdout[/[0-9a-f]+/]
+        when :ignore
+          nil
+        else
+          raise ArgumentError, 'unknown option for :output'
+        end
+      end
+
+      def run_and_attach(image, *command, stdout: nil, stderr: nil, stdin: nil, env: {}, network: nil, volumes: [], working_dir: nil, allow_failure: false)
+        process_redirections = {}
+        args = []
+        if stdout
+          process_redirections[:out] = stdout
+          args += ['-a', 'STDOUT']
+        end
+        if stderr
+          process_redirections[:err] = stderr
+          args += ['-a', 'STDERR']
+        end
+        if stdin
+          process_redirections[:in] = stdin
+          args += ['-a', 'STDIN', '--interactive', '--tty']
+        end
+        if working_dir
+          args += ['-w', working_dir.to_s]
+        end
+        volumes.each do |volume|
+          args += ['-v', volume.to_param]
+        end
+        env.each do |key, value|
+          args += ['-e', "#{key}=#{value}"]
+        end
+        if network
+          args += ['--network', network.to_s]
+        end
+        exit_status = spawn(
+          env,
+          'docker',
+          'container',
+          'run',
+          '--rm',
+          *args,
+          image.to_s,
+          *stringify_command(command),
+          process_redirections,
+        )
+        unless allow_failure || exit_status.success?
+          raise Error, "docker container run failed"
+        end
+      end
+
+      private
+
+      def stringify_command(command)
+        command.collect(&:to_s)
+      end
+
+      def spawn(*command)
+        pid = Process.spawn(*command)
+        Process.wait(pid)
+        $?
+      end
+
+      def popen3(*command, &block)
+        Open3.popen3(*command, &block)
+      end
+
+      def read_lines(io, save_to, output_to = nil)
+        Thread.new do
+          io.each_line do |l|
+            output_to&.write(l)
+            save_to << l
+          end
+        rescue IOError
+        end
+      end
+    end
+  end
+end

data/lib/rascal/docker/network.rb

@@ -0,0 +1,42 @@
+module Rascal
+  module Docker
+    class Network
+      def initialize(name)
+        @name = name
+        @prefixed_name = "#{NAME_PREFIX}#{name}"
+      end
+
+      def create
+        Docker.interface.run(
+          'network',
+          'create',
+          @prefixed_name,
+        )
+      end
+
+      def exists?
+        !!id
+      end
+
+      def clean
+        if exists?
+          Docker.interface.run(
+            'network',
+            'rm',
+            id,
+          )
+        end
+      end
+
+      def id
+        @id ||= Docker.interface.run(
+          'network',
+          'ls',
+          '--quiet',
+          '--filter', "name=^#{@prefixed_name}$",
+          output: :id,
+        )
+      end
+    end
+  end
+end

data/lib/rascal/docker/volume.rb

@@ -0,0 +1,42 @@
+module Rascal
+  module Docker
+    module Volume
+      class Base
+      end
+
+      class Named < Base
+        def initialize(name, container_path)
+          @prefixed_name = "#{NAME_PREFIX}#{name}"
+          @container_path = container_path
+        end
+
+        def to_param
+          "#{@prefixed_name}:#{@container_path}"
+        end
+
+        def clean
+          Docker.interface.run(
+            'volume',
+            'rm',
+            @prefixed_name,
+          )
+        end
+      end
+
+      class Bind < Base
+        def initialize(local_path, container_path)
+          @local_path = local_path
+          @container_path = container_path
+        end
+
+        def to_param
+          "#{@local_path}:#{@container_path}"
+        end
+
+        def clean
+          # nothing to do
+        end
+      end
+    end
+  end
+end

data/lib/rascal/docker.rb

@@ -0,0 +1,18 @@
+module Rascal
+  module Docker
+    NAME_PREFIX = 'rascal-'
+
+    autoload :Container, 'rascal/docker/container'
+    autoload :Interface, 'rascal/docker/interface'
+    autoload :Network,   'rascal/docker/network'
+    autoload :Volume,    'rascal/docker/volume'
+
+    class << self
+      attr_writer :interface
+
+      def interface
+        @interface ||= Interface.new
+      end
+    end
+  end
+end

data/lib/rascal/environment.rb

@@ -0,0 +1,47 @@
+module Rascal
+  class Environment
+    attr_reader :name
+
+    def initialize(name, image:, env_variables: {}, services: [], volumes: [], before_shell: [], working_dir: nil)
+      @name = name
+      @network = Docker::Network.new(name)
+      @container = Docker::Container.new(name, image)
+      @env_variables = env_variables
+      @services = services
+      @volumes = volumes
+      @working_dir = working_dir
+      @before_shell = before_shell
+    end
+
+    def run_shell
+      download_missing
+      start_services
+      command = [*@before_shell, 'bash'].join(';')
+      @container.run_and_attach('bash', '-c', command,
+        env: @env_variables,
+        network: @network,
+        volumes: @volumes,
+        working_dir: @working_dir,
+        allow_failure: true
+      )
+    end
+
+    def clean
+      @services.each(&:clean)
+      @network.clean
+      @volumes.each(&:clean)
+    end
+
+    private
+
+    def download_missing
+      @container.download_missing
+      @services.each(&:download_missing)
+    end
+
+    def start_services
+      @network.create unless @network.exists?
+      @services.each { |s| s.start_if_stopped(network: @network) }
+    end
+  end
+end

data/lib/rascal/environments_definition/gitlab.rb

@@ -0,0 +1,117 @@
+require 'yaml'
+
+module Rascal
+  module EnvironmentsDefinition
+    class Gitlab
+      class << self
+        def detect(path)
+          if path.directory?
+            path = path.join('.gitlab-ci.yml')
+          end
+          if path.file?
+            new(path)
+          end
+        end
+      end
+
+      class Config
+        def initialize(config, prefix)
+          @config = config
+          @prefix = prefix
+        end
+
+        def get(key, *default)
+          if @config.has_key?(key)
+            @config[key]
+          elsif default.size > 0
+            default.first
+          else
+            raise Error.new("missing config for '#{@prefix}.#{key}'")
+          end
+        end
+      end
+
+
+      def initialize(config_path)
+        @info = parse_definition(config_path.read)
+        @repo_dir = config_path.parent
+        @rascal_config = @info.fetch('.rascal', {})
+      end
+
+      def environment(name)
+        environments.detect do |e|
+          e.name == name
+        end
+      end
+
+      def available_environment_names
+        environments.collect(&:name).sort
+      end
+
+      private
+
+      def parse_definition(yaml)
+        YAML.safe_load(yaml, [], [], true)
+      end
+
+      def environments
+        @environments ||= begin
+          @info.collect do |key, environment_config|
+            config = Config.new(deep_merge(environment_config, @rascal_config), key)
+            docker_repo_dir = config.get('repo_dir')
+            unless key.start_with?('.')
+              Environment.new(key,
+                image: config.get('image'),
+                env_variables: (config.get('variables', {})),
+                services: build_services(key, config.get('services', [])),
+                volumes: [build_repo_volume(docker_repo_dir), *build_volumes(key, config.get('volumes', {}))],
+                before_shell: config.get('before_shell', []),
+                working_dir: docker_repo_dir,
+              )
+            end
+          end.compact
+        end
+      end
+
+      def deep_merge(hash1, hash2)
+        if hash1.is_a?(Hash) && hash2.is_a?(Hash)
+          result = {}
+          hash1.each do |key1, value1|
+            if hash2.has_key?(key1)
+              result[key1] = deep_merge(value1, hash2[key1])
+            else
+              result[key1] = value1
+            end
+          end
+          hash2.each do |key2, value2|
+            result[key2] ||= value2
+          end
+          result
+        else
+          hash2
+        end
+      end
+
+      def build_services(name, services)
+        services.collect do |service_config|
+          service_alias = service_config['alias']
+          Service.new("#{name}_#{service_alias}",
+            alias_name: service_config['alias'],
+            image: service_config['name'],
+          )
+        end
+      end
+
+      def build_repo_volume(docker_repo_dir)
+        Docker::Volume::Bind.new(@repo_dir, docker_repo_dir)
+      end
+
+      def build_volumes(name, volume_config)
+        volume_config.collect do |volume_name, docker_path|
+          Docker::Volume::Named.new("#{name}-#{volume_name}", docker_path)
+        end
+      end
+    end
+  end
+end
+

data/lib/rascal/environments_definition.rb

@@ -0,0 +1,23 @@
+module Rascal
+  module EnvironmentsDefinition
+    autoload :Gitlab, 'rascal/environments_definition/gitlab'
+
+    class << self
+      def detect(working_dir)
+        definition_formats.each do |format|
+          definition = format.detect(working_dir)
+          return definition if definition
+        end
+        nil
+      end
+
+      private
+
+      def definition_formats
+        [
+          Gitlab
+        ]
+      end
+    end
+  end
+end

data/lib/rascal/io_helper.rb

@@ -0,0 +1,30 @@
+module Rascal
+  module IOHelper
+    class << self
+      attr_accessor :stdout, :stdin, :stderr
+
+      def setup
+        @stdout = $stdout
+        @stderr = $stderr
+        @stdin = $stdin
+      end
+    end
+    setup
+
+    def say(message)
+      stdout.puts(message)
+    end
+
+    def stdout
+      IOHelper.stdout
+    end
+
+    def stderr
+      IOHelper.stderr
+    end
+
+    def stdin
+      IOHelper.stdin
+    end
+  end
+end

data/lib/rascal/service.rb

@@ -0,0 +1,25 @@
+module Rascal
+  class Service
+    attr_reader :name
+
+    def initialize(name, image:, alias_name:)
+      @name = name
+      @container = Docker::Container.new(name, image)
+      @alias = alias_name
+    end
+
+    def download_missing
+      @container.download_missing
+    end
+
+    def start_if_stopped(network: nil)
+      unless @container.running?
+        @container.start(network: network, network_alias: @alias)
+      end
+    end
+
+    def clean
+      @container.clean
+    end
+  end
+end

data/lib/rascal/version.rb

@@ -0,0 +1,3 @@
+module Rascal
+  VERSION = "0.1.0"
+end

data/lib/rascal.rb

@@ -0,0 +1,11 @@
+require "rascal/version"
+
+module Rascal
+  class Error < StandardError; end
+
+  autoload :Docker,                 'rascal/docker'
+  autoload :Environment,            'rascal/environment'
+  autoload :EnvironmentsDefinition, 'rascal/environments_definition'
+  autoload :IOHelper,               'rascal/io_helper'
+  autoload :Service,                'rascal/service'
+end

data/rascal.gemspec

@@ -0,0 +1,37 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rascal/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rascal"
+  spec.version       = Rascal::VERSION
+  spec.authors       = ["Tobias Kraze"]
+  spec.email         = ["tobias.kraze@makandra.de"]
+
+  spec.summary       = "Spin up CI environments locally."
+  spec.homepage      = "https://github.com/makandra/rascal"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/makandra/rascal"
+    spec.metadata["changelog_uri"] = "https://github.com/makandra/rascal/blob/master/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", "~> 0.20.3"
+end