rconrb 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b2d90b6a2bacdf1d213da0356764b3e911cd0c5caf8a6516fcc8562cc88aec1a
+  data.tar.gz: 77f7e0038e8a2aa2eb05265c07adae7b4b05ced177fa86fc226f7aa6b6ef4933
+SHA512:
+  metadata.gz: 2e54c3a135b6ab6df953bc05e893a30e495f4a9f20415edd3c6a4eb65c1c32887f2a8178bef0c259578584f708e9955a9445ec9376d5364ab1cb92c8c0fbf518
+  data.tar.gz: f13555248995c93017d61eba73685ed2999c37c5833c68ec59bcc51e30601e5f78f0b811d696f419076b1cd2c77ea6c17e9ef8cc69de73553bb3a323327d4ccc

data/.circleci/config.yml

@@ -0,0 +1,25 @@
+version: 2
+jobs:
+  build:
+    parallelism: 1
+    docker:
+      - image: circleci/ruby:2.6.0-stretch
+        environment:
+          BUNDLE_JOBS: 1
+          BUNDLE_RETRY: 3
+          BUNDLE_PATH: vendor/bundle
+    steps:
+      - checkout
+
+      - run:
+          name: run setup
+          command: bin/setup
+
+      - run:
+          name: Run rspec in parallel
+          command: |
+            bundle exec rspec --profile 10 \
+                              --format RspecJunitFormatter \
+                              --out test_results/rspec.xml \
+                              --format progress \
+                              $(circleci tests glob "spec/**/*_spec.rb" | circleci tests split --split-by=timings)

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+Gemfile.lock
+
+vendor

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rcon.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem "rspec_junit_formatter"

data/README.md

@@ -0,0 +1,104 @@
+# Rcon
+
+[![hernanat](https://circleci.com/gh/hernanat/rconrb/tree/master.svg?style=svg)](https://circleci.com/gh/hernanat/rconrb/tree/master)
+[![Gem Version](https://badge.fury.io/rb/rconrb.svg)](https://badge.fury.io/rb/rconrb)
+
+[The Source RCON Protocol](https://developer.valvesoftware.com/wiki/Source_RCON_Protocol) is a protocol
+  designed to allow for the remote execution of commands on a server that supports it.
+
+It is used for many different game servers running on the [Source Dedicated Server](https://developer.valvesoftware.com/wiki/Source_Dedicated_Server), but other
+  types of game servers (Minecraft) support it (or flavors of it) as well.
+
+This gem intends to provide a means of executing remote commands via the "vanilla" RCON protocol by default,
+  but also offers some configuration options to allow you to work with the more problematic implementations
+  of the protocol (i.e. Minecraft).
+
+See the [docs](https://rubydoc.info/github/hernanat/rconrb) for more information.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rconrb'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rconrb
+
+## Usage
+
+### Basic Usage
+
+#### Vanilla
+
+```ruby
+client = Rcon::Client.new(host: "1.2.3.4", port: 25575, password: "foreveryepsilonbiggerthanzero")
+client.authenticate!
+client.execute("list")
+```
+
+#### Minecraft
+
+Minecraft implements the protocol in such a way that makes me want to tear my hair out. Anyways:
+
+```ruby
+client = Rcon::Client.new(host: "1.2.3.4", port: 25575, password: "foreveryepsilonbiggerthanzero")
+client.authenticate!(ignore_first_packet: false) # Minecraft RCON does not send a preliminary auth packet
+client.execute("list")
+```
+
+### Segmented Responses
+
+Some responses are too large to send back in one packet, and so they are broken up across several.
+We handle this by sending a "trash" packet along immediately following our initial packet. Since
+SRCDS guarantees that packets will be processed in order, and responded to in order, so we basically
+we build the response body across several packets until we encounter the trash packet id, in which
+case we know that we are finished. It's worth noting that I'm not positive that Minecraft follows
+this behavioral guarantee, but throughout the testing that I've done it has seemed to.
+
+Note that the segmented response workflow is disabled by default since most commands won't result
+in a segmented response.
+
+#### Vanilla
+
+```ruby
+client = Rcon::Client.new(host: "1.2.3.4", port: 25575, password: "foreveryepsilonbiggerthanzero")
+client.authenticate!
+client.execute("cvarlist", expect_segmented_response: true)
+```
+
+#### Minecraft
+
+Minecraft RCON doesn't handle receiving multiple packets in quick succession very well, and seems
+to get confused and just close the TCP connection. This has been a long standing issue. The solution
+is basically to wait a brief period between the initial packet and the trash packet to give the
+server some time to process. This isn't an exact science unfortunately.
+
+```ruby
+client = Rcon::Client.new(host: "1.2.3.4", port: 25575, password: "foreveryepsilonbiggerthanzero")
+client.authenticate!(ignore_first_packet: false) # Minecraft RCON does not send a preliminary auth packet
+client.execute("banlist", expect_segmented_response: true, wait: 0.25)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Documentation
+
+Documentation can be viewed at https://rubydoc.info/github/hernanat/rconrb
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hernanat/rconrb
+
+TODO: contribution guidelines
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rcon"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rcon.rb

@@ -0,0 +1,12 @@
+require "rcon/version"
+require "rcon/error/error"
+require "rcon/client"
+
+# This module is based on the {https://developer.valvesoftware.com/wiki/Source_RCON_Protocol Source RCON Protocol}.
+# It is to be used for executing remote commands on servers that implement this protocol, or various flavors of it.
+#
+# The goal was to design something that could be used to work with the default protocol implementation, but also offer
+#   the flexibility to work with problem-children implementations such as the one used by Minecraft.
+#
+module Rcon
+end

data/lib/rcon/client.rb

@@ -0,0 +1,130 @@
+require "rcon/packet"
+require "rcon/response"
+require "rcon/socket_wrapper"
+require "socket"
+require "securerandom"
+
+module Rcon
+  # Basic client for executing commands on your server remotely using the Source RCON protocol.
+  # See {https://developer.valvesoftware.com/wiki/Source_RCON_Protocol here} for more details.
+  #
+  # This is intended to be flexible enough to suit the needs of various flavors of RCON (for
+  # example, Minecraft).
+  #
+  # See individual method summaries for more information.
+  class Client
+    # Instantiates an {Client}.
+    #
+    # @param host [String] IP address of the server running RCON
+    # @param port [Integer] RCON port
+    # @param password [String] RCON password
+    # @return [Client]
+    def initialize(host:, port:, password:)
+      @host = host
+      @port = port
+      @password = password
+      @socket = nil
+    end
+
+    # Opens a TCP socket and authenticates with RCON.
+    #
+    # According to the RCON spec, the server will respond to an authentication request with a
+    # SERVERDATA_RESPONSE_VALUE packet, followed by a SERVERDATA_AUTH_RESPONSE packet by
+    # default.
+    #
+    # However, this is not the case in every implementation (looking at you Minecraft). For the
+    # sake of being flexible, we include a param which allows us to enable / disable this default behavior (see below).
+    #
+    # It is not recommended to call this method more than once before ending the session.
+    #
+    # @param ignore_first_packet [Boolean]
+    # @return [AuthResponse]
+    # @raise [Error::AuthError] if authentication fails
+    def authenticate!(ignore_first_packet: true)
+      packet_id = SecureRandom.rand(1000)
+      auth_packet = Packet.new(packet_id, :SERVERDATA_AUTH, password)
+      @socket = SocketWrapper.new(TCPSocket.open(host, port))
+      socket.deliver_packet(auth_packet)
+      read_packet_from_socket if ignore_first_packet
+
+      read_packet_from_socket.
+        then { |packet| Response.from_packet(packet) }.
+        tap { |response| raise Error::AuthError unless response.success? }
+    end
+
+    # Execute the given command.
+    #
+    # Some commands require their responses to be sent across several packets because
+    # they are larger than the maximum (default) RCON packet size of 4096 bytes.
+    #
+    # In order to deal with this, we send an additional "trash" packet immediately
+    # following the initial command packet. SRCDS guarantees that requests are processed
+    # in order, and the subsequent responses are also in order, so we use this fact to
+    # append the packet bodies to the result on the client side until we see the trash
+    # packet id.
+    #
+    # Many commands won't require a segmented response, so we disable this behavior by
+    # default. You can enable it if you'd like using the option describe below.
+    #
+    # Additionally, some implementations of RCON servers (MINECRAFT) cannot handle two 
+    # packets in quick succession, so you may want to wait a short duration (i.e. <= 1 second)
+    # before sending the trash packet. We give the ability to do this using the
+    # wait option described below.
+    #
+    # @param [Hash] opts options for executing the command
+    # @option opts [Boolean] :expect_segmented_response follow segmented response logic described above if true
+    # @option opts [Integer] :wait seconds to wait before sending trash packet (i.e. Minecraft 😡)
+    # @return [CommandResponse]
+    def execute(command, opts = {})
+      packet_id = SecureRandom.rand(1000)
+      socket.deliver_packet(Packet.new(packet_id, :SERVERDATA_EXECCOMMAND, command))
+      trash_packet_id = build_and_send_trash_packet(opts) if opts[:expect_segmented_response]
+      build_response(trash_packet_id)
+    end
+
+    # Close the TCP socket and end the RCON session.
+    # @return [nil]
+    def end_session!
+      @socket = socket.close
+    end
+
+    private
+
+    attr_reader :host, :port, :password, :socket
+
+    def build_response(trash_packet_id)
+      if trash_packet_id.nil?
+        read_packet_from_socket.then { |p| Response.from_packet(p) }
+      else
+        build_segmented_response(trash_packet_id, read_packet_from_socket)
+      end
+    end
+
+    def build_segmented_response(trash_packet_id, first_segment)
+      next_segment = read_packet_from_socket
+      response = Response.from_packet(first_segment)
+      loop do
+        break if next_segment.id == trash_packet_id
+        response.body = "#{response.body}#{next_segment.body}"
+        next_segment = read_packet_from_socket
+      end
+      response
+    end
+
+    def build_and_send_trash_packet(opts = {})
+      # some RCON implementations (I'm looking at you Minecraft)
+      # blow up if you send successive packets too quickly
+      # the work around (currently) is to allow the server some
+      # time to catch up. Note that this isn't an exact science.
+      wait = opts[:wait]
+      SecureRandom.rand(1000).tap do |packet_id|
+        sleep(wait) if wait
+        socket.deliver_packet(Packet.new(packet_id, :SERVERDATA_RESPONSE_VALUE, ""))
+      end
+    end
+
+    def read_packet_from_socket
+      Packet.read_from_socket_wrapper(socket)
+    end
+  end
+end

data/lib/rcon/error/error.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Rcon
+  # module for Rcon related errors and their messages.
+  module Error
+    # used for communicating that there was an issue authenticating
+    # with the RCON server.
+    class AuthError < StandardError
+      # @return [String]
+      def message
+        "error authenticating with server. is your password correct?"
+      end
+    end
+
+    # used for communicating that the packet type is not supported
+    #
+    # @attr_reader packet_type [Integer]
+    class InvalidPacketTypeError < StandardError
+      # @param packet_type [Symbol] the packet type
+      # @return [InvalidPacketTypeError]
+      def initialize(packet_type)
+        @packet_type = packet_type
+        super
+      end
+
+      attr_reader :packet_type
+
+      # @return [String]
+      def message
+        "invalid packet_type: #{packet_type}"
+      end
+    end
+
+    # used for communicating that the integer packet type code is not supported
+    #
+    # @attr_reader type_code [Integer]
+    class InvalidResponsePacketTypeCodeError < StandardError
+      # @param type_code [Integer] packet type code
+      # @return [InvalidResponsePacketTypeCodeError]
+      def initialize(type_code)
+        @type_code = type_code
+        super
+      end
+
+      attr_reader :type_code
+
+      # @return [String]
+      def message
+        "invalid response packet type code: #{type_code}"
+      end
+    end
+
+    # used for communicating that we timed out trying to read from the socket
+    class SocketReadTimeoutError < StandardError
+      # @return [String]
+      def message
+        "timed out waiting for socket to be read-ready"
+      end
+    end
+
+    # used for communicating that we timed out trying to write to the socket
+    class SocketWriteTimeoutError < StandardError
+      # @return [String]
+      def message
+        "timed out waiting for socket to be write-ready"
+      end
+    end
+
+    # used for communicating that the response type of the packet is unsupported
+    #
+    # @attr_reader response_type [Symbol]
+    class UnsupportedResponseTypeError < StandardError
+      # @param response_type [Symbol] the response type
+      # @return [UnsupportedResponseTypeError]
+      def initialize(response_type)
+        @response_type = response_type
+      end
+
+      attr_reader :response_type
+
+      # @return [String]
+      def message
+        "unsupported response type: #{response_type}"
+      end
+    end
+  end
+end

data/lib/rcon/packet.rb

@@ -0,0 +1,119 @@
+module Rcon
+  # Data structure representing packets sent to / received from RCON server.
+  class Packet
+    INTEGER_PACK_DIRECTIVE = "l<".freeze
+    STR_PACK_DIRECTIVE = "a".freeze
+    PACKET_PACK_DIRECTIVE = "#{INTEGER_PACK_DIRECTIVE}2#{STR_PACK_DIRECTIVE}*#{STR_PACK_DIRECTIVE}".freeze
+    ENCODING = Encoding::ASCII
+    TRAILER = "\x00".freeze
+    INT_BYTE_SIZE = 4
+    TRAILER_BYTE_SIZE = 1 
+
+    # Types of packets that the server expects to receive.
+    #
+    # The keys correspond with the Source RCON spec names, the values correspond with
+    # what the server expects to see in the type segment of a packet.
+    REQUEST_PACKET_TYPE = {
+      SERVERDATA_AUTH: 3,
+      SERVERDATA_EXECCOMMAND: 2
+    }.freeze
+
+    # Types of packets that the client can expect to receive
+    # back from the server.
+    #
+    # The keys correspond with the Source RCON spec names, the values correspond with
+    # what the client expects to see in the type segment of a packet.
+    RESPONSE_PACKET_TYPE = {
+      SERVERDATA_AUTH_RESPONSE: 2,
+      SERVERDATA_RESPONSE_VALUE: 0
+    }.freeze
+
+    private_constant(
+      :INTEGER_PACK_DIRECTIVE, :STR_PACK_DIRECTIVE, :PACKET_PACK_DIRECTIVE,
+      :ENCODING, :TRAILER, :INT_BYTE_SIZE, :TRAILER_BYTE_SIZE
+    )
+
+    # Read a packet from the given {SocketWrapper}.
+    #
+    # @param socket_wrapper [SocketWrapper]
+    # @return [Packet]
+    # @raise [Error::SocketReadTimeoutError] if timeout occurs while waiting to read from socket
+    def self.read_from_socket_wrapper(socket_wrapper)
+      if socket_wrapper.ready_to_read?
+        size = socket_wrapper.recv(INT_BYTE_SIZE).unpack(INTEGER_PACK_DIRECTIVE).first
+        id_and_type_length = 2 * INT_BYTE_SIZE
+        body_length = size - id_and_type_length - (2 * TRAILER_BYTE_SIZE) # ignore trailing nulls
+
+        payload = socket_wrapper.recv(size)
+        id, type_int = payload[0...id_and_type_length].unpack("#{INTEGER_PACK_DIRECTIVE}*")
+        body = payload[id_and_type_length..].unpack("#{STR_PACK_DIRECTIVE}#{body_length}").first
+        type = RESPONSE_PACKET_TYPE.key(type_int) || raise(Error::InvalidResponsePacketTypeCodeError.new(type_int))
+
+        new(id, RESPONSE_PACKET_TYPE.key(type_int), body)
+      end
+    end
+
+    # Instantiates a {Packet}
+    #
+    # @param id [Integer] the packet id
+    # @param type [Symbol] see {REQUEST_PACKET_TYPE} and {RESPONSE_PACKET_TYPE} keys
+    # @param body [String] the packet body
+    # @return [Packet]
+    def initialize(id, type, body)
+      @id = id
+      @type = type
+      @body = body
+    end
+
+    # Compares two objects to see if they are equal
+    # 
+    # Returns true if other is a Packet and attributes match self, false otherwise.
+    # @param other [Packet, Object]
+    # @return [Boolean]
+    def ==(other)
+      eql?(other)
+    end
+
+    # Compares two objects to see if they are equal
+    # Returns true if other is a Packet and attributes match self, false otherwise.
+    #
+    # @param other [Packet, Object]
+    # @return [Boolean]
+    def eql?(other)
+      if other.is_a?(Packet)
+        id == other.id && type == other.type && body == other.body
+      else
+        false
+      end
+    end
+
+    # Converts the packet into an ASCII-encoded RCON Packet string for transmitting
+    # to the server.
+    #
+    # @return [String]
+    def to_s
+      [id, type_to_i, "#{body}#{TRAILER}", TRAILER].pack(PACKET_PACK_DIRECTIVE).then do |packet_str|
+        "#{[packet_str.length].pack(INTEGER_PACK_DIRECTIVE)}#{packet_str}".force_encoding(ENCODING)
+      end
+    end
+
+    # Get the integer representation of the packet's type, which is used in the string
+    # representation of the packet.
+    # 
+    # @return [Integer]
+    # @raise [Error::InvalidPacketTypeError] if the packet type is unknown / invalid.
+    def type_to_i
+      type_sym = type.to_sym
+      case type_sym
+      when ->(t) { REQUEST_PACKET_TYPE.keys.include?(t) }
+        REQUEST_PACKET_TYPE[type_sym]
+      when ->(t) { RESPONSE_PACKET_TYPE.keys.include?(t) }
+        RESPONSE_PACKET_TYPE[type_sym]
+      else
+        raise Error::InvalidPacketTypeError.new(type)
+      end
+    end
+
+    attr_reader :id, :type, :body
+  end
+end

data/lib/rcon/response.rb

@@ -0,0 +1,69 @@
+module Rcon
+  # wraps the response we receive from the server. It might not be obvious at
+  # first why have this additional datastructure. There are two main motivations.
+  #
+  # First, to separate how we deal with an {AuthResponse} vs a {CommandResponse}.
+  #
+  # Secondly, when we are dealing with segmented responses, instead of modifying
+  # the first packet in place to add subsequent parts of the body, we modify the
+  # {Response} object corresponding with the total response. i.e. a {Response} is
+  # a sum of {Packet}s.
+  #
+  # @attr_reader id [Integer] the initial request packet id corresponding to the response
+  #   (except maybe for {AuthResponse}, see {AuthResponse#success?}
+  # @attr_reader type [Symbol] the type of response; see {Packet::RESPONSE_PACKET_TYPE}
+  # @attr body [String] the response body, which may be the concatenation of
+  #   the bodies of several packets.
+  class Response
+    # instantiate an instance of a {Response} subclass given a packet.
+    #
+    # @param packet [Packet] the packet
+    # @return [AuthResponse, CommandResponse]
+    def self.from_packet(packet)
+      params = { id: packet.id, type: packet.type, body: packet.body }
+      case packet.type
+      when :SERVERDATA_AUTH_RESPONSE
+        AuthResponse.new(**params)
+      when :SERVERDATA_RESPONSE_VALUE
+        CommandResponse.new(**params)
+      else
+        raise Error::UnsupportedResponseTypeError.new(packet.type)
+      end
+    end
+
+    # instantiate a new {Response}
+    #
+    # @param id [Integer] the id of the initial request packet that the response
+    #   corresponds to
+    # @param type [Symbol] the response type; see {Packet::RESPONSE_PACKET_TYPE}
+    # @param body [String] the response body
+    def initialize(id:, type:, body:)
+      @id = id
+      @type = type
+      @body = body
+    end
+
+    attr_reader :id, :type
+    attr_accessor :body
+  end
+
+  # the {Response} subclass corresponding with authentication response packets
+  # from the server.
+  class AuthResponse < Response
+    # when authentication fails, the ID field of the auth respone packet will
+    # be set to -1
+    AUTH_FAILURE_RESPONSE = -1
+
+    # determines whether or not authentication has succeeded.
+    #
+    # according to the RCON spec, when authentication fails, -1 is returned in the id field of the packet.
+    # @return [Boolean]
+    def success?
+      id != AUTH_FAILURE_RESPONSE
+    end
+  end
+
+  # the {Response} subclass corresponding with response packets from the server
+  # that result from executing a command
+  class CommandResponse < Response; end
+end

data/lib/rcon/socket_wrapper.rb

@@ -0,0 +1,40 @@
+require "delegate"
+
+module Rcon
+  # Simple wrapper to give some convenience methods around sockets.
+  class SocketWrapper < SimpleDelegator
+    TIMEOUT = 5 
+
+    private_constant :TIMEOUT
+
+    # deliver the packet to the server if the socket is ready to
+    # be written.
+    #
+    # @param packet [Packet] the packet to be delivered
+    # @return [Integer] the number of bytes sent
+    # @raise [Error::SocketWriteTimeoutError] if a timeout occurs while waiting to write to socket
+    def deliver_packet(packet)
+      write(packet.to_s) if ready_to_write?
+    end
+
+    # check if socket is ready to read
+    #
+    # @return [Array] containing socket in first subarray if socket is ready to read
+    # @raise [Error::SocketReadTimeoutError] if timeout occurs
+    def ready_to_read?
+      IO.select([__getobj__], nil, nil, TIMEOUT).tap do |io|
+        raise Error::SocketReadTimeoutError if io.nil?
+      end
+    end
+
+    # check if socket is ready to write
+    #
+    # @return [Array] containing socket in second subarray if socket is ready to write
+    # @raise [Error::SocketReadTimeoutError] if timeout occurs
+    def ready_to_write?
+      IO.select(nil, [__getobj__], nil, TIMEOUT).tap do |io|
+        raise Error::SocketWriteTimeoutError if io.nil?
+      end
+    end
+  end
+end

data/lib/rcon/version.rb

@@ -0,0 +1,4 @@
+module Rcon
+  # current version number
+  VERSION = "0.1.2"
+end

data/rconrb.gemspec

@@ -0,0 +1,30 @@
+require_relative 'lib/rcon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rconrb"
+  spec.version       = Rcon::VERSION
+  spec.authors       = ["Anthony Felix Hernandez"]
+  spec.email         = ["ant@antfeedr.com"]
+
+  spec.summary       = %q{An flexible RCON client written in Ruby, based on the Source RCON protocol.}
+  spec.homepage      = "https://github.com/hernanat/rconrb"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = "https://rubydoc.info/github/hernanat/rconrb"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "yard", "~> 0.9.9"
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: rconrb
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Anthony Felix Hernandez
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+description: 
+email:
+- ant@antfeedr.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rcon.rb
+- lib/rcon/client.rb
+- lib/rcon/error/error.rb
+- lib/rcon/packet.rb
+- lib/rcon/response.rb
+- lib/rcon/socket_wrapper.rb
+- lib/rcon/version.rb
+- rconrb.gemspec
+homepage: https://github.com/hernanat/rconrb
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/hernanat/rconrb
+  source_code_uri: https://github.com/hernanat/rconrb
+  documentation_uri: https://rubydoc.info/github/hernanat/rconrb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: An flexible RCON client written in Ruby, based on the Source RCON protocol.
+test_files: []