docker-template 0.1.0

data/lib/docker/template/routable.rb

@@ -0,0 +1,28 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    module Routable
+      def route_to_hash(methods, hash, alt_key = nil)
+        methods = [methods] unless methods.is_a?(Array)
+        methods.each do |method|
+          class_eval <<-STR, __FILE__, __LINE__
+            def #{method}
+              #{alt_key ? "#{hash}['#{alt_key}']" : "#{hash}['#{method}']"}
+            end
+          STR
+        end
+      end
+
+      def route_to_ivar(method, var, bool: false, revbool: false)
+        class_eval <<-STR, __FILE__, __LINE__
+          def #{method}#{"?" if bool || revbool}
+            #{revbool ? "!!!" : "!!" if bool || revbool}#{var}
+          end
+        STR
+      end
+    end
+  end
+end

data/lib/docker/template/scratch.rb

@@ -0,0 +1,139 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    class Scratch < Common
+      attr_reader :rootfs, :img, :repo
+      def initialize(repo)
+        @repo = repo
+      end
+
+      #
+
+      def data
+        Template.get(:scratch, {
+          :maintainer => @repo.metadata["maintainer"],
+          :entrypoint => @repo.metadata["entry"].fallback,
+          :tar_gz => @tar_gz.basename
+        })
+      end
+
+      #
+
+      def unlink(img: false)
+        @copy.rmtree if @copy && @copy.directory?
+        @img.delete "force" => true if @img && img
+        @context.rmtree if @context && @context.directory?
+        @tar_gz.unlink if @tar_gz && @tar_gz.file?
+      end
+
+      #
+
+      private
+      def setup_context
+        @context = @repo.tmpdir
+        @tar_gz = @repo.tmpfile "archive", ".tar.gz", root: @context
+        @copy = @repo.tmpdir "copy"
+        copy_dockerfile
+      end
+
+      #
+
+      private
+      def build_rootfs
+        @rootfs ||= begin
+          self.class.rootfs_for(@repo)
+        end
+      end
+
+      # Caches and builds the master rootfs for repos, this is cached
+      # on the class because it could be used many times in a single build
+      # so we make sure to keep it around so you don't have tons of
+      # replication going about slowing down all of the builds.
+
+      def self.rootfs_for(repo)
+        (@rootfs ||= {})[repo.name] ||= begin
+          Rootfs.new(repo).tap(&:build)
+        end
+      end
+
+      #
+
+      private
+      def build_context
+        build_rootfs
+
+        output_given = false
+        img = Container.create(create_args)
+        img.start(start_args).attach do |type, str|
+          type == :stdout ? $stdout.print(str) : $stderr.print(Ansi.red(str))
+          output_given = true
+        end
+
+        # NOTE: Sometimes the instance exists too quickly for attach to even
+        # work, through the remote API, so we need to detect those situations
+        # and stream the logs after it's exited if we have given no output,
+        # we want you to always get the output that was given.
+
+        if !output_given
+          img.streaming_logs "stdout" => true, "stderr" => true do |type, str|
+            type == :stdout ? $stdout.print(str) : $stderr.print(Ansi.red(str))
+          end
+        end
+
+        if (status = img.json["State"]["ExitCode"]) != 0
+          raise Error::BadExitStatus, status
+        end
+      ensure
+        if img
+          img.stop rescue nil
+          img.delete
+        end
+      end
+
+      #
+
+      def verify_context
+        unless @tar_gz.size > 0
+          raise Error::InvalidTargzFile, @tar_gz
+        end
+      end
+
+      #
+
+      private
+      def copy_dockerfile
+        data = self.data % @tar_gz.basename
+        dockerfile = @context.join("Dockerfile")
+        dockerfile.write(data)
+      end
+
+      #
+
+      private
+      def create_args
+        {
+          "Env"     => @repo.to_env_hash(tar_gz: @tar_gz, copy_dir: @copy).to_env_ary,
+          "Name"    => ["rootfs", @repo.name, @repo.tag, "image"].join("-"),
+          "Image"   => @rootfs.img.id,
+          "Volumes" => {
+            @tar_gz.to_s => {}, @copy.to_s => {}
+          }
+        }
+      end
+
+      #
+
+      private
+      def start_args
+        {
+          "Binds" => [
+            "#{@copy.to_s}:#{@copy.to_s}:ro", "#{@tar_gz.to_s}:#{@tar_gz.to_s}"
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/docker/template/simple.rb

@@ -0,0 +1,51 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    class Simple < Common
+      attr_reader :repo
+      def initialize(repo)
+        @repo = repo
+      end
+
+      #
+
+      def sync
+        copy_build_and_verify unless @context
+        Util.create_dockerhub_context( \
+          self, @context)
+      end
+
+      #
+
+      def unlink(img: false, sync: true)
+        self.sync if sync && @repo.syncable?
+        @img.delete "force" => true if @img && img
+        @context.rmtree if @context && \
+          @context.directory?
+      end
+
+      #
+
+      def setup_context
+        @context = @repo.tmpdir
+        @copy = @context.join("copy")
+        copy_dockerfile
+        @copy.mkdir
+      end
+
+      #
+
+      private
+      def copy_dockerfile
+        dockerfile = @repo.root.join("Dockerfile").read
+        data = Util::Data.new(:metadata => @repo.metadata)
+        data = ERB.new(dockerfile).result(data._binding)
+        context = @context.join("Dockerfile")
+        context.write(data)
+      end
+    end
+  end
+end

data/lib/docker/template/stream.rb

@@ -0,0 +1,62 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    class Stream
+      def initialize
+        @lines  = {}
+      end
+
+      #
+
+      def log(part)
+        stream = JSON.parse(part)
+        return progress_bar(stream) if stream.any_keys?("progress", "progressDetail")
+        return $stdout.puts stream["status"] || stream["stream"] if stream.any_keys?("status", "stream")
+        return progress_error(stream) if stream.any_keys?("errorDetail", "error")
+
+        warn Ansi.red("Unhandled stream message")
+        $stderr.puts Ansi.red("Please file a bug ticket.")
+        $stdout.puts part
+      end
+
+      #
+
+      def progress_error(stream)
+        abort Ansi.red((stream["error"] || stream["errorDetail"]["message"]).capitalize)
+      end
+
+      #
+
+      private
+      def progress_bar(stream)
+        id = stream["id"]
+        unless id
+          return
+        end
+
+        before, diff = progress_diff(id)
+        $stdout.print  before if before
+        str = stream["progress"] || stream["status"]
+        str = "%s: %s\r" % [id, str]
+
+        $stdout.print(Ansi.jump(str, both: diff))
+      end
+
+      #
+
+      private
+      def progress_diff(id)
+        if @lines.has_key?(id)
+          return nil, @lines.size - @lines[id]
+        end
+
+        @lines[id] = @lines.size
+        before = "\n" unless @lines.size == 1
+        return before, 0
+      end
+    end
+  end
+end

data/lib/docker/template/templates/rootfs.erb

@@ -0,0 +1,8 @@
+FROM <%= @rootfs_base_img %>
+RUN apt-get update && apt-get install --no-install-recommends -yf \
+    xz-utils git ca-certificates wget
+
+COPY copy /
+ENTRYPOINT [ \
+  "/usr/local/bin/mkimg" \
+]

data/lib/docker/template/templates/scratch.erb

@@ -0,0 +1,7 @@
+FROM scratch
+MAINTAINER <%= @maintainer %>
+ENV TERM=xterm
+ADD <%= @tar_gz %> /
+<% if @entrypoint %>
+  ENTRYPOINT ["<%= @entrypoint %>"]
+<% end %>

data/lib/docker/template/util.rb

@@ -0,0 +1,39 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    module Util module_function
+      autoload :Copy, "docker/template/util/copy"
+      autoload :Data, "docker/template/util/data"
+
+      def notify_alias(aliased)
+        repo = aliased.repo
+        parent_repo = aliased.parent_repo
+        $stdout.puts Ansi.green("Aliasing #{repo} -> #{parent_repo}")
+      end
+
+      #
+
+      def notify_build(repo, rootfs: false)
+        img = rootfs ? repo.to_rootfs_s : repo.to_s
+        $stdout.puts Ansi.green("Building: #{img}")
+      end
+
+      #
+
+      def create_dockerhub_context(builder, context)
+        tags = builder.repo.root.join("tags")
+        readme = builder.repo.root.children.select { |val| val.to_s =~ /readme/i }.first
+        context = tags.join(builder.repo.aliased) if builder.aliased?
+        dir = tags.join(builder.repo.tag)
+
+        FileUtils.mkdir_p dir
+        $stdout.puts Ansi.yellow("Storing a Docker context for #{builder.repo}")
+        Util::Copy.directory(context, dir)
+        Util::Copy.file(readme, dir)
+      end
+    end
+  end
+end

data/lib/docker/template/util/copy.rb

@@ -0,0 +1,82 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    module Util
+      class Copy
+        def initialize(from, to)
+          @root = Template.root.realpath
+          @repos_root = Template.repos_root.realpath
+          @from = from.to_pathname
+          @to = to.to_pathname
+        end
+
+        #
+
+        def self.directory(from, to)
+          if from && to && File.exist?(from)
+            new(from, to).directory
+          end
+        end
+
+        # Copy a directory checking for symlinks and resolving them (only
+        # at the top level) if they are in the repos root, the root or the from
+        # path. The reason we check all three is because repos might be a
+        # symlink that resolves out of path so we need to allow symlinks
+        # from it. The same for the copy folder.
+
+        def directory
+          FileUtils.cp_r(@from.children, @to, :dereference_root => false)
+          @from.all_children.select(&:symlink?).each do |path|
+            resolved = path.realpath
+            pth = path.relative_path_from(@from)
+            pth = @to.join(path)
+
+            unless in_path?(resolved)
+              raise Errno::EPERM, "#{pth} not in #{@root}"
+            end
+
+            FileUtils.rm_r(pth)
+            FileUtils.cp_r(resolved, pth, {
+              :dereference_root => false
+            })
+          end
+        end
+
+        #
+
+        def self.file(from, to)
+          if to && from && File.exist?(from)
+            new(from, to).file
+          end
+        end
+
+        #
+
+        def file
+          if !@from.symlink?
+            return FileUtils.cp(@from, @to)
+          end
+
+          resolved = @from.realpath
+          allowed = resolved.in_path?(@root)
+          raise Errno::EPERM, "#{resolved} not in #{@root}." unless allowed
+          FileUtils.cp(resolved, @to)
+        end
+
+        # Check to see if the path falls within the users roots, while
+        # getting the real path of the from root just incase it, itself is
+        # a symlink, we don't want it to fail because of that.
+
+        private
+        def in_path?(resolved)
+          resolved.in_path?(@repos_root) || \
+          resolved.in_path?(@from.realpath) || \
+          resolved.in_path?(@root)
+        end
+      end
+    end
+  end
+end

data/lib/docker/template/util/data.rb

@@ -0,0 +1,26 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    module Util
+
+      # Provides a way to encapsulate data for ERB processing so that we
+      # don't get full unfettered access to the entire binding from within
+      # our ERB processing context.  Nobody wants that.
+
+      class Data
+        def initialize(vars)
+          vars.each do |key, val|
+            instance_variable_set("@#{key}", val)
+          end
+        end
+
+        def _binding
+          return binding
+        end
+      end
+    end
+  end
+end