mako 0.0.0

data/lib/mako/data/flash_widget_dev_core/src/org/rubyamf/remoting/ssr/RemotingCall.as

@@ -0,0 +1,211 @@
+// Copyright (c) 2007 rubyamf.org (aaron@rubyamf.org)
+// License - http://www.gnu.org/copyleft/gpl.html
+package org.rubyamf.remoting.ssr
+{
+	import flash.events.ErrorEvent;
+	import flash.events.EventDispatcher;
+	import flash.net.Responder;
+	import flash.utils.*;
+	import org.rubyamf.remoting.ssr.FaultEvent;
+	import org.rubyamf.remoting.ssr.RemotingConnection;
+	import org.rubyamf.remoting.ssr.RemotingService;
+	import org.rubyamf.remoting.ssr.ResultEvent;
+	public class RemotingCall extends EventDispatcher
+	{
+		private var connection:RemotingConnection;			//the remoting connection
+		private var operationPath:String;								//the operation
+		private var responder:Responder;								//a call responder
+		private var onresult:Function;									//result handler
+		private var onfault:Function;										//fault handler
+		private var args:Array;													//call arguments
+		private var meta:Object;												//operation meta (timeout, maxAttempts, returnArgs)
+		private var attempt:uint = 0;										//number of attemts
+		private var busyInt:Number;											//busy interval
+		private var timeoutInt:Number;									//timeout interval
+		private var completed:Boolean = false;					//complete flag
+		private var service:RemotingService
+		/*
+		 * Constructor
+		 * @param remotingConnection:RemotingConnection
+		 * @param operation:String
+		 * @param onresult:Function
+		 * @param onfault:Function
+		 * @param arguments:Array
+		 * @param meta:Object
+		 */
+		public function RemotingCall(connection:RemotingConnection, operationPath:String, onresult:Function, onfault:Function, args:Array, meta:Object)
+		{
+			this.connection = connection;
+			this.operationPath = operationPath;
+			this.args = args;
+			this.onresult = onresult;
+			this.onfault = onfault;
+			this.meta = meta;
+		}
+		/*
+		 * onResult - result of a remoting call. The result propogates through this method
+		 * and is turned into a ResultEvent, then the onresult callback is called.
+		 * @param obj:Object
+		 */
+		private function onResult(resObj:Object):void
+		{
+			if(!completed)
+			{
+				completed = true;
+				clearIntervals();
+				var re:ResultEvent = new ResultEvent(ResultEvent.RESULT, false, true, resObj);
+				var fe:FaultEvent = new FaultEvent(FaultEvent.FAULT, false, true, resObj);
+				try
+				{
+					if(resObj == null || resObj == undefined as Object)
+					{
+						service.removePendingCall();
+						dispatchEvent(re);
+						//service.dispatchResult(re);
+						(meta.returnArgs) ? onresult(re,args) : onresult(re);
+					}
+					else if(typeof(resObj) != 'object')
+					{
+						service.removePendingCall();
+						//service.dispatchResult(re);
+						dispatchEvent(re);
+						if (onresult != null) // this can be null and cause errors, this might be a problem
+						{
+							(meta.returnArgs) ? onresult(re,args) : onresult(re);
+						}
+					}
+					else if(resObj.faultCode != null && resObj.faultString != null)
+					{
+						if(resObj.faultString == 'Authentication Failed' && this.hasEventListener(FaultEvent.AUTHENTICATION_FAILED))
+						{
+							dispatchEvent(new ErrorEvent(FaultEvent.AUTHENTICATION_FAILED, false,false)); //dispatch to the service
+						}
+						else
+						{
+							service.removePendingCall();
+							(meta.returnArgs) ? onfault(fe,args) : onfault(fe);
+						}
+					}
+					else
+					{
+						service.removePendingCall();
+						//service.dispatchResult(re);
+						dispatchEvent(re);
+						(meta.returnArgs) ? onresult(re,args) : onresult(re);
+					}
+				}
+				catch(e:*)
+				{
+						service.removePendingCall();
+						//service.dispatchResult(re);
+						dispatchEvent(re);
+						(meta.returnArgs) ? onresult(re,args) : onresult(re);
+				}
+			}
+		}
+		/*
+		 * onFault - fault of a remoting call. The fault propogates through this method
+		 * and is turned into a FaultEvent, then the onfault callback is called.
+		 * @param obj:Object
+		 */
+		private function onFault(resObj:Object):void
+		{
+			completed = true;
+			clearIntervals();
+			try
+			{
+				if(resObj.faultString == 'Authentication Failed' && this.hasEventListener(FaultEvent.AUTHENTICATION_FAILED))
+				{
+					dispatchEvent(new ErrorEvent(FaultEvent.AUTHENTICATION_FAILED, false,false)); //dispatch to the service
+					return;
+				}
+			}catch(e:*){} //do nothing. will forward to onFault handler if not dispatched correctly
+			var fe:FaultEvent = new FaultEvent(FaultEvent.FAULT, false, true, resObj);
+			try
+			{
+				service.removePendingCall();
+				(meta.returnArgs) ? onfault(fe,args) : onfault(fe);
+			}
+			catch(e:*){}
+		}
+		/*
+		 * execute - execute the remoting call
+		 */
+		public function execute(service:RemotingService):void
+		{
+			this.service = service
+			if(!completed)
+			{
+				var responder:Responder = new Responder(onResult, onFault);
+				var callArgs:Array = new Array(operationPath, responder);
+				connection.call.apply(null, callArgs.concat(args));
+				if(attempt == 0)
+				{
+					if(meta.maxAttempts) busyInt = setInterval( handleBusy, RemotingService.BUSY_TIMEOUT);
+					if(meta.timeout) timeoutInt = setInterval( handleTimeout, meta.timeout);
+				}
+				this.service.addPendingCall();
+				attempt++;
+			}
+		}
+		/*
+		 * handleBusy - when a busy timeout happens
+		 */
+		private function handleBusy():void
+		{
+			if(attempt >= meta.maxAttempts)
+			{
+				completed = true;
+				clearIntervals();
+				service.removePendingCall();
+				var fo:Object = {faultString:"" + operationPath + " was busy on all attempts.", faultCode:"SSR_SERVER_BUSY_TIMEOUT"};
+				var fe:FaultEvent = new FaultEvent(FaultEvent.FAULT, false, true, fo);
+				(meta.returnArgs) ? onfault(fe,args) : onfault(fe);
+			}
+			else
+			{
+				execute(service);
+			}
+		}
+		/*
+		 * handleTimeout - when a timeout happens (from meta.timeout)
+		 */
+		private function handleTimeout():void
+		{
+			if(!completed)
+			{
+				if(attempt > meta.maxAttempts)
+				{
+					completed = true;
+					clearIntervals();
+					service.removePendingCall();
+					var fo:Object = {
+						faultString:"faultString: " + operationPath + " timed out completely over " + meta.maxAttempts + " attempts.",
+						faultCode:"faultCode: SSR_COMPLETE_TIMEOUT"
+					}
+					var fe:FaultEvent = new FaultEvent(FaultEvent.FAULT, false, true, fo);
+					(meta.returnArgs) ? onfault(fe,args) : onfault(fe);
+				}
+				else
+				{
+					execute(service);
+				}
+			}
+		}
+		/*
+		 * clearIntervals - clears timeout intervals
+		 */
+		private function clearIntervals():void
+		{
+			clearInterval(busyInt);
+			clearInterval(timeoutInt);
+		}
+		/*
+		 * toString
+		 */
+		//public function toString():String
+		//{
+		//	return "org.rubyamf.remoting.ssr.RemotingCall";
+		//}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/org/rubyamf/remoting/ssr/RemotingConnection.as

@@ -0,0 +1,41 @@
+// Copyright (c) 2007 rubyamf.org (aaron@rubyamf.org)
+// License - http://www.gnu.org/copyleft/gpl.html
+package org.rubyamf.remoting.ssr
+{
+	import flash.net.NetConnection;
+	import flash.net.ObjectEncoding;
+	/*
+	 * RemotinConnection - a child of NetConnection that adds methods to support AppendToGatewayUrl, AddHeader, setCredentials and ReplaceGatewayUrl
+	 */
+	public class RemotingConnection extends NetConnection
+	{
+		/*
+		 * AppendToGatewayUrl - AMF0
+		 */
+		public function AppendToGatewayUrl(s:String):void{}
+		/*
+		 * AddHeader - add a persistent header. After adding a header it get's sent with every request
+		 */
+		public function AddHeader(name:String, mustUnderstand:Boolean, value:Object ):void
+		{
+			super.addHeader(name, mustUnderstand, value);
+		}
+		/*
+		 * ReplaceGatewayUrl - Replace the current gateway url
+		 */
+		public function ReplaceGatewayUrl():void{}
+		/*
+		 * setCredentials - implements authentication
+		 * @param username:String
+		 * @param password:String
+		 */
+		public function setCredentials( username:String, password:String ):void
+		{
+			super.addHeader( "Credentials", false, { userid:username, password:password } );
+		}
+		public override function toString():String
+		{
+			return "org.rubyamf.remoting.ssr.ResultEvent";
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/org/rubyamf/remoting/ssr/RemotingService.as

@@ -0,0 +1,214 @@
+// Copyright (c) 2007 rubyamf.org (aaron@rubyamf.org)
+// License - http://www.gnu.org/copyleft/gpl.html
+package org.rubyamf.remoting.ssr
+{
+	import flash.events.*;
+	import flash.net.ObjectEncoding;
+	import flash.utils.Proxy;
+	import flash.utils.flash_proxy;
+	import org.rubyamf.remoting.ssr.RemotingCall;
+	import org.rubyamf.remoting.ssr.RemotingConnection;
+	public dynamic class RemotingService extends Proxy implements IEventDispatcher
+	{
+		public static var BUSY_TIMEOUT:Number = 3500;	//server busy time
+		private var PendingCalls:Number = 0;		//amount of current remoting calls
+		private var gateway:String;										//the gateway location
+		private var service:String;										//the service to call
+		private var connection:RemotingConnection;		//the remoting connection
+		private var eventDispatcher:EventDispatcher;	//concrete event dispatcher
+		private var remotingID:String
+		/*
+		 * Constructor
+		 * @param gateway:String
+		 * @param service:String
+		 * @param objectEncoding:Number
+		 */
+		public function RemotingService(gate:String, serv:String, objectEncoding:Number = 3){
+			if(gate == '')
+				throw(new Error("Gateway cannot be null"));
+			if(serv == '')
+				throw(new Error("Service path cannot be null"));
+			if(objectEncoding != 0 && objectEncoding != 3)
+				throw(new Error("Object encoding must be 0 0r 3"));
+			gateway = gate;
+			service = serv;
+			eventDispatcher = new EventDispatcher();
+			connection = new RemotingConnection();
+			connection.objectEncoding = objectEncoding;
+			connection.addEventListener(NetStatusEvent.NET_STATUS, onConnectionStatus, false, 0, true);
+			connection.addEventListener(IOErrorEvent.IO_ERROR, onConnectionError, false, 0, true);
+			connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR , onConnectionError, false, 0, true);
+			connection.connect(gateway);
+		}
+		public function destroy():void
+		{
+			connection.removeEventListener(NetStatusEvent.NET_STATUS, onConnectionStatus);
+			connection.removeEventListener(IOErrorEvent.IO_ERROR, onConnectionError);
+			connection.removeEventListener(SecurityErrorEvent.SECURITY_ERROR , onConnectionError);
+		}
+		/*
+		 * onConnectionError
+		 */
+		private function onConnectionError(event:ErrorEvent):void{
+			dispatchEvent(new FaultEvent(FaultEvent.CONNECTION_ERROR, true, true, {text:"Connection Error: " + event.text}));
+		}
+		/*
+		 * onConnectionStatus
+		 */
+		private function onConnectionStatus(event:NetStatusEvent):void{
+			switch(event.info.code)
+			{
+				case "NetConnection.Call.Failed":
+					dispatchEvent(new FaultEvent(FaultEvent.CONNECTION_ERROR, true, true, {text:"Connection Error: " + event.info.code}));
+					break;
+			}
+		}
+		/*
+		 * call
+		 */
+		private function call(methodName:String, args:Array, onResult:Function, onFault:Function, meta:Object):void
+		{
+			var operationPath:String = service + "." + methodName.toString();
+			var operation:RemotingCall = new RemotingCall(connection, operationPath, onResult, onFault, args, meta);
+			operation.addEventListener(FaultEvent.AUTHENTICATION_FAILED, handleAuthFailure, false, 0, true);
+			operation.addEventListener(ResultEvent.RESULT, handleResult, false, 0, true);
+			operation.execute(this);
+		}
+		/*
+		 * Authentication Failure
+		 */
+		private function handleAuthFailure(e:*):void{
+			dispatchEvent(new FaultEvent(FaultEvent.AUTHENTICATION_FAILED, true,true, {text:'Authentication Failed'}));
+		}
+		/*
+		 * Result obtained
+		 */
+		private function handleResult(event:ResultEvent):void{
+			dispatchEvent(new ResultEvent(ResultEvent.RESULT, event.bubbles, event.cancelable, event.result));
+		}
+		/*
+		 * callProperty - proxy override (__resolve)
+		 */
+		flash_proxy override function callProperty(methodName:*, ...args):*{
+			if(!args[3])
+				args[3] = {}
+			//if method was apply, use other args for call, this is so that you can
+			//make remoting calles with string methods names, not having to use eval or
+			//some other hack
+			//	 myService.apply('myMethod',args,result,fault,metaObject);  would be the same as:
+			//   myService.myMethod(args,result,fault,metaObject);
+			if(methodName == 'apply')
+			{
+				if(!args[4])
+				{
+					args[4] = {}
+				}
+				try
+				{
+					call(args[0], args[1], args[2], args[3], args[4]);
+				}
+				catch(error:Error)
+				{
+					trace(error.toString());
+				}
+			}
+			else
+			{
+				try
+				{
+					call(methodName.toString(), args[0], args[1], args[2], args[3]);
+				}
+				catch(error:Error)
+				{
+					trace(error.toString());
+				}
+			}
+			return null;
+		}
+		/*
+		 * hasProperty - override getters to return false always
+		 */
+  		flash_proxy override function hasProperty(name:*):Boolean{
+			return false;
+		}
+		/*
+		 * getProperty - override getters to return null always
+		 */
+		flash_proxy override function getProperty(name:*):*{
+			return null;
+		}
+		/*
+		 * addHeader - public facing method to add header persistent hader to RemotingConnection
+		 */
+		public function addHeader(name:String, mustUnderstand:Boolean, value:Object):void{
+			connection.AddHeader(name, mustUnderstand, value);
+		}
+		/*
+		 * AppendToGatewayUrl - AMF0 compliancy
+		 */
+		public function AppendToGatewayUrl(s:String):void{
+			gateway += s;
+		}
+		/*
+		 * ReplaceGatewayUrl - replace the current gateway with new
+		 */
+		public function ReplaceGatewayUrl(newGateway:String):void{
+			gateway = newGateway;
+		}
+		/*
+		 * setCredentials - AMF0 compliancy. Implements authencication
+		 */
+		public function setCredentials(username:String, password:String):void{
+			connection.AddHeader('Credentials', false, {userid:username, password:password});
+		}
+		/*
+		 * addPendingCall - add a pending call. Used internally to the remoting package.
+		 */
+		public function addPendingCall():void{
+			PendingCalls++;
+		}
+		/*
+		 * removePendingCall - remove a pending call. Used internally to the remoting package.
+		 */
+		public function removePendingCall():void{
+			PendingCalls--;
+		}
+		/*
+		 * addEventListener - implement EventDispatcher
+		 */
+		public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, weakRef:Boolean = false):void{
+			eventDispatcher.addEventListener(type, listener, useCapture, priority, weakRef);
+		}
+		/*
+		 * dispatchEvent - implement EventDispatcher
+		 */
+		public function dispatchEvent(event:Event):Boolean{
+			return eventDispatcher.dispatchEvent(event);
+		}
+		/*
+		 * hasEventListener - implement EventDispatcher
+		 */
+		public function hasEventListener(type:String):Boolean{
+			return eventDispatcher.hasEventListener(type);
+		}
+		/*
+		 * removeEventListener - implement EventDispatcher
+		 */
+		public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void{
+			eventDispatcher.removeEventListener(type, listener, useCapture);
+		}
+		/*
+		 * willTrigger - implement EventDispatcher
+		 */
+		public function willTrigger(type:String):Boolean{
+			return eventDispatcher.willTrigger(type);
+		}
+		public function dispatchResult(re:ResultEvent):void{
+			eventDispatcher.addEventListener(re.type, onReDispatch);
+			eventDispatcher.dispatchEvent(re);
+		}
+		// TODO: check if we should get rid of this?
+		private function onReDispatch(event:ResultEvent):void{
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/org/rubyamf/remoting/ssr/ResultEvent.as

@@ -0,0 +1,36 @@
+// Copyright (c) 2007 rubyamf.org (aaron@rubyamf.org)
+// License - http://www.gnu.org/copyleft/gpl.html
+package org.rubyamf.remoting.ssr
+{
+	import flash.events.Event;
+	/*
+	 * ResultEvent - stores results of a service call
+	 */
+	public class ResultEvent extends Event
+	{
+		public static const RESULT:String = "RESULT";
+		public var result:Object;
+		/**
+		 * Constructor
+		 * @param type:String
+		 * @param bubbles:Boolean
+		 * @param cancelable:Boolean
+		 * @param result:Object
+		 */
+		public function ResultEvent(type:String = "RESULT", bubbles:Boolean = false, cancelable:Boolean = false, result:* = null){
+			super(type, bubbles, cancelable);
+			this.result = result;
+		}
+		/*
+		 * toString - duh
+		 */
+		public override function toString():String
+		{
+			return "org.rubyamf.remoting.ssr.ResultEvent";
+		}
+		public override function clone():Event
+		{
+			return new ResultEvent(type, bubbles, cancelable, result);
+		}
+	}
+}