swarmkit-client 0.1.0

data/lib/swarmkit-client/api.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'grpc'
+require 'google/protobuf/descriptor_pb'
+
+module Swarmkit
+  module API
+    REVISION = '17b8d222e7dd'
+    PACKAGE = 'docker.swarmkit.v1'
+    POOL = Google::Protobuf::DescriptorPool.new
+    SCHEMA = Google::Protobuf::FileDescriptorSet.decode(File.binread(File.join(__dir__, 'schema.pb')))
+
+    SCHEMA.file.each { |file| POOL.add_serialized_file(file.to_proto) }
+
+    # reason: the pinned descriptors define every type and RPC without duplicated Ruby bindings.
+    def self.define_types(parent, prefix, messages, enums)
+      enums.each do |type|
+        parent.const_set(type.name, POOL.lookup("#{prefix}.#{type.name}").enummodule)
+      end
+      messages.each do |type|
+        next if type.options&.map_entry
+
+        name = "#{prefix}.#{type.name}"
+        klass = parent.const_set(type.name, POOL.lookup(name).msgclass)
+        define_types(klass, name, type.nested_type, type.enum_type)
+      end
+    end
+    private_class_method :define_types
+
+    SCHEMA.file.select { |file| file.package == PACKAGE }.each do |file|
+      define_types(self, PACKAGE, file.message_type, file.enum_type)
+    end
+
+    SERVICES = SCHEMA.file.flat_map(&:service).to_h do |definition|
+      service = const_set(definition.name, Class.new { include GRPC::GenericService })
+      service.service_name = "#{PACKAGE}.#{definition.name}"
+      service.marshal_class_method = :encode
+      service.unmarshal_class_method = :decode
+      POOL.lookup(service.service_name).each do |method|
+        input = method.input_type.msgclass
+        output = method.output_type.msgclass
+        input = service.stream(input) if method.client_streaming
+        output = service.stream(output) if method.server_streaming
+        service.rpc(method.name.to_sym, input, output)
+      end
+      service.const_set(:Stub, service.rpc_stub_class)
+      [GRPC::GenericService.underscore(definition.name).to_sym, service]
+    end.freeze
+    private_constant :SCHEMA
+  end
+end

data/lib/swarmkit-client/cli.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'optparse'
+require_relative '../swarmkit-client'
+
+module Swarmkit
+  class CLI
+    class UsageError < StandardError; end
+
+    SENSITIVE = /auth|password|credential|token|(?:^|_)keys?$|
+                 \A(?:data|payload|env|command|args|labels|options|headers|test|value|message|err)\z/ix
+
+    def initialize(input: $stdin, output: $stdout, error: $stderr)
+      @input = input
+      @output = output
+      @error = error
+    end
+
+    def run(argv)
+      options = {}
+      parser = OptionParser.new do |opts|
+        opts.banner = <<~HELP
+          Usage: swarmkit-client [options] SERVICE METHOD [JSON|@FILE|-]
+                 swarmkit-client methods [SERVICE]
+                 swarmkit-client describe SERVICE METHOD
+          JSON defaults to {}. Client streams take a JSON array; responses use JSON lines.
+          Sensitive fields are redacted. Explicit RPC calls can change cluster state.
+        HELP
+        %i[target ca cert key server_name].each do |name|
+          opts.on("--#{name.to_s.tr('_', '-')} VALUE") { |value| options[name] = value }
+        end
+        opts.on('--timeout SECONDS', Float, 'Deadline duration (default: 10)') { |value| options[:timeout] = value }
+        opts.on('-v', '--version') do
+          @output.puts VERSION
+          return 0
+        end
+        opts.on('-h', '--help') do
+          @output.puts opts
+          return 0
+        end
+      end
+      args = parser.parse(argv)
+      case args.first
+      when nil then @output.puts parser
+      when 'methods' then list_methods(args.drop(1))
+      when 'describe'
+        raise UsageError, 'describe requires SERVICE METHOD' unless args.size == 3
+
+        _, _, method = resolve(*args.drop(1))
+        describe(method)
+      else
+        raise UsageError, 'expected SERVICE METHOD [JSON|@FILE|-]' unless (2..3).cover?(args.size)
+
+        service, name, method = resolve(*args.first(2))
+        request = request(method, args[2] || '{}')
+        call(service, name, method, request, options)
+      end
+      0
+    rescue UsageError, OptionParser::ParseError => e
+      @error.puts "error: #{e.message}"
+      2
+    rescue JSON::ParserError, Google::Protobuf::ParseError, ArgumentError, TypeError
+      @error.puts 'error: invalid JSON request or connection options; use --help and describe SERVICE METHOD'
+      2
+    rescue GRPC::BadStatus => e
+      @error.puts "error: RPC failed (gRPC status #{e.code})"
+      1
+    rescue Errno::EPIPE
+      0
+    rescue SystemCallError, IOError => e
+      @error.puts "error: I/O failed (#{e.class})"
+      1
+    rescue Interrupt
+      130
+    end
+
+    private
+
+    def list_methods(args)
+      raise UsageError, 'methods accepts at most one SERVICE' if args.size > 1
+
+      services = args.empty? ? API::SERVICES : {args.first.to_sym => service(args.first)}
+      services.each do |name, definition|
+        definition.rpc_descs.each_key { |rpc| @output.puts "#{name} #{GRPC::GenericService.underscore(rpc.to_s)}" }
+      end
+    end
+
+    def service(name)
+      API::SERVICES.fetch(name.to_sym) { raise UsageError, "unknown service; use 'methods'" }
+    end
+
+    def resolve(service_name, method_name)
+      method = API::POOL.lookup(service(service_name).service_name).find do |rpc|
+        GRPC::GenericService.underscore(rpc.name) == method_name
+      end
+      raise UsageError, "unknown RPC; use 'methods SERVICE'" unless method
+
+      [service_name, method_name, method]
+    end
+
+    def describe(method)
+      types = {}
+      queue = [method.input_type, method.output_type]
+      until queue.empty?
+        type = queue.shift
+        next if types.key?(type.name)
+
+        types[type.name] = type.to_proto.to_h
+        queue.concat(type.filter_map(&:subtype)) if type.is_a?(Google::Protobuf::Descriptor)
+      end
+      @output.puts JSON.pretty_generate(method: method.to_proto.to_h, types: types)
+    end
+
+    def request(method, source)
+      json = if source == '-'
+               @input.read
+             elsif source.start_with?('@')
+               File.read(source.delete_prefix('@'))
+             else
+               source
+             end
+      type = method.input_type.msgclass
+      return type.decode_json(json) unless method.client_streaming
+
+      items = JSON.parse(json)
+      raise UsageError, 'client-streaming RPCs require a JSON array' unless items.is_a?(Array)
+
+      items.map { |item| type.decode_json(JSON.generate(item)) }.each
+    end
+
+    def call(service, name, method, request, options)
+      Client.open(**options) do |client|
+        operation = client.public_send(service).public_send(name, request, return_op: true)
+        begin
+          response = operation.execute
+          method.server_streaming ? response.each { |message| emit(message) } : emit(response)
+        ensure
+          operation.cancel
+        end
+      end
+    end
+
+    def emit(message)
+      data = JSON.parse(message.class.encode_json(message, preserve_proto_fieldnames: true))
+      @output.puts JSON.generate(redact(data))
+      @output.flush
+    end
+
+    def redact(value)
+      case value
+      when Hash
+        value.to_h { |key, item| [key, key.match?(SENSITIVE) ? '[REDACTED]' : redact(item)] }
+      when Array then value.map { |item| redact(item) }
+      else value
+      end
+    end
+  end
+end

data/lib/swarmkit-client.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'swarmkit-client/api'
+
+module Swarmkit
+  class Client
+    SOCKET = '/var/run/docker/swarm/control.sock'
+    CA = '/var/lib/docker/swarm/certificates/swarm-root-ca.crt'
+
+    def self.open(**)
+      client = new(**)
+      yield client
+    ensure
+      client&.close
+    end
+
+    def initialize(target: "unix:#{SOCKET}", ca: CA, cert: nil, key: nil,
+                   server_name: 'swarm-manager', timeout: 10, channel_args: {})
+      raise ArgumentError, 'cert and key must be supplied together' if cert.nil? != key.nil?
+
+      unless timeout.is_a?(Numeric) && timeout.finite? && timeout.positive?
+        raise ArgumentError,
+              'timeout must be finite and positive'
+      end
+
+      credentials = GRPC::Core::ChannelCredentials.new(
+        File.read(ca), key && File.read(key), cert && File.read(cert)
+      )
+      args = {'grpc.max_receive_message_length' => 16 * 1024 * 1024}.merge(channel_args)
+      if server_name
+        args['grpc.ssl_target_name_override'] = server_name
+        args['grpc.default_authority'] = server_name
+      end
+      @channel = GRPC::Core::Channel.new(target, args, credentials)
+      @stubs = API::SERVICES.transform_values do |service|
+        service::Stub.new(target, credentials, channel_override: @channel, timeout: timeout)
+      end
+    end
+
+    # reason: all 11 services share one channel and the same accessor behavior.
+    API::SERVICES.each_key do |name|
+      define_method(name) { @stubs.fetch(name) }
+    end
+
+    def close
+      @channel.close
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Swarmkit
+  VERSION = '0.1.0'
+end

data/schema/sources.json

@@ -0,0 +1,58 @@
+{
+  "gogoproto/gogo.proto": {
+    "url": "https://raw.githubusercontent.com/gogo/protobuf/v1.3.2/gogoproto/gogo.proto",
+    "sha256": "f2f77edf7de807ded7884813d851656f4ccb18262db717a8f31061995f3e7324"
+  },
+  "github.com/docker/swarmkit/api/types.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/types.proto",
+    "sha256": "f0a9f0dad6a87380feb7ba6715887250d4df64fc74a9ca5b9d7c14775dc81240"
+  },
+  "github.com/docker/swarmkit/api/specs.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/specs.proto",
+    "sha256": "f25c844176ba6874af81b3b182721b96a107129319825ed796ed812208be082d"
+  },
+  "github.com/docker/swarmkit/protobuf/plugin/plugin.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/protobuf/plugin/plugin.proto",
+    "sha256": "e1e65b489db311503b9fdc5e1f984b77660d1b7a3018ae92c0bbb124a86f4021"
+  },
+  "github.com/docker/swarmkit/api/objects.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/objects.proto",
+    "sha256": "dd76a9c58c6af0a4d81dcababd569b344b3926b069fc67a7225e2f85474110e9"
+  },
+  "github.com/docker/swarmkit/api/control.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/control.proto",
+    "sha256": "cd4ba9a8902eb1e468a0a6e718a952844e712d7db5a7f81dcedeaa889586778a"
+  },
+  "github.com/docker/swarmkit/api/watch.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/watch.proto",
+    "sha256": "83eb87a44ca3a9d93977430c32c719422f92ce3a1bc7dd458175c567543752f7"
+  },
+  "github.com/docker/swarmkit/api/logbroker.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/logbroker.proto",
+    "sha256": "8894f2e4f0c97bb082454dfccbf01e0cf26951a1f770aee163d28f64f2da5cd9"
+  },
+  "github.com/docker/swarmkit/api/dispatcher.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/dispatcher.proto",
+    "sha256": "c93c7f3ace11a3c946bd2ddcbe34966932c05e5160b3b91051a8caeb268bc968"
+  },
+  "github.com/docker/swarmkit/api/ca.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/ca.proto",
+    "sha256": "2ea6cf7bcb89d792fe5b4a98c8b1c7364de13cb149aefbb56c820043c2bc3c9d"
+  },
+  "go.etcd.io/raft/v3/raftpb/raft.proto": {
+    "url": "https://raw.githubusercontent.com/etcd-io/raft/v3.6.0/raftpb/raft.proto",
+    "sha256": "312ce6c6ff1dd797e17edfa8dbc7133f965d5fc5423a76e6aaff7b09ba8be19f"
+  },
+  "github.com/docker/swarmkit/api/raft.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/raft.proto",
+    "sha256": "ad575667ea693066de0557cdff76e5bde4daaec35e8041ff4e3c5c5da066e6e4"
+  },
+  "github.com/docker/swarmkit/api/resource.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/resource.proto",
+    "sha256": "c309a506da325a7c5801993d7e6a28a7597a2f4667eec4ee41aea87efd036229"
+  },
+  "github.com/docker/swarmkit/api/health.proto": {
+    "url": "https://raw.githubusercontent.com/moby/swarmkit/17b8d222e7dd/api/health.proto",
+    "sha256": "920a69b4b3296ceb46081982b98cb7b4bd0d79f3c6ccba4536f5320dbae59df8"
+  }
+}

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: swarmkit-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Artyom B
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.36'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.36'
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.85'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.85'
+description: Typed requests, responses and streams for all SwarmKit services over
+  verified TLS.
+executables:
+- swarmkit-client
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- NOTICE
+- README.md
+- bin/swarmkit-client
+- docs/api.md
+- lib/swarmkit-client.rb
+- lib/swarmkit-client/api.rb
+- lib/swarmkit-client/cli.rb
+- lib/swarmkit-client/schema.pb
+- lib/version.rb
+- schema/sources.json
+homepage: https://github.com/artyomb/swarmkit-client
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://github.com/artyomb/swarmkit-client
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Compact Ruby client for the complete SwarmKit gRPC API
+test_files: []