blubber 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fc43a8d69b7d4d93a797191b720892f7b8ad4a853f450d6177cb32064a03ebc
-  data.tar.gz: b56d0301887bc29ab7dbf07328db241f7230afc7ee101cf475350250187c1850
+  metadata.gz: 4f4ffd9a2666bed028135a571e27d7993fd1646656d8a18682a632ea6fcc52cc
+  data.tar.gz: 3e987000d6a8344b3893e5cdf0f0d9120d9f134400e1b8f99155cbf432f92916
 SHA512:
-  metadata.gz: cb8a7675b4959203c9675d3dd1e35cc645924f8e66638e5c94d5b4a9f1d19eea96aba8c662a32c8e51e0c1b5b9d6adae157c5b471cfc274849644d2602cec767
-  data.tar.gz: b6696c0121a6cc8fef1e541c1e4b0216171e7cfa476370b06a9fee5e74400d4fa2eab841aa129e03230413b43e5253d1fe004db7eed36eb85510bc414dd8b4fe
+  metadata.gz: 59125f6668acfb8cab8e06c9854f77f229c863f436566bbdf6d6578e0ea604f153b9f6f6bae56066e25789f9c98c6f257b6eb7e72c287918b4c38066ac11b2f5
+  data.tar.gz: bd1e86b80d26b8ac5b598e6321a46cee7d6dbedbf3948f71f6370e626c0d8ffd74208a68093853421c47296671760a8f657383652a6834e01583419a01b62e0a

data/lib/blubber/build_info.rb

@@ -0,0 +1,46 @@
+require 'singleton'
+require 'forwardable'
+
+module Blubber
+  class BuildInfo
+    extend Forwardable
+    def_delegators :shared, :branch_name, :dirty?, :commit, :last_successful_commit
+
+    def initialize(layer:)
+      @layer = layer
+    end
+
+    def dirty?
+      @dirty ||= system("git status --porcelain 2>&1 | grep -q '#{layer.directory}'")
+    end
+
+    private
+
+    attr_reader :layer
+
+    def shared
+      @shared ||= Class.new do
+        include Singleton
+
+        def branch_name
+          @branch_name ||= ENV.fetch('BRANCH_NAME') do
+            `
+              git rev-parse HEAD |
+              git branch -a --contains |
+              sed -n 2p |
+              cut -d'/' -f 3-
+            `.strip
+          end
+        end
+
+        def commit
+          @commit ||= ENV.fetch('GIT_COMMIT') { `git rev-parse HEAD`.strip }
+        end
+
+        def last_successful_commit
+          @last_successful_commit ||= ENV['GIT_PREVIOUS_SUCCESSFUL_COMMIT']
+        end
+      end.instance
+    end
+  end
+end

data/lib/blubber/builder.rb

@@ -1,25 +1,59 @@
 require 'highline'
 require 'logger'
-require 'open3'
 
 require 'blubber/runner'
-require 'blubber/tagger'
+require 'blubber/logger'
 
 module Blubber
   class Builder
     def initialize(layer:, logger: nil)
       @layer = layer
-      @logger = logger
+      @logger = logger || Logger.for(name: layer.name)
     end
 
-    def run
-      logger.info ui.color("BUILDING", :yellow)
-      retval = build(layer)
-      level, color = retval.zero? ? [:info, :green] : [:error, :red]
+    def build
+      logger.info ui.color('BUILDING', :yellow)
+      retval = do_build
+      level, color = retval.zero? ? %i[info green] : %i[error red]
 
-      logger.public_send(level, ui.color("#{layer}: #{retval.zero? ? 'SUCCESS' : 'ERROR'}", color))
+      logger.public_send(level,
+                         ui.color((retval.zero? ? 'SUCCESS' : 'ERROR'), color))
 
-      { success: retval.zero?, id: build_ids[layer] }
+      retval.zero?
+    end
+
+    def tag
+      logger.info ui.color('TAGGING', :yellow)
+      status = {}
+      layer.tags.each do |tag|
+        status[tag] = runner.run("docker tag #{layer.build_id} #{layer.project_tag(tag)}")
+      end
+
+      retval = status.values.reduce(:+)
+
+      level, color = retval.zero? ? %i[info green] : %i[error red]
+
+      logger.public_send(level,
+                         ui.color((retval.zero? ? 'SUCCESS' : 'ERROR'), color))
+
+      retval.zero?
+    end
+
+    def push
+      logger.info ui.color('PUSHING', :yellow)
+      status = {}
+      layer.tags.each do |tag|
+        status[tag] = runner.run("docker push #{layer.project_tag(tag)}")
+      end
+
+      retval = status.values.reduce(:+)
+
+      level, color = retval.zero? ? %i[info green] : %i[error red]
+
+      logger.public_send(level,
+                         ui.color((retval.zero? ? 'SUCCESS' : 'ERROR'), color))
+
+      retval.zero?
     end
 
     private
@@ -34,23 +68,22 @@ module Blubber
       @runner ||= Runner.new(logger: logger)
     end
 
-    def tagger
-      @tagger ||= Tagger.new(layer: layer, image_id: nil)
-    end
-
-    def build_ids
-      @build_ids ||= {}
-    end
-
-    def build(layer)
+    def do_build
       status = nil
-      Dir.chdir(layer) do
-        status = runner.run("docker build --build-arg BRANCH_NAME=#{tagger.branch_name} .") do |stdout, _, _|
+      Dir.chdir(layer.directory) do
+        cmd = []
+        cmd += %w[docker build]
+        cmd += %W[--build-arg VERSION=#{layer.build_tag}]
+        cmd += %W[--cache-from #{layer.cache}] if layer.cache
+        cmd << '.'
+
+        status = runner.run(cmd) do |stdout, _, _|
           if stdout && (m = stdout.match(/Successfully built ([a-z0-9]{12})/))
-            build_ids[layer] = m[1]
+            layer.build_id = m[1]
           end
         end
       end
+
       status
     end
   end

data/lib/blubber/cli.rb

@@ -1,12 +1,24 @@
 require 'thor'
 
 require 'blubber/flow'
+require 'blubber/context'
 
 module Blubber
   class Cli < Thor
-    desc 'build', 'Builds all found Docker images'
-    def build
-      exit(Flow.build) # Fails to build if any layer fails
+    class_option :registry, aliases: %w(-r), desc: 'Docker Registry', default: ENV['DOCKER_REGISTRY']
+
+    desc 'build LAYER [LAYER...]', 'Builds all found Docker images'
+    method_option :tag,  aliases: %w(-t), desc: 'Tag all built images', default: true
+    method_option :push, aliases: %w(-p), desc: 'Push images as they are built', default: true
+    def build(layers = nil)
+      flow = Flow.new(
+        layers: layers,
+        build: true,
+        tag: options.tag,
+        push: options.push,
+        context: Context.new(docker_registry: options.registry)
+      )
+      exit flow.run
     end
   end
 end

data/lib/blubber/context.rb

@@ -0,0 +1,12 @@
+require 'singleton'
+require 'forwardable'
+
+module Blubber
+  class Context
+    attr_reader :docker_registry
+
+    def initialize(docker_registry: nil)
+      @docker_registry = docker_registry || ENV.fetch('DOCKER_REGISTRY')
+    end
+  end
+end

data/lib/blubber/flow.rb

@@ -1,83 +1,48 @@
 require 'highline'
-require 'open3'
 
-require 'blubber/builder'
-require 'blubber/tagger'
+require 'blubber/layer'
 
 module Blubber
   class Flow
-    def self.build(layers = nil)
-      layers ||= changed_layers
+    def initialize(layers:, context:, build: true, tag: true, push: true)
+      @context = context
+      @layers = detect_layers(layers: layers)
+      @flow = { build: build, tag: tag, push: push }
+    end
 
-      puts "Building layers: #{layers.join(', ')}"
+    def run
+      results = layers.map do |layer|
+        status = true
+        status &= layer.build if flow[:build]
+        status &= layer.tag if flow[:tag] && layer.build_id
+        status &= layer.push if flow[:push] && layer.build_id
 
-      images = layers.map { |layer| Flow.new(layer: layer).run }
+        [layer, status]
+      end.to_h
 
       table = [HighLine.color('Layer', :bold), HighLine.color('Tag', :bold)]
-      table += images.map do |image|
-        if image[:success]
-          image[:tags].map { |tag| [image[:project], tag] }
+      table += results.map do |layer, result|
+        if result
+          layer.tags.map { |tag| [layer.project, tag] }
         else
-          [image[:project], HighLine.color('FAILED', :red)]
+          [layer.project, HighLine.color('FAILED', :red)]
         end
       end
-
       puts HighLine.new.list(table.flatten, :columns_across, 2)
 
-      images.all? { |image| image[:success] }
-    end
-
-    def self.changed_layers
-      @changed_layers ||= begin
-        if ENV.fetch('GIT_PREVIOUS_SUCCESSFUL_COMMIT', '').empty? || ENV['BUILD_ALL'] == 'true'
-          Dir['**/*/Dockerfile'].map { |d| File.dirname(d) }.sort
-        else
-          commit = ENV['GIT_COMMIT'] || `git rev-parse HEAD`.strip
-
-          puts "Detecting changed layers between #{ENV['GIT_PREVIOUS_SUCCESSFUL_COMMIT']}..#{commit}"
-
-          changes = `git diff --name-only #{ENV['GIT_PREVIOUS_SUCCESSFUL_COMMIT']}..#{commit}`.split("\n")
-          paths = []
-          changes.each do |path|
-            dirs = File.dirname(path).split(File::SEPARATOR)
-            dirs.map.with_index { |_, i| dirs[0..i].join(File::SEPARATOR) }.reverse.each do |dir|
-              paths << dir if File.exist?(File.join(dir, 'Dockerfile'))
-            end
-          end
-          paths
-        end
-      end
-    end
-
-    def initialize(layer:)
-      @layer = layer
-    end
-
-    def run
-      image = Builder.new(layer: layer, logger: logger).run
-
-      tagger = Tagger.new(layer: layer, image_id: image[:id], logger: logger)
-      tagger.run if image[:success]
-
-      image.merge(project: tagger.project, tags: tagger.tags)
+      results.values.reduce(:&)
     end
 
     private
 
-    attr_reader :layer
+    attr_reader :layers, :context, :flow
 
-    def logger
-      STDOUT.sync = true
-      @logger ||= Logger.new(STDOUT).tap do |logger|
-        logger.progname = layer
-        logger.formatter = proc do |severity, datetime, progname, msg|
-          format("%<severity>s, [%<datetime>s] -- %<progname>s: %<msg>s\n",
-                 severity: severity[0],
-                 datetime: datetime.strftime('%Y-%m-%d %H:%M:%S'),
-                 progname: progname,
-                 msg: msg)
-        end
-      end
+    def detect_layers(layers: nil)
+      Dir['**/*/Dockerfile']
+        .map { |d| File.dirname(d) }
+        .sort
+        .select { |layer| layers.nil? || layers.include?(layer) }
+        .map { |layer| Layer.new(name: layer, directory: File.expand_path('.', layer), context: context) }
     end
   end
 end

data/lib/blubber/layer.rb

@@ -0,0 +1,107 @@
+require 'blubber/build_info'
+require 'blubber/builder'
+require 'blubber/runner'
+
+module Blubber
+  class Layer
+    attr_reader :directory, :name
+    attr_accessor :build_id
+
+    def initialize(context:, directory:, name:)
+      @context = context
+      @directory = Pathname.new(directory)
+      @name = name
+    end
+
+    # Actions
+    def build
+      builder.build
+    end
+
+    def tag
+      builder.tag
+    end
+
+    def push
+      builder.push
+    end
+
+    # Accessors
+    def repo
+      @repo ||= name.split('/').select { |p| p[/[a-z0-9]+/] }.join('/')
+    end
+
+    def project
+      "#{context.docker_registry}/#{repo}"
+    end
+
+    def project_tag(tag)
+      "#{project}:#{tag}"
+    end
+
+    def cache
+      @cache ||= begin
+        cache_tags = []
+
+        if build_info.last_successful_commit
+          cache_tags << build_info.last_successful_commit.to_s
+        end
+        cache_tags << build_tag.to_s if build_tag
+        cache_tags << branch_tag.to_s if branch_tag
+        cache_tags << 'latest'
+
+        cache_tags
+          .map { |tag| "#{project}:#{tag}" }
+          .find { |img| runner.run("docker pull #{img}").zero? }
+      end
+    end
+
+    def tags
+      @tags ||= begin
+        tags = []
+        tags << build_info.commit
+
+        unless build_info.dirty?
+          tags << branch_tag if branch_tag
+          tags << 'latest' if branch_tag == 'master'
+        end
+
+        tags << File.read(directory.join('Dockerfile')).scan(/LABEL version=([\w][\w.-]*)/)
+
+        tags.flatten.map { |t| "#{t}#{build_info.dirty? ? '-dirty' : ''}" }
+      end
+    end
+
+    def branch_tag
+      filter(build_info.branch_name) unless build_info.branch_name.empty?
+    end
+
+    def build_tag
+      branch_tag || build_info.commit
+    end
+
+    private
+
+    attr_reader :context
+
+    def builder
+      @builder ||= Builder.new(layer: self, logger: logger)
+    end
+
+    def filter(thing)
+      thing.gsub(/[^\w.-]/, '_')
+    end
+
+    def build_info
+      @build_info ||= BuildInfo.new(layer: self)
+    end
+
+    def runner
+      @runner ||= Runner.new(logger: logger)
+    end
+
+    def logger
+      Logger.for(name: name)
+    end
+  end
+end

data/lib/blubber/logger.rb

@@ -0,0 +1,35 @@
+require 'singleton'
+require 'forwardable'
+require 'logger'
+
+module Blubber
+  class Logger
+    include Singleton
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, :for
+    end
+
+    def for(name:)
+      loggers.fetch(name) do
+        ::Logger.new(STDOUT).tap do |logger|
+          logger.progname = name
+          logger.formatter = proc do |severity, datetime, progname, msg|
+            format("%<severity>s, [%<datetime>s] -- %<progname>s: %<msg>s\n",
+                   severity: severity[0],
+                   datetime: datetime.strftime('%Y-%m-%d %H:%M:%S'),
+                   progname: progname,
+                   msg: msg)
+          end
+        end
+      end
+    end
+
+    private
+
+    def loggers
+      @loggers ||= {}
+    end
+  end
+end

data/lib/blubber/runner.rb

@@ -6,9 +6,10 @@ module Blubber
       @logger = logger
     end
 
-    def run(cmd)
+    def run(*cmd)
+      logger.info "Running #{cmd}"
       # see: http://stackoverflow.com/a/1162850/83386
-      Open3.popen3(cmd) do |_stdin, stdout, stderr, thread|
+      Open3.popen3(cmd.join(' ')) do |_stdin, stdout, stderr, thread|
         # read each stream from a new thread
         { out: stdout, err: stderr }.each do |key, stream|
           Thread.new do

data/lib/blubber/version.rb

@@ -1,3 +1,3 @@
 module Blubber
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.3.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blubber
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Mikko Kokkonen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-21 00:00:00.000000000 Z
+date: 2018-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -99,11 +99,14 @@ files:
 - blubber.gemspec
 - exe/blubber
 - lib/blubber.rb
+- lib/blubber/build_info.rb
 - lib/blubber/builder.rb
 - lib/blubber/cli.rb
+- lib/blubber/context.rb
 - lib/blubber/flow.rb
+- lib/blubber/layer.rb
+- lib/blubber/logger.rb
 - lib/blubber/runner.rb
-- lib/blubber/tagger.rb
 - lib/blubber/version.rb
 homepage: https://github.com/mikian/blubber
 licenses: []

data/lib/blubber/tagger.rb

@@ -1,86 +0,0 @@
-require 'highline'
-require 'logger'
-require 'open3'
-
-require 'blubber/runner'
-
-module Blubber
-  class Tagger
-    def self.docker_registry
-      ENV.fetch('DOCKER_REGISTRY')
-    end
-
-    def initialize(layer:, image_id:, logger: nil)
-      @layer = layer
-      @image_id = image_id
-      @logger = logger
-    end
-
-    def run
-      logger.info ui.color("#{layer}: PUSHING", :yellow)
-
-      push
-    end
-
-    def tags
-      @tags ||= begin
-        tags = []
-        tags << commit
-
-        unless dirty?
-          tags << branch_name.gsub(/[^\w.-]/, '_') unless branch_name.empty?
-          tags << 'latest' if branch_name == 'master'
-        end
-
-        tags << File.read("#{layer}/Dockerfile").scan(/LABEL version=([\w][\w.-]*)/)
-
-        tags.flatten.map { |t| "#{t}#{dirty? ? '-dirty' : ''}" }
-      end
-    end
-
-    def project
-      [
-        Tagger.docker_registry,
-        *layer.split('/').select { |p| p[/[a-z0-9]+/] }
-      ].join('/')
-    end
-
-    def branch_name
-      @branch_name ||= ENV['BRANCH_NAME'] || `git rev-parse HEAD | git branch -a --contains | sed -n 2p | cut -d'/' -f 3-`.strip
-    end
-
-    private
-
-    attr_reader :layer, :image_id, :logger
-
-    def runner
-      @runner ||= Runner.new(logger: logger)
-    end
-
-    def ui
-      @ui ||= HighLine.new
-    end
-
-    def dirty?
-      @dirty ||= system("git status --porcelain 2>&1 | grep -q '#{layer}'")
-    end
-
-    def commit
-      @commit ||= ENV['GIT_COMMIT'] || `git rev-parse HEAD`.strip
-    end
-
-    def push
-      status = true
-      tags.each do |tag|
-        logger.info "Tagging #{image_id} as #{layer}:#{tag}"
-        retval = runner.run("docker tag #{image_id} #{project}:#{tag}")
-        next unless retval.zero?
-        retval = runner.run("docker push #{project}:#{tag}")
-
-        status &= retval.zero?
-      end
-
-      tags if status
-    end
-  end
-end