socketry 0.5.0 → 0.6.0

data/lib/socketry/tcp/socket.rb

@@ -1,345 +0,0 @@
-# frozen_string_literal: true
-
-module Socketry
-  # Transmission Control Protocol
-  module TCP
-    # Transmission Control Protocol sockets: Provide stream-like semantics
-    class Socket
-      include Socketry::Timeout
-
-      attr_reader :addr_fmaily, :remote_addr, :remote_port, :local_addr, :local_port
-      attr_reader :read_timeout, :write_timeout, :resolver, :socket_class
-
-      # Create a Socketry::TCP::Socket with the default options, then connect
-      # to the given host.
-      #
-      # @param remote_addr [String] DNS name or IP address of the host to connect to
-      # @param remote_port [Fixnum] TCP port to connect to
-      #
-      # @return [Socketry::TCP::Socket]
-      def self.connect(remote_addr, remote_port, **args)
-        new.connect(remote_addr, remote_port, **args)
-      end
-
-      # Create an unconnected Socketry::TCP::Socket
-      #
-      # @param read_timeout  [Numeric] Seconds to wait before an uncompleted read errors
-      # @param write_timeout [Numeric] Seconds to wait before an uncompleted write errors
-      # @param timer         [Object]  A timekeeping object to use for measuring timeouts
-      # @param resolver      [Object]  A resolver object to use for resolving DNS names
-      # @param socket_class  [Object]  Underlying socket class which implements I/O ops
-      #
-      # @return [Socketry::TCP::Socket]
-      def initialize(
-        read_timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:read],
-        write_timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:write],
-        timer: Socketry::Timeout::DEFAULT_TIMER.new,
-        resolver: Socketry::Resolver::DEFAULT_RESOLVER,
-        socket_class: ::Socket
-      )
-        @read_timeout = read_timeout
-        @write_timeout = write_timeout
-
-        @socket_class = socket_class
-        @resolver = resolver
-
-        @addr_family = nil
-        @socket = nil
-
-        @remote_addr = nil
-        @remote_port = nil
-        @local_addr  = nil
-        @local_port  = nil
-
-        start_timer(timer)
-      end
-
-      # Connect to a remote host
-      #
-      # @param remote_addr  [String]  DNS name or IP address of the host to connect to
-      # @param remote_port  [Fixnum]  TCP port to connect to
-      # @param local_addr   [String]  DNS name or IP address to bind to locally
-      # @param local_port   [Fixnum]  Local TCP port to bind to
-      # @param timeout      [Numeric] Number of seconds to wait before aborting connect
-      #
-      # @raise [Socketry::AddressError] an invalid address was given
-      # @raise [Socketry::TimeoutError] connect operation timed out
-      #
-      # @return [self]
-      def connect(
-        remote_addr,
-        remote_port,
-        local_addr: nil,
-        local_port: nil,
-        timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:connect]
-      )
-        ensure_disconnected
-
-        @remote_addr = remote_addr
-        @remote_port = remote_port
-        @local_addr  = local_addr
-        @local_port  = local_port
-
-        begin
-          set_timeout(timeout)
-
-          remote_addr = @resolver.resolve(remote_addr, timeout: time_remaining(timeout))
-          local_addr  = @resolver.resolve(local_addr,  timeout: time_remaining(timeout)) if local_addr
-          raise ArgumentError, "expected IPAddr from resolver, got #{remote_addr.class}" unless remote_addr.is_a?(IPAddr)
-
-          @addr_family = if remote_addr.ipv4?    then ::Socket::AF_INET
-                         elsif remote_addr.ipv6? then ::Socket::AF_INET6
-                         else raise Socketry::AddressError, "unsupported IP address family: #{remote_addr}"
-                         end
-
-          socket = @socket_class.new(@addr_family, ::Socket::SOCK_STREAM, 0)
-          socket.bind Addrinfo.tcp(local_addr.to_s, local_port) if local_addr
-          remote_sockaddr = ::Socket.sockaddr_in(remote_port, remote_addr.to_s)
-
-          # Note: `exception: false` for Socket#connect_nonblock is only supported in Ruby 2.3+
-          begin
-            socket.connect_nonblock(remote_sockaddr)
-          rescue Errno::ECONNREFUSED => ex
-            raise Socketry::ConnectionRefusedError, "connection to #{remote_addr}:#{remote_port} refused", ex.backtrace
-          rescue Errno::EINPROGRESS, Errno::EALREADY
-            # Earlier JRuby 9.x versions do not seem to correctly support Socket#wait_writable in this case
-            # Newer versions seem to behave correctly
-            retry if IO.select(nil, [socket], nil, time_remaining(timeout))
-
-            socket.close
-            raise Socketry::TimeoutError, "connection to #{remote_addr}:#{remote_port} timed out"
-          rescue Errno::EISCONN
-            # Sometimes raised when we've connected successfully
-          end
-
-          @socket = socket
-        ensure
-          clear_timeout(timeout)
-        end
-
-        self
-      end
-
-      # Re-establish a lost TCP connection
-      #
-      # @param timeout [Numeric] Number of seconds to wait before aborting re-connect
-      # @raise [Socketry::StateError] not in a disconnected state
-      def reconnect(timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:connect])
-        ensure_disconnected
-        raise StateError, "can't reconnect: never completed initial connection" unless @remote_addr
-        connect(@remote_addr, @remote_port, local_addr: @local_addr, local_port: @local_port, timeout: timeout)
-      end
-
-      # Wrap a Ruby/low-level socket in an Socketry::TCP::Socket
-      #
-      # @param socket [::Socket] (or specified socket_class) low-level socket to wrap
-      def from_socket(socket)
-        ensure_disconnected
-        raise TypeError, "expected #{@socket_class}, got #{socket.class}" unless socket.is_a?(@socket_class)
-        @socket = socket
-        self
-      end
-
-      # Perform a non-blocking read operation
-      #
-      # @param size [Fixnum] number of bytes to attempt to read
-      # @param outbuf [String, NilClass] an optional buffer into which data should be read
-      #
-      # @raise [Socketry::Error] an I/O operation failed
-      #
-      # @return [String, :wait_readable] data read, or :wait_readable if operation would block
-      def read_nonblock(size, outbuf: nil)
-        ensure_connected
-        case outbuf
-        when String
-          @socket.read_nonblock(size, outbuf, exception: false)
-        when NilClass
-          @socket.read_nonblock(size, exception: false)
-        else raise TypeError, "unexpected outbuf class: #{outbuf.class}"
-        end
-      rescue IO::WaitReadable
-        # Some buggy Rubies continue to raise this exception
-        :wait_readable
-      rescue IOError => ex
-        raise Socketry::Error, ex.message, ex.backtrace
-      end
-
-      # Read a partial amounth of data, blocking until it becomes available
-      #
-      # @param size [Fixnum] number of bytes to attempt to read
-      # @param outbuf [String] an output buffer to read data into
-      # @param timeout [Numeric] Number of seconds to wait for read operation to complete
-      # @raise [Socketry::Error] an I/O operation failed
-      # @return [String, :eof] bytes read, or :eof if socket closed while reading
-      def readpartial(size, outbuf: nil, timeout: @read_timeout)
-        set_timeout(timeout)
-
-        begin
-          while (result = read_nonblock(size, outbuf: outbuf)) == :wait_readable
-            next if @socket.wait_readable(time_remaining(timeout))
-            raise TimeoutError, "read timed out after #{timeout} seconds"
-          end
-        ensure
-          clear_timeout(timeout)
-        end
-
-        result || :eof
-      end
-
-      # Read all of the data in a given string to a socket unless timeout or EOF
-      #
-      # @param size [Fixnum] number of bytes to attempt to read
-      # @param outbuf [String] an output buffer to read data into
-      # @param timeout [Numeric] Number of seconds to wait for read operation to complete
-      #
-      # @raise [Socketry::Error] an I/O operation failed
-      #
-      # @return [String, :eof] bytes read, or :eof if socket closed while reading
-      def read(size, outbuf: String.new, timeout: @write_timeout)
-        outbuf.clear
-        deadline = lifetime + timeout if timeout
-
-        begin
-          until outbuf.size == size
-            time_remaining = deadline - lifetime if deadline
-            raise Socketry::TimeoutError, "read timed out after #{timeout} seconds" if timeout && time_remaining <= 0
-
-            chunk = readpartial(size - outbuf.size, timeout: time_remaining)
-            return :eof if chunk == :eof
-
-            outbuf << chunk
-          end
-        end
-
-        outbuf
-      end
-
-      # Perform a non-blocking write operation
-      #
-      # @param data [String] data to write to the socket
-      #
-      # @raise [Socketry::Error] an I/O operation failed
-      #
-      # @return [Fixnum, :wait_writable] number of bytes written, or :wait_writable if op would block
-      def write_nonblock(data)
-        ensure_connected
-        @socket.write_nonblock(data, exception: false)
-      rescue IO::WaitWriteable
-        # Some buggy Rubies continue to raise this exception
-        :wait_writable
-      rescue IOError => ex
-        raise Socketry::Error, ex.message, ex.backtrace
-      end
-
-      # Write a partial amounth of data, blocking until it's completed
-      #
-      # @param data [String] data to write to the socket
-      # @param timeout [Numeric] Number of seconds to wait for write operation to complete
-      # @raise [Socketry::Error] an I/O operation failed
-      # @return [Fixnum, :eof] number of bytes written, or :eof if socket closed during writing
-      def writepartial(data, timeout: @write_timeout)
-        set_timeout(timeout)
-
-        begin
-          while (result = write_nonblock(data)) == :wait_writable
-            next if @socket.wait_writable(time_remaining(timeout))
-            raise TimeoutError, "write timed out after #{timeout} seconds"
-          end
-        ensure
-          clear_timeout(timeout)
-        end
-
-        result || :eof
-      end
-
-      # Write all of the data in a given string to a socket unless timeout or EOF
-      #
-      # @param data [String] data to write to the socket
-      # @param timeout [Numeric] Number of seconds to wait for write operation to complete
-      #
-      # @raise [Socketry::Error] an I/O operation failed
-      #
-      # @return [Fixnum] number of bytes written, or :eof if socket closed during writing
-      def write(data, timeout: @write_timeout)
-        total_written = data.size
-        deadline = lifetime + timeout if timeout
-
-        begin
-          until data.empty?
-            time_remaining = deadline - lifetime if deadline
-            raise Socketry::TimeoutError, "write timed out after #{timeout} seconds" if timeout && time_remaining <= 0
-
-            bytes_written = writepartial(data, timeout: time_remaining)
-            return :eof if bytes_written == :eof
-
-            break if bytes_written == data.bytesize
-            data = data.byteslice(bytes_written..-1)
-          end
-        end
-
-        total_written
-      end
-
-      # Check whether Nagle's algorithm has been disabled
-      #
-      # @return [true]  Nagle's algorithm has been explicitly disabled
-      # @return [false] Nagle's algorithm is enabled (default)
-      def nodelay
-        ensure_connected
-        @socket.getsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY).int.nonzero?
-      end
-
-      # Disable or enable Nagle's algorithm
-      #
-      # @param flag [true, false] disable or enable coalescing multiple writesusing Nagle's algorithm
-      def nodelay=(flag)
-        ensure_connected
-        @socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, flag ? 1 : 0)
-      end
-
-      # Return a raw Ruby I/O object
-      #
-      # @return [IO] Ruby I/O object
-      def to_io
-        ensure_connected
-        ::IO.try_convert(@socket)
-      end
-
-      # Close the socket
-      #
-      # @return [true, false] true if the socket was open, false if closed
-      def close
-        return false if closed?
-        @socket.close
-        true
-      ensure
-        @socket = nil
-      end
-
-      # Is the socket closed?
-      #
-      # This method returns the local connection state. However, it's possible
-      # the remote side has closed the connection, so it's not actually
-      # possible to actually know if the socket is actually still open without
-      # reading from or writing to it. It's sort of like the Heisenberg
-      # uncertainty principle of sockets.
-      #
-      # @return [true, false] do we locally think the socket is closed?
-      def closed?
-        @socket.nil?
-      end
-
-      private
-
-      def ensure_connected
-        raise StateError, "not connected" if closed?
-        true
-      end
-
-      def ensure_disconnected
-        return true if closed?
-        raise StateError, "already connected"
-      end
-    end
-  end
-end

data/lib/socketry/timeout.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module Socketry
-  # Timeout subsystem
-  module Timeout
-    DEFAULT_TIMER = Hitimes::Interval
-
-    # Default timeouts (in seconds)
-    DEFAULT_TIMEOUTS = {
-      read:    5,
-      write:   5,
-      connect: 5
-    }.freeze
-
-    # Start a timer in the included object
-    #
-    # @param timer [#start, #to_f] a timer object (ideally monotonic)
-    # @return [true] timer started successfully
-    # @raise [Socketry::InternalError] if timer is already started
-    def start_timer(timer = DEFAULT_TIMER_CLASS.new)
-      raise Socketry::InternalError, "timer already started" if defined?(@timer)
-      raise Socketry::InternalError, "deadline already set"  if defined?(@deadline)
-
-      @deadline = nil
-      @timer = timer
-      @timer.start
-      true
-    end
-
-    # Return how long since the timer has been started
-    #
-    # @return [Float] number of seconds since the timer has been started
-    # @raise [Socketry::InternalError] if timer has not been started
-    def lifetime
-      raise Socketry::InternalError, "timer not started" unless @timer
-      @timer.to_f
-    end
-
-    # Set a timeout. Only one timeout may be active at a given time for a given object.
-    #
-    # @param timeout [Numeric] number of seconds until the timeout is reached
-    # @return [Float] deadline (relative to #lifetime) at which the timeout is reached
-    # @raise [Socketry::InternalError] if timeout is already set
-    def set_timeout(timeout)
-      raise Socketry::InternalError, "deadline already set" if @deadline
-      return unless timeout
-      raise Socketry::TimeoutError, "time expired" if timeout < 0
-
-      @deadline = lifetime + timeout
-    end
-
-    # Clear an already-set timeout
-    #
-    # @param timeout [Numeric] to gauge whether the timeout actually needs to be cleared
-    # @raise [Socketry::InternalError] if timeout has not been set
-    def clear_timeout(timeout)
-      return unless timeout
-      raise Socketry::InternalError, "no deadline set" unless @deadline
-      @deadline = nil
-    end
-
-    # Calculate number of seconds remaining until we hit the timeout
-    #
-    # @param timeout [Numeric] to gauge whether a timeout needs to be calculated
-    # @return [Float] number of seconds remaining until we hit the timeout
-    # @raise [Socketry::TimeoutError] if we've already hit the timeout
-    # @raise [Socketry::InternalError] if timeout has not been set
-    def time_remaining(timeout)
-      return unless timeout
-      raise Socketry::InternalError, "no deadline set" unless @deadline
-      remaining = @deadline - lifetime
-      raise Socketry::TimeoutError, "time expired" if remaining <= 0
-      remaining
-    end
-  end
-end

data/lib/socketry/udp/datagram.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Socketry
-  # User Datagram Protocol: "fire-and-forget" packet protocol
-  module UDP
-    # Represents a received UDP message
-    class Datagram
-      attr_reader :message, :sockaddr, :remote_host, :remote_addr, :remote_port
-
-      def initialize(message, sockaddr)
-        @message  = message
-        @sockaddr = sockaddr
-        @remote_port = sockaddr[1]
-        @remote_host = sockaddr[2]
-        @remote_addr = sockaddr[3]
-      end
-
-      def addrinfo
-        addr_family = case @sockaddr[0]
-                      when "AF_INET"  then ::Socket::AF_INET
-                      when "AF_INET6" then ::Socket::AF_INET6
-                      else raise Socketry::AddressError, "unsupported IP address family: #{@sockaddr[0]}"
-                      end
-
-        Addrinfo.new(@sockaddr, addr_family, ::Socket::SOCK_DGRAM)
-      end
-    end
-  end
-end

data/lib/socketry/udp/socket.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-module Socketry
-  # User Datagram Protocol: "fire-and-forget" packet protocol
-  module UDP
-    # User Datagram Protocol sockets
-    class Socket
-      include Socketry::Timeout
-
-      attr_reader :addr_family, :read_timeout, :write_timeout, :resolver, :socket_class
-
-      # Create a UDP socket matching the given socket's address family
-      #
-      # @param remote_addr [String] Address to connect/bind to
-      # @param resolver    [Object] Resolver object to use for resolving DNS names
-      #
-      # @return [Socketry::UDP::Socket]
-      def self.from_addr(remote_addr, resolver: Socketry::Resolver::DEFAULT_RESOLVER)
-        addr = resolver.resolve(remote_addr)
-        if addr.ipv4?    then new(addr_family: :ipv4)
-        elsif addr.ipv6? then new(addr_family: :ipv6)
-        else raise Socketry::AddressError, "unsupported IP address family: #{addr}"
-        end
-      end
-
-      # Create a UDP server bound to the given address and port
-      #
-      # @param local_addr [String] Local DNS name or IP address to listen on
-      # @param local_port [Fixnum] Local UDP port to listen on
-      # @param resolver   [Object] Resolver object to use for resolving DNS names
-      #
-      # @return [Socketry::UDP::Socket]
-      def self.bind(local_addr, local_port, resolver: Socketry::Resolver::DEFAULT_RESOLVER)
-        from_addr(local_addr, resolver: resolver).bind(local_addr, local_port)
-      end
-
-      # Connect to the given address and port
-      #
-      # @param remote_addr [String] DNS name or IP address of the host to connect to
-      # @param remote_port [Fixnum] UDP port to connect to
-      # @param resolver    [Object] Resolver object to use for resolving DNS names
-      #
-      # @return [Socketry::UDP::Socket]
-      def self.connect(remote_addr, remote_port, resolver: Socketry::Resolver::DEFAULT_RESOLVER)
-        from_addr(remote_addr, resolver: resolver).connect(remote_addr, remote_port)
-      end
-
-      # Create a new UDP socket
-      #
-      # @param addr_family   [:ipv4, :ipv6] (default :ipv4) address family for this socket
-      # @param read_timeout  [Numeric] Seconds to wait before an uncompleted read errors
-      # @param write_timeout [Numeric] Seconds to wait before an uncompleted write errors
-      # @param timer         [Object]  Time interval object to use for measuring timeouts
-      # @param resolver      [Object]  Resolver object to use for resolving DNS names
-      # @param socket_class  [Object]  Underlying socket class which implements I/O ops
-      #
-      # @raise [ArgumentError] an invalid argument was given
-      #
-      # @return [Socketry::UDP::Socket]
-      def initialize(
-        addr_family: :ipv4,
-        read_timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:read],
-        write_timeout: Socketry::Timeout::DEFAULT_TIMEOUTS[:write],
-        timer: Socketry::Timeout::DEFAULT_TIMER.new,
-        resolver: Socketry::Resolver::DEFAULT_RESOLVER,
-        socket_class: ::UDPSocket
-      )
-        @addr_family = case addr_family
-                       when :ipv4 then ::Socket::AF_INET
-                       when :ipv6 then ::Socket::AF_INET6
-                       when ::Socket::AF_INET, ::Socket::AF_INET6 then addr_family
-                       else raise ArgumentError, "invalid address family: #{addr_family.inspect}"
-                       end
-
-        @socket        = socket_class.new(@addr_family)
-        @read_timeout  = read_timeout
-        @write_timeout = write_timeout
-        @resolver      = resolver
-
-        start_timer(timer)
-      end
-
-      # Start a UDP server bound to a particular address and port
-      #
-      # @param local_addr [String] Local DNS name or IP address to listen on
-      # @param local_port [Fixnum] Local UDP port to listen on
-      #
-      # @return [self]
-      def bind(local_addr, local_port)
-        @socket.bind(@resolver.resolve(local_addr).to_s, local_port)
-        self
-      rescue Errno::EADDRINUSE => ex
-        raise AddressInUseError, ex.message, ex.backtrace
-      rescue => ex
-        raise Socketry::Error, ex.message, ex.backtrace
-      end
-
-      # Make a UDP client connection to the given address and port
-      #
-      # @param remote_addr [String] DNS name or IP address of the host to connect to
-      # @param remote_port [Fixnum] UDP port to connect to
-      #
-      # @return [self]
-      def connect(remote_addr, remote_port)
-        @socket.connect(@resolver.resolve(remote_addr).to_s, remote_port)
-        self
-      rescue => ex
-        # TODO: more specific exceptions
-        raise Socketry::Error, ex.message, ex.backtrace
-      end
-
-      # Perform a non-blocking receive
-      #
-      # @param maxlen [Fixnum] Maximum packet length to receive
-      #
-      # @return [Socketry::UDP::Datagram, :wait_readable] Received datagram or indication to wait
-      def recvfrom_nonblock(maxlen)
-        Socketry::UDP::Datagram.new(*@socket.recvfrom_nonblock(maxlen))
-      rescue ::IO::WaitReadable
-        :wait_readable
-      rescue => ex
-        # TODO: more specific exceptions
-        raise Socketry::Error, ex.message, ex.backtrace
-      end
-
-      # Perform a blocking receive
-      #
-      # @param maxlen  [Fixnum] Maximum packet length to receive
-      # @param timeout [Numeric] Number of seconds to wait for recvfrom operation to complete
-      #
-      # @return [String] Received data
-      def recvfrom(maxlen, timeout: @read_timeout)
-        set_timeout(timeout)
-
-        begin
-          while (result = recvfrom_nonblock(maxlen)) == :wait_readable
-            next if @socket.wait_readable(time_remaining(timeout))
-            raise Socketry::TimeoutError, "recvfrom timed out after #{timeout} seconds"
-          end
-        ensure
-          clear_timeout(timeout)
-        end
-
-        result
-      end
-
-      # Send a UDP packet to a remote host
-      #
-      # @param msg  [String] Data to write to the remote host/port
-      # @param host [String] Remote host to send data to. May be omitted if `connect` was called previously
-      # @param port [Fixnum] UDP port to send data to. May be omitted if `connect` was called previously
-      #
-      # @return [Fixum] Number of bytes sent
-      def send(msg, host: nil, port: nil)
-        host = @resolver.resolve(host).to_s if host
-        if host || port
-          @socket.send(msg, 0, host, port)
-        else
-          @socket.send(msg, 0)
-        end
-      rescue => ex
-        # TODO: more specific exceptions
-        raise Socketry::Error, ex.message, ex.backtrace
-      end
-
-      # Close the socket
-      #
-      # @return [true, false] true if the socket was open, false if closed
-      def close
-        return false if closed?
-        @socket.close
-        true
-      ensure
-        @socket = nil
-      end
-
-      # Is the socket closed?
-      #
-      # @return [true, false] do we locally think the socket is closed?
-      def closed?
-        @socket.nil?
-      end
-    end
-  end
-end

data/socketry.gemspec

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "socketry/version"
-
-Gem::Specification.new do |spec|
-  spec.name        = "socketry"
-  spec.version     = Socketry::VERSION
-  spec.authors     = ["Tony Arcieri"]
-  spec.email       = ["bascule@gmail.com"]
-  spec.licenses    = ["MIT"]
-  spec.homepage    = "https://github.com/socketry/socketry/"
-  spec.summary     = "High-level wrappers for Ruby sockets with advanced thread-safe timeout support"
-  spec.description = <<-DESCRIPTION.strip.gsub(/\s+/, " ")
-    Socketry wraps Ruby's sockets with an advanced timeout engine which is able to provide multiple
-    simultaneous timeout behaviors in a thread-safe way.
-  DESCRIPTION
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = ">= 2.2.6"
-
-  spec.add_runtime_dependency "hitimes", ">= 1.2"
-
-  spec.add_development_dependency "bundler", "~> 1.0"
-end