manymo 2.0.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 821c784a5b085a534bc0589b61a990ab57544780
+  data.tar.gz: 05416b27426bf6c3c54cff2979a0ec446ed3c017
+SHA512:
+  metadata.gz: ace13b861a68a2f7a2420662cf8851e533639acccc22d8e07cb3d1ddeb0afaef29e4aa7d64da131eefc79a2c82e84f2d2297e4445f8fe4c001f882074e177f1b
+  data.tar.gz: 2a254bf0950e742c68b6eb3cf8570e4a1e501ef216463948cb150f940757819aac78057c178c71416d65c779fea3ddd4d6dc3525c965233568f2c11ae2734700

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in manymo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Pete Schwamb
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Manymo
+
+TODO: Write a gem description
+
+## Dependencies
+
+You will need adb (from the [Android SDK](http://developer.android.com/sdk)) in your PATH.
+
+## Installation
+
+    $ gem install manymo
+
+## Usage
+
+```
+manymo [options] COMMAND [ARGUMENTS]
+
+Commands:
+        launch EMULATORNAME          Launch a headless emulator and make it appear like a local device
+        list                         List emulators; use the name attribute with the launch command
+        shutdown [SERIALNUMBER]      Shutdown specified headless emulator or tunnel, or all if serial number omitted 
+        token                        Display a prompt to enter authorization token
+        tunnel TUNNELKEY             Make an in-browser emulator appear like a local device
+
+Options:
+        --adb-path PATH_TO_ADB       Specify path to adb executable; otherwise uses the one in your path
+```
+
+More documentation is at https://www.manymo.com/pages/documentation/manymo-command-line-tool
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/manymo

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'manymo'
+
+Manymo::Command.start(ARGV)

data/bin/tunnel_test.rb

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+

data/lib/manymo.rb

@@ -0,0 +1,12 @@
+require "manymo/version"
+require "manymo/adb"
+require "manymo/adb_connection_verifier"
+require "manymo/adb_packet"
+require "manymo/adb_stream"
+require "manymo/adb_tunnel"
+require "manymo/console_tunnel"
+require "manymo/command"
+require "manymo/service"
+require "manymo/tunnel"
+require "manymo/tunnel_close_event"
+

data/lib/manymo/adb.rb

@@ -0,0 +1,33 @@
+
+module Manymo
+  class ADB
+    attr_accessor :path
+    def initialize(path = nil)
+      @path = path
+    end
+
+    def path
+      @path || 'adb'
+    end
+
+    def ensure_available
+      if @path
+        if !File.exists?(@path)
+          STDERR.puts "Specified ADB executable (#{@path}) not found."
+          exit 1
+        end
+      else
+        found_adb = false
+        begin
+          `adb version`
+          found_adb = true
+        rescue Errno::ENOENT
+        end
+        if (!found_adb)
+          STDERR.puts "Could not find adb. Please install the Android SDK and make sure its platform-tools directory is in your PATH."
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/manymo/adb_connection_verifier.rb

@@ -0,0 +1,37 @@
+require 'eventmachine'
+
+module Manymo
+  class ADBConnectionVerifier
+    include EM::Deferrable
+
+    module ADBConnection
+      def initialize(verifier)
+        @verifier = verifier
+        @packet = ADBPacket.new
+      end
+
+      def post_init
+        #puts "Local adb socket opened. Sending CNXN packet."
+        send_data ADBPacket.build("CNXN", 0x01000000, 0x00001000, "host::\x00").data
+      end
+
+      def receive_data(data)
+        #puts "Client receive data!"
+        remainder = @packet.consume(data)
+        while @packet.complete? do
+          @verifier.succeed
+          @packet = ADBPacket.new
+          remainder = @packet.consume(remainder)
+        end
+      end
+
+      def unbind
+        #@verifier.fail("Could not connect to adb over tunnel.")
+      end
+    end
+
+    def initialize(port)
+      EM.connect('127.0.0.1', port+1, ADBConnection, self)
+    end
+  end
+end

data/lib/manymo/adb_packet.rb

@@ -0,0 +1,90 @@
+
+module Manymo
+  class ADBPacket
+    attr_accessor :data
+
+    def initialize(data = "")
+      @data = data
+    end
+
+    def self.build(cmd, arg0, arg1, body = "")
+      # Should be 0x00000232 for a CNXN packet
+      new(cmd + [arg0, arg1, body.length, compute_checksum(body), compute_magic(cmd)].pack("V*") + body)
+    end
+
+    def self.compute_magic(cmd)
+      cmd.unpack("V").first ^ 0xffffffff
+    end
+
+    def consume(data)
+      @data = @data + data
+      remainder = ""
+      if @data.length >= 16 && @data.length > data_length
+        remainder = @data[data_length..-1]
+        @data = @data[0,data_length]
+      end
+      remainder
+    end
+
+    def complete?
+      @data.length >= 16 && @data.length == data_length
+    end
+
+    def command
+      @data[0,4]
+    end
+
+    def arg0
+      @data[4,4].unpack('V').first
+    end
+
+    def arg1
+      @data[8,4].unpack('V').first
+    end
+
+    def payload_size
+      @data[12,4].unpack('V').first
+    end
+
+    def checksum
+      @data[16,4].unpack('V').first
+    end
+
+    def body
+      @data[header_size..-1]
+    end
+
+    def magic
+      @data[20,4].unpack('V').first
+    end
+
+    def self.compute_checksum(data)
+      # Not really a crc32
+      data.bytes.inject{|sum,x| sum + x } || 0
+    end
+
+    def computed_checksum
+      self.class.compute_checksum(body)
+    end
+
+    def header_size
+      24
+    end
+
+    def data_length
+      payload_size + header_size
+    end
+
+    def checksum_ok?
+      computed_checksum == checksum
+    end
+
+    def hex_str(v)
+      "0x%08x" % v unless v.nil?
+    end
+
+    def to_s
+      "#{command}(#{hex_str(arg0)}, #{hex_str(arg1)}), payload_size=#{payload_size}, checksum=#{hex_str(checksum)}, computed_checksum=#{hex_str(computed_checksum)}, magic=#{hex_str(magic)}, body=#{body.inspect}"
+    end
+  end
+end

data/lib/manymo/adb_stream.rb

@@ -0,0 +1,18 @@
+module Manymo
+  class ADBStream
+    attr_accessor :local_id, :remote_id
+    attr_accessor :systemtype, :banner
+    attr_accessor :window_length, :spoofed_ack_count
+
+    def initialize(local_id, open_data)
+      @spoofed_ack_count = 0
+      @local_id = local_id
+      @system_type, @banner = open_data.split(':')
+    end
+
+    def quick_ack
+      @spoofed_ack_count += 1
+      ADBPacket.build("OKAY", remote_id, local_id)
+    end
+  end
+end

data/lib/manymo/adb_tunnel.rb

@@ -0,0 +1,132 @@
+require 'faye'
+
+module Manymo
+  module ADBTunnel
+
+    def initialize(server, display, password)
+      @server = server
+      @display = display
+      @password = password
+      @connected = false
+      @q = []
+      @in_packet = ADBPacket.new
+      @out_packet = ADBPacket.new
+      @out_streams = {}
+      @local_port, @local_ip = Socket.unpack_sockaddr_in(get_sockname)
+      @peer_port, @peer_ip = Socket.unpack_sockaddr_in(get_peername)
+    end
+
+    def onclose(&blk)
+      @onclose = blk
+    end
+
+    def log_packet(prefix, pkt)
+      #puts prefix + ": " + pkt.to_s
+    end
+
+    # Packet from local socket out to websocket
+    def handle_outgoing_packet(p)
+      log_packet "#{@peer_port} -> ws", p
+      @ws.send p.data.bytes.to_a
+      case p.command
+      when "OPEN"
+        @out_streams[p.arg0] = ADBStream.new(p.arg0, p.body)
+      when "WRTE"
+        stream = @out_streams[p.arg0]
+        if stream
+          ack = stream.quick_ack
+          log_packet "+ws -> #{@peer_port}", ack
+          send_data ack.data
+        end
+      end
+    end
+
+    # Packet from remote websocket to local socket
+    def handle_incoming_packet(p)
+      should_send = true
+      case p.command
+      when "CLSE"
+        @out_streams.delete p.arg1
+      when "OKAY"
+        stream = @out_streams[p.arg1]
+        if stream 
+          if stream.spoofed_ack_count > 0
+            stream.spoofed_ack_count -= 1
+            should_send = false
+            log_packet "-ws -> #{@peer_port}", p
+          else
+            stream.remote_id = p.arg0
+          end
+        end
+      end
+      if should_send
+        log_packet "ws -> #{@peer_port}", p
+        send_data p.data
+      end
+    end
+
+    def post_init
+      #puts "opening ws wss://#{@server}/adb_tunnel?display=#{@display}&password=#{@password}"
+      @ws = Faye::WebSocket::Client.new("wss://#{@server}/adb_tunnel?display=#{@display}&password=#{@password}", nil, {ping: 10})
+      @ws.on :open do
+        @connected = true
+        flush
+      end
+
+      @ws.on :message do |msg|
+        data = msg.data.pack('c*')
+        remainder = @in_packet.consume(data)
+        while @in_packet.complete? do
+          handle_incoming_packet(@in_packet)
+          @in_packet = ADBPacket.new
+          remainder = @in_packet.consume(remainder)
+        end
+      end
+
+      @ws.on :close do |event|
+        puts "remote adb ws closed connection: #{event.code}"
+        if @onclose
+          close_event = TunnelCloseEvent.new(:websocket)
+          close_event.websocket_event = event
+          @onclose.call(close_event)
+          @onclose = nil
+        end
+        close_connection
+      end  
+    end
+
+    def unbind
+      #puts "unbind local adb"
+      if @onclose
+        close_event = TunnelCloseEvent.new(:local)
+        @onclose.call(close_event)
+        @onclose = nil
+      end
+
+      if @ws
+        @ws.close
+        @ws = nil
+      end
+    end
+
+    def flush
+      if @connected
+        @q.each do |data|
+          remainder = @out_packet.consume(data)
+          while @out_packet.complete? do
+            handle_outgoing_packet(@out_packet)
+            @out_packet = ADBPacket.new
+            remainder = @out_packet.consume(remainder)
+          end
+        end
+        @q = []
+      end
+    end
+
+    def receive_data(data)
+      #puts "local data: #{data.inspect}"
+      @q << data
+      flush
+    end
+  end
+end

data/lib/manymo/command.rb

@@ -0,0 +1,106 @@
+require "optparse"
+
+module Manymo
+  class Command
+    class <<self
+      def start(argv)
+        @argv = argv
+        @options = {}
+        @parser = OptionParser.new do |opts|
+          opts.banner = <<EOT
+manymo - Manymo Command Line Tool (Version #{Manymo::VERSION})
+
+Full documentation at https://www.manymo.com/pages/documentation/manymo-command-line-tool
+ 
+Usage:
+
+manymo [options] COMMAND [ARGUMENTS]
+
+Commands:
+        launch EMULATORNAME          Launch a headless emulator and make it appear like a local device
+        list                         List emulators; use the name attribute with the launch command
+        token                        Display a prompt to enter authorization token
+        tunnel TUNNELKEY             Make an in-browser emulator appear like a local device
+
+Options:
+EOT
+
+          opts.on("--adb-path PATH_TO_ADB", "Specify path to adb executable; otherwise uses the one in your path") do |v|
+            @options[:adb_path] = v
+          end
+        end
+        
+        begin
+          @parser.parse!
+        rescue
+          usage
+          exit
+        end
+
+        command = @argv[0]
+
+        @adb = ADB.new(@options[:adb_path])
+
+        @adb.ensure_available
+
+        @service = Service.new
+
+        case command
+        when /token/
+          get_auth_token(true)
+        when /tunnel/
+          args = @argv[1].split(':')
+          if args.count == 3
+            start_tunnel(args[0], args[1], args[2])
+          else
+            usage
+          end
+        when /list/
+          list_emulators
+        when /launch/
+          if @argv[1]
+            launch(@argv[1])
+          else
+            usage
+          end
+        when /version/
+          puts "Version #{Manymo::VERSION}"
+        else
+          usage
+        end
+      end
+
+      def usage
+        puts "#{@parser.banner}#{@parser.summarize.join("\n")}"
+      end
+
+
+      def list_emulators  
+        puts @service.get("/emulators")
+      end
+
+      def launch(name)
+          hostname, emulator_console_port, password = @service.get("/emulators/launch_emulator/#{name}").split(":")
+          start_tunnel(hostname, emulator_console_port, password)
+      end
+
+      def start_tunnel(server, port, password)
+        EM.run {
+          # hit Control + C to stop
+          Signal.trap("INT")  { EventMachine.stop }
+          Signal.trap("TERM") { EventMachine.stop }
+          EM
+          tunnel = Tunnel.new(server, port, password, @adb)
+
+          EM.add_shutdown_hook {
+            tunnel.shutdown("Process terminated")
+          }
+          tunnel.errback{ |message|
+            STDERR.puts message
+            exit 1
+          }
+        }
+      end
+    end
+  end
+end

data/lib/manymo/console_tunnel.rb

@@ -0,0 +1,68 @@
+module Manymo
+  module ConsoleTunnel
+    def initialize(server, display, password)
+      @server = server
+      @display = display
+      @password = password
+      @connected = false
+      @q = []
+    end
+
+    def onclose(&blk)
+      @onclose = blk
+    end
+
+    def post_init
+      #puts "opening ws wss://#{@server}/console_tunnel?display=#{@display}&password=#{@password}"
+      @ws = Faye::WebSocket::Client.new("wss://#{@server}/console_tunnel?display=#{@display}&password=#{@password}")
+      @ws.on :open do
+        @connected = true
+        flush
+      end
+
+      @ws.on :message do |msg|
+        #puts "console incoming: #{msg.data}"
+        send_data msg.data
+      end
+
+      @ws.on :close do |event|
+        if @onclose
+          close_event = TunnelCloseEvent.new(:websocket)
+          close_event.websocket_event = event
+          @onclose.call(close_event)
+          @onclose = nil
+        end
+        @ws = nil
+        close_connection
+      end  
+    end
+
+    def unbind
+      if @onclose
+        close_event = TunnelCloseEvent.new(:local)
+        @onclose.call(close_event)
+        @onclose = nil
+      end
+      if @ws
+        @ws.close
+        @ws = nil
+      end
+    end
+
+    def flush
+      if @connected
+        @q.each do |msg|
+          @ws.send msg.bytes.to_a
+        end
+        @q = []
+      end
+    end
+
+    def receive_data(data)
+      #puts "console outgoing: #{data.inspect}"
+      @q << data
+      flush
+    end
+  end
+end
+

data/lib/manymo/service.rb

@@ -0,0 +1,71 @@
+require "net/https"
+require "uri"
+
+module Manymo
+  class Service
+    HOST= ENV["MANYMO_API_HOST"] || "www.manymo.com"
+    BASE_URL="https://#{HOST}/api/v1"
+    def get_auth_token(force = false)
+      manymo_config_dir = File.expand_path('~/.manymo')
+      auth_token_path = manymo_config_dir + '/auth_token'
+      if ! force and File.exists?(auth_token_path)
+        return File.read(auth_token_path)
+      else
+        print "Please visit https://#{HOST}/user/client_applications to get your authorization token. Enter it here: "
+        STDOUT.flush
+        auth_token = STDIN.gets.chomp
+        if auth_token.empty?
+          STDERR.puts "No token supplied. Exiting."
+          exit 1
+        else
+          begin
+            if !File.exists?(manymo_config_dir)
+              FileUtils.mkdir(manymo_config_dir)
+            end
+            File.open(auth_token_path, "w") do |auth_token_path_file_handle|
+              auth_token_path_file_handle.write(auth_token)
+            end
+          rescue Errno::EACCES
+            STDERR.puts "Unable to store api token in #{auth_token_path}. You will be prompted again, next time this command is run."
+          end
+        end
+        return auth_token
+      end
+    end
+
+    def get(endpoint)
+      auth_token = get_auth_token
+      #puts "Auth token: #{auth_token}"
+      uri = URI.parse(BASE_URL + endpoint)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      if uri.scheme == 'https'
+        http.use_ssl = true
+      end
+      
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request["Authorization"] = "OAuth token=#{auth_token}"
+      request["Accept"] = "text/plain"
+      
+      begin
+        response = http.request(request)
+        if response.code.to_i / 100 == 2
+          response.body
+        elsif response.code.to_i == 401
+          puts "Invalid authorization token."
+          get_auth_token(true)
+          get(endpoint)
+        else
+          STDERR.puts "Error #{response.code}: #{response.body}"
+          exit 1
+        end
+      rescue SystemExit, Interrupt
+        exit 1
+      rescue Exception => e
+        STDERR.puts "Error: #{e.inspect}"
+        STDERR.puts "Please check that your network is connected and that no firewall rules are blocking #{uri.scheme} requests."
+        exit 1
+      end    
+    end
+  end
+end

data/lib/manymo/tunnel.rb

@@ -0,0 +1,145 @@
+require 'eventmachine'
+require "socket"
+require 'fileutils'
+require 'shellwords'
+
+module Manymo
+  class Tunnel
+    include EM::Deferrable
+    attr_accessor :serial_number
+
+    def initialize(server, port, password, adb)
+      @shutdown = false
+      @server = server
+      @port = port
+      @password = password
+      @display = (port.to_i - 5554) / 2
+      @adb = adb
+      EM::next_tick {
+        start
+      }
+      @adb_tunnels = []
+    end
+
+    def lockfile_for_port(port)
+      File.expand_path("~/.manymo/.tunnel_#{port}.lock")
+    end
+
+    def create_lockfile(port)
+      # Raises Errno::EEXIST if lockfile cannot be created
+      tunnel_lockfile = lockfile_for_port(port)
+      if File.exists?(tunnel_lockfile) && (Time.new - File.mtime(tunnel_lockfile)) > 60
+        File.unlink(tunnel_lockfile)
+      end
+      File.open(tunnel_lockfile, File::WRONLY|File::CREAT|File::EXCL) { |file| file.write $$ }
+    end
+
+    def remove_lockfile(port)
+      begin
+        File.unlink(lockfile_for_port(port))
+      rescue Errno::ENOENT
+      end
+    end
+
+    def find_available_local_emulator_port
+      (5554...5754).step(2) do |local_port|
+        created_lock = false
+        begin
+          create_lockfile(local_port)
+          created_lock = true
+          socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+          socket.bind(Socket.pack_sockaddr_in( local_port, '127.0.0.1' ))
+          socket.close
+          return local_port
+        rescue Errno::EADDRINUSE, Errno::EEXIST
+          remove_lockfile(local_port) if created_lock
+        end
+      end
+      nil
+    end
+
+    def is_device_listed?(console_port)
+      devices_output = `#{@adb.path.shellescape} devices`
+      #puts "output #{devices_output}"
+      devices_output.match(/emulator-#{console_port}/)
+    end
+
+    def start_tunnels_with_local_port(local_port)
+      #puts "Starting tunnels for #{local_port}"
+      EventMachine::start_server '0.0.0.0', local_port, ConsoleTunnel, @server, @display, @password do |tunnel|
+        tunnel.onclose { |event|
+          if event.authorization_denied?
+            self.fail("Authorization denied for console connection.")
+          end
+        }
+      end
+      EventMachine::start_server '0.0.0.0', local_port+1, ADBTunnel, @server, @display, @password do |tunnel|
+        @adb_tunnels << tunnel
+        tunnel.onclose { |event|
+          #puts "adb closed: #{event}"
+          @adb_tunnels.delete(tunnel)
+          if event.authorization_denied?
+            shutdown("Authorization denied for adb connection.")
+          elsif event.emulator_terminated?
+            shutdown("Emulator terminated.")
+          elsif @adb_tunnels.empty? && !@shutdown
+            # retry
+            puts "adb tunnel closed. retrying..."
+            connect_emulator_to_adb_server(local_port)
+          end
+        }
+      end
+      connect_emulator_to_adb_server(local_port)
+
+      @timeout_timer = EM::Timer.new(50) do 
+        shutdown("Timed out attempting to connect to emulator.")
+      end
+    end
+
+    def connect_emulator_to_adb_server(port)
+      connection_verifier = ADBConnectionVerifier.new(port)
+      connection_verifier.callback {
+        @serial_number = "emulator-#{port}"
+
+        # This will start adb server if it isn't started
+        listed = is_device_listed?(port)
+
+        if !listed
+          s = TCPSocket.open('localhost', 5037)
+          #s.puts("0012host:emulator:#{port+1}")
+          # Check again
+          listed = is_device_listed?(port)
+          listed = true
+        end
+
+        if listed
+          @timeout_timer.cancel if @timeout_timer
+          puts "Tunnel established; local serial number is: " + @serial_number
+        else
+          shutdown("Error connecting emulator to adb server.")
+        end        
+      }
+      connection_verifier.errback {
+        shutdown("Error connecting to emulator emulator.")
+      }
+    end
+
+    def shutdown(reason)
+      @shutdown = true
+      self.fail(reason)
+    end
+
+    def start
+      local_port = find_available_local_emulator_port
+      if local_port
+        begin
+          start_tunnels_with_local_port(local_port)
+        ensure
+          remove_lockfile(local_port)
+        end
+      else
+        self.fail("Unable to allocate local port in range 5554-5754 for tunnel")
+      end
+    end
+  end
+end

data/lib/manymo/tunnel_close_event.rb

@@ -0,0 +1,23 @@
+module Manymo
+  class TunnelCloseEvent
+    attr_accessor :reason
+    attr_accessor :websocket_event
+
+    def initialize(reason)
+      @reason = reason
+    end
+
+    def normal_closure?
+      @reason == :websocket && @websocket_event.code == 1000
+    end
+
+    def authorization_denied?
+      @reason == :websocket && @websocket_event.code == 4008
+    end
+
+    def emulator_terminated?
+      @reason == :websocket && @websocket_event.code == 4009
+    end
+  end
+
+end

data/lib/manymo/version.rb

@@ -0,0 +1,3 @@
+module Manymo
+  VERSION = "2.0.0.beta"
+end

data/manymo.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'manymo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "manymo"
+  spec.version       = Manymo::VERSION
+  spec.authors       = ["Pete Schwamb"]
+  spec.email         = ["pete@manymo.com"]
+  spec.description   = %q{Manymo client tool.}
+  spec.summary       = %q{A command line utility for connecting to remote emulators.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'faye', '~> 1.0.1'
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: manymo
+version: !ruby/object:Gem::Version
+  version: 2.0.0.beta
+platform: ruby
+authors:
+- Pete Schwamb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faye
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+description: Manymo client tool.
+email:
+- pete@manymo.com
+executables:
+- manymo
+- tunnel_test.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/manymo
+- bin/tunnel_test.rb
+- lib/manymo.rb
+- lib/manymo/adb.rb
+- lib/manymo/adb_connection_verifier.rb
+- lib/manymo/adb_packet.rb
+- lib/manymo/adb_stream.rb
+- lib/manymo/adb_tunnel.rb
+- lib/manymo/command.rb
+- lib/manymo/console_tunnel.rb
+- lib/manymo/service.rb
+- lib/manymo/tunnel.rb
+- lib/manymo/tunnel_close_event.rb
+- lib/manymo/version.rb
+- manymo.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: A command line utility for connecting to remote emulators.
+test_files: []