docker-template 0.2.0 → 0.3.0

data/lib/docker/template.rb

@@ -1,99 +1,85 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
 # Encoding: utf-8
-
-require "docker/template/version"
-require "docker/template/patches"
+# ----------------------------------------------------------------------------
 
 require "docker"
-require "forwardable"
-require "json"
-require "erb"
+require "extras/all"
+require "erb/context"
+require "forwardable/extended"
+require "simple/ansi"
+require "pathutil"
 require "set"
 
+# ----------------------------------------------------------------------------
+
+Excon.defaults[ :read_timeout] = 1440
+Excon.defaults[:write_timeout] = 1440
+
+# ----------------------------------------------------------------------------
+
 module Docker
   module Template
     module_function
 
-    autoload :Util, "docker/template/util"
-    autoload :Config, "docker/template/config"
-    autoload :Ansi, "docker/template/ansi"
-    autoload :Parser, "docker/template/parser"
-    autoload :Routable, "docker/template/routable"
-    autoload :Interface, "docker/template/interface"
-    autoload :Metadata, "docker/template/metadata"
-    autoload :Stream, "docker/template/stream"
-    autoload :Safe, "docker/template/safe"
+    # ------------------------------------------------------------------------
+
+    autoload :Notify, "docker/template/notify"
+    autoload :Utils, "docker/template/utils"
     autoload :Repo, "docker/template/repo"
     autoload :Error, "docker/template/error"
-    autoload :Common, "docker/template/common"
-    autoload :Rootfs, "docker/template/rootfs"
+    autoload :Logger, "docker/template/logger"
+    autoload :Normal, "docker/template/normal"
+    autoload :Parser, "docker/template/parser"
+    autoload :Builder, "docker/template/builder"
+    autoload :Metadata, "docker/template/metadata"
     autoload :Scratch, "docker/template/scratch"
-    autoload :Simple, "docker/template/simple"
+    autoload :Rootfs, "docker/template/rootfs"
+    autoload :Cache, "docker/template/cache"
     autoload :Alias, "docker/template/alias"
-    autoload :Auth, "docker/template/auth"
+    autoload :CLI, "docker/template/cli"
 
-    def repo_is_root?
-      root.join("copy").exist? && !root.join("../..", config["repos_dir"]).exist?
-    end
-
-    def config
-      @config ||= begin
-        Config.new
-      end
-    end
-
-    #
+    # ------------------------------------------------------------------------
 
     def root
       @root ||= begin
-        Pathname.new(Dir.pwd)
+        Pathutil.new(Dir.pwd)
       end
     end
 
-    # The location of the standard repos/ dir, you can change this by adding
-    # `repos_dir` into your configuration file. I'm not saying it has to be but
-    # it should probably be relative rather than absolute, ther are no
-    # guarantees that an absolute path will work.
-
-    def repos_root
-      @repos_root ||= begin
-        root.join(config["repos_dir"])
-      end
-    end
-
-    #
-
-    def repo_root_for(name)
-      repo_is_root?? root : repos_root.join(name)
-    end
-
-    # Provides the root to Docker template, wherever it is installed so that
-    # we can do things, mostly ignore files for the profiler. Otherwise it's
-    # not really used, it's just an encapsulator.
+    # ------------------------------------------------------------------------
 
     def gem_root
       @gem_root ||= begin
-        path = File.expand_path("../../", __dir__)
-        Pathname.new(path)
+        Pathutil.new("../../").expand_path(
+          __dir__
+        )
       end
     end
 
-    # Provides the templates directory so you can quickly pull a template
-    # from our templates and use it if you wish to.
+    # ------------------------------------------------------------------------
 
     def template_root
       @template_root ||= begin
-        gem_root.join("lib/docker/template/templates")
+        gem_root.join("templates")
       end
     end
 
-    #
+    # ------------------------------------------------------------------------
+    # Pull a `template` from the `template_root` to parse it's data.
+    # TODO: Rename this get template!
+    # ------------------------------------------------------------------------
 
     def get(name, data = {})
-      data = Util::Data.new(data)
-      template = template_root.join("#{name}.erb").read
-      ERB.new(template).result(data._binding)
+      data = ERB::Context.new(data)
+      template = template_root.join("#{name}.erb").read unless name.is_a?(Pathutil)
+      template = name.read if name.is_a?(Pathutil)
+      template = ERB.new(template)
+
+      return template.result(
+        data._binding
+      )
     end
   end
 end

data/lib/docker/template/builder.rb

@@ -0,0 +1,302 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Docker
+  module Template
+    class Builder
+      extend Forwardable::Extended
+
+      # ----------------------------------------------------------------------
+
+      attr_reader :repo
+      attr_reader :context
+      attr_reader :img
+
+      # ----------------------------------------------------------------------
+
+      ALIAS_SETUP = [:cache_context]
+      SETUP = [:setup_context, :copy_global, :copy_all,
+        :copy_group, :copy_tag, :copy_cleanup, :build_context,
+          :verify_context, :cache_context].freeze
+
+      # ----------------------------------------------------------------------
+
+      def initialize(repo)
+        @repo = repo
+      end
+
+      # ----------------------------------------------------------------------
+      # Checks to see if this repository is an alias. This happens when the
+      # user has alised data inside of their configuration file.  At this point
+      # we will not only copy the parent's data but the aliased data.
+      # ----------------------------------------------------------------------
+
+      def alias?
+        !@repo.complex_alias? && @repo.alias? && !rootfs?
+      end
+
+      # ----------------------------------------------------------------------
+
+      def rootfs?
+        is_a?(
+          Rootfs
+        )
+      end
+
+      # ----------------------------------------------------------------------
+
+      def normal?
+        @repo.type == "normal" \
+          && !rootfs?
+      end
+
+      # ----------------------------------------------------------------------
+
+      def scratch?
+        @repo.type == "scratch" \
+          && !rootfs?
+      end
+
+      # ----------------------------------------------------------------------
+
+      def aliased_img
+        return unless alias?
+        @aliased_img ||= Docker::Image.get(
+          aliased_repo.to_s
+        )
+
+      rescue Docker::Error::NotFoundError
+        if alias?
+          nil
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      def push
+        return if rootfs? || !@repo.pushable?
+        Notify.push self
+        auth!
+
+        img = @img || Image.get(@repo.to_s)
+        img.push nil, :repo_tag => \
+          @repo.to_s, &Logger.new.method(:api)
+
+      rescue Docker::Error::NotFoundError
+        $stderr.puts Simple::Ansi.red(
+          "Image does not exist, unpushable."
+        )
+      end
+
+      # ----------------------------------------------------------------------
+
+      def build
+        Simple::Ansi.clear if @repo.buildable?
+        return build_alias if alias?
+        setup
+
+        if @repo.buildable?
+          Notify.build(@repo, {
+            :rootfs => rootfs?
+          })
+
+          chdir_build
+        end
+
+        push
+      rescue SystemExit => exit_
+        teardown :img => true
+        raise exit_
+      ensure
+        if !rootfs?
+          teardown else teardown({
+            :img => false
+          })
+        end
+      end
+
+      # ----------------------------------------------------------------------
+      # This method is a default reference.  It is called when the image is
+      # done building or when there is an error and we need to clean up some
+      # stuff before exiting, use it... please.
+      # ----------------------------------------------------------------------
+
+      def teardown(*_)
+        $stderr.puts Ansi.red(
+          "#{__method__}: Not Implemented."
+        )
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def build_alias
+        alias_setup
+
+        if @repo.buildable?
+          aliased = self.class.new(aliased_repo)
+          aliased.build unless aliased_img
+          Notify.alias(self)
+
+          aliased_img.tag(
+            @repo.to_tag_h
+          )
+        end
+
+        push
+      end
+
+      # ----------------------------------------------------------------------
+      # The prebuild happens when a user has "setup_context", which typically
+      # only happens with scratch, which will prebuild it's rootfs image so
+      # it can get to building it's actual image.
+      # ----------------------------------------------------------------------
+
+      private
+      def setup
+        unless respond_to?(:setup_context, true)
+          raise Error::NoSetupContext
+        end
+
+        SETUP.map do |val|
+          if respond_to?(val, true)
+            send(val)
+          end
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def alias_setup
+        ALIAS_SETUP.map do |m|
+          if respond_to?(m, true)
+            send(m)
+          end
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def chdir_build
+        @context.chdir do
+          logger = Logger.new(self).method(:api)
+          opts = { :t => @repo.to_s(rootfs: rootfs?) }
+          $stderr.puts Simple::Ansi.yellow("TTY not supported: Ignored.") if @repo.metadata["tty"]
+          @img = Docker::Image.build_from_dir(".", opts, &logger)
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def cache_context
+        if repo.cacheable?
+          $stderr.puts Simple::Ansi.red(
+            "Context caching not supported"
+          )
+        end
+      end
+
+      # ----------------------------------------------------------------------
+      # The root can have it's own global copy directory shared across all
+      # repos in your repo container dir so this encapsulates those.
+      # ----------------------------------------------------------------------
+
+      private
+      def copy_global
+        unless rootfs?
+          dir = Template.root.join(
+            @repo.metadata["copy_dir"]
+          )
+
+          if dir.exist?
+            then dir.safe_copy(
+              @copy, :root => Template.root
+            )
+          end
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def copy_tag
+        unless rootfs?
+          dir = @repo.copy_dir("tag", @repo.tag)
+
+          if dir.exist?
+            then dir.safe_copy(
+              @copy, :root => Template.root
+            )
+          end
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def copy_group
+        build_group = @repo.metadata["tags"][
+          @repo.tag
+        ]
+
+        unless rootfs? || !build_group
+          dir = @repo.copy_dir("group", build_group)
+
+          if dir.exist?
+            then dir.safe_copy(
+              @copy, :root => Template.root
+            )
+          end
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def copy_all
+        unless rootfs?
+          dir = @repo.copy_dir("all")
+
+          if dir.exist?
+            then dir.safe_copy(
+              @copy, :root => Template.root
+            )
+          end
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def auth!
+        credentials = Pathutil.new("~/.docker/config.json").expand_path.read_json
+        return if credentials.empty?
+
+        credentials["auths"].each do |server, info|
+          user, pass = Base64.decode64(info["auth"]).split(
+            ":", 2
+          )
+
+          Docker.authenticate!({
+            "username" => user,
+            "serveraddress" => server,
+            "email" => info["email"],
+            "password" => pass
+          })
+        end
+      end
+
+      # ----------------------------------------------------------------------
+
+      rb_delegate :aliased_repo, {
+        :to => :repo, :alias_of => :aliased
+      }
+    end
+  end
+end

data/lib/docker/template/cache.rb

@@ -0,0 +1,71 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Docker
+  module Template
+    module Cache
+      module_function
+
+      # ----------------------------------------------------------------------
+      # Cache the context into the cache directory.
+      # ----------------------------------------------------------------------
+
+      def context(builder, context)
+        if builder.alias? && builder.aliased_repo.cache_dir.exist?
+          parent_cache_dir = builder.aliased_repo.cache_dir
+          $stderr.puts Simple::Ansi.yellow("Copying #{builder.aliased_repo} context to #{builder.repo}")
+          cache_dir = builder.repo.cache_dir
+
+          parent_cache_dir.cp_r(cache_dir.tap(
+            &:rm_rf
+          ))
+        elsif context
+          builder.repo.cache_dir.rm_rf
+          $stderr.puts Simple::Ansi.yellow("Copying context for #{builder.repo}")
+          cache_dir = builder.repo.cache_dir
+          cache_dir.parent.mkdir_p
+
+          readme(builder)
+          context.cp_r(cache_dir.tap(
+            &:rm_rf
+          ))
+        end
+      end
+
+      # ----------------------------------------------------------------------
+      # Cleanup the context caches, removing the caches we no longer need.
+      # ----------------------------------------------------------------------
+
+      def cleanup(repo)
+        repo.cache_dir.parent.children.each do |file|
+          unless repo.metadata.tags.include?(file.basename)
+            $stdout.puts Simple::Ansi.yellow("Removing %s." % [
+              file.relative_path_from(Template.root)
+            ])
+
+            file.rm_rf
+          end
+        end
+      end
+
+      # ----------------------------------------------------------------------
+      # Note: We normally expect but do not require you to have a README.
+      # Search for and copy the readme if available.
+      # ----------------------------------------------------------------------
+
+      def readme(builder)
+        file = builder.repo.root.children.find do |val|
+          val =~ /readme/i
+        end
+
+        return unless file
+        file.safe_copy(builder.repo.cache_dir, {
+          :root => file.parent
+        })
+      end
+    end
+  end
+end