noah 0.0.5-jruby → 0.1-jruby

data/examples/js/web_socket.js

@@ -0,0 +1,312 @@
+// Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
+// Lincense: New BSD Lincense
+// Reference: http://dev.w3.org/html5/websockets/
+// Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol
+
+(function() {
+  
+  if (window.WebSocket) return;
+
+  var console = window.console;
+  if (!console) console = {log: function(){ }, error: function(){ }};
+
+  function hasFlash() {
+    if ('navigator' in window && 'plugins' in navigator && navigator.plugins['Shockwave Flash']) {
+      return !!navigator.plugins['Shockwave Flash'].description;
+    }
+    if ('ActiveXObject' in window) {
+      try {
+        return !!new ActiveXObject('ShockwaveFlash.ShockwaveFlash').GetVariable('$version');
+      } catch (e) {}
+    }
+    return false;
+  }
+  
+  if (!hasFlash()) {
+    console.error("Flash Player is not installed.");
+    return;
+  }
+
+  WebSocket = function(url, protocol, proxyHost, proxyPort, headers) {
+    var self = this;
+    self.readyState = WebSocket.CONNECTING;
+    self.bufferedAmount = 0;
+    WebSocket.__addTask(function() {
+      self.__flash =
+        WebSocket.__flash.create(url, protocol, proxyHost || null, proxyPort || 0, headers || null);
+
+      self.__flash.addEventListener("open", function(fe) {
+        try {
+          if (self.onopen) self.onopen();
+        } catch (e) {
+          console.error(e.toString());
+        }
+      });
+
+      self.__flash.addEventListener("close", function(fe) {
+        try {
+          if (self.onclose) self.onclose();
+        } catch (e) {
+          console.error(e.toString());
+        }
+      });
+
+      self.__flash.addEventListener("message", function(fe) {
+        var data = decodeURIComponent(fe.getData());
+        try {
+          if (self.onmessage) {
+            var e;
+            if (window.MessageEvent) {
+              e = document.createEvent("MessageEvent");
+              e.initMessageEvent("message", false, false, data, null, null, window);
+            } else { // IE
+              e = {data: data};
+            }
+            self.onmessage(e);
+          }
+        } catch (e) {
+          console.error(e.toString());
+        }
+      });
+
+      self.__flash.addEventListener("stateChange", function(fe) {
+        try {
+          self.readyState = fe.getReadyState();
+          self.bufferedAmount = fe.getBufferedAmount();
+        } catch (e) {
+          console.error(e.toString());
+        }
+      });
+
+      //console.log("[WebSocket] Flash object is ready");
+    });
+  }
+
+  WebSocket.prototype.send = function(data) {
+    if (!this.__flash || this.readyState == WebSocket.CONNECTING) {
+      throw "INVALID_STATE_ERR: Web Socket connection has not been established";
+    }
+    var result = this.__flash.send(data);
+    if (result < 0) { // success
+      return true;
+    } else {
+      this.bufferedAmount = result;
+      return false;
+    }
+  };
+
+  WebSocket.prototype.close = function() {
+    if (!this.__flash) return;
+    if (this.readyState != WebSocket.OPEN) return;
+    this.__flash.close();
+    // Sets/calls them manually here because Flash WebSocketConnection.close cannot fire events
+    // which causes weird error:
+    // > You are trying to call recursively into the Flash Player which is not allowed.
+    this.readyState = WebSocket.CLOSED;
+    if (this.onclose) this.onclose();
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {string} type
+   * @param {function} listener
+   * @param {boolean} useCapture !NB Not implemented yet
+   * @return void
+   */
+  WebSocket.prototype.addEventListener = function(type, listener, useCapture) {
+    if (!('__events' in this)) {
+      this.__events = {};
+    }
+    if (!(type in this.__events)) {
+      this.__events[type] = [];
+      if ('function' == typeof this['on' + type]) {
+        this.__events[type].defaultHandler = this['on' + type];
+        this['on' + type] = WebSocket_FireEvent(this, type);
+      }
+    }
+    this.__events[type].push(listener);
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {string} type
+   * @param {function} listener
+   * @param {boolean} useCapture NB! Not implemented yet
+   * @return void
+   */
+  WebSocket.prototype.removeEventListener = function(type, listener, useCapture) {
+    if (!('__events' in this)) {
+      this.__events = {};
+    }
+    if (!(type in this.__events)) return;
+    for (var i = this.__events.length; i > -1; --i) {
+      if (listener === this.__events[type][i]) {
+        this.__events[type].splice(i, 1);
+        break;
+      }
+    }
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {WebSocketEvent} event
+   * @return void
+   */
+  WebSocket.prototype.dispatchEvent = function(event) {
+    if (!('__events' in this)) throw 'UNSPECIFIED_EVENT_TYPE_ERR';
+    if (!(event.type in this.__events)) throw 'UNSPECIFIED_EVENT_TYPE_ERR';
+
+    for (var i = 0, l = this.__events[event.type].length; i < l; ++ i) {
+      this.__events[event.type][i](event);
+      if (event.cancelBubble) break;
+    }
+
+    if (false !== event.returnValue &&
+        'function' == typeof this.__events[event.type].defaultHandler)
+    {
+      this.__events[event.type].defaultHandler(event);
+    }
+  };
+
+  /**
+   *
+   * @param {object} object
+   * @param {string} type
+   */
+  function WebSocket_FireEvent(object, type) {
+    return function(data) {
+      var event = new WebSocketEvent();
+      event.initEvent(type, true, true);
+      event.target = event.currentTarget = object;
+      for (var key in data) {
+        event[key] = data[key];
+      }
+      object.dispatchEvent(event, arguments);
+    };
+  }
+
+  /**
+   * Basic implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-interface">DOM 2 EventInterface</a>}
+   *
+   * @class
+   * @constructor
+   */
+  function WebSocketEvent(){}
+
+  /**
+   *
+   * @type boolean
+   */
+  WebSocketEvent.prototype.cancelable = true;
+
+  /**
+   *
+   * @type boolean
+   */
+  WebSocketEvent.prototype.cancelBubble = false;
+
+  /**
+   *
+   * @return void
+   */
+  WebSocketEvent.prototype.preventDefault = function() {
+    if (this.cancelable) {
+      this.returnValue = false;
+    }
+  };
+
+  /**
+   *
+   * @return void
+   */
+  WebSocketEvent.prototype.stopPropagation = function() {
+    this.cancelBubble = true;
+  };
+
+  /**
+   *
+   * @param {string} eventTypeArg
+   * @param {boolean} canBubbleArg
+   * @param {boolean} cancelableArg
+   * @return void
+   */
+  WebSocketEvent.prototype.initEvent = function(eventTypeArg, canBubbleArg, cancelableArg) {
+    this.type = eventTypeArg;
+    this.cancelable = cancelableArg;
+    this.timeStamp = new Date();
+  };
+
+
+  WebSocket.CONNECTING = 0;
+  WebSocket.OPEN = 1;
+  WebSocket.CLOSED = 2;
+
+  WebSocket.__tasks = [];
+
+  WebSocket.__initialize = function() {
+    if (!WebSocket.__swfLocation) {
+      //console.error("[WebSocket] set WebSocket.__swfLocation to location of WebSocketMain.swf");
+      //return;
+      WebSocket.__swfLocation = "js/WebSocketMain.swf";
+    }
+    var container = document.createElement("div");
+    container.id = "webSocketContainer";
+    // Puts the Flash out of the window. Note that we cannot use display: none or visibility: hidden
+    // here because it prevents Flash from loading at least in IE.
+    container.style.position = "absolute";
+    container.style.left = "-100px";
+    container.style.top = "-100px";
+    var holder = document.createElement("div");
+    holder.id = "webSocketFlash";
+    container.appendChild(holder);
+    document.body.appendChild(container);
+    swfobject.embedSWF(
+      WebSocket.__swfLocation, "webSocketFlash", "8", "8", "9.0.0",
+      null, {bridgeName: "webSocket"}, null, null,
+      function(e) {
+        if (!e.success) console.error("[WebSocket] swfobject.embedSWF failed");
+      }
+    );
+    FABridge.addInitializationCallback("webSocket", function() {
+      try {
+        //console.log("[WebSocket] FABridge initializad");
+        WebSocket.__flash = FABridge.webSocket.root();
+        WebSocket.__flash.setCallerUrl(location.href);
+        for (var i = 0; i < WebSocket.__tasks.length; ++i) {
+          WebSocket.__tasks[i]();
+        }
+        WebSocket.__tasks = [];
+      } catch (e) {
+        console.error("[WebSocket] " + e.toString());
+      }
+    });
+  };
+
+  WebSocket.__addTask = function(task) {
+    if (WebSocket.__flash) {
+      task();
+    } else {
+      WebSocket.__tasks.push(task);
+    }
+  }
+
+  // called from Flash
+  function webSocketLog(message) {
+    console.log(decodeURIComponent(message));
+  }
+
+  // called from Flash
+  function webSocketError(message) {
+    console.error(decodeURIComponent(message));
+  }
+
+  if (window.addEventListener) {
+    window.addEventListener("load", WebSocket.__initialize, false);
+  } else {
+    window.attachEvent("onload", WebSocket.__initialize);
+  }
+  
+})();

data/examples/logger.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..','lib','noah','custom_watcher')
+require 'logger'
+
+class LoggingWatcher < Noah::CustomWatcher
+  redis_host "redis://127.0.0.1:6379/0"
+  pattern "//noah"
+  destination Proc.new {|x| log = Logger.new(STDOUT); log.debug(x)}
+  run!
+end

data/examples/reconfiguring-sinatra-watcher.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..','lib','noah','custom_watcher')
+require 'em-http-request'
+
+class HttpPostWatch < Noah::CustomWatcher
+  redis_host "redis://127.0.0.1:6379/0"
+  pattern "//noah/configuration/redis_server"
+  destination Proc.new {|x| ::EM::HttpRequest.new('http://localhost:4567/webhook', :connection_timeout => 2, :inactivity_timeout => 4).post :body => x}
+  run!
+end

data/examples/reconfiguring-sinatra.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require 'sinatra'
+require 'ohm'
+require 'open-uri'
+require 'json'
+
+set :noah_server, 'http://localhost:5678'
+set :noah_client_name, 'my_sinatra_app'
+
+def get_config_from_noah(setting)
+  begin
+    c = open("#{settings.noah_server}/c/#{settings.noah_client_name}/#{setting}").read
+    set setting.to_sym, c
+  end
+end
+
+get_config_from_noah('redis_server')
+
+def get_redis_version
+  Ohm.connect :url => settings.redis_server
+  Ohm.redis.info["redis_version"]
+end
+
+get "/" do
+  "Redis version: #{get_redis_version}"
+end
+
+put "/webhook" do
+  data = JSON.parse(request.body.read)
+  settings.redis_server = data["body"]
+  resp = {:message => "reconfigured", :setting => data["name"], :body => data["body"]}.to_json
+  "#{resp}"
+end

data/examples/simple-post.rb

@@ -0,0 +1,17 @@
+require 'sinatra/base'
+require 'json'
+
+class NoahPostDemo < Sinatra::Base
+  configure do
+    set :app_file, __FILE__
+    set :server, %w[thin]
+    set :logging, true
+    set :run, true
+  end
+
+  post '/webhook/?' do
+    x = request.body.read
+    p JSON.load(x)
+  end
+
+end

data/examples/websocket.html

@@ -0,0 +1,24 @@
+<html>
+  <head>
+    <script src='http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js'></script>
+    <script src='js/swfobject.js'></script>
+    <script src='js/FABridge.js'></script>
+    <script src='js/web_socket.js'></script>
+    <script>
+      $(document).ready(function(){
+        function debug(str){ $("#debug").append("<p>" +  str); };
+
+        ws = new WebSocket("ws://localhost:3009/");
+        ws.onmessage = function(evt) { $("#msg").append("<p>"+evt.data+"</p>"); };
+        ws.onclose = function() { debug("socket closed"); };
+        ws.onopen = function() {
+          debug("connected...");
+        };
+      });
+    </script>
+  </head>
+  <body>
+    <div id="debug"></div>
+    <div id="msg"></div>
+  </body>
+</html>

data/examples/websocket.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
+require 'rubygems'
+require 'em-websocket'
+require 'em-hiredis'
+require 'thin'
+require 'noah'
+## Uncomment the following to hardcode a redis url
+#ENV['REDIS_URL'] = "redis://localhost:6379/0"
+
+EventMachine.run do
+
+  # Passing messages...like a boss
+  @channel = EventMachine::Channel.new
+
+  Thin::Server.start Noah::App
+  r = EventMachine::Hiredis::Client.connect
+  r.psubscribe("//noah/*")
+  r.on(:pmessage) do |pattern, event, message|
+    @channel.push "(#{event}) #{message}"
+  end
+
+  EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 3009) do |ws|
+    ws.onopen {
+      sub = @channel.subscribe { |msg| 
+        ws.send msg 
+      }
+
+      @channel.push "#{sub} connected and waiting...."
+
+      ws.onmessage { |msg|
+        @channel.push "<#{sub}>: #{msg}"
+      }
+
+      ws.onclose {
+        @channel.unsubscribe(sub)
+      }
+    }
+  end
+
+end