docker-template 0.2.0 → 0.3.0

data/lib/docker/template/normal.rb

@@ -0,0 +1,46 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Docker
+  module Template
+    class Normal < Builder
+      def teardown(img: false)
+        @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 = ERB::Context.new(:metadata => @repo.metadata)
+        data = ERB.new(dockerfile).result(data._binding)
+        context = @context.join("Dockerfile")
+        context.write(data)
+      end
+
+      # ----------------------------------------------------------------------
+
+      private
+      def cache_context
+        if @repo.cacheable?
+          Cache.context self, @context
+        end
+      end
+    end
+  end
+end

data/lib/docker/template/notify.rb

@@ -0,0 +1,44 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Docker
+  module Template
+    module Notify
+      module_function
+
+      # ----------------------------------------------------------------------
+      # Notify the user of a push that is happening.
+      # ----------------------------------------------------------------------
+
+      def push(builder)
+        $stderr.puts Simple::Ansi.green(
+          "Pushing: #{builder.repo}"
+        )
+      end
+
+      # ----------------------------------------------------------------------
+      # Notify the user that we are tag aliasing.
+      # ----------------------------------------------------------------------
+
+      def alias(builder)
+        repo = builder.repo
+        aliased_repo = builder.aliased_repo
+        msg = Simple::Ansi.green("Aliasing #{repo} -> #{aliased_repo}")
+        $stderr.puts msg
+      end
+
+      # ----------------------------------------------------------------------
+      # Notify the user that we are building their repository.
+      # ----------------------------------------------------------------------
+
+      def build(repo, **kwd)
+        img = repo.to_s(**kwd)
+        msg = Simple::Ansi.green("Building: #{img}")
+        $stderr.puts msg
+      end
+    end
+  end
+end

data/lib/docker/template/parser.rb

@@ -1,66 +1,76 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 module Docker
   module Template
     class Parser
-      SLASH_REGEXP = /\//.freeze
-      SPLIT_REGEXP = /:|\//.freeze
-      COLON_REGEXP = /:/.freeze
+      SLASH_REGEXP = /\//
+      SPLIT_REGEXP = /:|\//
+      COLON_REGEXP = /:/
 
-      def initialize(argv = [].freeze)
-        @argv = argv.freeze
+      def initialize(raw_repos = [], argv = {})
+        @raw_repos = raw_repos
+        @argv = argv
       end
 
-      # Return ARGV if you send us a list of repos you wish to build,
-      # otherwise we get the children of the repo folder and ship that off
-      # so you can build *every* repo, I don't know if you want that.
+      # ----------------------------------------------------------------------
+      # Return `raw_repos` if you send us a list of repos you wish to build,
+      # otherwise we get the children of the repo folder and ship that off so
+      # you can build *every* repo, I don't know if you want that.
+      # ----------------------------------------------------------------------
 
       def all
-        return @argv unless @argv.empty?
-        Template.repos_root.children.map do |path|
+        return @raw_repos unless @raw_repos.empty?
+        Template.root.join(Metadata.new({}).repos_dir).children.map do |path|
           path.basename.to_s
         end
+
       rescue Errno::ENOENT
-        raise Error::RepoNotFound
+        then raise Error::RepoNotFound
       end
 
-      #
+      # ----------------------------------------------------------------------
+
+      def parse
+        repos = {
+          :scratch => [],
+          :simple  => [],
+          :aliases => []
+        }
 
-      def parse(as: :repos, out: Set.new)
-        all.each do |val|
-          hash = build_repo_hash(val)
-          raise Docker::Template::Error::BadRepoName, val if hash.empty?
-          out += as == :repos ? Repo.new(hash).to_repos : [hash]
+        all.each do |v|
+          hash = to_repo_hash(v)
+          if hash.empty?
+            raise Docker::Template::Error::BadRepoName, v
+
+          else
+            Repo.new(hash, @argv).to_repos.each do |r|
+              r.alias?? repos[:aliases] << r : r.builder.scratch?? \
+                repos[:scratch] << r : repos[:simple] << r
+            end
+          end
         end
-        out
+
+        repos.values.reduce(
+          :|
+        )
       end
 
-      #
+      # ----------------------------------------------------------------------
 
       private
-      def build_repo_hash(val)
+      def to_repo_hash(val)
         data = val.split(SPLIT_REGEXP)
-        hsh  = {}
 
-        if data.size == 1
-          hsh["repo"] = data[0]
+        return "name" => data[0] if data.one?
+        return "name" => data[0], "tag"  => data[1] if val =~ COLON_REGEXP && data.size == 2
+        return "user" => data[0], "name" => data[1] if val =~ SLASH_REGEXP && data.size == 2
+        return "user" => data[0], "name" => data[1], "tag" => data[2] if data.size == 3
 
-        elsif val =~ COLON_REGEXP && data.size == 2
-          hsh["repo"] = data[0]
-          hsh[ "tag"] = data[1]
-
-        elsif val =~ SLASH_REGEXP && data.size == 2
-          hsh["user"] = data[0]
-          hsh["repo"] = data[1]
-
-        elsif data.size == 3
-          hsh["user"] = data[0]
-          hsh["repo"] = data[1]
-          hsh[ "tag"] = data[2]
-        end
-        hsh
+        {}
       end
     end
   end

data/lib/docker/template/repo.rb

@@ -1,85 +1,109 @@
+# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Copyright: 2015 - 2016 Jordon Bedwell - Apache v2.0 License
 # Encoding: utf-8
+# ----------------------------------------------------------------------------
 
 module Docker
   module Template
-
-    # * A repo is not an image but a parent name w/ a tag.
-    # * An image is the final result of a build on a repo, and is associated.
-    # * Think of an image as the binary of the source in the repo.
-
     class Repo
-      extend Forwardable, Routable
+      extend Forwardable::Extended
 
-      def_delegator :builder, :build
-      route_to_hash :name, :@base_metadata, :repo
-      route_to_hash [:tag, :type, :user], :metadata
-      def_delegator :@base_metadata, :to_h
-      def_delegator :metadata, :aliased
-      def_delegator :metadata, :tags
+      # ----------------------------------------------------------------------
 
-      def initialize(base_metadata)
-        raise ArgumentError, "Metadata not a hash" unless base_metadata.is_a?(Hash)
-
-        @base_metadata = base_metadata.freeze
-        @sync_allowed  = type == "simple" ? true : false
-        raise Error::InvalidRepoType, type unless Template.config.build_types.include?(type)
+      def initialize(*hashes)
+        @base_meta = hashes.compact.reduce(:deep_merge).freeze
         raise Error::RepoNotFound, name unless root.exist?
       end
 
-      def builder
-        const = Template.const_get(type.capitalize)
-        const.new(self)
-      end
-
-      #
+      # ----------------------------------------------------------------------
+      # Determines whether or not we should (or you should) push the repo.
+      # ----------------------------------------------------------------------
 
-      def disable_sync!
-        @sync_allowed = false
+      def pushable?
+        (metadata["push"] || metadata["push_only"]) && !metadata[
+          "cache_only"
+        ]
       end
 
-      #
+      # ----------------------------------------------------------------------
+      # Determines whether or not we should (or you should) cache the repo.
+      # ----------------------------------------------------------------------
 
-      def syncable?
-        metadata["dockerhub_copy"] && @sync_allowed
+      def cacheable?
+        (metadata["cache"] || metadata["cache_only"]) && !metadata[
+          "push_only"
+        ]
       end
 
-      #
+      # ----------------------------------------------------------------------
+      # Determines whether or not we should (or you should) build the repo.
+      # ----------------------------------------------------------------------
 
-      def to_s
-        "#{user}/#{name}:#{tag}"
+      def buildable?
+        !metadata["push_only"] && !metadata["cache_only"] && !metadata[
+          "clean_only"
+        ]
       end
 
-      #
+      # ----------------------------------------------------------------------
+      # Pulls out the repo this repo is aliasing it, this happens when you
+      # when you set the tag in the "alias" section of your `opts.yml`.
+      # ----------------------------------------------------------------------
 
-      def copy_dir(*path)
-        dir = metadata["copy_dir"]
-        root.join(dir, *path)
+      def aliased
+        if alias?
+          self.class.new(to_h.merge({
+            "tag" => metadata.aliased_tag
+          }))
+        end
       end
 
-      #
+      # ----------------------------------------------------------------------
+      # Initializes and returns the builder so that you can build the repo.
+      # ----------------------------------------------------------------------
 
-      def building_all?
-        !@base_metadata.key?("tag")
+      def builder
+        return @builder ||= begin
+          Template.const_get(type.capitalize).new(
+            self
+          )
+        end
       end
 
-      #
+      # ----------------------------------------------------------------------
+      # Convert the repo into it's final image name, however if you tell, us
+      # this is a rootfs build we will convert it into the rootfs name.
+      # ----------------------------------------------------------------------
 
-      def to_rootfs_s
+      def to_s(rootfs: false)
         prefix = metadata["local_prefix"]
+        return "#{user}/#{name}:#{tag}" unless rootfs
         "#{prefix}/rootfs:#{name}"
       end
 
-      #
+      # ----------------------------------------------------------------------
+      # The directory you wish to cache to (like `cache/`) or other.
+      # ----------------------------------------------------------------------
 
-      def root
-        @root ||= begin
-          Template.repo_root_for(name)
-        end
+      def cache_dir
+        return root.join(
+          metadata["cache_dir"], tag
+        )
       end
 
-      #
+      # ----------------------------------------------------------------------
+      # The directory you store your image data in (by default `copy/`.)
+      # ----------------------------------------------------------------------
+
+      def copy_dir(*path)
+        dir = metadata["copy_dir"]
+        root.join(dir,
+          *path
+        )
+      end
+
+      # ----------------------------------------------------------------------
 
       def to_tag_h
         {
@@ -89,86 +113,96 @@ module Docker
         }
       end
 
-      #
+      # ----------------------------------------------------------------------
 
       def to_rootfs_h
-        prefix = metadata["local_prefix"]
-
         {
           "tag"   => name,
-          "repo"  => "#{prefix}/rootfs",
+          "repo"  => "#{metadata["local_prefix"]}/rootfs",
           "force" => true
         }
       end
 
-      #
+      # ----------------------------------------------------------------------
 
-      def tmpdir(*prefixes, root: nil)
-        prefixes = [user, name, tag] + prefixes
-        args = ["#{prefixes.join("-")}-", root].delete_if(&:nil?)
-        Pathname.new(Dir.mktmpdir(*args))
+      def tmpdir(*args, root: nil)
+        args.unshift(user, name, tag)
+        Pathutil.tmpdir(args,
+          nil, root
+        )
       end
 
-      #
+      # ----------------------------------------------------------------------
 
-      def tmpfile(*prefixes, root: nil)
-        prefixes = [user, name, tag] + prefixes
-        ext = prefixes.pop if prefixes.last =~ /\A\./
-        prefixes = ["#{prefixes.join("-")}-"]
-        prefixes = ext ? prefixes.push(ext) : prefixes.first
-        args = [prefixes, root].delete_if(&:nil?)
-        Pathname.new(Tempfile.new(*args))
+      def tmpfile(*args, root: nil)
+        args.unshift(user, name, tag)
+        Pathutil.tmpfile(args,
+          nil, root
+        )
       end
 
-      # If a tag was given then it returns [self] and if a tag was not
-      # sent it then goes on to detect the type and split itself accordingly
-      # returning multiple AKA all repos to be built.
+      # ----------------------------------------------------------------------
+      # If a tag was given then it returns [self] and if a tag was not sent
+      # it then goes on to detect the type and split itself accordingly
+      # returning multiple, AKA all repos that should be built.
+      # ----------------------------------------------------------------------
 
       def to_repos
-        if building_all?
-          set  = Set.new
-          base = to_h
-
+        set = Set.new
+        if @base_meta.key?("tag")
+          set << self
+        else
           tags.each do |tag|
-            base = base.merge("tag" => tag)
-            set << self.class.new(base)
+            hash = to_h.merge("tag" => tag)
+            set << self.class.new(
+              hash, @cli_opts
+            )
           end
-
-          set
-        else
-          Set.new([
-            self
-          ])
         end
+        set
       end
 
-      #
+      # ----------------------------------------------------------------------
 
       def metadata
-        @metadata ||= begin
-          metadata = Template.repo_root_for(name)
-          metadata = Template.config.read_config_from(metadata)
-          Metadata.new(metadata).merge(@base_metadata)
+        return @metadata ||= begin
+          Metadata.new(
+            @base_meta
+          )
         end
       end
 
-      #
+      # ----------------------------------------------------------------------
 
-      def to_env_hash(tar_gz: nil, copy_dir: nil)
-        metadata["env"].as_hash.merge({
+      def to_env(tar_gz: nil, copy_dir: nil)
+        hash = metadata["env"] || { "all" => {}}
+        Metadata.new(hash, :root => metadata).merge({
           "REPO" => name,
-          "NAME" => name,
           "TAR_GZ" => tar_gz,
-          "TYPE" => metadata["tags"][tag],
-          "VERSION" => metadata["version"].fallback,
-          "PKGS" => metadata["pkgs"].as_string_set,
-          "RELEASE" => metadata["release"].fallback,
+          "GROUP" => metadata.group,
+          "COPY_DIR" => copy_dir,
           "BUILD_TYPE" => type,
-          "COPY" => copy_dir,
-          "TAR" => tar_gz,
           "TAG" => tag
-        }).to_env
-      end
+        })
+      end
+
+      # ----------------------------------------------------------------------
+
+      rb_delegate :build, :to => :builder
+      rb_delegate :alias?, :to => :metadata
+      rb_delegate :complex_alias?, :to => :metadata
+      rb_delegate :type, :to => :metadata, :type => :hash
+      rb_delegate :user, :to => :metadata, :type => :hash
+      rb_delegate :name, :to => :metadata, :type => :hash
+      rb_delegate :tag,  :to => :metadata, :type => :hash
+      rb_delegate :to_h, :to => :@base_meta
+      rb_delegate :root, :to => :metadata
+      rb_delegate :tags, :to => :metadata
+      rb_delegate :clean, {
+        :to => Cache, :alias_of => :cleanup, :args => %w(
+          self
+        )
+      }
     end
   end
 end