jscmd 0.0.2 → 0.1.0

data/lib/jscmd/pipebroker.rb

@@ -0,0 +1,62 @@
+module JSCommander
+  class PipeBroker
+    class PipeQueue
+      attr_reader :reader, :writer
+      
+      def initialize(r, w)
+        @reader, @writer = [r, w]
+      end
+      
+      def push(obj)
+        data = Marshal.dump(obj)
+        @writer.write([data.size].pack("N") + data)
+      end
+      
+      def pop
+        size = @reader.read(4).unpack("N")[0]
+        Marshal.load(@reader.read(size))
+      end
+      
+      def close
+        @reader.close
+        @writer.close
+      end
+    end
+  
+    PipeMessage = Struct.new(:name, :message)
+    
+    def initialize(reader, writer)
+      @subscribers = {}
+      @queue = PipeQueue.new(reader, writer)
+      Thread.start do
+        begin
+          loop do
+            pm = @queue.pop
+            if @subscribers[pm.name]
+              @subscribers[pm.name].each do |proc|
+                proc.call pm.message
+              end
+            end
+          end
+        rescue Exception
+          $stderr.puts $!
+        end
+      end
+    end
+
+    def subscribe(name, &proc)
+      @subscribers[name] ||= []
+      @subscribers[name] << proc
+      proc
+    end
+
+    def unsubscribe(name, subscriber)
+      sub = @subscribers[name].delete(subscriber)
+    end
+
+    def send(name, msg)
+#      puts "send #{name}, #{msg.inspect}"
+      @queue.push(PipeMessage.new(name, msg))
+    end
+  end
+end

data/lib/jscmd/proxyserver.rb

@@ -0,0 +1,224 @@
+#
+# jscommander.rb: Remote JavaScript Console
+#
+# Copyright 2007 Shinya Kasatani
+#
+
+require 'uri'
+require 'thread'
+require 'webrick'
+require 'zlib'
+
+require "jscmd/asynchttpproxy"
+
+module WEBrick
+  class HTTPResponse
+    alias_method :original_send_body, :send_body
+    def send_body(socket)
+      begin
+        original_send_body(socket)
+      rescue Errno::ECONNABORTED
+        raise Errno::ECONNRESET
+      end
+    end
+  end
+end
+
+module JSCommander
+  class ProxyServer < WEBrick::AsyncHTTPProxyServer
+    SCRIPT_DIR = "/_remote_js_proxy/"
+    
+    class CommandDispatcher
+      class CLIENT_ABORTED < StandardError; end
+      class SHUTDOWN < StandardError; end
+      
+      def initialize(server, command_queue)
+        @client_mutex = Mutex.new
+        @client_ready = ConditionVariable.new
+        @clients = []
+        @thread = Thread.start do
+          while server.status != :Shutdown
+            command = command_queue.pop
+            @client_mutex.synchronize do
+              while @clients.empty?
+                @client_ready.wait(@client_mutex)
+              end
+              @clients.first.push_command(command)
+            end
+          end
+        end
+      end
+
+      def shutdown
+        @clients.each do |client|
+          client.push_command SHUTDOWN
+        end
+      end
+
+      def format_clients
+        @clients.map{|c|"[#{c.hostname}]"}.join(",")
+      end
+
+      def new_client(req, &block)
+        client = Client.new(req)
+        @client_mutex.synchronize do
+          @clients << client
+          @client_ready.signal
+        end
+        begin
+          yield client
+        ensure
+          @client_mutex.synchronize do
+            @clients.delete(client)
+          end
+        end
+      end
+
+      class Client
+        def initialize(req)
+          @request = req
+          @queue = Queue.new
+          req_socket = req.instance_eval{@socket}
+          @thread = Thread.start do
+            sleep 1 until req_socket.eof?
+            @queue.push CLIENT_ABORTED
+          end
+        end
+
+        def hostname
+          uri = @request.header["referer"].to_s
+          if uri =~ %r{^\w+://([^/]+)}
+            $1
+          else
+            uri
+          end
+        end
+        
+        def push_command(command)
+          @queue.push(command)
+        end
+        
+        def pop_command
+          r = @queue.pop
+          # thread is automatically stopped if r == CLIENT_ABORTED
+          if r != CLIENT_ABORTED
+            @thread.kill
+          end
+          r
+        end
+      end
+    end
+
+    def initialize(broker, args = {})
+      @broker = broker
+      @commands = Queue.new
+      @command_dispatcher = CommandDispatcher.new(self, @commands)
+      @broker.subscribe("commands") do |msg|
+        if msg.attributes["type"] == "ping"
+          @broker.send("events", Message.new(nil, 
+                                             :type => "pong", 
+                                             :clients => @command_dispatcher.format_clients,
+                                             "in-reply-to" => msg.attributes["id"]))
+        else
+          @commands.push(msg)
+        end
+      end
+      @clients = []
+      super({:ProxyContentHandler => method(:handle_content).to_proc}.merge(args))
+    end
+
+    def service(req, res)
+      if req.path == "#{SCRIPT_DIR}agent.js"
+        res.content_type = "application/x-javascript"
+        res.body = File.read(File.join(File.dirname(__FILE__), "agent.js"))
+      elsif req.path == "#{SCRIPT_DIR}poll"
+        serve_script(req, res)
+      else
+        if req.header["accept-encoding"] && !req.header["accept-encoding"].empty?
+          if req.header["accept-encoding"].first.split(/,/).include?("gzip")
+            req.header["accept-encoding"] = ["gzip"]
+          else
+            req.header.delete "accept-encoding"
+          end
+        end
+        super
+      end
+    end
+
+    def shutdown
+      @command_dispatcher.shutdown
+      super
+    end
+
+    def serve_script(req, res)
+      # puts "serve:#{req.body}"
+      begin
+        @command_dispatcher.new_client(req) do |client|
+          type = req.header["x-jscmd-type"].first
+          if type && type != "connect"
+            @broker.send("events", Message.new(URI.decode(req.body), 
+                                               :type => type,
+                                               :clients => @command_dispatcher.format_clients,
+                                               "in-reply-to" => req.header["x-jscmd-in-reply-to"].first))
+            if "true" == req.header["x-jscmd-more"].first
+              # immediately send empty response to wait for another event
+              res.content_type = "text/plain"
+              res.body = ''
+              return
+            end
+          else
+            # new connection
+            @broker.send("events", Message.new(nil, :type => "connect",
+                                               :clients => @command_dispatcher.format_clients))
+          end
+          
+          command = client.pop_command
+          if command.is_a?(Class) # exception class
+            raise command
+          end
+          res.content_type = "text/plain"
+          res.header["X-JSCmd-Command-Id"] = command.attributes["id"]
+          res.header["X-JSCmd-Type"] = command.attributes["type"]
+          res.body = command.body
+        end
+      rescue CommandDispatcher::CLIENT_ABORTED
+        @broker.send("events", Message.new(nil, :type => "abort",
+                                           :clients => @command_dispatcher.format_clients))
+        raise WEBrick::HTTPStatus::EOFError
+      rescue CommandDispatcher::SHUTDOWN
+        raise WEBrick::HTTPStatus::EOFError
+      end
+    end
+
+    def handle_content(req, res)
+      # $stderr.puts "handle_content:type=#{res.content_type}, status=#{res.status}, encoding=#{res.header["content-encoding"]}"
+      if res.content_type =~ %r{^text/html} && res.status == 200
+        res.flush_body
+        # we cannot always trust content_type, so check if the content looks like html
+        body = res.body
+        if res.header["content-encoding"] == "gzip"
+          body = Zlib::GzipReader.new(StringIO.new(body)).read
+        end
+        if body =~ /^\s*</
+          body = body.dup
+          # puts "injecting javascript"
+          script_tag = '<script type="text/javascript" src="/_remote_js_proxy/agent.js"></script>'
+          unless body.sub!(%r{<head( .*?)?>}i){|s|s+script_tag}
+            body = script_tag + body
+          end
+          if res.header["content-encoding"] == "gzip"
+            io = StringIO.new
+            writer = Zlib::GzipWriter.new(io)
+            writer.write(body)
+            writer.close
+            res.body = io.string
+          else
+            res.body = body
+          end
+          res.content_length = res.body.size if res.content_length
+        end
+      end
+    end
+  end
+end
+

data/lib/jscmd/shell.rb

@@ -0,0 +1,201 @@
+begin
+  require "readline"
+rescue LoadError
+end
+
+module JSCommander
+  class Shell
+    class SimpleConsole
+      def initialize(input = $stdin)
+        @input = input
+      end
+
+      def show_banner
+      end
+
+      def readline
+        begin
+          line = @input.readline
+          line.chomp! if line
+          line
+        rescue EOFError
+          nil
+        end
+      end
+      
+      def close
+      end
+    end
+    
+    class ReadlineConsole
+      HISTORY_FILE = ".jscmd_history"
+      MAX_HISTORY = 200
+      
+      def history_path
+        File.join(ENV['HOME'] || ENV['USERPROFILE'], HISTORY_FILE)
+      end
+
+      def initialize(shell)
+        @shell = shell
+        if File.exist?(history_path)
+          hist = File.readlines(history_path).map{|line| line.chomp}
+          Readline::HISTORY.push(*hist)
+        end
+        if Readline.methods.include?("basic_word_break_characters=")
+          Readline.basic_word_break_characters = " \t\n\\`@><=;|&{([+-*/%"
+        end
+        Readline.completion_append_character = nil
+        Readline.completion_proc = @shell.method(:complete_property).to_proc
+      end
+      
+      def show_banner
+        $stderr.puts "Press Ctrl+D to exit."
+      end
+      
+      def close
+        open(history_path, "wb") do |f|
+          history = Readline::HISTORY.to_a
+          if history.size > MAX_HISTORY
+            history = history[history.size - MAX_HISTORY, MAX_HISTORY]
+          end
+          history.each{|line| f.puts(line)}
+        end
+      end
+
+      def readline
+        line = Readline.readline("#{@shell.clients}> ", true)
+        Readline::HISTORY.pop if /^\s*$/ =~ line
+        line
+      end
+    end
+
+    def console
+      @console ||= $stdin.tty? ? ReadlineConsole.new(self) : SimpleConsole.new
+      # @console ||= SimpleConsole.new
+    end
+
+    attr_reader :clients
+    
+    def initialize(broker)
+      @broker = broker
+      @clients = nil
+      @msg_lock = Mutex.new
+      @wait_for_event = {}
+    end
+
+    def generate_id
+      Array.new(16){rand(62)}.pack("C*").tr("\x00-\x3d", "A-Za-z0-9")
+    end
+
+    def send_script(line, type, &handler)
+      queue = Queue.new
+      @msg_lock.synchronize do
+        id = generate_id
+        @broker.send "commands", Message.new(line, 
+                                             :type => type, 
+                                             :id => id)
+        # wait until it gets response
+        @wait_for_event[id] = [queue, proc{|msg| yield msg}]
+      end
+      queue.pop
+    end
+
+    def object_props(object)
+      send_script(object, "properties") do |msg|
+        if msg.attributes["type"] == "value" && msg.body
+          msg.body.split(/,/)
+        else
+          []
+        end
+      end
+    end
+
+    def complete_property(word)
+      if word =~ /\.$/
+        object_props($`).map{|name| word + name}
+      elsif word =~ /\.([^.]+)$/
+        prefix = $1
+        parent = $`
+        props = object_props(parent)
+        props.select{|name|name[0...(prefix.size)] == prefix}.map{|name| "#{parent}.#{name}"}
+      else
+        props = object_props("this")
+        prefix = word
+        props.select{|name|name[0...(prefix.size)] == prefix}
+      end
+    end
+
+    def run
+      console.show_banner
+      
+      main_thread = Thread.current
+      
+      @broker.subscribe("events") do |msg|
+        id = msg.attributes["in-reply-to"]
+        type = msg.attributes["type"]
+        @clients = msg.attributes["clients"]
+        if id
+          @msg_lock.synchronize do
+            handler = @wait_for_event.delete(id)
+            if handler
+              queue, proc = handler
+              queue.push(proc.call(msg))
+            end
+          end
+          msg = nil
+        elsif "abort" == type
+          @msg_lock.synchronize do
+            handler =  @wait_for_event.values.first
+            if handler
+              queue, proc = handler
+              queue.push(nil)
+            end
+          end
+        end
+        unless msg.nil?
+          case type
+          when "value", "error"
+            puts msg.body
+          when "abort"
+            puts "aborted"
+          when "connect"
+            puts
+          end
+          if Process.methods.include?("kill")
+            Process.kill "INT", $$  # interrupt readline
+          else
+            # JRuby
+            main_thread.raise Interrupt
+          end
+        end
+      end
+      
+      begin
+        loop do
+          break unless line = console.readline
+          if line.chomp == ''
+            send_script(nil, "ping") {}
+          else
+            send_script(line, "eval") do |msg|
+              puts msg.body
+            end
+          end
+        end
+        $stderr.puts "Exiting shell..."
+      rescue Interrupt
+        # $stderr.puts "int"
+        retry
+      rescue SystemExit
+        return
+      rescue Exception => e
+        $stderr.puts "#{e.inspect} at:\n#{e.backtrace.join("\n")}"
+      ensure
+        begin
+          console.close
+        rescue Exception => e
+          $stderr.puts "failed to close console: #{e.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/jscmd/stompproxy.rb

@@ -0,0 +1,36 @@
+module JSCommander
+  # This broker proxy should be instantiated in each process.
+  class StompProxy
+    def initialize(url = nil)
+      require "stomp"
+      
+      url = "stomp://localhost:61613/" if url.nil?
+      @stomp = Stomp::Client.new(url)
+    end
+
+    def subscribe(name, &proc)
+      @stomp.subscribe("/topic/#{name}") do |msg|
+        attributes = {}
+        msg.headers.each do |key, value|
+          if key =~ /^jscmd\.(.*)/
+            attributes[$1] = value
+          end
+        end
+        proc.call(Message.new(msg.body, attributes))
+      end
+      proc
+    end
+
+    def unsubscribe(name, subscriber)
+      @stomp.unsubscribe("/topic/#{name}")
+    end
+
+    def send(name, msg)
+      headers = {}
+      msg.attributes.each do |key, value|
+        headers["jscmd." + key] = value
+      end
+      @stomp.send("/topic/#{name}", msg.body || "", headers)
+    end
+  end
+end

data/lib/jscmd/urlforwarder.rb

@@ -0,0 +1,43 @@
+require "cgi"
+
+module JSCommander
+  class URLForwarder < WEBrick::HTTPServer
+    def initialize(broker, args)
+      @broker = broker
+      super(args)
+      mount_proc("/send/", method(:forward_url).to_proc)
+      mount_proc("/", method(:show_bookmarklet).to_proc)
+    end
+
+    def show_bookmarklet(req, res)
+      res.content_type = "text/html"
+      res.body = <<EOS
+<html>
+<head>
+<title>Bookmarklet for forwarding URL</title>
+<script type="text/javascript">
+function setBrowserName(name) {
+  var link = document.getElementById("link");
+  link.removeChild(link.firstChild);
+  link.appendChild(document.createTextNode("Open with " + name));
+}
+</script>
+</head>
+<body>
+<form onsubmit="return false">Enter the name of another browser: <input type="text" value="Wii" oninput="setBrowserName(this.value)"/></form>
+<p>Drag the following link to your bookmarks toolbar.</p>
+<p><a id="link" href="javascript:void(window.open('http://localhost:#{@config[:Port]}/send/'+escape(location.href)))">Open with Wii</a></p>
+</body>
+EOS
+    end
+    
+    def forward_url(req, res)
+      uri = CGI.unescape(req.unparsed_uri.sub(%r{^/send/}, ""))
+      puts "opening " + uri
+      line = "(function() { var c = location.href; var l = '#{uri.gsub(/\\/, "\\\\").gsub("'", "\\'")}'; location.href = l; if (l.replace(/#.*$/,'') == c.replace(/#.*$/,'')) location.reload(); })()"
+      @broker.send("commands", Message.new(line, :type => "eval"))
+      res.content_type = "text/html"
+      res.body = '<html><head><script type="text/javascript">window.close()</script></head></html>'
+    end   
+  end
+end

data/lib/jscmd/version.rb

@@ -1,8 +1,8 @@
 module Jscmd #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 0
-    TINY  = 2
+    MINOR = 1
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/jscmd.rb

@@ -1 +1,14 @@
-Dir[File.join(File.dirname(__FILE__), 'jscmd/**/*.rb')].sort.each { |lib| require lib }
+# Dir[File.join(File.dirname(__FILE__), 'jscmd/**/*.rb')].sort.each { |lib| require lib }
+
+# message
+require "jscmd/message"
+
+# brokers
+require "jscmd/inprocessbroker"
+require "jscmd/pipebroker"
+require "jscmd/stompproxy"
+
+# clients
+require "jscmd/proxyserver"
+require "jscmd/shell"
+require "jscmd/urlforwarder"

data/test/test_helper.rb

@@ -1,2 +1,4 @@
-# require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/jscmd'
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require "rubygems"
+require "test/unit"
+require "jscmd"