kamaze-docker_image 0.0.5

data/lib/kamaze/docker_image/loader/tasks.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative 'helper'
+
+# @type [Kamaze::DockerImage::Loader::Context] self
+self.singleton_class.__send__(:define_method, :helper) do
+  Kamaze::DockerImage::Loader::Helper.new(image)
+end
+
+# tasks --------------------------------------------------------------
+
+Pathname.new(__dir__).join('tasks').tap do |path|
+  Dir.glob(path.join('*.rb')).map { |fp| Pathname.new(fp) }.each do |file|
+    self.instance_eval(file.read, file.to_s, 1)
+  end
+end

data/lib/kamaze/docker_image/loader/tasks/build.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# @type [Kamaze::DockerImage::Loader::Helper] helper
+
+if image.available_commands.include?(:build)
+  desc 'Build image'
+
+  task helper.appoint(:build), [:cached] do |task, args|
+    autoload(:YAML, 'yaml')
+
+    YAML.safe_load(args.key?(:cached) ? args[:cached] : 'true').tap do |cached|
+      helper.call(task, args) { cached ? image.build : image.rebuild }
+    end
+
+    task.reenable
+  end
+end

data/lib/kamaze/docker_image/loader/tasks/exec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# @type [Kamaze::DockerImage::Loader::Helper] helper
+
+if image.available_commands.include?(:exec)
+  desc 'Run a command in a running container'
+
+  task helper.appoint(:exec), [:command] do |task, args|
+    helper.call(task, args) { image.exec(args[:command]) }
+
+    task.reenable
+  end
+end

data/lib/kamaze/docker_image/loader/tasks/push.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# @type [Kamaze::DockerImage::Loader::Helper] helper
+
+if image.available_commands.include?(:push)
+  desc 'Push image'
+
+  task helper.appoint(:push) do |task|
+    helper.call(task) { image.push }
+
+    task.reenable
+  end
+end

data/lib/kamaze/docker_image/loader/tasks/restart.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# @type [Kamaze::DockerImage::Loader::Helper] helper
+
+%i[start stop].map { |v| image.available_commands.include?(v) }.uniq.tap do |v|
+  if v == [true]
+    desc 'Restart container'
+
+    task helper.appoint(:restart) do |task|
+      helper.call(task) { image.restart }
+
+      task.reenable
+    end
+  end
+end

data/lib/kamaze/docker_image/loader/tasks/run.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# @type [Kamaze::DockerImage::Loader::Helper] helper
+
+if image.available_commands.include?(:run)
+  desc 'Run a command in a new container'
+
+  task helper.appoint(:run), [:command] do |task, args|
+    helper.call(task, args) { image.run(args[:command]) }
+
+    task.reenable
+  end
+end

data/lib/kamaze/docker_image/loader/tasks/ssh.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# @type [Kamaze::DockerImage::Loader::Helper] helper
+
+if image.ssh.enabled?
+  desc 'Connect to container using Secure Shell (SSH)'
+
+  task helper.appoint(:ssh), [:command] do |task, args|
+    helper.call(task) { image.ssh.call(args[:command]) }
+
+    task.reenable
+  end
+end

data/lib/kamaze/docker_image/loader/tasks/start.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# @type [Kamaze::DockerImage::Loader::Helper] helper
+
+if image.available_commands.include?(:start)
+  desc 'Start container as %<run_as>s' % { run_as: image.run_as }
+
+  task helper.appoint(:start) do |task|
+    helper.call(task) { image.start }
+
+    task.reenable
+  end
+end

data/lib/kamaze/docker_image/loader/tasks/stop.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# @type [Kamaze::DockerImage::Loader::Helper] helper
+
+if image.available_commands.include?(:stop)
+  desc 'Stop container'
+
+  task helper.appoint(:stop) do |task|
+    helper.call(task) { image.stop }
+
+    task.reenable
+  end
+end

data/lib/kamaze/docker_image/runner.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../docker_image'
+
+# Runner provide methods to execute image related actions
+#
+# @see #actions
+# @see Kamaze::DockerImage::Concern::Setup#default_commands
+class Kamaze::DockerImage::Runner
+  include Kamaze::DockerImage::Concern::Containers
+
+  # noinspection RubyConstantNamingConvention
+  Command = Kamaze::DockerImage::Command
+
+  # Available actions
+  #
+  # Actions registrable on ``image``.
+  # @see Runner#actions
+  ACTIONS = %i[restart start stop exec run build push rm rebuild].sort
+
+  autoload :Storage, "#{__dir__}/runner/storage"
+
+  # @param [Kamaze::DockerImage] image
+  #
+  # @see Kamaze::DockerImage::Concern::Setup#default_commands
+  def initialize(image)
+    @config = image.to_h.reject! { |k| k == :commands }.freeze
+    @commands = Storage[image.commands].tap do |store|
+      store.config = @config
+    end
+
+    @commands.freeze
+  end
+
+  # Build image
+  def build(&block)
+    command(:build).run(&block)
+  end
+
+  # Push image
+  def push(&block)
+    command(:push).run(&block)
+  end
+
+  # Build image (do not use cache)
+  def rebuild(&block)
+    command(:rebuild).run(&block)
+  end
+
+  def run(extra = nil, &block)
+    command(:run, extra).run(&block)
+  end
+
+  def exec(extra = nil, &block)
+    default = config.fetch(:exec_command)
+    extra ||= default
+
+    command(:exec, extra).run(&block)
+  end
+
+  def start(&block)
+    command(:start).run(&block) unless running?
+  end
+
+  def stop(&block)
+    command(:stop).run(&block) if started?
+  end
+
+  def rm(&block)
+    command(:rm).run(&block) if started?
+  end
+
+  def restart(&block)
+    stop(&block)
+    rm(&block)
+    start(&block)
+  end
+
+  # @return [Array<Symbol>]
+  def actions
+    ACTIONS
+  end
+
+  # Denote container is started.
+  #
+  # @return [Boolean]
+  def started?
+    # !fetch_containers(config.fetch(:run_as)).empty?
+    config.fetch(:run_as).yield_self { |name| !containers[name].nil? }
+  end
+
+  # Denote container is running.
+  #
+  # @return [Boolean]
+  def running?
+    # !fetch_containers(config.fetch(:run_as), :running).empty?
+    config.fetch(:run_as).yield_self { |name| containers[name]&.running? }
+  end
+
+  protected
+
+  # @return [Hash]
+  attr_reader :config
+
+  # Get commands
+  #
+  # @return [Hash]
+  attr_reader :commands
+
+  # Generate command.
+  #
+  # @param [String|Symbol] name
+  # @param [String|nil] extra
+  # @return [Command]
+  def command(name, extra = nil)
+    command = commands.fetch(name.to_sym)
+
+    Command.new(command, config, extra)
+  end
+end

data/lib/kamaze/docker_image/runner/storage.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../runner'
+
+# Store commands to be executed.
+#
+# Command is shaped (formatted) on retrieval, using ``config``.
+#
+# @see #shape
+# @see #config=
+class Kamaze::DockerImage::Runner::Storage < Hash
+  include(Kamaze::DockerImage::Concern::Executable)
+
+  # @param [Hash] config
+  def config=(config)
+    @config = config.clone.freeze
+  end
+
+  # @return [Hash]
+  def config
+    @config.to_h
+  end
+
+  # Retrieves the value object corresponding to the key object.
+  #
+  # @return [Array<String>]
+  def [](key)
+    self.fetch(key)
+  rescue KeyError
+    super
+  end
+
+  # Returns a value from the hash for the given key.
+  #
+  # @raise [KeyError]
+  # @return [Array<String>]
+  def fetch(key)
+    key = key.to_sym
+    val = super
+
+    val ? shape(val) : val
+  end
+
+  protected
+
+  # Get executable
+  #
+  # @raise [Cliver::Dependency::NotFound]
+  # @return [String]
+  def executable
+    config[:docker_bin] || super
+  end
+
+  # Format given command
+  #
+  # @param [Array] command
+  # @return [Array<String>]
+  def shape(command)
+    # rubocop:disable Style/TernaryParentheses
+    h = {
+      opt_it: ($stdout.tty? and $stderr.tty?) ? '-it' : nil,
+    }
+    # rubocop:enable Style/TernaryParentheses
+
+    [executable]
+      .push(*command)
+      .map(&:to_s)
+      .map { |w| w % config.merge(h) }
+      .map { |w| w.to_s.empty? ? nil : w }
+      .compact
+  end
+end

data/lib/kamaze/docker_image/ssh.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2021 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../docker_image'
+autoload :YAML, 'yaml'
+autoload :Pathname, 'pathname'
+autoload :Shellwords, 'shellwords'
+autoload :Timeout, 'timeout'
+autoload :Cliver, 'cliver'
+
+# Runner provide methods to connect into image using ssh.
+#
+# Sample of use:
+#
+# ```ruby
+# require 'kamaze/docker_image'
+#
+# ssh = Kamaze::DockerImage::SSH.new(run_as: 'kamaze_sample_image')
+# ```
+class Kamaze::DockerImage::SSH < Hash
+  include Kamaze::DockerImage::Concern::Containers
+
+  # noinspection RubyConstantNamingConvention
+  Command = Kamaze::DockerImage::Command
+
+  # @return [Hash]
+  attr_reader :config
+
+  # @param [Kamaze::DockerImage] image
+  #
+  # @see Kamaze::DockerImage::Concern::Setup#default_commands
+  def initialize(image)
+    defaults.merge(image.to_h[:ssh].to_h).tap do |ssh|
+      @config = image.to_h.merge(ssh: ssh).freeze
+    end.each { |k, v| self[k] = v }
+  end
+
+  # Connect to ssh (executing optional command ``cmd``).
+  #
+  # @param [Array<String|Object>] cmd
+  # @raise [Errno::ENONET]
+  #
+  # @see #command
+  def call(cmd = nil, &block)
+    network? ? wait : (raise Errno::ENONET)
+  rescue Timeout::Error
+    nil
+  ensure
+    command(cmd).run(&block)
+  end
+
+  # Wait until ssh is available.
+  #
+  # @return [self]
+  def wait
+    Timeout.timeout(config.fetch(:ssh).fetch(:timeout)) do
+      loop do
+        command(config.fetch(:ssh).fetch(:test)).tap do |command|
+          if command.execute
+            return block_given? ? yield(self) : self
+          end
+
+          sleep(0.5)
+        end
+      end
+    end
+  end
+
+  # Get defaults for config.
+  #
+  # @return [Hash{Symbol => Object}]
+  def defaults
+    YAML.safe_load(Pathname.new(__dir__).join('ssh.yml').read, [Symbol])
+  end
+
+  # @return [Command]
+  def command(cmd = nil)
+    cmd = Shellwords.split(cmd) if cmd.is_a?(String)
+
+    config.fetch(:ssh).fetch(:command)
+          .map { |w| w % params }
+          .push(*cmd.to_a)
+          .tap { |command| return Command.new(command, config) }
+  end
+
+  # Params used to shape command.
+  #
+  # @return [Hash{Symbol => Object}]
+  def params
+    # rubocop:disable Style/TernaryParentheses
+    {
+      executable: executable,
+      port: config.fetch(:ssh).fetch(:port),
+      user: config.fetch(:ssh).fetch(:user),
+      host: network.fetch(0),
+      opt_pty: ($stdout.tty? and $stderr.tty?) ? '-t' : '-T',
+    }
+    # rubocop:enable Style/TernaryParentheses
+  end
+
+  # Get absolute path for executable.
+  #
+  # @return [String|Object]
+  def executable
+    config.fetch(:ssh).fetch(:executable).tap do |executable|
+      Cliver.detect(executable).tap do |s|
+        return (s || executable).freeze
+      end
+    end
+  end
+
+  # Denote SSH is enabled.
+  #
+  # @return [Boolean]
+  def enabled?
+    config.fetch(:ssh)[:enabled]
+  end
+
+  # Get ip addresses.
+  #
+  # @return [Array<String>]
+  def network
+    # container = fetch_containers(config.fetch(:run_as), [:running])[0]
+    containers[config.fetch(:run_as)].yield_self do |container|
+      return [] if container.nil?
+      return [] unless container.running?
+
+      container.info
+               .fetch('NetworkSettings').fetch('Networks')
+               .values.keep_if { |v| v.to_h['IPAddress'] }.map { |v| v['IPAddress'] }.compact
+    end
+  end
+
+  # @return [Boolean]
+  def network?
+    !network.empty?
+  end
+end