steam_mist 1.3.0

data/lib/steam_mist/rcon/packet.rb

@@ -0,0 +1,146 @@
+module SteamMist
+  class Rcon
+
+    # Represents a packet either received from the server or sent by the
+    # client.
+    class Packet
+
+      # This is used as a {#type}.  This is for the client, authenticating to
+      # the server.
+      SERVERDATA_AUTH = 3
+
+      # Used for {#type}.  This is for the response from the server from the 
+      # client.
+      SERVERDATA_AUTH_RESPONSE = 2
+
+      # Used for {#type}.  This is for the client executing a response to the
+      # server.
+      SERVERDATA_EXECCOMMAND = 2
+
+      # Used for {#type}.  This is for the server sending back response data
+      # for `EXECCOMMAND`.
+      SERVERDATA_RESPONSE_VALUE = 0
+
+      # This matches the requests with their responses.
+      RESPONSE_MATCH = { SERVERDATA_AUTH        => SERVERDATA_AUTH_RESPONSE,
+                         SERVERDATA_EXECCOMMAND => SERVERDATA_RESPONSE_VALUE }
+      
+      # The id of the packet.  This is mainly used to match request packets
+      # with their response.
+      #
+      # @return [Numeric]
+      attr_accessor :id
+
+      # The type of the packet.
+      #
+      # @return [Numeric]
+      attr_accessor :type
+
+      # The body of the packet.
+      #
+      # @return [Numeric]
+      attr_accessor :body
+
+      # Initialize the packet.
+      #
+      # @param id [Numeric] the id of the packet.
+      def initialize(id=nil)
+        @id   = id || 0
+        @type = SERVERDATA_EXECCOMMAND
+        @body = ""
+      end
+
+      # Formats the packet for sending to the server. See
+      # [this](https://developer.valvesoftware.com/wiki/Source_RCON_Protocol)
+      # on how it's done.
+      #
+      # @return [String] a formatted string containing the data.
+      def format
+        [size, id, type, body].pack("l<l<l<a#{body.bytesize+1}x")
+      end
+
+      # This returns the size of the packet.  This is the size of the body, in
+      # bytes.  It also adds 10 bytes for the type (4 bytes), id (4 bytes), and
+      # the two nul-terminators (one for the body and one for the packet).
+      #
+      # @return [Numeric]
+      def size
+        body.bytesize + 10
+      end
+
+      # Compare this with another object.  Calls {#to_i} on the other object
+      # and this one and delegates to that.
+      #
+      # @return [Numeric]
+      def <=>(other)
+        self.to_i <=> other.to_i
+      end
+
+      # Shows whether or not the packet is empty.  The packet is not empty if
+      # the body contains more than "" and the type is not 2.
+      #
+      # @return [Boolean]
+      def empty?
+        body.empty? && (type != 2)
+      end
+
+      # This checks to see if it is SRCDS's weird packet response.
+      #
+      # @return [Boolean]
+      def weird?
+        (type == 0) and (body == "\x00\x01\x00\x00")
+      end
+
+      # This loads the packet data from a hash.  Overwrites the contents of the
+      # packet.
+      #
+      # @param hash [Hash]
+      # @return [self]
+      def load!(hash)
+        self.id   = hash[:id]   || hash["id"]   || id
+        self.type = hash[:type] || hash["type"] || type
+        self.body = hash[:body] || hash["body"] || body
+        self
+      end
+
+      alias :to_i :id
+
+      # This takes a formatted string and turns it into a packet instance.
+      # This is mainly used for responses from the server.
+      #
+      # @param raw [String] the raw data from the server.
+      # @return [Packet] the packet representing the data.
+      def self.from_raw(raw)
+        packet = Packet.new
+        size, = raw.unpack("l<")
+        _, packet.id, packet.type, packet.body = 
+          raw.unpack("l<l<l<a#{size - 10}xx")
+        packet
+      end
+
+      # This reads from a stream and converts it into a packet.
+      #
+      # @param socket [#read] the stream to read from.
+      # @return [Packet] the packet representing the data.
+      def self.from_stream(socket)
+        packet = Packet.new
+        size, = socket.read(4).unpack("l<")
+        packet.id, packet.type, packet.body = 
+          socket.read(size).unpack("l<l<a#{size - 10}xx")
+        packet
+      end
+
+      # This sets up the packet from a given hash.
+      #
+      # @param data [Hash] the data to map to the packet.
+      # @return [Packet]
+      def self.from_hash(data)
+        packet = Packet.new
+        packet.load! data
+
+        packet
+      end
+
+    end
+  end
+end

data/lib/steam_mist/rcon/packet_factory.rb

@@ -0,0 +1,45 @@
+require 'set'
+
+module SteamMist
+  class Rcon
+
+    # Creates packets for use.
+    class PacketFactory
+
+      # An {SortedSet} containing all of the packets that have been created.
+      #
+      # @return [SortedSet]
+      attr_accessor :packets
+
+      # The current packet number.
+      #
+      # @return [Numeric]
+      attr_accessor :number
+
+      # initializes.
+      def initialize
+        @number  = 1
+        @packets = SortedSet.new
+      end
+
+      # Creates a packet.  Automatically assigns it an id, based off of the
+      # current packet number.
+      #
+      # @return [Packet]
+      def create_packet
+        packet = Packet.new(@number)
+        @packets << packet
+        @number = @number + 1
+        packet
+      end
+
+      # Pretty inspect
+      #
+      # @return [String]
+      def inspect
+        "#<SteamMist::Rcon::PacketFactory #{@number}>"
+      end
+      
+    end
+  end
+end

data/lib/steam_mist/rcon/pass.rb

@@ -0,0 +1,123 @@
+module SteamMist
+  class Rcon
+
+    # This basically handles sending and receiving packets.
+    class Pass
+        
+      # The packet factory that should be used when creating packets.  This
+      # factory is used to increment the ID number on sequential packets.
+      #
+      # @return [PacketFactory]
+      attr_reader :packet_factory
+
+      # The listener for sending and receiving data from the server.
+      #
+      # @return [Listener]
+      attr_reader :listener
+
+      # Initialize.
+      #
+      # @param ip [String] the IP address of the Rcon server.  Passed to 
+      #   Listener.
+      # @param port [Numeric] the port of the Rcon server.  Passed to Listener.
+      def initialize(ip, port = 27015)
+        @packet_factory = PacketFactory.new
+        @listener       = Listener.new ip, port
+        @empty_packet   = Packet.from_hash :type => Packet::SERVERDATA_RESPONSE_VALUE
+      end
+
+      # Retrieves the next packet from the stream.  If a block is given, it
+      # yields to that.
+      #
+      # @yieldparam packet [Packet]
+      # @return [Packet]
+      def on_packet(&block)
+        ensure_connected.on_data do |con|
+          packet = Packet.from_stream con
+          
+          if block
+            block.call packet
+          end
+
+          packet
+        end
+      end
+
+      # Sends the given packet to the server.
+      #
+      # @param packet [Packet]
+      # @return [void, Numeric]
+      def write(packet)
+        ensure_connected.write packet.format
+      end
+
+      # Sends a packet along with an empty packet.  This allows the client to
+      # figure out the server sent multiple packets to the client for the same
+      # request packet.  Returns an array of packets if the server sent
+      # multiple packets.
+      #
+      # @param packet [Packet] the packet to send
+      # @return [Packet, Array<Packet>]
+      def send_packet(packet)
+        empty_packet = @empty_packet.dup
+        empty_packet.id = packet.id
+        write(packet) and write(empty_packet)
+        response_packets = []
+
+        begin
+          while response_packets.empty? || !response_packets.last.weird? do
+            response_packets << on_packet
+          end
+
+        rescue TimeoutError; end
+
+        response_packets.pop(2)
+
+        if response_packets.length == 1
+          response_packets[0]
+        else
+          response_packets
+        end
+      end
+
+      # This authenticates the connection with the server.  A password is
+      # required.
+      #
+      # @param password [String] the password to authenticate with.
+      # @return [Boolean]
+      def auth(password)
+        packet = packet_factory.create_packet
+        packet.type = Packet::SERVERDATA_AUTH
+        packet.body = password
+
+        #response = send_packet packet
+        write packet
+
+        # discard
+        on_packet
+
+        response = on_packet
+
+        response.id == packet.id
+      end
+
+      # This closes the connection by calling {Listener#close}.
+      #
+      # @return [void]
+      def close
+        listener.close
+      end
+
+      private
+
+      # This makes sure the listener is connected before trying to perform an
+      # I/O operation.
+      #
+      # @return [Listener]
+      def ensure_connected
+        listener.bind! unless listener.connection
+        listener
+      end
+    end
+  end
+end

data/lib/steam_mist/rcon.rb

@@ -0,0 +1,47 @@
+require 'forwardable'
+require 'steam_mist/rcon/pass'
+require 'steam_mist/rcon/packet'
+require 'steam_mist/rcon/listener'
+require 'steam_mist/rcon/packet_factory'
+
+module SteamMist
+
+  # This class provides RCON capabilities.
+  class Rcon
+
+    extend Forwardable
+
+    # This is the class that handles reading and writing packets from the
+    # listener.
+    #
+    # @return [Pass]
+    attr_reader :pass
+
+    # Initialize.
+    #
+    # @param ip [String] the IP to connect to.
+    # @param port [Numeric] the port to connect to.
+    def initialize(ip, port = 27015)
+      @pass = Pass.new(ip, port)
+    end
+
+    # This takes a hash, turns it into a packet, and sends it.
+    #
+    # @param hash [Hash] the data to turn into a packet.
+    # @return [Packet, Array<Packet>]
+    def send(hash)
+      send_packet packet_factory.create_packet.load!(hash)
+    end
+
+    # Pretty inspect
+    #
+    # @return [String]
+    def inspect
+      "#<SteamMist::Rcon>"
+    end
+
+    def_delegators :@pass, :on_packet, :send_packet, :auth, :close, 
+      :packet_factory
+
+  end
+end

data/lib/steam_mist/request_uri.rb

@@ -0,0 +1,77 @@
+module SteamMist
+
+  # This represents a request that may be made to the steam api.  It is mainly
+  # used for obtaining paths to request to.
+  class RequestUri
+
+    extend Forwardable
+
+    # This is the interface the request will be made to, like +ISteamUser+.
+    #
+    # @return [String]
+    attr_accessor :interface
+
+    # This is the method of the interface the request will be made to.
+    #
+    # @return [String]
+    attr_accessor :method
+
+    # These are the arguments that will be passed for the request.
+    #
+    # @return [Enumerable]
+    attr_accessor :arguments
+
+    # The version of the method to request.
+    #
+    # @return [Numeric]
+    attr_accessor :version
+
+    # The domain to make the reuqest to.
+    #
+    # @return [String]
+    attr_accessor :domain
+
+    # Initialize the request.  Can take a hash.  Options for the hash can be
+    # `:interface`, `:method`, `:version`, `:domain` and `:arguments`.  
+    # Anything else will cause an  argument error.  See the attributes for 
+    # each respectively on what they're for.
+    #
+    # @param options [Hash] the options to be used.
+    def initialize(options)
+      {
+        :interface => "", 
+        :method => "", 
+        :arguments => {}, 
+        :version   => 0,  
+        :domain => "api.steampowered.com"
+       }.merge(options).each do |k, v|
+        if respond_to? "#{k}="
+          send "#{k}=", v
+        else
+          raise ArgumentError, "don't know how to handle #{k}!"
+        end
+      end
+    end
+
+    # Takes the request data and formats it into an URI.
+    #
+    # @return [URI] the URI of the request.
+    def format_uri
+      basic = "http://%s/%s/%s/v%04d" % [domain, interface, method, version]
+
+      uri = URI(basic)
+      uri.query = URI.encode_www_form(arguments)
+
+      uri
+    end
+
+    # Outputs a string version of the request.
+    #
+    # @return [String] the fully formated URL of the request.
+    def to_s
+      format_uri.to_s
+    end
+
+    def_delegator :format_uri, :open
+  end
+end

data/lib/steam_mist/schema.rb

@@ -0,0 +1,42 @@
+require 'set'
+require 'hashie/mash'
+
+module SteamMist
+
+  # Handles the Schema for games.
+  #
+  # @todo More tests.
+  class Schema
+
+    # Initialize the schema.  The first argument is the application id,
+    # which valve uses internally to distinguish games from each other.
+    #
+    # @param app_id [Numeric]
+    # @param lang [String] the language the schema should return its
+    #   results in.
+    def initialize(key, app_id, lang = nil)
+      @app_id = app_id
+      @session = Session.new
+      @get_schema = @session.get_interface("IEconItems_#{app_id}").get_schema
+
+      if lang
+        @get_schema.with_arguments!(:language => lang)
+      end
+    end
+
+    # Returns a list of items in the schema.
+    #
+    # @return [SortedSet<Item>]
+    def items
+      @_items ||= data.items
+    end
+
+    # Retrieves the data from the request.
+    #
+    # @return [Hashie::Mash]
+    def data
+      @_data ||= Hashie::Mash.new(@get_schema.get.data["result"])
+    end
+
+  end
+end

data/lib/steam_mist/session.rb

@@ -0,0 +1,60 @@
+# We're placing these here so that if someone wants to only use this part of
+# the library, they don't have to require the entire thing.
+require 'oj'
+require 'uri'
+require 'forwardable'
+require 'steam_mist/version'
+require 'steam_mist/connector'
+require 'steam_mist/connectors'
+require 'steam_mist/request_uri'
+require 'steam_mist/pseudo_interface'
+require 'steam_mist/schema'
+
+module SteamMist
+
+  # The session is used as a starting point for connecting to the Steam API.
+  class Session
+
+    # The connector that the session is going to use.
+    #
+    # @return [Class] the connector.
+    attr_accessor :connector
+
+    # The default arguments that the session will use.
+    #
+    # @return [Hash]
+    attr_accessor :default_arguments
+
+    # Initialize.
+    #
+    # @param connector [Class] the connector (should be subclass of {Connector}).
+    def initialize(connector = Connectors::LazyConnector)
+      @connector   = connector
+      @_interfaces = {}
+      @default_arguments = {}
+    end
+
+    # Grabs an interface for use.  These are cached, so every call with the
+    # same argument returns the same object.
+    #
+    # @param interface [Symbol] the interface name.
+    # @return [PseudoInterface]
+    def get_interface(interface)
+      @_interfaces[interface] ||= PseudoInterface.new(self, interface)
+    end
+
+    # Some {#method_missing} magic.  Sorry @charliesome!
+    #
+    # @see {#get_interface}
+    def method_missing(method, *args)
+      super if args.length > 0 or block_given?
+      get_interface method
+    end
+
+    # pretty inspection
+    def inspect
+      "#<SteamMist::Session #{connector.inspect}>"
+    end
+
+  end
+end

data/lib/steam_mist/version.rb

@@ -0,0 +1,5 @@
+module SteamMist
+
+  # The version of Steam Mist.
+  VERSION = "1.3.0"
+end

data/lib/steam_mist.rb

@@ -0,0 +1,7 @@
+require 'steam_mist/rcon'
+require 'steam_mist/session'
+
+# Steam Mist is an interface for the Web API.
+module SteamMist
+
+end

data/spec/cache_spec.rb

@@ -0,0 +1,25 @@
+describe SteamMist::Connectors::LazyConnector do
+
+  subject { described_class.new(request_uri) }
+  let(:request_uri) { "https://api.twitter.com/1/statuses/oembed.json?id=133640144317198338" }
+
+  it "can cache" do
+    subject.enable_caching "tmp/example_cache.json"
+    expect(subject).to be_cache
+  end
+
+  it "does cache" do
+    subject.enable_caching "tmp/example_cache.json"
+    subject.data
+    expect { |p| subject.send(:with_cache, &p) }.to_not yield_control
+  end
+
+  it "loads from cache file" do
+    subject.enable_caching "tmp/example_cache.json"
+    expect { |p| subject.send(:with_cache, &p) }.to_not yield_control
+  end
+
+  after :all do
+    File.unlink "tmp/example_cache.json"
+  end
+end

data/spec/packet_factory_spec.rb

@@ -0,0 +1,8 @@
+describe SteamMist::Rcon::PacketFactory do
+  it "should generate sequential packets" do
+    packet1 = subject.create_packet
+    packet2 = subject.create_packet
+
+    (packet1.id + 1).should be packet2.id
+  end
+end

data/spec/packet_spec.rb

@@ -0,0 +1,26 @@
+require 'stringio'
+
+describe SteamMist::Rcon::Packet do
+  it "should format itself correctly" do
+    subject.id = 5
+    subject.type = 2
+    subject.body << "hello world"
+
+    subject.format.should eq "\x15\0\0\0\x05\0\0\0\x02\0\0\0hello world\0\0"
+  end
+
+  it "should properly deserialize data from raw" do
+    packet = described_class.from_raw "\x15\0\0\0\x05\0\0\0\x02\0\0\0hello world\0\0"
+    packet.id.should be 5
+    packet.type.should be 2
+    packet.body.should eq "hello world"
+  end
+
+  it "should properly deserialize data from a stream" do
+    s = StringIO.new "\x15\0\0\0\x05\0\0\0\x02\0\0\0hello world\0\0"
+    packet = described_class.from_stream s
+    packet.id.should be 5
+    packet.type.should be 2
+    packet.body.should eq "hello world"
+  end
+end

data/spec/pseudo_interface_spec.rb

@@ -0,0 +1,15 @@
+describe SteamMist::PseudoInterface do
+
+  subject(:interface) do
+    described_class.new(nil, :some_interface)
+  end
+  
+  it "turns the interface name into the correct api name" do
+    interface.api_name.should == "ISomeInterface"
+  end
+
+  it "gives a pseudo method" do
+    interface.get_method(:some_method) \
+      .should be_instance_of SteamMist::PseudoInterface::PseudoMethod
+  end
+end

data/spec/pseudo_method_spec.rb

@@ -0,0 +1,37 @@
+describe SteamMist::PseudoInterface::PseudoMethod do
+
+  subject(:pseudo_method) do
+    session = SteamMist::Session.new(SteamMist::Connectors::LazyConnector)
+    session.default_arguments[:something] = "value"
+    interface = SteamMist::PseudoInterface.new(session, :some_interface) 
+    described_class.new(interface, :some_method, 4)
+  end
+
+  it "should turn the method name into an api name" do
+    pseudo_method.api_name.should == "SomeMethod"
+  end
+
+  it "should return a copy when adding arguments" do
+    pseudo_method.with_arguments(:hello => "world").should_not be pseudo_method
+  end
+
+  it "should return a copy when changing versions" do
+    pseudo_method.with_version(3).should_not be pseudo_method
+  end
+
+  it "should return a request uri" do
+    pseudo_method.request_uri.should be_instance_of SteamMist::RequestUri
+  end
+
+  it "should give a connector instance" do
+    pseudo_method.get.should be_instance_of SteamMist::Connectors::LazyConnector
+  end
+
+  it "should use default arguments" do
+    pseudo_method.request_uri.arguments.should include(:something => "value")
+  end
+
+  it "should give a connector with caching" do
+    expect(pseudo_method.with_caching("some_file").get).to be_cache
+  end
+end

data/spec/request_uri_spec.rb

@@ -0,0 +1,19 @@
+describe SteamMist::RequestUri do
+
+  subject(:request_uri) do
+    SteamMist::RequestUri.new(:interface => "ISomeInterface", :method => "SomeMethod", 
+      :version => 1)
+  end
+
+  it "should raise an argument error" do
+    expect { described_class.new(:something => :else) }.to raise_error(ArgumentError)
+  end
+
+  it "should return a uri" do
+    request_uri.format_uri.should be_instance_of(URI::HTTP)
+  end
+
+  it "should format the right string" do
+    request_uri.to_s.should eq "http://api.steampowered.com/ISomeInterface/SomeMethod/v0001?"
+  end
+end