pi-codex-auto-review 0.1.0

package/node_modules/node-forge/flash/SocketPool.as

@@ -0,0 +1,754 @@
+/*
+ * Copyright (c) 2009-2010 Digital Bazaar, Inc. All rights reserved.
+ *
+ * @author Dave Longley
+ */
+package
+{
+   import flash.display.Sprite;
+
+   /**
+    * A SocketPool is a flash object that can be embedded in a web page to
+    * allow javascript access to pools of Sockets.
+    *
+    * Javascript can create a pool and then as many Sockets as it desires. Each
+    * Socket will be assigned a unique ID that allows continued javascript
+    * access to it. There is no limit on the number of persistent socket
+    * connections.
+    */
+   public class SocketPool extends Sprite
+   {
+      import flash.events.Event;
+      import flash.events.EventDispatcher;
+      import flash.errors.IOError;
+      import flash.events.IOErrorEvent;
+      import flash.events.ProgressEvent;
+      import flash.events.SecurityErrorEvent;
+      import flash.events.TextEvent;
+      import flash.external.ExternalInterface;
+      import flash.net.SharedObject;
+      import flash.system.Security;
+      import flash.utils.ByteArray;
+      import mx.utils.Base64Decoder;
+      import mx.utils.Base64Encoder;
+
+      // a map of ID to Socket
+      private var mSocketMap:Object;
+
+      // a counter for Socket IDs (Note: assumes there will be no overflow)
+      private var mNextId:uint;
+
+      // an event dispatcher for sending events to javascript
+      private var mEventDispatcher:EventDispatcher;
+
+      /**
+       * Creates a new, uninitialized SocketPool.
+       *
+       * @throws Error - if no external interface is available to provide
+       *                 javascript access.
+       */
+      public function SocketPool()
+      {
+         if(!ExternalInterface.available)
+         {
+            trace("ExternalInterface is not available");
+            throw new Error(
+               "Flash's ExternalInterface is not available. This is a " +
+               "requirement of SocketPool and therefore, it will be " +
+               "unavailable.");
+         }
+         else
+         {
+            try
+            {
+               // set up javascript access:
+
+               // initializes/cleans up the SocketPool
+               ExternalInterface.addCallback("init", init);
+               ExternalInterface.addCallback("cleanup", cleanup);
+
+               // creates/destroys a socket
+               ExternalInterface.addCallback("create", create);
+               ExternalInterface.addCallback("destroy", destroy);
+
+               // connects/closes a socket
+               ExternalInterface.addCallback("connect", connect);
+               ExternalInterface.addCallback("close", close);
+
+               // checks for a connection
+               ExternalInterface.addCallback("isConnected", isConnected);
+
+               // sends/receives data over the socket
+               ExternalInterface.addCallback("send", send);
+               ExternalInterface.addCallback("receive", receive);
+
+               // gets the number of bytes available on a socket
+               ExternalInterface.addCallback(
+                  "getBytesAvailable", getBytesAvailable);
+
+               // add a callback for subscribing to socket events
+               ExternalInterface.addCallback("subscribe", subscribe);
+
+               // add callbacks for deflate/inflate
+               ExternalInterface.addCallback("deflate", deflate);
+               ExternalInterface.addCallback("inflate", inflate);
+
+               // add callbacks for local disk storage
+               ExternalInterface.addCallback("setItem", setItem);
+               ExternalInterface.addCallback("getItem", getItem);
+               ExternalInterface.addCallback("removeItem", removeItem);
+               ExternalInterface.addCallback("clearItems", clearItems);
+
+               // socket pool is now ready
+               ExternalInterface.call("window.forge.socketPool.ready");
+            }
+            catch(e:Error)
+            {
+               log("error=" + e.errorID + "," + e.name + "," + e.message);
+               throw e;
+            }
+
+            log("ready");
+         }
+      }
+
+      /**
+       * A debug logging function.
+       *
+       * @param obj the string or error to log.
+       */
+      CONFIG::debugging
+      private function log(obj:Object):void
+      {
+         if(obj is String)
+         {
+            var str:String = obj as String;
+            ExternalInterface.call("console.log", "SocketPool", str);
+         }
+         else if(obj is Error)
+         {
+            var e:Error = obj as Error;
+            log("error=" + e.errorID + "," + e.name + "," + e.message);
+         }
+      }
+
+      CONFIG::release
+      private function log(obj:Object):void
+      {
+         // log nothing in release mode
+      }
+
+      /**
+       * Called by javascript to initialize this SocketPool.
+       *
+       * @param options:
+       *        marshallExceptions: true to pass exceptions to and from
+       *           javascript.
+       */
+      private function init(... args):void
+      {
+         log("init()");
+
+         // get options from first argument
+         var options:Object = args.length > 0 ? args[0] : null;
+
+         // create socket map, set next ID, and create event dispatcher
+         mSocketMap = new Object();
+         mNextId = 1;
+         mEventDispatcher = new EventDispatcher();
+
+         // enable marshalling exceptions if appropriate
+         if(options != null &&
+            "marshallExceptions" in options &&
+            options.marshallExceptions === true)
+         {
+            try
+            {
+               // Note: setting marshallExceptions in IE, even inside of a
+               // try-catch block will terminate flash. Don't set this on IE.
+               ExternalInterface.marshallExceptions = true;
+            }
+            catch(e:Error)
+            {
+               log(e);
+            }
+         }
+
+         log("init() done");
+      }
+
+      /**
+       * Called by javascript to clean up a SocketPool.
+       */
+      private function cleanup():void
+      {
+         log("cleanup()");
+
+         mSocketMap = null;
+         mNextId = 1;
+         mEventDispatcher = null;
+
+         log("cleanup() done");
+      }
+
+      /**
+       * Handles events.
+       *
+       * @param e the event to handle.
+       */
+      private function handleEvent(e:Event):void
+      {
+         // dispatch socket event
+         var message:String = (e is TextEvent) ? (e as TextEvent).text : null;
+         mEventDispatcher.dispatchEvent(
+            new SocketEvent(e.type, e.target as PooledSocket, message));
+      }
+
+      /**
+       * Called by javascript to create a Socket.
+       *
+       * @return the Socket ID.
+       */
+      private function create():String
+      {
+         log("create()");
+
+         // create a Socket
+         var id:String = "" + mNextId++;
+         var s:PooledSocket = new PooledSocket();
+         s.id = id;
+         s.addEventListener(Event.CONNECT, handleEvent);
+         s.addEventListener(Event.CLOSE, handleEvent);
+         s.addEventListener(ProgressEvent.SOCKET_DATA, handleEvent);
+         s.addEventListener(IOErrorEvent.IO_ERROR, handleEvent);
+         s.addEventListener(SecurityErrorEvent.SECURITY_ERROR, handleEvent);
+         mSocketMap[id] = s;
+
+         log("socket " + id + " created");
+         log("create() done");
+
+         return id;
+      }
+
+      /**
+       * Called by javascript to clean up a Socket.
+       *
+       * @param id the ID of the Socket to clean up.
+       */
+      private function destroy(id:String):void
+      {
+         log("destroy(" + id + ")");
+
+         if(id in mSocketMap)
+         {
+            // remove Socket
+            delete mSocketMap[id];
+            log("socket " + id + " destroyed");
+         }
+
+         log("destroy(" + id + ") done");
+      }
+
+      /**
+       * Connects the Socket with the given ID to the given host and port,
+       * using the given socket policy port.
+       *
+       * @param id the ID of the Socket.
+       * @param host the host to connect to.
+       * @param port the port to connect to.
+       * @param spPort the security policy port to use, 0 to use a url.
+       * @param spUrl the http URL to the policy file to use, null for default.
+       */
+      private function connect(
+         id:String, host:String, port:uint, spPort:uint,
+         spUrl:String = null):void
+      {
+         log("connect(" +
+            id + "," + host + "," + port + "," + spPort + "," + spUrl + ")");
+
+         if(id in mSocketMap)
+         {
+            // get the Socket
+            var s:PooledSocket = mSocketMap[id];
+
+            // load socket policy file
+            // (permits socket access to backend)
+            if(spPort !== 0)
+            {
+               spUrl = "xmlsocket://" + host + ":" + spPort;
+               log("using cross-domain url: " + spUrl);
+               Security.loadPolicyFile(spUrl);
+            }
+            else if(spUrl !== null && typeof(spUrl) !== undefined)
+            {
+               log("using cross-domain url: " + spUrl);
+               Security.loadPolicyFile(spUrl);
+            }
+            else
+            {
+               log("not loading any cross-domain url");
+            }
+
+            // connect
+            s.connect(host, port);
+         }
+         else
+         {
+            // no such socket
+            log("socket " + id + " does not exist");
+         }
+
+         log("connect(" + id + ") done");
+      }
+
+      /**
+       * Closes the Socket with the given ID.
+       *
+       * @param id the ID of the Socket.
+       */
+      private function close(id:String):void
+      {
+         log("close(" + id + ")");
+
+         if(id in mSocketMap)
+         {
+            // close the Socket
+            var s:PooledSocket = mSocketMap[id];
+            if(s.connected)
+            {
+               s.close();
+            }
+         }
+         else
+         {
+            // no such socket
+            log("socket " + id + " does not exist");
+         }
+
+         log("close(" + id + ") done");
+      }
+
+      /**
+       * Determines if the Socket with the given ID is connected or not.
+       *
+       * @param id the ID of the Socket.
+       *
+       * @return true if the socket is connected, false if not.
+       */
+      private function isConnected(id:String):Boolean
+      {
+         var rval:Boolean = false;
+         log("isConnected(" + id + ")");
+
+         if(id in mSocketMap)
+         {
+            // check the Socket
+            var s:PooledSocket = mSocketMap[id];
+            rval = s.connected;
+         }
+         else
+         {
+            // no such socket
+            log("socket " + id + " does not exist");
+         }
+
+         log("isConnected(" + id + ") done");
+         return rval;
+      }
+
+      /**
+       * Writes bytes to a Socket.
+       *
+       * @param id the ID of the Socket.
+       * @param bytes the string of base64-encoded bytes to write.
+       *
+       * @return true on success, false on failure.
+       */
+      private function send(id:String, bytes:String):Boolean
+      {
+         var rval:Boolean = false;
+         log("send(" + id + ")");
+
+         if(id in mSocketMap)
+         {
+         	// write bytes to socket
+            var s:PooledSocket = mSocketMap[id];
+            try
+            {
+               var b64:Base64Decoder = new Base64Decoder();
+               b64.decode(bytes);
+               var b:ByteArray = b64.toByteArray();
+               s.writeBytes(b, 0, b.length);
+               s.flush();
+               rval = true;
+            }
+            catch(e:IOError)
+            {
+               log(e);
+
+               // dispatch IO error event
+               mEventDispatcher.dispatchEvent(new SocketEvent(
+                  IOErrorEvent.IO_ERROR, s, e.message));
+               if(s.connected)
+               {
+                  s.close();
+               }
+            }
+         }
+         else
+         {
+            // no such socket
+            log("socket " + id + " does not exist");
+         }
+
+         log("send(" + id + ") done");
+         return rval;
+      }
+
+      /**
+       * Receives bytes from a Socket.
+       *
+       * @param id the ID of the Socket.
+       * @param count the maximum number of bytes to receive.
+       *
+       * @return an object with 'rval' set to the received bytes,
+       *         base64-encoded, or set to null on error.
+       */
+      private function receive(id:String, count:uint):Object
+      {
+      	 var rval:String = null;
+         log("receive(" + id + "," + count + ")");
+
+         if(id in mSocketMap)
+         {
+         	// only read what is available
+            var s:PooledSocket = mSocketMap[id];
+            if(count > s.bytesAvailable)
+            {
+               count = s.bytesAvailable;
+            }
+
+            try
+            {
+               // read bytes from socket
+               var b:ByteArray = new ByteArray();
+               s.readBytes(b, 0, count);
+               b.position = 0;
+               var b64:Base64Encoder = new Base64Encoder();
+               b64.insertNewLines = false;
+               b64.encodeBytes(b, 0, b.length);
+               rval = b64.toString();
+            }
+            catch(e:IOError)
+            {
+               log(e);
+
+               // dispatch IO error event
+               mEventDispatcher.dispatchEvent(new SocketEvent(
+                  IOErrorEvent.IO_ERROR, s, e.message));
+               if(s.connected)
+               {
+                  s.close();
+               }
+            }
+         }
+         else
+         {
+            // no such socket
+            log("socket " + id + " does not exist");
+         }
+
+         log("receive(" + id + "," + count + ") done");
+         return {rval: rval};
+      }
+
+      /**
+       * Gets the number of bytes available from a Socket.
+       *
+       * @param id the ID of the Socket.
+       *
+       * @return the number of available bytes.
+       */
+      private function getBytesAvailable(id:String):uint
+      {
+         var rval:uint = 0;
+         log("getBytesAvailable(" + id + ")");
+
+         if(id in mSocketMap)
+         {
+            var s:PooledSocket = mSocketMap[id];
+            rval = s.bytesAvailable;
+         }
+         else
+         {
+            // no such socket
+            log("socket " + id + " does not exist");
+         }
+
+         log("getBytesAvailable(" + id +") done");
+         return rval;
+      }
+
+      /**
+       * Registers a javascript function as a callback for an event.
+       *
+       * @param eventType the type of event (socket event types).
+       * @param callback the name of the callback function.
+       */
+      private function subscribe(eventType:String, callback:String):void
+      {
+         log("subscribe(" + eventType + "," + callback + ")");
+
+         switch(eventType)
+         {
+            case Event.CONNECT:
+            case Event.CLOSE:
+            case IOErrorEvent.IO_ERROR:
+            case SecurityErrorEvent.SECURITY_ERROR:
+            case ProgressEvent.SOCKET_DATA:
+            {
+               log(eventType + " => " + callback);
+               mEventDispatcher.addEventListener(
+                  eventType, function(event:SocketEvent):void
+               {
+                  log("event dispatched: " + eventType);
+
+                  // build event for javascript
+                  var e:Object = new Object();
+                  e.id = event.socket ? event.socket.id : 0;
+                  e.type = eventType;
+                  if(event.socket && event.socket.connected)
+                  {
+                     e.bytesAvailable = event.socket.bytesAvailable;
+                  }
+                  else
+                  {
+                     e.bytesAvailable = 0;
+                  }
+                  if(event.message)
+                  {
+                     e.message = event.message;
+                  }
+
+                  // send event to javascript
+                  ExternalInterface.call(callback, e);
+               });
+               break;
+            }
+            default:
+               throw new ArgumentError(
+                  "Could not subscribe to event. " +
+                  "Invalid event type specified: " + eventType);
+         }
+
+         log("subscribe(" + eventType + "," + callback + ") done");
+      }
+
+      /**
+       * Deflates the given data.
+       *
+       * @param data the base64-encoded data to deflate.
+       *
+       * @return an object with 'rval' set to deflated data, base64-encoded.
+       */
+      private function deflate(data:String):Object
+      {
+         log("deflate");
+
+         var b64d:Base64Decoder = new Base64Decoder();
+         b64d.decode(data);
+         var b:ByteArray = b64d.toByteArray();
+         b.compress();
+         b.position = 0;
+         var b64e:Base64Encoder = new Base64Encoder();
+         b64e.insertNewLines = false;
+         b64e.encodeBytes(b, 0, b.length);
+
+         log("deflate done");
+         return {rval: b64e.toString()};
+      }
+
+      /**
+       * Inflates the given data.
+       *
+       * @param data the base64-encoded data to inflate.
+       *
+       * @return an object with 'rval' set to the inflated data,
+       *         base64-encoded, null on error.
+       */
+      private function inflate(data:String):Object
+      {
+         log("inflate");
+         var rval:Object = {rval: null};
+      	
+      	 try
+      	 {
+            var b64d:Base64Decoder = new Base64Decoder();
+            b64d.decode(data);
+            var b:ByteArray = b64d.toByteArray();
+            b.uncompress();
+            b.position = 0;
+            var b64e:Base64Encoder = new Base64Encoder();
+            b64e.insertNewLines = false;
+            b64e.encodeBytes(b, 0, b.length);
+            rval.rval = b64e.toString();
+         }
+         catch(e:Error)
+         {
+         	log(e);
+            rval.error = {
+                id: e.errorID,
+                name: e.name,
+                message: e.message
+            };
+         }
+
+         log("inflate done");
+         return rval;
+      }
+
+      /**
+       * Stores an item with a key and arbitrary base64-encoded data on local
+       * disk.
+       *
+       * @param key the key for the item.
+       * @param data the base64-encoded item data.
+       * @param storeId the storage ID to use, defaults to "forge.storage".
+       *
+       * @return an object with rval set to true on success, false on failure
+       *         with error included.
+       */
+      private function setItem(
+         key:String, data:String, storeId:String = "forge.storage"):Object
+      {
+         var rval:Object = {rval: false};
+         try
+         {
+            var store:SharedObject = SharedObject.getLocal(storeId);
+            if(!('keys' in store.data))
+            {
+               store.data.keys = {};
+            }
+            store.data.keys[key] = data;
+            store.flush();
+            rval.rval = true;
+         }
+         catch(e:Error)
+         {
+         	log(e);
+         	rval.error = {
+                id: e.errorID,
+                name: e.name,
+                message: e.message
+            };
+         }
+         return rval;
+      }
+
+      /**
+       * Gets an item from the local disk.
+       *
+       * @param key the key for the item.
+       * @param storeId the storage ID to use, defaults to "forge.storage".
+       *
+       * @return an object with rval set to the item data (which may be null),
+       *         check for error object if null.
+       */
+      private function getItem(
+         key:String, storeId:String = "forge.storage"):Object
+      {
+         var rval:Object = {rval: null};
+         try
+         {
+            var store:SharedObject = SharedObject.getLocal(storeId);
+            if('keys' in store.data && key in store.data.keys)
+            {
+               rval.rval = store.data.keys[key];
+            }
+         }
+         catch(e:Error)
+         {
+         	log(e);
+            rval.error = {
+                id: e.errorID,
+                name: e.name,
+                message: e.message
+            };
+         }
+         return rval;
+      }
+
+      /**
+       * Removes an item from the local disk.
+       *
+       * @param key the key for the item.
+       * @param storeId the storage ID to use, defaults to "forge.storage".
+       *
+       * @return an object with rval set to true if removed, false if not.
+       */
+      private function removeItem(
+         key:String, storeId:String = "forge.storage"):Object
+      {
+         var rval:Object = {rval: false};
+         try
+         {
+            var store:SharedObject = SharedObject.getLocal(storeId);
+            if('keys' in store.data && key in store.data.keys)
+            {
+               delete store.data.keys[key];
+
+               // clean up storage entirely if empty
+               var empty:Boolean = true;
+               for(var prop:String in store.data.keys)
+               {
+                  empty = false;
+                  break;
+               }
+               if(empty)
+               {
+                  store.clear();
+               }
+               rval.rval = true;
+            }
+         }
+         catch(e:Error)
+         {
+            log(e);
+            rval.error = {
+                id: e.errorID,
+                name: e.name,
+                message: e.message
+            };
+         }
+         return rval;
+      }
+
+      /**
+       * Clears an entire store of all of its items.
+       *
+       * @param storeId the storage ID to use, defaults to "forge.storage".
+       *
+       * @return an object with rval set to true if cleared, false if not.
+       */
+      private function clearItems(storeId:String = "forge.storage"):Object
+      {
+         var rval:Object = {rval: false};
+         try
+         {
+            var store:SharedObject = SharedObject.getLocal(storeId);
+            store.clear();
+            rval.rval = true;
+         }
+         catch(e:Error)
+         {
+            log(e);
+            rval.error = {
+                id: e.errorID,
+                name: e.name,
+                message: e.message
+            };
+         }
+         return rval;
+      }
+   }
+}