docker_core 0.0.16 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbaa902624f73c386b5a294fdcc0a7dffff512dae884b08c8ee0dd6facc6de57
-  data.tar.gz: 1a91928b1a48399cb184fb0dbd69ab9a8df936c30db2edb010c908f8aba29e60
+  metadata.gz: a39a514720435a65fbc3f039eee7c86503e501ab70b821656510b3ba8e8fe941
+  data.tar.gz: 7c95deb803d9b5a095a8cc2a5758e926000065e22aaac2a2420a896ef2be2c81
 SHA512:
-  metadata.gz: f611c33f83c264638550cfd7e6ea965081b280bdf581e96bd195acf3cffec03d3dc7fd95ae1d10caaa6d435a65160e47af62c71dbd4e532ecca066c7e04932a2
-  data.tar.gz: d4f35905d557fa37b672b732cd4e6d7fd76fb7208f22feb4a7fdf1a260cbb55fb77067558735eff67c5c07421b078f0f1ea1a1da2043566a0824a8d6d16e1f95
+  metadata.gz: e0929e952d6d9c3bca9f1d0e5ca3a5f5fa9f193c545bbd0e286361ef7811f54c624db153354664f32e74eef2d20ce36632380a84c343273a05c5e71c435bf968
+  data.tar.gz: 4e8ede2a599f2d820649d667f8b64e14d33227cd25abba7838b16202b1002633f4b363a91c7cf9dd709b99c036ff59210fb4deb76c8818946292a3a853c537fc

data/lib/docker_core.rb

@@ -1,268 +1,387 @@
+require('etc')
 require('fileutils')
 require('json')
 require('net/http')
 require('rubygems/package')
+require('thor')
 require('zlib')
 
 module DockerCore
-  COLOR_CODE = { error: 31, info: 32, warn: 33 }
-  ARCH_SUFFIX = { x86: '386', x86_64: 'amd64', armhf: 'armv6', aarch64: 'arm64' }
-
-  # @param [String] text
-  # @param [Integer] code
-  def self.color(text, code)
-    escape = "\033"
-    prefix = "#{escape}[#{code}m"
-    suffix = "#{escape}[0m"
-    return "#{prefix}#{text}#{suffix}"
-  end
+  USER = 'core'
+  GROUP = 'core'
+
+  class Color < Thor::Shell::Color
+    # @param [String] text
+    # @param [Array<String>] colors
+    def self.echo(text, *colors)
+      if 0 == colors.size
+        return puts(text)
+      end
 
-  # @param [String] text
-  # @param [Integer] code
-  def self.echo(text, code: self::COLOR_CODE[:info])
-    puts(self.color(text, code))
-  end
+      color = colors.map do |color|
+        if color.is_a?(Symbol)
+          next self.const_get(color.to_s.upcase)
+        end
 
-  # @param [String] title
-  # @param [Method] run
-  # @param [Array] argumets
-  def self.execute(title, run, *argumets)
-    code = self::COLOR_CODE[:warn]
-    self.echo("> #{title}", code: code)
-    run.call(*argumets)
-    self.echo("< #{title}", code: code)
-  end
+        next "#{color}"
+      end.join
 
-  # @param [String] command
-  # @param [Boolean] force
-  def self.run(command, force: false)
-    begin
-      self.echo("+ #{command}")
-      print(`#{command}`)
-    rescue
-      raise unless force
+      return puts("#{color}#{text}#{self::CLEAR}")
     end
   end
 
-  # @param [String] command
-  # @param [Boolean] force
-  def self.suexec(command, force: false)
-    command = "su-exec core #{command}"
-    self.run(command, force: force)
+  class Runner < Thor
   end
 
-  # @param [Integer] uid
-  # @param [Integer] gid
-  def self.update_user(uid: 500, gid: 500)
-    uid = ENV.fetch('DOCKER_CORE_UID', uid)
-    gid = ENV.fetch('DOCKER_CORE_GID', gid)
-    self.run('deluser core', force: true)
-    self.run('delgroup core', force: true)
-    self.run("addgroup --system --gid=#{gid} core")
-    self.run("adduser --system --disabled-password --no-create-home --ingroup=core --gecos=core --shell=/bin/bash --uid=#{uid} core")
+  module Image
   end
 
-  # @param [Array<String>] arguments
-  def self.glob(*arguments)
-    return Dir.glob(arguments.flatten, File::FNM_DOTMATCH).map do |item|
-      File.path(item)
-    end.filter do |item|
-      false == %w[. ..].include?(File.basename(item))
-    end.uniq
+  module Command
   end
 
-  # @param [Array<String>] arguments
-  def self.chown(*arguments)
-    self.glob(*arguments).each do |path|
-      FileUtils.chown_R('core', 'core', path, force: true)
+  module Paser
+    # @param [String] text
+    def self.boolean(text)
+      return %w[true yes on].include?("#{text}".strip.downcase)
     end
-  end
 
-  # @param [Array<String>] arguments
-  def self.chmod(mode, *arguments)
-    self.glob(*arguments).each do |path|
-      FileUtils.chmod_R(mode, path, force: true)
+    # @param [String] text
+    def self.kebab(text)
+      return "#{text}".gsub(/_/, '-')
     end
-  end
 
-  # @param [Array<String>] arguments
-  def self.mkdir(*arguments, mode: nil)
-    stack = []
-    paths = arguments.map { |path| File.path(path) }.uniq
+    # @param [Hash] hash
+    def self.options(hash)
+      items = []
+
+      if hash.is_a?(Hash)
+        hash.each do |key, value|
+          name = '--' + self.kebab(key)
+
+          if true == value
+            items << name
+            next
+          end
 
-    paths.each do |path|
-      until path == stack.last
-        stack << path
-        path = File.dirname(path)
+          value = "#{value}".gsub(/\\/, '\&\&').gsub('"', '\"')
+          items << %(#{name}="#{value}")
+          next
+        end
       end
+
+      return items
     end
 
-    stack.uniq.each do |path|
-      if File.exist?(path) && false == File.directory?(path)
-        File.delete(path)
+    # @param [Array] items
+    def self.arguments(*items)
+      list = []
+
+      items.each do |item|
+        if item.is_a?(Array)
+          list.concat(item.map { |value| "#{value}" })
+          next
+        end
+
+        if item.is_a?(Hash)
+          list.concat(self.options(item))
+          next
+        end
+
+        list << "#{item}"
+        next
       end
-    end
 
-    FileUtils.mkdir_p(paths, mode: mode)
+      return list
+    end
   end
 
-  # @param [Array<String>] arguments
-  def self.rm(*arguments)
-    self.glob(*arguments).each do |path|
-      FileUtils.rm_rf(path)
+  module Process
+    # @param [Array] arguments
+    # @param [Boolean] substitute
+    def self.command(*arguments, substitute: false)
+      if substitute
+        arguments.unshift('su-exec', USER)
+      end
+
+      return Paser.arguments(*arguments).join(' ')
     end
-  end
 
-  # @param [String, Array<String>] source
-  # @param [String] target
-  def self.mv(source, target)
-    source = [source].flatten
-    FileUtils.mv(self.glob(*source), target)
-  end
+    # @param [Array] arguments
+    # @param [Boolean] strip
+    # @param [Boolean] verbose
+    # @param [Boolean] substitute
+    def self.capture(*arguments, strip: true, verbose: false, substitute: false)
+      command = self.command(*arguments, substitute: substitute)
 
-  # @param [String] value
-  def self.to_boolean(value)
-    return %w[true yes on].include?("#{value}".strip.downcase)
-  end
+      if verbose
+        Color.echo("+ #{command}", Color::GREEN)
+      end
 
-  # @param [String] stdout
-  # @param [String] stderr
-  def self.link_log(stdout: '', stderr: '')
-    if '' != stdout
-      File.symlink('/dev/stdout', File.path(stdout))
+      data = `#{command}`
+      return strip ? "#{data}".strip : data
     end
 
-    if '' != stderr
-      File.symlink('/dev/stderr', File.path(stderr))
+    # @param [Array] arguments
+    # @param [Boolean] force
+    # @param [Boolean] substitute
+    def self.run(*arguments, force: false, substitute: false)
+      begin
+        data = self.capture(*arguments, strip: false, verbose: true, substitute: substitute)
+        print(data)
+      rescue
+        raise unless force
+      end
     end
-  end
 
-  # @param [Array<String>] arguments
-  def self.clear_path(*arguments, mode: nil)
-    self.rm(*arguments)
-    self.mkdir(*arguments, mode: mode)
-  end
+    # @param [Array] arguments
+    # @param [Boolean] substitute
+    def self.execute(*arguments, substitute: false)
+      command = self.command(*arguments, substitute: substitute)
+      Color.echo("= #{command}", Color::CYAN)
+      exec(command)
+    end
 
-  def self.arch_suffix
-    arch = "#{`apk --print-arch`}".strip
-    return ARCH_SUFFIX.fetch(arch.to_sym, arch)
-  end
+    # @param [String] title
+    # @param [Method] delegate
+    # @param [Array] arguments
+    def self.invoke(title, delegate, *arguments)
+      color = Color::YELLOW
+      Color.echo("> #{title}", color)
+      delegate.call(*arguments)
+      Color.echo("< #{title}", color)
+    end
 
-  # @param [String] repository
-  def self.github_latest_version(repository)
-    uri = URI("https://api.github.com/repos/#{repository}/releases/latest")
-    return JSON.parse(Net::HTTP.get(uri))['tag_name']
   end
 
-  # @param [String] uri
-  # @param [Integer] max_redirect
-  def self.uri_resolve(uri, max_redirect = 10)
-    response = Net::HTTP.get_response(URI.parse(uri))
-
-    if false == response.is_a?(Net::HTTPRedirection)
-      return uri
+  module Shell
+    def self.architecture
+      hash = { x86: '386', x86_64: 'amd64', armhf: 'armv6', armv7l: 'armv7', aarch64: 'arm64' }
+      machine = "#{Etc.uname[:machine]}"
+      return hash.fetch(machine.to_sym, machine)
     end
 
-    max_redirect = max_redirect - 1
-
-    if 0 == max_redirect
-      raise('maximum redirect reached')
+    # @param [Array<String>] arguments
+    # @return [Array<String>]
+    def self.find_paths(*arguments)
+      return Dir.glob(arguments.flatten, File::FNM_DOTMATCH).map do |item|
+        next File.path(item)
+      end.filter do |item|
+        next false == %w[. ..].include?(File.basename(item))
+      end.uniq
     end
 
-    return self.uri_resolve(response['location'], max_redirect)
-  end
+    # @param [Array<String>] arguments
+    # @param [String] user
+    # @param [String] group
+    def self.change_owner(*arguments, user: USER, group: GROUP)
+      self.find_paths(*arguments).each do |path|
+        FileUtils.chown_R(user, group, path, force: true)
+      end
+    end
 
-  # @param [String] uri
-  # @param [String] file
-  def self.download_file(uri, file)
-    uri = self.uri_resolve(uri)
-    content = Net::HTTP.get(URI(uri))
-    return File.binwrite(file, content)
-  end
+    # @param [Array<String>] arguments
+    # @param [String, Integer] mode
+    def self.change_mode(mode, *arguments)
+      self.find_paths(*arguments).each do |path|
+        FileUtils.chmod_R(mode, path, force: true)
+      end
+    end
 
-  # @param [String] path
-  # @param [Boolean] verbose
-  def self.untar(io, path, verbose: false)
-    # @type [Gem::Package::TarReader] reader
-    Gem::Package::TarReader.new(io) do |reader|
-      reader.rewind
-      reader.each do |entry|
-        # @type [Gem::Package::TarHeader] header
-        header = entry.header
-        mode = header.mode
-        file = File.join(path, entry.full_name)
-
-        if verbose
-          self.echo(": #{file}")
+    # @param [Array<String>] arguments
+    # @param [Integer, nil] mode
+    def self.make_folders(*arguments, mode: nil)
+      stack = []
+      paths = arguments.map do |path|
+        next File.path(path)
+      end.uniq
+
+      paths.each do |path|
+        until path == stack.last
+          stack << path
+          path = File.dirname(path)
         end
+      end
 
-        if entry.directory?
-          self.mkdir(file, mode: mode)
-          next
+      stack.uniq.each do |path|
+        if File.exist?(path) && false == File.directory?(path)
+          File.delete(path)
         end
+      end
 
-        if entry.file?
-          self.mkdir(File.dirname(file))
-          File.binwrite(file, entry.read)
-          self.chmod(mode, file)
-          next
-        end
+      FileUtils.mkdir_p(paths, mode: mode)
+    end
+
+    # @param [Array<String>] arguments
+    def self.remove_paths(*arguments)
+      self.find_paths(*arguments).each do |path|
+        FileUtils.rm_rf(path)
       end
     end
-  end
 
-  # @param [String] file
-  # @param [String] path
-  # @param [Boolean] verbose
-  def self.ungzip(file, path, verbose: false)
-    # @type [Zlib::GzipReader] reader
-    Zlib::GzipReader.open(file) do |reader|
-      self.untar(reader, path, verbose: verbose)
+    # @param [String, Array<String>] source
+    # @param [String] target
+    def self.move_paths(source, target)
+      paths = [source].flatten
+      FileUtils.mv(self.find_paths(*paths), target)
     end
-  end
 
-  # @param [String] path
-  # @param [Boolean] verbose
-  def self.tar(path, verbose: false)
-    io = StringIO.new('')
-    offset = path.size + 1
-
-    # @type [Gem::Package::TarWriter] writer
-    Gem::Package::TarWriter.new(io) do |writer|
-      # @type [String] file
-      self.glob(File.join(path, '**/*')).each do |name|
-        mode = File.stat(name).mode
-        file = name.slice(offset ..)
-
-        if verbose
-          self.echo(": #{file}")
-        end
+    # @param [String] uri
+    # @param [Integer] max_redirect
+    def self.resolve_link(uri, max_redirect = 10)
+      response = Net::HTTP.get_response(URI.parse(uri))
 
-        if File.directory?(name)
-          writer.mkdir(file, mode)
-          next
+      if false == response.is_a?(Net::HTTPRedirection)
+        return uri
+      end
+
+      max_redirect = max_redirect - 1
+
+      if 0 == max_redirect
+        raise('maximum redirect reached')
+      end
+
+      return self.resolve_link(response['location'], max_redirect)
+    end
+
+    # @param [String] uri
+    # @param [String] file
+    def self.download_file(uri, file)
+      uri = self.resolve_link(uri)
+      content = Net::HTTP.get(URI(uri))
+      return File.binwrite(file, content)
+    end
+
+    # @param [Object] io
+    # @param [String] path
+    # @param [Boolean] verbose
+    def self.unpack_archive(io, path, verbose: false)
+      Gem::Package::TarReader.new(io) do
+
+        # @type [Gem::Package::TarReader] reader
+      |reader|
+        reader.rewind
+        reader.each do |entry|
+          # @type [Gem::Package::TarHeader] header
+          header = entry.header
+          mode = header.mode
+          file = File.join(path, entry.full_name)
+
+          if verbose
+            Color.echo(": #{file}", Color::GREEN)
+          end
+
+          if entry.directory?
+            self.make_folders(file, mode: mode)
+            next
+          end
+
+          if entry.file?
+            self.make_folders(File.dirname(file))
+            File.binwrite(file, entry.read)
+            self.change_mode(mode, file)
+            next
+          end
         end
+      end
+    end
+
+    # @param [String] file
+    # @param [String] path
+    # @param [Boolean] verbose
+    def self.inflate_file(file, path, verbose: false)
+      Zlib::GzipReader.open(file) do
+
+        # @type [Zlib::GzipReader] reader
+      |reader|
+        self.unpack_archive(reader, path, verbose: verbose)
+      end
+    end
+
+    # @param [String] path
+    # @param [Boolean] verbose
+    def self.tape_archive(path, verbose: false)
+      io = StringIO.new('')
+      offset = path.size + 1
+
+      Gem::Package::TarWriter.new(io) do
 
-        if File.file?(name)
-          writer.add_file(file, mode) do |stream|
-            stream.write(File.binread(name))
+        # @type [Gem::Package::TarWriter] writer
+      |writer|
+        self.find_paths(File.join(path, '**/*')).each do |name|
+          mode = File.stat(name).mode
+          file = name.slice(offset ..)
+
+          if verbose
+            Color.echo(": #{file}", Color::GREEN)
+          end
+
+          if File.directory?(name)
+            writer.mkdir(file, mode)
+            next
+          end
+
+          if File.file?(name)
+            writer.add_file(file, mode) do |stream|
+              stream.write(File.binread(name))
+            end
+            next
           end
-          next
         end
       end
+
+      io.rewind
+      return io.string
     end
 
-    io.rewind
-    return io.string
-  end
+    # @param [String] file
+    # @param [String] path
+    # @param [Boolean] verbose
+    def self.deflate_file(file, path, verbose: false)
+      Zlib::GzipWriter.open(file, Zlib::BEST_COMPRESSION) do
+
+        # @type [Zlib::GzipWriter] writer
+      |writer|
+        writer.write(self.tape_archive(path, verbose: verbose))
+      end
+    end
+
+    # @param [Integer] uid
+    # @param [Integer] gid
+    def self.update_user(uid: 500, gid: 500)
+      uid = ENV.fetch('DOCKER_CORE_UID', uid)
+      gid = ENV.fetch('DOCKER_CORE_GID', gid)
+      Process.run('deluser', USER, force: true)
+      Process.run('delgroup', GROUP, force: true)
+      Process.run('addgroup', { system: true, gid: gid }, GROUP)
+      Process.run('adduser', { system: true, 'disabled-password': true, 'no-create-home': true, ingroup: GROUP, gecos: USER, shell: '/bin/bash', uid: uid }, USER)
+    end
+
+    # @param [String] stdout
+    # @param [String] stderr
+    def self.link_logs(stdout: '', stderr: '')
+      if '' != stdout
+        File.symlink('/dev/stdout', File.path(stdout))
+      end
+
+      if '' != stderr
+        File.symlink('/dev/stderr', File.path(stderr))
+      end
+
+      return
+    end
+
+    # @param [Array<String>] arguments
+    # @param [Integer ,nil] mode
+    def self.clear_folders(*arguments, mode: nil)
+      self.remove_paths(*arguments)
+      self.make_folders(*arguments, mode: mode)
+    end
 
-  # @param [String] file
-  # @param [String] path
-  # @param [Boolean] verbose
-  def self.gzip(file, path, verbose: false)
-    # @type [Zlib::GzipWriter] writer
-    Zlib::GzipWriter.open(file, Zlib::BEST_COMPRESSION) do |writer|
-      writer.write(self.tar(path, verbose: verbose))
+    # @param [String] repository
+    def self.github_latest_version(repository)
+      uri = URI("https://api.github.com/repos/#{repository}/releases/latest")
+      data = JSON.parse(Net::HTTP.get(uri))['tag_name']
+      return "#{data}"
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: docker_core
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.20
 platform: ruby
 authors:
 - agrozyme
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-13 00:00:00.000000000 Z
+date: 2021-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fileutils
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: zlib
   requirement: !ruby/object:Gem::Requirement