squared 0.3.6 → 0.4.1

data/lib/squared/workspace/project/docker.rb

@@ -0,0 +1,622 @@
+# frozen_string_literal: true
+
+module Squared
+  module Workspace
+    module Project
+      class Docker < Base
+        include Prompt
+
+        COMPOSEFILE = %w[compose.yaml compose.yml docker-compose.yaml compose.yml docker-compose.yml].freeze
+        BAKEFILE = %w[docker-bake.json docker-bake.hcl docker-bake.override.json docker-bake.override.hcl].freeze
+        DIR_DOCKER = (COMPOSEFILE + BAKEFILE).freeze
+        OPT_DOCKER = {
+          common: %w[tls tlsverify config=p c|context=b D|debug H|host=q l|log-level=b tlscacert=p tlscert=p
+                     tlskey=p].freeze,
+          buildx: {
+            common: %w[builder=b D|debug],
+            build: %w[load pull push add-host=q annotation=q attest=q build-arg=qq ent=q iidfile=p label=q a-file=p
+                      network=b no-cache-filter=b o|output=q platform=b q|quiet secret=qq shm-size=b ssh=qq t|tag=b
+                      target=b ulimit=q].freeze,
+            bake: %w[load print pull push list=q metadata-file=p set=q].freeze,
+            shared: %w[check no-cache allow=q call=b? f|file=p progress=b provenance=q sbom=q].freeze
+          }.freeze,
+          compose: {
+            common: %w[all-resources compatibility dry-run ansi|b env-file=p f|file=p parallel=b profile=b progress=b
+                       project-directory=p p|project-name=e].freeze,
+            build: %w[no-cache pull push with-dependencies q|quiet build-arg=qq builder=b m|memory=b ssh=qq].freeze,
+            exec: %w[dry-run privileged d|detach e|env=qq index=i T|no-TTY=b? user=e w|workdir=q].freeze,
+            run: %w[build dry-run no-deps quiet-pull remove-orphans rm P|service-ports use-aliases cap-add=b cap-drop=b
+                    d|detach entrypoint=q e|env=qq i|interactive=b? l|label=q name=b T|no-TTY=b? p|publish=e pull=b
+                    u|user=e v|volume=q w|workdir=q].freeze,
+            up: %w[y abort-on-container-exit abort-on-container-failure always-recreate-deps attach-dependencies build
+                   d|detach dry-run force-recreate menu no-build no-color no-deps no-log-prefix no-recreate no-start
+                   quiet-pull remove-orphans V|renew-anon-volumes timestamps wait w|watch attach=b exit-code-from=b
+                   no-attach=b pull=b scale=i t|timeout=i wait-timeout=i].freeze
+          }.freeze,
+          container: {
+            run: %w[d|detach init i|interactive no-healthcheck oom-kill-disable privileged P|publish-all q|quiet
+                    read-only rm runtime t|tty add-host=q annotation=q a|attach=b blkio-weight-device=i cap-add=b
+                    cap-drop=b cgroup-parent=b cgroupns=b cidfile=p detach-keys=q device=q device-cgroup-rule=q
+                    device-read-bps=q device-read-iops=q device-write-bps=q device-write-iops=q
+                    disable-content-trust=b? dns=e dns-option=e dns-search=e domainname=b entrypoint=q e|env=qq
+                    env-file=p expose=e gpus=q group-add=b health-cmd=q health-interval=b health-retries=i
+                    health-start-interval=b health-start-period=b health-timeout=b h|hostname=e io-maxbandwidth=b
+                    io-maxiops=b ip=b ip6=e ipc=b isolation=b kernel-memory=b l|label=q label-file=p link=b
+                    link-local-ip=b log-driver=b log-opt=q mac-address=e memory-swappiness=b mount=qq name=b network=b
+                    network-alias=b oom-score-adj=b pid=b platform=b p|publish=e pull=b restart=b runtime=b
+                    security-opt=q shm-size=b sig-proxy=b? stop-signal=b stop-timeout=i storage-opt=q sysctl=q tmpfs=q
+                    ulimit=q user=e userns=b uts=b v|volume=q volume-driver=b volumes-from=b w|workdir=q].freeze,
+            exec: %w[d|detach i|interactive privileged t|tty detach-keys=q e|env=qq env-file=p user=e
+                     w|workdir=q].freeze,
+            update: %w[blkio-weight=i cpu-period=i cpu-quota=i cpu-rt-period=i cpu-rt-runtime=i c|cpu-shares=i cpus=f
+                       cpuset-cpus=b cpuset-mems=b m|memory=b memory-reservation=b memory-swap=b pids-limit=b
+                       restart=q].freeze,
+            commit: %w[a|author=q c|change=q m|message=q pause=b?].freeze,
+            inspect: %w[s|size f|format=q].freeze,
+            start: %w[a|attach i|interactive detach-keys=q].freeze,
+            stop: %w[s|signal=b t|time=i].freeze,
+            restart: %w[s|signal=b t|time=i].freeze,
+            kill: %w[s|signal=b].freeze,
+            stats: %w[no-trunc format|q].freeze
+          }.freeze,
+          image: {
+            list: %w[a|all digests no-trunc f|filter=q format=q].freeze,
+            push: %w[a|all-tags disable-content-trust=b? platform=b q|quiet].freeze,
+            rm: %w[f|force no-prune].freeze
+          }.freeze
+        }.freeze
+        VAL_DOCKER = {
+          run: {
+            bind: %w[type source src destination dst target readonly ro bind-propagation].freeze,
+            tmpfs: %w[type destination dst target tmpfs-size tmpfs-mode].freeze
+          }.freeze
+        }.freeze
+        private_constant :COMPOSEFILE, :BAKEFILE, :OPT_DOCKER, :VAL_DOCKER
+
+        class << self
+          def tasks
+            [].freeze
+          end
+
+          def config?(val)
+            return false unless (val = as_path(val))
+
+            val.join('Dockerfile').exist? || DIR_DOCKER.any? { |file| val.join(file).exist? }
+          end
+        end
+
+        @@tasks[ref] = {
+          'build' => %i[tag context bake].freeze,
+          'compose' => %i[build run exec up].freeze,
+          'image' => %i[list rm push].freeze,
+          'container' => %i[run exec update commit inspect diff start stop restart pause unpause top stats kill
+                            rm].freeze
+        }.freeze
+
+        attr_reader :context
+        attr_accessor :tag
+
+        def initialize(*, file: nil, context: nil, tag: nil, secrets: nil, mounts: [], registry: nil, **kwargs)
+          super
+          return unless dockerfile(file).exist?
+
+          @context = context
+          @tag = tag || "#{@project}:latest"
+          @mounts = mounts
+          @secrets = secrets
+          @registry = [registry, kwargs[:username]].compact.join('/')
+          initialize_ref Docker.ref
+          initialize_logger(**kwargs)
+          initialize_env(**kwargs)
+          @output[4] = merge_opts(kwargs[:args], @output[4]) if kwargs[:args]
+        end
+
+        def ref
+          Docker.ref
+        end
+
+        def populate(*, **)
+          super
+          return unless ref?(Docker.ref)
+
+          namespace name do
+            @@tasks[Docker.ref].each do |action, flags|
+              next if @pass.include?(action)
+
+              namespace action do
+                flags.each do |flag|
+                  case action
+                  when 'build'
+                    case flag
+                    when :tag, :context
+                      format_desc(action, flag, 'opts*', before: flag == :tag ? 'name' : 'dir')
+                      task flag, [flag] do |_, args|
+                        param = param_guard(action, flag, args: args, key: flag)
+                        buildx(:build, args.to_a.drop(1), "#{flag}": param)
+                      end
+                    when :bake
+                      format_desc action, flag, 'opts*,target*,context?'
+                      task flag do |_, args|
+                        args = param_guard(action, flag, args: args.to_a)
+                        buildx flag, args
+                      end
+                    end
+                  when 'compose'
+                    case flag
+                    when :build, :up
+                      format_desc action, flag, 'opts*,service*'
+                      task flag do |_, args|
+                        composex flag, args.to_a
+                      end
+                    when :exec, :run
+                      format_desc action, flag, "service,command#{flag == :exec ? '' : '?'},args*,opts*"
+                      task flag, [:service] do |_, args|
+                        service = param_guard(action, flag, args: args, key: :service)
+                        composex(flag, args.to_a.drop(1), service: service)
+                      end
+                    end
+                  when 'container'
+                    case flag
+                    when :exec, :commit
+                      format_desc(action, flag, 'id/name,opts*', after: flag == :exec ? 'args+' : 'tag?')
+                      task flag, [:id] do |_, args|
+                        id = param_guard(action, flag, args: args, key: :id)
+                        container(flag, args.to_a.drop(1), id: id)
+                      end
+                    when :run
+                      format_desc action, flag, 'image,opts*,args*'
+                      task flag, [:image] do |_, args|
+                        image = param_guard(action, flag, args: args, key: :image)
+                        container(flag, args.to_a.drop(1), id: image)
+                      end
+                    else
+                      format_desc(action, flag, 'opts*', after: "id/name#{flag == :update ? '+' : '*'}")
+                      task flag do |_, args|
+                        container flag, args.to_a
+                      end
+                    end
+                  when 'image'
+                    case flag
+                    when :push
+                      format_desc action, flag, 'tag,registry/username?,opts*'
+                      task flag, [:tag] do |_, args|
+                        tag = param_guard(action, flag, args: args, key: :tag)
+                        image(flag, args.to_a.drop(1), id: tag)
+                      end
+                    else
+                      format_desc(action, flag, flag == :rm ? 'id*,opts*' : 'opts*,args*')
+                      task flag do |_, args|
+                        image flag, args.to_a
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def clean(*, sync: invoked_sync?('clean'), **)
+          return super unless @clean.nil?
+
+          image(:rm, sync: sync)
+        end
+
+        def compose(opts, flags = nil, script: false, args: nil, from: :build, **)
+          return opts if script == false
+
+          ret = docker_session
+          if from == :build
+            case (n = filetype)
+            when 1, 2
+              ret << 'buildx' << 'bake'
+              append_file n
+              from = :bake
+            when 3, 4
+              ret << 'compose' << 'build'
+              append_file n
+              from = :compose
+            else
+              ret << 'build'
+            end
+          else
+            ret << from
+          end
+          case opts
+          when String
+            ret << opts
+          when Hash
+            ret.merge(append_hash(opts, build: true))
+          when Enumerable
+            ret.merge(opts.to_a)
+          end
+          [args, flags].each_with_index do |target, index|
+            next unless target
+
+            target = append_any(target, target: []) unless target.is_a?(Array)
+            ret.merge(target.map { |arg| index == 0 ? fill_option(arg) : quote_option('build-arg', arg) })
+          end
+          case from
+          when :build
+            case @secrets
+            when String
+              quote_option('secret', @secrets, double: true)
+            when Hash
+              append = lambda do |type|
+                as_a(@secrets[type]).each { |arg| ret << quote_option('secret', "type=#{type},#{arg}", double: true) }
+              end
+              append.(:file)
+              append.(:env)
+            else
+              as_a(@secrets).each { |arg| ret << quote_option('secret', arg) }
+            end
+            if (val = option('tag', ignore: false))
+              ret << quote_option('tag', val)
+            elsif !session_arg?('t', 'tag')
+              ret << quote_option('tag', tag)
+            end
+            append_context
+          when :bake, :compose
+            if (val = option(from == :bake ? 'target' : 'service', ignore: false))
+              ret.merge(split_escape(val).map { |s| shell_escape(s) })
+            end
+          end
+          ret
+        end
+
+        def buildx(flag, opts = [], tag: nil, context: nil)
+          cmd, opts = docker_session('buildx', opts: opts)
+          opts = option_sanitize(opts, OPT_DOCKER[:buildx][:common]).first
+          cmd << flag
+          out = option_sanitize(opts, OPT_DOCKER[:buildx][flag] + OPT_DOCKER[:buildx][:shared]).first
+          case flag
+          when :build
+            cmd.merge(as_a(tag).map { |val| quote_option('tag', val) })
+            append_context context
+          when :bake
+            unless out.empty?
+              args = out.dup
+              out.clear
+              if Dir.exist?(args.last)
+                if projectpath?(val = args.pop)
+                  context = val
+                else
+                  out << val
+                end
+              end
+              append_value(args, escape: true)
+              contextdir(context) if context
+            end
+          end
+          option_clear out
+          run(from: :"buildx:#{flag}")
+        end
+
+        def composex(flag, opts = [], service: nil)
+          cmd, opts = docker_session('compose', opts: opts)
+          opts = option_sanitize(opts, OPT_DOCKER[:compose][:common]).first
+          append_file filetype unless session_arg?('f', 'file')
+          cmd << flag
+          out = option_sanitize(opts, OPT_DOCKER[:compose][flag] + OPT_DOCKER[:common]).first
+          from = :"compose:#{flag}"
+          case flag
+          when :build, :up
+            append_value(out, escape: true)
+          when :exec, :run
+            append_command(flag, service, out, from: from)
+          end
+          run(from: from)
+        end
+
+        def container(flag, opts = [], id: nil)
+          cmd, opts = docker_session('container', flag, opts: opts)
+          list = OPT_DOCKER[:container].fetch(flag, [])
+          list += OPT_DOCKER[:container][:update] if flag == :run
+          out = option_sanitize(opts, list, first: flag == :exec).first
+          from = :"container:#{flag}"
+          case flag
+          when :run, :exec
+            if flag == :run && !session_arg?('mount')
+              run = VAL_DOCKER[:run]
+              both = run[:bind] + run[:tmpfs]
+              diff = run[:bind].reject { |val| run[:tmpfs].include?(val) }
+              delim = Regexp.new(",\\s*(?=#{both.join('|')})")
+              as_a(@mounts).each do |val|
+                args = []
+                tmpfs = true
+                val.split(delim).each do |opt|
+                  k, v, q = split_option(opt)
+                  next unless both.include?(k)
+
+                  if k == 'type'
+                    tmpfs = false if v == 'bind'
+                    next
+                  elsif diff.include?(k)
+                    tmpfs = false
+                  end
+                  case k
+                  when 'readonly', 'ro'
+                    args << k
+                    next
+                  when 'source', 'src', 'destination', 'dst', 'target'
+                    v = basepath(v)
+                    v = shell_quote(v, option: false, force: false) if q == ''
+                    tmpfs = false if k[0] == 's'
+                  end
+                  args << "#{k}=#{q + v + q}"
+                end
+                cmd << "--mount type=#{tmpfs ? 'tmpfs' : 'bind'},#{args.join(',')}"
+              end
+            end
+            append_command(flag, id.to_s.empty? ? tag : id, out, target: cmd, from: from)
+          when :update
+            raise_error('missing container', hint: from) if out.empty?
+            append_value(out, escape: true)
+          when :commit
+            latest = out.shift || tag
+            cmd << id << latest
+            raise_error("unknown args: #{out.join(', ')}", hint: from) unless out.empty?
+            return unless confirm_command(cmd.to_s, title: from, target: id, as: latest)
+
+            registry = option('registry') || @registry
+            run(from: from, exception: registry.nil? ? exception : true)
+            return unless registry
+
+            opts = []
+            append_option('platform', target: opts, equals: true)
+            case option('disable-content-trust', ignore: false)
+            when 'true', '1'
+              opts << 'disable-content-trust'
+            when 'false', '0'
+              opts << 'disable-content-trust=false'
+            end
+            opts << '--quiet' unless verbose
+            return image(:push, opts, id: latest, registry: registry)
+          else
+            if out.empty?
+              ps = docker_output 'ps', '-a'
+              status = []
+              no = true
+              case flag
+              when :inspect, :diff
+                no = false
+              when :start
+                status = %w[created exited]
+                no = false
+              when :stop, :pause
+                status = %w[running restarting]
+              when :restart
+                status = %w[running paused exited]
+              when :unpause
+                status << 'paused'
+                no = false
+              when :top, :stats
+                status << 'running'
+                cmd << '--no-stream' if flag == :stats
+                no = false
+              when :kill
+                status = %w[running restarting paused]
+              when :rm
+                status = %w[created exited dead]
+              end
+              ps.merge(status.map { |s| "--filter=\"status=#{s}\"" })
+              list_image(flag, ps, no: no, hint: "status: #{status.join(', ')}", from: from) do |id|
+                run(cmd.temp(id), from: from)
+              end
+              return
+            else
+              append_value(out, escape: true)
+            end
+          end
+          run(from: from)
+        end
+
+        def image(flag, opts = [], sync: true, id: nil, registry: nil)
+          cmd, opts = docker_session('image', flag == :exec ? :list : flag, opts: opts)
+          out = option_sanitize(opts, OPT_DOCKER[:image][flag]).first
+          from = :"image:#{flag}"
+          case flag
+          when :list
+            if opts.size == out.size
+              index = 0
+              name = nil
+              opts.each do |opt|
+                if (name = opt[/^name=["']?(.+)["']?$/, 1])
+                  opts.delete(opt)
+                  break
+                end
+              end
+              flag = :run if flag == :list
+              list_image(flag, cmd << '-a', from: from) do |val|
+                container(flag, if name
+                                  opts.dup << "name=#{index == 0 ? name : "#{name}-#{index}"}"
+                                else
+                                  opts
+                                end, id: val)
+                index += 1
+              end
+              return
+            else
+              option_clear out
+            end
+          when :rm
+            if id
+              cmd << id
+            elsif !out.empty?
+              out.each { |val| run(cmd.temp(val), sync: sync, from: from) }
+              return
+            else
+              list_image(flag, docker_output('image', 'ls -a'), from: from) do |val|
+                image(:rm, opts, sync: sync, id: val)
+              end
+              return
+            end
+          when :push
+            id ||= tag
+            registry ||= out.shift || @registry
+            raise_error(id ? "unknown args: #{out.join(', ')}" : 'no id/tag given', hint: from) unless id && out.empty?
+            raise_error('username/registry not provided', hint: from) unless registry
+            registry.chomp!('/')
+            uri = shell_quote("#{registry}/#{id}")
+            cmd << uri
+            img = docker_output 'image', 'tag', id, uri
+            return unless confirm_command(img.to_s, cmd.to_s, target: id, as: registry, title: from)
+
+            run(img, exception: true, sync: false, banner: false)
+          end
+          run(sync: sync, from: from)
+        end
+
+        def build?
+          @output[0] != false && dockerfile.exist?
+        end
+
+        def clean?
+          super || dockerfile.exist?
+        end
+
+        def dockerfile(val = nil)
+          if val == 'Dockerfile'
+            @file = false
+          elsif val
+            @file = if val.is_a?(Array)
+                      val = val.select { |file| basepath(file).exist? }
+                      val.size > 1 ? val : val.first
+                    else
+                      val || DIR_DOCKER.find { |file| basepath(file).exist? }
+                    end
+            @file ||= false
+          end
+          basepath((@file.is_a?(Array) ? @file.first : @file) || 'Dockerfile')
+        end
+
+        private
+
+        def docker_session(*cmd, opts: nil)
+          return session('docker', *cmd) unless opts
+
+          ret = session 'docker'
+          opts = option_sanitize(opts, OPT_DOCKER[:common]).first
+          [ret.merge(cmd), opts]
+        end
+
+        def docker_output(*cmd, **kwargs)
+          session('docker', *cmd, main: false, options: false, **kwargs)
+        end
+
+        def append_command(flag, val, list, target: @session, from: nil)
+          raise_error('no command args', hint: from) if flag == :exec && list.empty?
+          target << val << list.shift
+          target << shell_quote(list.join(' && '), double: true, option: false) unless list.empty?
+        end
+
+        def append_file(type, target: @session)
+          return unless type == 2 || type == 4 || @file.is_a?(Array)
+
+          target.merge(as_a(@file).map { |val| quote_option('file', basepath(val)) })
+        end
+
+        def append_context(ctx = nil, target: @session)
+          if @file.is_a?(String) && !session_arg?('f', 'file') && !bake?(dockerfile) && !compose?(dockerfile)
+            target << quote_option('file', dockerfile)
+          end
+          target << contextdir(ctx || context)
+        end
+
+        def list_image(flag, cmd, hint: nil, from: nil, no: true, &blk)
+          pwd_set do
+            found = false
+            IO.popen(session_done(cmd << '--format=json')).each_with_index do |line, index|
+              data = JSON.parse(line)
+              rt = [data['Repository'], data['Tag']].reject { |val| val == '<none>' }.join(':')
+              rt = nil if tag.empty?
+              aa = if data['Names']
+                     as_a(data['Names']).join(', ')
+                   elsif tag
+                     dd = true
+                     data['Repository']
+                   else
+                     data['ID']
+                   end
+              bb = index.succ.to_s
+              cc = bb.size + 1
+              a = sub_style(data['Image'] || rt || aa, styles: theme[:inline])
+              b = "Execute #{sub_style(flag, styles: theme[:active])} on #{a} (#{data['ID']})"
+              c, d = no ? ['y/N', 'N'] : ['Y/n', 'Y']
+              e = time_format(time_offset(data['CreatedAt']), pass: ['ms'])
+              f = sub_style(ARG[:BORDER][0], styles: theme[:inline])
+              g = ' ' * (cc + 1)
+              h = "#{sub_style(bb.rjust(cc), styles: theme[:current])} #{f} "
+              puts unless index == 0
+              puts "#{h + sub_style(aa, styles: theme[:subject])} (created #{e} ago)"
+              %w[Tag Status Ports Size].each do |key|
+                next if (key == 'Tag' && !dd) || (key == 'Size' && data[key] == '0B')
+
+                puts "#{g + f} #{key}: #{as_a(data[key]).join(', ')}" unless data[key].to_s.empty?
+              end
+              w = 9 + flag.to_s.size + 4 + aa.size
+              puts g + sub_style(ARG[:BORDER][6] + (ARG[:BORDER][1] * w), styles: theme[:inline])
+              found = true
+              next unless confirm("#{h + b}? [#{c}] ", d, timeout: 60)
+
+              puts if @@print_order == 0
+              blk.call data['ID']
+            end
+            puts log_message(Logger::INFO, 'none detected', subject: "#{name}:#{from}", hint: hint) unless found
+          end
+        rescue StandardError => e
+          log.error e
+          ret = on(:error, from, e)
+          raise if exception && ret != true
+
+          warn log_message(Logger::WARN, e, pass: true) if warning?
+        end
+
+        def confirm_command(*args, title: nil, target: nil, as: nil)
+          return false unless title && target
+
+          puts unless @@print_order == 0
+          t = title.to_s.split(':')
+          emphasize(args, title: message(t.first.upcase, *t.drop(1)), border: borderstyle, sub: [
+            { pat: /\A(\w+(?: => \w+)+)(.*)\z/, styles: theme[:header] },
+            { pat: /\A(.+)\z/, styles: theme[:caution] }
+          ])
+          @@print_order += 1
+          a = t.last.capitalize
+          b = sub_style(target, styles: theme[:subject])
+          c = as && sub_style(as, styles: theme[:inline])
+          confirm("#{a} #{b}#{c ? " as #{c}" : ''}? [y/N] ", 'N', timeout: 60)
+        end
+
+        def filetype(val = dockerfile)
+          case File.extname(val)
+          when '.hcl', '.json'
+            bake?(val) ? 1 : 2
+          when '.yml', '.yaml'
+            if compose?(val)
+              path.children.any? { |file| bake?(file) } ? 1 : 3
+            else
+              4
+            end
+          else
+            0
+          end
+        end
+
+        def contextdir(val = nil)
+          val && projectpath?(val) ? shell_quote(basepath(val)) : '.'
+        end
+
+        def compose?(file)
+          COMPOSEFILE.include?(File.basename(file))
+        end
+
+        def bake?(file)
+          BAKEFILE.include?(File.basename(file))
+        end
+      end
+
+      Application.implement Docker
+    end
+  end
+end