thuban 0.3.0 → 0.4.0

data/lib/thuban/remote/ssh.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+require "timeout"
+require "uri"
+
+module Thuban
+  module Remote
+    class SSHConnection < Connection
+      MAX_COMMAND_ARGUMENTS = 64
+      MAX_COMMAND_ARGUMENT_SIZE = 4096
+      USER_PATTERN = /\A[A-Za-z0-9][A-Za-z0-9._-]{0,63}\z/n
+      HOST_PATTERN = /\A(?:[A-Za-z0-9](?:[A-Za-z0-9.-]{0,251}[A-Za-z0-9])?|\[[0-9A-Fa-f:.]+\])\z/n
+      PATH_PATTERN = /\A[0-9A-Za-z._~+\/:@=-]{1,4096}\z/n
+
+      def initialize(url, credentials: nil, ssh: nil, timeout: 30)
+        raise AuthenticationError, "HTTP credentials cannot be used with SSH remotes" unless credentials.nil?
+
+        @user, @host, @port, @path = parse_ssh_url(url)
+        @ssh_command = parse_ssh_command(ssh)
+        @timeout = Float(timeout)
+        raise ArgumentError, "timeout must be between 0 and 300 seconds" unless @timeout.positive? && @timeout <= 300
+
+        @process_lock = Mutex.new
+        @process = nil
+        @closed = false
+      rescue AuthenticationError
+        raise
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "timeout must be between 0 and 300 seconds" if defined?(@timeout)
+
+        raise TransportError, "invalid SSH remote"
+      end
+
+      def refs
+        ensure_open
+        @refs = with_process("git-upload-pack") do |stdin, stdout|
+          reader = Protocol::Reader.new(stdout, max_bytes: MAX_ADVERTISEMENT_SIZE)
+          first = reader.read
+          @protocol_version = 0
+          result = read_v0_refs(reader, first)
+          stdin.close
+          result
+        end
+      end
+
+      def close
+        process = @process_lock.synchronize do
+          @closed = true
+          @process
+        end
+        cleanup(process)
+        nil
+      end
+
+      private
+
+      def receive_refs
+        return @receive_refs if @receive_refs
+
+        fetch_capabilities = @capabilities
+        begin
+          ensure_open
+          with_process("git-receive-pack") do |stdin, stdout|
+            reader = Protocol::Reader.new(stdout, max_bytes: MAX_ADVERTISEMENT_SIZE)
+            first = reader.read
+            result = read_v0_refs(reader, first)
+            @receive_capabilities = @capabilities
+            stdin.close
+            @receive_refs = result
+          end
+        ensure
+          @capabilities = fetch_capabilities
+        end
+      end
+
+      def request_each(method, suffix, query: nil, headers: {}, body: nil, content_type:, limit:)
+        services = {"/git-upload-pack" => "git-upload-pack", "/git-receive-pack" => "git-receive-pack"}
+        service = services[suffix]
+        raise TransportError, "invalid SSH request" unless method == :post && service && query.nil? && body
+
+        received = 0
+        with_process(service, check_status: true) do |stdin, stdout|
+          discard_advertisement(stdout)
+          stdin.write(body)
+          stdin.close
+          while (chunk = stdout.read(65_536))
+            received += chunk.bytesize
+            raise TransportError, "SSH response exceeds size limit" if received > limit
+
+            yield chunk
+          end
+        end
+        received
+      end
+
+      def discard_advertisement(stdout)
+        reader = Protocol::Reader.new(stdout, max_bytes: MAX_ADVERTISEMENT_SIZE)
+        loop do
+          packet = reader.read
+          return if packet == Protocol::FLUSH
+          raise TransportError, "truncated SSH advertisement" unless packet.is_a?(String)
+        end
+      end
+
+      def with_process(service, check_status: false)
+        process = start_process(service)
+        result = Timeout.timeout(@timeout) do
+          value = yield(process[:stdin], process[:stdout])
+          if check_status
+            status = process[:waiter].value
+            raise TransportError, "SSH transport failed" unless status.success?
+          end
+          value
+        end
+        result
+      rescue Timeout::Error
+        raise TransportError, "SSH transport timed out", cause: nil
+      rescue TransportError
+        raise
+      rescue Errno::ENOENT
+        raise TransportError, "SSH executable not found", cause: nil
+      rescue IOError, SystemCallError
+        raise TransportError, "SSH transport failed", cause: nil
+      ensure
+        @process_lock&.synchronize { @process = nil if @process.equal?(process) }
+        cleanup(process)
+      end
+
+      def start_process(service)
+        ensure_open
+        grouped = !Gem.win_platform?
+        options = grouped ? {pgroup: true} : {}
+        stdin, stdout, stderr, waiter = Open3.popen3(process_environment, *command(service), **options)
+        [stdin, stdout, stderr].each(&:binmode)
+        process = {stdin: stdin, stdout: stdout, stderr: stderr, waiter: waiter, grouped: grouped}
+        process[:errors] = Thread.new { while stderr.read(4096); end rescue nil }
+        @process_lock.synchronize do
+          if @closed
+            cleanup(process)
+            raise TransportError, "connection is closed"
+          end
+          @process = process
+        end
+        process
+      end
+
+      def command(service)
+        destination = @user ? "#{@user}@#{@host}" : @host
+        port = @port ? ["-p", @port.to_s] : []
+        @ssh_command + ["-o", "BatchMode=yes", *port, "--", destination,
+          "#{service} #{Shellwords.escape(@path)}"]
+      end
+
+      def process_environment
+        {"GIT_PROTOCOL" => nil, "GIT_TERMINAL_PROMPT" => "0", "GIT_TRACE" => nil,
+         "GIT_TRACE2" => nil, "GIT_TRACE_PACKET" => nil}
+      end
+
+      def safe_message(_data) = "remote reported an error"
+
+      def cleanup(process)
+        return unless process
+
+        [process[:stdin], process[:stdout], process[:stderr]].each { |io| io.close unless io.closed? }
+        terminate(process[:waiter], process[:grouped]) if process[:waiter].alive? && !process[:waiter].join(0.2)
+        process[:errors]&.join
+      rescue IOError, Errno::ECHILD
+        nil
+      end
+
+      def terminate(waiter, grouped)
+        unless grouped
+          Process.kill("KILL", waiter.pid)
+          waiter.join
+          return
+        end
+
+        target = -waiter.pid
+        Process.kill("TERM", target)
+        return if waiter.join(0.2)
+
+        Process.kill("KILL", target)
+        waiter.join
+      rescue Errno::EPERM
+        begin
+          Process.kill("TERM", waiter.pid)
+          Process.kill("KILL", waiter.pid) unless waiter.join(0.2)
+          waiter.join
+        rescue SystemCallError
+          nil
+        end
+      rescue SystemCallError
+        nil
+      end
+
+      def parse_ssh_url(url)
+        raise TypeError unless url.is_a?(String) && url.bytesize <= 8192
+
+        target = url.match?(/\Assh:\/\//i) ? parse_uri(url) : parse_scp(url)
+        user, host, port, path = target
+        raise ArgumentError unless (!user || USER_PATTERN.match?(user)) && HOST_PATTERN.match?(host) &&
+          (!port || (1..65_535).cover?(port)) && PATH_PATTERN.match?(path) && !path.start_with?("-")
+
+        target
+      end
+
+      def parse_uri(url)
+        uri = URI.parse(url)
+        raise AuthenticationError, "passwords in SSH remote URLs are not supported" if uri.password
+        raise ArgumentError unless uri.scheme == "ssh" && uri.host && !uri.host.empty? &&
+          uri.path && !uri.path.empty? && !uri.query && !uri.fragment
+
+        [decode(uri.user), uri.host, uri.port, decode(uri.path)]
+      end
+
+      def parse_scp(url)
+        match = /\A(?:(?<user>[A-Za-z0-9][A-Za-z0-9._-]{0,63})@)?(?<host>\[[0-9A-Fa-f:.]+\]|[^:]+):(?<path>.+)\z/n.match(url)
+        raise ArgumentError unless match
+
+        [match[:user], match[:host], nil, match[:path]]
+      end
+
+      def decode(value)
+        value && URI::RFC2396_PARSER.unescape(value)
+      end
+
+      def parse_ssh_command(value)
+        value = ENV["GIT_SSH_COMMAND"] if value.nil? && !ENV["GIT_SSH_COMMAND"].to_s.empty?
+        arguments = case value
+        when nil then ["ssh"]
+        when String then Shellwords.split(value)
+        when Array then value.dup
+        else raise TypeError
+        end
+        valid = arguments.length.between?(1, MAX_COMMAND_ARGUMENTS) && arguments.all? do |argument|
+          argument.is_a?(String) && !argument.empty? && argument.bytesize <= MAX_COMMAND_ARGUMENT_SIZE &&
+            !argument.match?(/[\0\r\n]/)
+        end
+        raise ArgumentError unless valid
+
+        arguments.map! { |argument| argument.dup.freeze }
+        arguments.freeze
+      end
+    end
+  end
+end

data/lib/thuban/remote.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Thuban
+  class Error < StandardError; end
+  class TransportError < Error; end
+  class AuthenticationError < TransportError; end
+
+  Ref = Struct.new(:name, :oid, :symref_target, :peeled, keyword_init: true)
+  Progress = Struct.new(:phase, :current, :total, :bytes, keyword_init: true)
+
+  module Remote
+    def self.open(url, credentials: nil, ssh: nil, timeout: 30)
+      local_drive = url.is_a?(String) && url.match?(/\A[A-Za-z]:[\\\/]/)
+      local_path = local_drive || (url.is_a?(String) && url.start_with?("/", "./", "../", "~"))
+      if url.is_a?(String) && (url.match?(/\Assh:\/\//i) || (!local_path && !url.include?("://") && url.include?(":")))
+        return SSHConnection.new(url, credentials: credentials, ssh: ssh, timeout: timeout)
+      end
+      raise ArgumentError, "ssh configuration requires an SSH remote" if ssh
+
+      if url.is_a?(String) && !url.match?(/\Ahttps?:\/\//i)
+        return LocalConnection.new(url, credentials: credentials, timeout: timeout)
+      end
+
+      Connection.new(url, credentials: credentials, timeout: timeout)
+    end
+  end
+end

data/lib/thuban/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Thuban
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/thuban.rb

@@ -25,3 +25,13 @@ require_relative "thuban/commit_writer"
 require_relative "thuban/history_writer"
 require_relative "thuban/stash"
 require_relative "thuban/pack_writer"
+require_relative "thuban/pack_reader"
+require_relative "thuban/remote"
+require_relative "thuban/remote/credentials"
+require_relative "thuban/remote/protocol"
+require_relative "thuban/remote/http"
+require_relative "thuban/remote/fetch"
+require_relative "thuban/remote/push"
+require_relative "thuban/remote/ssh"
+require_relative "thuban/remote/local"
+require_relative "thuban/remote/repository"

data/sig/thuban.rbs

@@ -1,6 +1,7 @@
 module Thuban
   VERSION: String
   type object = [String, String]
+  type push_update = [String, String?, String]
 
   interface _Differ
     def edits: (Porrima::lines, Porrima::lines) -> Array[Porrima::Edit]
@@ -10,12 +11,72 @@ module Thuban
     def write: (String) -> Integer
   end
 
+  interface _PackInput
+    def read: (Integer) -> String?
+  end
+
   class CorruptObject < StandardError
   end
 
   class RefLockError < StandardError
   end
 
+  class Error < StandardError
+  end
+
+  class TransportError < Error
+  end
+
+  class AuthenticationError < TransportError
+  end
+
+  class Ref < Struct[untyped]
+    attr_accessor name: String
+    attr_accessor oid: String?
+    attr_accessor symref_target: String?
+    attr_accessor peeled: String?
+    def self.new: (name: String, oid: String?, ?symref_target: String?, ?peeled: String?) -> instance
+  end
+
+  class Progress < Struct[untyped]
+    attr_accessor phase: Symbol
+    attr_accessor current: Integer?
+    attr_accessor total: Integer?
+    attr_accessor bytes: Integer?
+    def self.new: (phase: Symbol, ?current: Integer?, ?total: Integer?, ?bytes: Integer?) -> instance
+  end
+
+  module Remote
+    type ssh_command = String | Array[String]
+    def self.open: (String url, ?credentials: untyped, ?ssh: ssh_command?, ?timeout: Numeric) -> Connection
+
+    module Credentials
+      MAX_HELPER_OUTPUT: Integer
+      def self.static: (username: String, password: String) -> untyped
+      def self.bearer: (token: String) -> untyped
+      def self.helper: (?String? name) -> untyped
+      def self.callback: () { (String) -> untyped } -> untyped
+    end
+
+    class Connection
+      def initialize: (String url, ?credentials: untyped, ?timeout: Numeric) -> void
+      def refs: () -> Array[Ref]
+      def fetch: (Repository repository, wants: Enumerable[String], ?haves: Enumerable[String], ?depth: Integer?, ?filter: String?) ?{ (Progress) -> void } -> Array[String]
+      def push: (Repository repository, Enumerable[push_update] updates, ?atomic: bool) ?{ (Progress) -> void } -> Array[Ref]
+      def close: () -> nil
+    end
+
+    class SSHConnection < Connection
+      MAX_COMMAND_ARGUMENTS: Integer
+      MAX_COMMAND_ARGUMENT_SIZE: Integer
+      def initialize: (String url, ?credentials: untyped, ?ssh: ssh_command?, ?timeout: Numeric) -> void
+    end
+
+    class LocalConnection < SSHConnection
+      def initialize: (String url, ?credentials: untyped, ?timeout: Numeric) -> void
+    end
+  end
+
   class Commit < Struct[untyped]
     attr_accessor oid: String
     attr_accessor tree: String?
@@ -96,6 +157,9 @@ module Thuban
     def stash_push: (?message: String?, ?include_untracked: bool) -> String?
     def stash_pop: (?Integer index) -> String
     def stash_list: () -> Array[Commit]
+    def remotes: () -> Hash[String, String]
+    def fetch: (?String remote, ?refspecs: String | Enumerable[String]?, ?depth: Integer?, ?filter: String?) ?{ (Progress) -> void } -> Array[Ref]
+    def push: (?String remote, refspecs: String | Enumerable[String], ?force: bool, ?lease: String | Hash[String, String]?, ?atomic: bool) ?{ (Progress) -> void } -> Array[Ref]
   end
 
   class ObjectDatabase
@@ -128,6 +192,7 @@ module Thuban
     def read: (String oid) ?{ (String) -> object } -> object
     def self.apply_delta: (String base, String delta) -> String
     def self.write: (_PackOutput io, Enumerable[object] objects) ?{ (Integer current, Integer total) -> void } -> String
+    def self.read_stream: (_PackInput io, ObjectDatabase odb) ?{ (Integer current, Integer total) -> void } -> Array[String]
   end
 
   class Index

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thuban
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
 email:
 - t.yudai92@gmail.com
 executables: []
@@ -44,9 +44,19 @@ files:
 - lib/thuban/object_database.rb
 - lib/thuban/object_writer.rb
 - lib/thuban/pack.rb
+- lib/thuban/pack_reader.rb
 - lib/thuban/pack_writer.rb
 - lib/thuban/ref_lock_error.rb
 - lib/thuban/ref_store.rb
+- lib/thuban/remote.rb
+- lib/thuban/remote/credentials.rb
+- lib/thuban/remote/fetch.rb
+- lib/thuban/remote/http.rb
+- lib/thuban/remote/local.rb
+- lib/thuban/remote/protocol.rb
+- lib/thuban/remote/push.rb
+- lib/thuban/remote/repository.rb
+- lib/thuban/remote/ssh.rb
 - lib/thuban/repository.rb
 - lib/thuban/signature.rb
 - lib/thuban/stash.rb
@@ -79,5 +89,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A pure Ruby implementation for local Git repositories
+summary: A pure Ruby Git implementation for local repositories and remote transfers
 test_files: []