bigrig 0.0.0 → 0.0.7

data/lib/bigrig/dependency_graph.rb

@@ -0,0 +1,21 @@
+module Bigrig
+  class DependencyGraph
+    def initialize(containers)
+      @containers = containers
+      @map = containers.each_with_object({}) { |e, o| o[e.name] = e }
+    end
+
+    def resolve
+      resolved = []
+      @containers.each { |c| resolve_deps(c, resolved) unless resolved.include? c.name }
+      resolved.map { |n| @map[n] }
+    end
+
+    def resolve_deps(container, resolved)
+      container.dependencies.each do |dep_name|
+        resolve_deps @map[dep_name], resolved unless resolved.include? dep_name
+      end
+      resolved << container.name
+    end
+  end
+end

data/lib/bigrig/descriptor.rb

@@ -0,0 +1,43 @@
+require 'json'
+
+module Bigrig
+  class Descriptor
+    attr_reader :as_json
+
+    def initialize(container_map, profiles)
+      profiles.each do |_name, containers|
+        containers.each do |container, overrides|
+          apply_overrides container_map, container, overrides
+        end
+      end
+      @as_json = container_map
+    end
+
+    def self.read(file, active_profiles = [])
+      json = JSON.parse File.read file
+      Descriptor.new json['containers'], profiles_for(json, active_profiles)
+    end
+
+    private
+
+    def apply_overrides(container_map, name, overrides)
+      overrides.each do |key, value|
+        container = container_map[name] ||= {}
+        if value.is_a? Hash
+          (container[key] ||= {}).merge! value
+        else
+          container[key] = value
+        end
+      end
+    end
+
+    def self.profiles_for(json, active_profiles)
+      if json['profiles']
+        profiles = active_profiles.map do |profile|
+          [profile, json['profiles'][profile]]
+        end
+      end
+      Hash[*(profiles || []).flatten].select { |_n, v| !v.nil? }
+    end
+  end
+end

data/lib/bigrig/docker_adapter.rb

@@ -0,0 +1,129 @@
+require 'docker'
+
+Excon.defaults[:ssl_verify_peer] = false
+Excon.defaults[:read_timeout] = 3600
+
+module Bigrig
+  class ContainerNotFoundError < StandardError; end
+  class ImageNotFoundError < StandardError; end
+  class RepoNotFoundError < StandardError; end
+  class ContainerRunningError < StandardError; end
+
+  class DockerAdapter
+    class << self
+      def build(path, &block)
+        Docker::Image.build_from_dir(path, {}, connection, &block).id
+      end
+
+      def container_exists?(name)
+        !Docker::Container.get(name).nil?
+      rescue Docker::Error::NotFoundError
+        false
+      end
+
+      def hosts(arr)
+        (arr || []).map do |line|
+          parts = line.split ':'
+          "#{Resolv.getaddress parts.first}:#{parts[1]}"
+        end
+      end
+
+      def image_id_by_tag(tag)
+        Docker::Image.get(tag).id
+      rescue Docker::Error::NotFoundError
+        raise ImageNotFoundError
+      end
+
+      def kill(name)
+        Docker::Container.get(name).kill
+      rescue Docker::Error::NotFoundError
+        raise ContainerNotFoundError
+      end
+
+      def logs(name, &block)
+        container = Docker::Container.get name, {}, connection
+        container.streaming_logs follow: true, stdout: true, stderr: true, &block
+      end
+
+      def pull(tag, &block)
+        Docker::Image.get(Docker::Image.create('fromImage' => tag, &block).id).id
+      rescue Docker::Error::ArgumentError => e
+        e.to_s =~ /"id"=>nil/ && raise(RepoNotFoundError)
+        raise
+      end
+
+      def push(tag, credentials = nil, &block)
+        puts "Pushing #{tag}"
+        Docker::Image.get(tag).push credentials, {}, &block
+      end
+
+      def tag(id, tag)
+        i = tag.rindex ':'
+        repo, version = [tag[0...i], tag[i + 1..-1]]
+        Docker::Image.get(id).tag 'repo' => repo, 'tag' => version, 'force' => true
+      end
+
+      def remove_container(name)
+        fail ContainerRunningError, 'You cannot remove a running container' if running?(name)
+        Docker::Container.get(name).delete
+        true
+      rescue Docker::Error::NotFoundError
+        raise ContainerNotFoundError
+      end
+
+      def remove_image(tag)
+        Docker::Image.get(tag).remove 'force' => true
+        true
+      rescue Docker::Error::NotFoundError
+        raise ImageNotFoundError
+      end
+
+      def run(args)
+        container = create_container args
+        container.start(
+          'Links' => args[:links],
+          'ExtraHosts' => hosts(args[:hosts]),
+          'PortBindings' => port_bindings(args[:ports]),
+          'VolumesFrom' => args[:volumes_from]
+        )
+        container.id
+      end
+
+      def running?(name)
+        Docker::Container.get(name).info['State']['Running']
+      rescue Docker::Error::NotFoundError
+        false
+      end
+
+      private
+
+      def connection
+        options = Docker.env_options.merge read_timeout: 31_536_000
+        Docker::Connection.new Docker.url, options
+      end
+
+      def create_container(args)
+        Docker::Container.create(
+          'Env' => (args[:env] || {}).map { |n, v| "#{n}=#{v}" },
+          'Image' => args[:image_id],
+          'name' => args[:name],
+          'ExposedPorts' => exposed_ports(args[:ports])
+        )
+      end
+
+      def exposed_ports(ports)
+        container_ports = (ports || []).map do |port|
+          port.include?(':') && port.split(':')[1] || port
+        end
+        Hash[*container_ports.map { |p| ["#{p}/tcp", {}] }.flatten]
+      end
+
+      def port_bindings(ports)
+        (ports || []).each_with_object({}) do |port, hash|
+          host_port, container_port = port.include?(':') && port.split(':') || [nil, port]
+          hash["#{container_port}/tcp"] = [host_port && { 'HostPort' => host_port } || {}]
+        end
+      end
+    end
+  end
+end

data/lib/bigrig/models/application.rb

@@ -0,0 +1,22 @@
+require 'json'
+
+module Bigrig
+  class Application < BaseModel
+    attr_accessor :name, :containers
+
+    def initialize(args = {})
+      @containers = []
+      super
+    end
+
+    class << self
+      def from_json(json)
+        containers = json.map do |name, value|
+          Container.from_json name, value
+        end
+
+        Application.new containers: containers
+      end
+    end
+  end
+end

data/lib/bigrig/models/base_model.rb

@@ -0,0 +1,7 @@
+module Bigrig
+  class BaseModel
+    def initialize(args = {})
+      args.each { |k, v| send "#{k}=", v }
+    end
+  end
+end

data/lib/bigrig/models/container.rb

@@ -0,0 +1,40 @@
+module Bigrig
+  class Container < BaseModel
+    attr_accessor :env, :name, :path, :ports, :tag, :volumes_from, :links, :hosts, :repo
+
+    class << self
+      def from_json(name, json)
+        opts = [:env, :path, :ports, :tag, :repo].each_with_object(name: name) do |e, o|
+          o[e] = json.send :[], e.to_s
+        end
+        opts[:volumes_from] = as_array json['volumes_from']
+        opts[:links] = as_array json['links']
+        opts[:hosts] = as_array json['hosts']
+
+        Container.new opts
+      end
+
+      private
+
+      def as_array(value)
+        value && [value].flatten.compact
+      end
+    end
+
+    def initialize(*opts)
+      super
+      @env ||= {}
+      @ports ||= []
+      @volumes_from ||= []
+      @links ||= []
+      @hosts ||= []
+
+      # Yes rubocop, I know this is a very stupid thing to do
+      @env = Hash[*@env.map { |k, v| [k, eval("\"#{v}\"")] }.flatten] # rubocop:disable Lint/Eval
+    end
+
+    def dependencies
+      volumes_from + links.map { |l| l.split(':').first }
+    end
+  end
+end

data/lib/bigrig/models.rb

@@ -0,0 +1,3 @@
+require 'bigrig/models/base_model'
+require 'bigrig/models/application'
+require 'bigrig/models/container'

data/lib/bigrig/output_parser.rb

@@ -0,0 +1,52 @@
+module Bigrig
+  class OutputParser
+    def self.parser_proc
+      proc { |chunk| print OutputParser.new.parse chunk }
+    end
+
+    def initialize
+      @last_line = ''
+    end
+
+    def parse(input)
+      json = JSON.parse input
+      if json['errorDetail']
+        "#{json['errorDetail']['message'].red}\n"
+      elsif json['stream'] || json['id'].nil?
+        json['stream'] || "#{json['status']}\n"
+      else
+        parse_progress json
+      end
+    end
+
+    private
+
+    def last_line_length
+      @last_line.strip.length
+    end
+
+    def padding(line)
+      if last_line_length > line.length
+        padding = ' ' * (last_line_length - line.length)
+      end
+      @last_line = line
+      padding || ''
+    end
+
+    def parse_progress(json)
+      line = should_print_cr?(json['id']) ? "\n" : ''
+      line << "#{json['id']}: #{json['status']} #{json['progress']}"
+      line << padding(line) << "\r"
+    end
+
+    def should_print_cr?(id)
+      @current_id ||= id
+      if id != @current_id
+        @current_id = id
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/bigrig/runner.rb

@@ -0,0 +1,94 @@
+module Bigrig
+  class Runner
+    def initialize(application)
+      @application = application
+    end
+
+    def run
+      steps.each { |s| perform_step s }
+    end
+
+    private
+
+    def build(path)
+      puts "Building #{path}"
+      DockerAdapter.build path, &OutputParser.parser_proc
+    end
+
+    def containers
+      @application.containers
+    end
+
+    def depends_on_containers(container, containers)
+      (containers.map(&:name) & container.dependencies).any?
+    end
+
+    def destroy_existing(containers)
+      containers.each do |container|
+        begin
+          DockerAdapter.remove_container container[:name]
+        rescue Bigrig::ContainerNotFoundError # rubocop:disable Lint/HandleExceptions
+        end
+      end
+    end
+
+    def docker_opts(step)
+      step.map do |container|
+        docker_opts_for(container).merge image_id: image_id(container)
+      end
+    end
+
+    def docker_opts_for(container)
+      { env: container.env,
+        name: container.name,
+        ports: container.ports,
+        volumes_from: container.volumes_from,
+        links: container.links,
+        hosts: container.hosts }
+    end
+
+    def image_id(container)
+      if container.path
+        build container.path
+      else
+        tag = "#{container.repo}:#{container.tag}"
+        begin
+          DockerAdapter.image_id_by_tag tag, &OutputParser.parser_proc
+        rescue ImageNotFoundError
+          DockerAdapter.pull tag, &OutputParser.parser_proc
+        end
+      end
+    end
+
+    def ordered_containers
+      DependencyGraph.new(containers).resolve
+    end
+
+    def perform_step(step)
+      containers = docker_opts step
+      destroy_existing containers
+
+      threads = containers.map do |container|
+        Thread.new do
+          puts "Starting #{container[:name]}"
+          puts DockerAdapter.run(container)
+        end
+      end
+
+      threads.each(&:join)
+    end
+
+    def steps
+      current_step = []
+      steps = [current_step]
+      ordered_containers.each do |container|
+        if depends_on_containers(container, current_step)
+          current_step = []
+          steps << current_step
+        end
+        current_step << container
+      end
+      steps
+    end
+  end
+end

data/lib/bigrig/version.rb

@@ -0,0 +1,3 @@
+module Bigrig
+  VERSION = '0.0.7'
+end

data/lib/bigrig.rb

@@ -1,2 +1,10 @@
+require 'bigrig/actions'
+require 'bigrig/descriptor'
+require 'bigrig/dependency_graph'
+require 'bigrig/docker_adapter'
+require 'bigrig/models'
+require 'bigrig/output_parser'
+require 'bigrig/runner'
 require 'bigrig/version'
+
 module Bigrig; end

data/spec/bigrig/actions/destroy_action_spec.rb

@@ -0,0 +1,55 @@
+module Bigrig
+  describe DestroyAction do
+    describe '#perform' do
+      subject { described_class.new(active_containers.as_json).perform }
+      let(:active_containers) { Descriptor.read test_file(file), profiles }
+      let(:profiles) { [] }
+
+      context 'given json with a single container' do
+        let(:container) do
+          image = Docker::Image.create 'fromImage' => 'hawknewton/show-env'
+          Docker::Container.create 'Image' => image.id, 'name' => 'single-test'
+        end
+
+        let(:file) { 'single.json' }
+
+        let(:exists?) do
+          begin
+            Docker::Container.get(container.id)
+            true
+          rescue Docker::Error::NotFoundError
+            false
+          end
+        end
+
+        after do
+          begin
+            container.kill.delete
+          rescue Docker::Error::NotFoundError # rubocop:disable Lint/HandleExceptions
+          end
+        end
+
+        context 'and the container is running' do
+          before { container.start }
+
+          it 'kills and removes the container', :vcr do
+            subject
+            expect(exists?).to be false
+          end
+        end
+
+        context 'and the container has exited' do
+          before do
+            container.start
+            container.kill
+          end
+
+          it 'should remove the container', :vcr do
+            subject
+            expect(exists?).to be false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/bigrig/actions/dev_action_spec.rb

@@ -0,0 +1,17 @@
+module Bigrig
+  describe DevAction do
+    describe '#perform' do
+      subject { described_class.new descriptor.as_json }
+      let(:descriptor) { Descriptor.new test_file(file), profiles }
+
+      context 'when no profile is provided' do
+        let(:profiles) { [] }
+        let(:file) { 'dev.json' }
+
+        it 'should initialize dev action' do
+          expect { subject }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/bigrig/actions/log_action_spec.rb

@@ -0,0 +1,33 @@
+module Bigrig
+  describe LogAction do
+    describe '#perform' do
+      subject { runner.perform }
+      let(:active_containers) { Descriptor.read test_file(file), active_profiles }
+      let(:active_profiles) { [] }
+      let(:runner) { described_class.new(active_containers.as_json) }
+      let(:file) { 'log.json' }
+      let(:image) { Docker::Image.create 'fromImage' => 'hawknewton/log-test:0.0.1' }
+      let(:container) { Docker::Container.get 'log-test' }
+
+      before do
+        Docker::Container.create('Image' => image.id, 'name' => 'log-test').start
+      end
+
+      after do
+        container.kill.delete
+      end
+
+      it 'follows the log', :vcr do
+        allow(Docker::Container).to receive(:get).
+          with('log-test', {}, anything).and_return container
+        allow(container).to receive(:streaming_logs).
+          and_yield(:stdout, 'stdout message').
+          and_yield(:stderr, 'stderr message')
+        expect($stdout).to receive(:puts).with "\e[0;32;49mlog-test\e[0m: stdout message"
+        expect(runner).to receive(:print).
+          with "\e[0;32;49mlog-test\e[0m: \e[0;91;49mstderr message\e[0m"
+        subject
+      end
+    end
+  end
+end