docker-template 0.1.0

data/lib/docker/template/parser.rb

@@ -0,0 +1,66 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    class Parser
+      SlashRegexp = /\//.freeze
+      SplitRegexp = /:|\//.freeze
+      ColonRegexp = /:/.freeze
+
+      def initialize(argv = [].freeze)
+        @argv = argv.freeze
+      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.
+
+      def all
+        return @argv unless @argv.empty?
+        Docker::Template.repos_root.children.map do |path|
+          path.basename.to_s
+        end
+      rescue Errno::ENOENT
+        raise Error::RepoNotFound
+      end
+
+      #
+
+      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]
+        end
+      out
+      end
+
+      #
+
+      private
+      def build_repo_hash(val)
+        data, hsh = val.split(SplitRegexp), {}
+        if data.size == 1
+          hsh["repo"] = data[0]
+
+        elsif val =~ ColonRegexp && data.size == 2
+          hsh["repo"] = data[0]
+          hsh[ "tag"] = data[1]
+
+        elsif val =~ SlashRegexp && 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
+end

data/lib/docker/template/patches.rb

@@ -0,0 +1,9 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+require "docker/template/patches/object"
+require "docker/template/patches/array"
+require "docker/template/patches/pathname"
+require "docker/template/patches/string"
+require "docker/template/patches/hash"

data/lib/docker/template/patches/array.rb

@@ -0,0 +1,11 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+class Array
+  def stringify
+    map do |val|
+      val.is_a?(Hash) || val.is_a?(Array) ? val.stringify : val.to_s
+    end
+  end
+end

data/lib/docker/template/patches/hash.rb

@@ -0,0 +1,76 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+class Hash
+  def to_env
+    inject({}) do |hsh, (key, val)|
+      val = val.is_a?(Array) ? val.join(" ") : val.to_s
+      key = key.to_s.upcase
+      hsh[key] = val
+    hsh
+    end
+  end
+
+  #
+
+  def any_keys?(*keys)
+    keys.map(&method(:has_key?)).any? do |val|
+      val == true
+    end
+  end
+
+  #
+
+  def leftover_keys?(*keys)
+    return (self.keys - keys).any?
+  end
+
+  #
+
+  def has_keys?(*keys)
+    return false unless rtn = true && any?
+    while rtn && key = keys.shift
+      rtn = has_key?(key) || false
+    end
+
+  rtn
+  end
+
+  #
+
+  def to_env_ary
+    inject([]) do |array, (key, val)|
+      array.push("#{key}=#{val}")
+    end
+  end
+
+  #
+
+  def deep_merge(newh)
+    merge(newh) do |key, oval, nval|
+      if oval.is_a?(self.class) && nval.is_a?(self.class)
+        then oval.deep_merge(nval) else nval
+      end
+    end
+  end
+
+  #
+
+  def stringify
+    inject({}) do |hsh, (key, val)|
+      hsh[key.to_s] = val.is_a?(Array) || val.is_a?(Hash) ? val.stringify : val.to_s
+    hsh
+    end
+  end
+
+  #
+
+  def stringify_keys
+    inject({}) do |hsh, (key, val)|
+      hsh[key.to_s] = val
+
+    hsh
+    end
+  end
+end

data/lib/docker/template/patches/object.rb

@@ -0,0 +1,9 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+class Object
+  def to_pathname
+    Object::Pathname.new(self)
+  end
+end

data/lib/docker/template/patches/pathname.rb

@@ -0,0 +1,46 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+class Pathname
+  def in_path?(path)
+    path_str = path.is_a?(self.class) ? path.expanded_realpath.to_s : path.to_s
+    expanded_realpath.to_s.start_with?(path_str)
+  end
+
+  #
+
+  def write(data)
+    File.write(self.to_s, data)
+  end
+
+  #
+
+  def expanded_path
+    @expanded_path ||= begin
+      expand_path Dir.pwd
+    end
+  end
+
+  #
+
+  def expanded_realpath
+    return @expanded_real_path ||= begin
+      expanded_path.realpath
+    end
+  end
+
+  #
+
+  def all_children
+    glob "**/*"
+  end
+
+  #
+
+  def glob(*args)
+    Dir.glob(self.join(*args)).map do |path|
+      self.class.new(path)
+    end
+  end
+end

data/lib/docker/template/patches/string.rb

@@ -0,0 +1,9 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+class String
+  def to_a
+    split " "
+  end
+end

data/lib/docker/template/repo.rb

@@ -0,0 +1,180 @@
+# Frozen-string-literal: true
+# Copyright: 2015 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
+
+      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" if !base_metadata.is_a?(Hash)
+        
+        @base_metadata = base_metadata.freeze
+        @sync_allowed  = type == "simple" ? true : false
+        raise Error::InvalidRepoType, type if !Template.config.build_types.include?(type)
+        raise Error::RepoNotFound, name if !root.exist?
+      end
+
+      def builder
+        const = Template.const_get(type.capitalize)
+        const.new(self)
+      end
+
+      # Simply initializes the the builder and passes itself onto
+      # it so that it the builder can take over and do it's job cleanly
+      # without us needing to care about what's going on.
+
+      def build
+        return builder.build
+      end
+
+      #
+
+      def disable_sync!
+        @sync_allowed = false
+      end
+
+      #
+
+      def syncable?
+        metadata["dockerhub_copy"] && @sync_allowed
+      end
+
+      #
+
+      def to_s
+        "#{user}/#{name}:#{tag}"
+      end
+
+      #
+
+      def copy_dir(*path)
+        dir = metadata["copy_dir"]
+        root.join(dir, *path)
+      end
+
+      #
+
+      def building_all?
+       !@base_metadata.has_key?("tag")
+      end
+
+      #
+
+      def to_rootfs_s
+        prefix = metadata["local_prefix"]
+        "#{prefix}/rootfs:#{name}"
+      end
+
+      #
+
+      def root
+        return @root ||= begin
+          Template.repos_root.join(name)
+        end
+      end
+
+      #
+
+      def to_tag_h
+        {
+          "force" => true,
+           "repo" => "#{user}/#{name}",
+            "tag" => tag,
+        }
+      end
+
+      #
+
+      def to_rootfs_h
+        prefix = metadata["local_prefix"]
+
+        {
+          "force" => true,
+           "repo" => "#{prefix}/rootfs",
+            "tag" => name
+        }
+      end
+
+      #
+
+      def tmpdir(*prefixes, root: nil)
+        prefixes = [user, name, tag] + prefixes
+        args = ["#{prefixes.join("-")}-", root].delete_if(&:nil?)
+        Pathname.new(Dir.mktmpdir(*args))
+      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))
+      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.
+
+      def to_repos
+        if building_all?
+          base, set = to_h, Set.new
+          tags.each do |tag|
+            set.add(self.class.new(base.merge({
+              "tag" => tag
+            })))
+          end
+
+          set
+        else
+          Set.new([
+            self
+          ])
+        end
+      end
+
+      #
+
+      def metadata
+        return @metadata ||= begin
+          metadata = Template.repos_root.join(name)
+          metadata = Template.config.read_config_from(metadata)
+          Metadata.new(metadata).merge(@base_metadata)
+        end
+      end
+
+      #
+
+      def to_env_hash(tar_gz: nil, copy_dir: nil)
+        metadata["env"].as_hash.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,
+          "BUILD_TYPE" => type,
+          "COPY" => copy_dir,
+          "TAR" => tar_gz,
+          "TAG" => tag,
+        }).to_env
+      end
+    end
+  end
+end

data/lib/docker/template/rootfs.rb

@@ -0,0 +1,75 @@
+# Frozen-string-literal: true
+# Copyright: 2015 Jordon Bedwell - Apache v2.0 License
+# Encoding: utf-8
+
+module Docker
+  module Template
+    class Rootfs < Common
+      attr_reader :img
+      def initialize(repo)
+        @repo = repo
+      end
+
+      #
+
+      def rootfs?
+        true
+      end
+
+      #
+
+      def data
+        Template.get(:rootfs, {
+          :rootfs_base_img => @repo.metadata["rootfs_base_img"]
+        })
+      end
+
+      # In a typical situation we do not remove the rootfs img and don't
+      # recommend removing it as it's better cached by Docker, if you wish
+      # to delete it we will.  Now, here we only remove it if we get told
+      # to exit, since we will be in the middle of a build and probably
+      # not have tagged yet, unless we are downstream, we will remove
+      # it so you have no broken images on your system.
+
+      def unlink(img: true)
+        keep = @repo.metadata["keep_rootfs"]
+        @img.delete "force" => true if img && @img && !keep
+        @context.rmtree if @context && @context.directory?
+      rescue Docker::Error::NotFoundError
+        nil
+      end
+
+      #
+
+      private
+      def setup_context
+        @context = @repo.tmpdir("rootfs")
+        @context.join("Dockerfile").write(data)
+        @copy = @context.join(@repo.metadata["copy_dir"])
+        @copy.mkdir
+        copy_rootfs
+      end
+
+      #
+
+      private
+      def copy_rootfs
+        dir = @repo.copy_dir("rootfs")
+        Util::Copy.new(dir, @copy).directory
+      rescue Errno::ENOENT => error_
+        if error_.message !~ /\/(copy|rootfs)\Z/
+          raise error_ else raise Error::NoRootfsCopyDir
+        end
+      end
+
+      #
+
+      private
+      def verify_context
+        unless @copy.join("usr/local/bin/mkimg").file?
+          raise Error::NoRootfsMkimg
+        end
+      end
+    end
+  end
+end