home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / messaging / MessageAgent.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  19.6 KB  |  628 lines
  1. package mx.messaging
  2. {
  3.    import flash.events.EventDispatcher;
  4.    import mx.core.IMXMLObject;
  5.    import mx.core.mx_internal;
  6.    import mx.events.PropertyChangeEvent;
  7.    import mx.logging.ILogger;
  8.    import mx.logging.Log;
  9.    import mx.messaging.config.ConfigMap;
  10.    import mx.messaging.config.ServerConfig;
  11.    import mx.messaging.errors.InvalidDestinationError;
  12.    import mx.messaging.events.ChannelEvent;
  13.    import mx.messaging.events.ChannelFaultEvent;
  14.    import mx.messaging.events.MessageAckEvent;
  15.    import mx.messaging.events.MessageFaultEvent;
  16.    import mx.messaging.messages.AbstractMessage;
  17.    import mx.messaging.messages.AcknowledgeMessage;
  18.    import mx.messaging.messages.CommandMessage;
  19.    import mx.messaging.messages.ErrorMessage;
  20.    import mx.messaging.messages.IMessage;
  21.    import mx.messaging.messages.MessagePerformanceUtils;
  22.    import mx.resources.IResourceManager;
  23.    import mx.resources.ResourceManager;
  24.    import mx.utils.Base64Encoder;
  25.    import mx.utils.UIDUtil;
  26.    
  27.    use namespace mx_internal;
  28.    
  29.    public class MessageAgent extends EventDispatcher implements IMXMLObject
  30.    {
  31.       mx_internal static const AUTO_CONFIGURED_CHANNELSET:int = 0;
  32.       
  33.       mx_internal static const MANUALLY_ASSIGNED_CHANNELSET:int = 1;
  34.       
  35.       private var _needsConfig:Boolean;
  36.       
  37.       protected var _disconnectBarrier:Boolean;
  38.       
  39.       protected var _log:ILogger;
  40.       
  41.       private var _connected:Boolean = false;
  42.       
  43.       private var _clientId:String;
  44.       
  45.       private var _sendRemoteCredentials:Boolean;
  46.       
  47.       private var _authenticated:Boolean;
  48.       
  49.       protected var _ignoreFault:Boolean = false;
  50.       
  51.       private var _id:String = UIDUtil.createUID();
  52.       
  53.       protected var _credentials:String;
  54.       
  55.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  56.       
  57.       private var _channelSetMode:int = 0;
  58.       
  59.       mx_internal var configRequested:Boolean = false;
  60.       
  61.       private var _pendingConnectEvent:ChannelEvent;
  62.       
  63.       protected var _credentialsCharset:String;
  64.       
  65.       private var _remoteCredentials:String = "";
  66.       
  67.       private var _destination:String = "";
  68.       
  69.       protected var _agentType:String;
  70.       
  71.       private var _requestTimeout:int = -1;
  72.       
  73.       private var _remoteCredentialsCharset:String;
  74.       
  75.       private var _clientIdWaitQueue:Array;
  76.       
  77.       private var _channelSet:ChannelSet;
  78.       
  79.       public function MessageAgent()
  80.       {
  81.          super();
  82.       }
  83.       
  84.       [Bindable(event="propertyChange")]
  85.       public function get connected() : Boolean
  86.       {
  87.          return _connected;
  88.       }
  89.       
  90.       [Bindable(event="propertyChange")]
  91.       public function get destination() : String
  92.       {
  93.          return _destination;
  94.       }
  95.       
  96.       protected function initChannelSet(param1:IMessage) : void
  97.       {
  98.          if(_channelSet == null)
  99.          {
  100.             _channelSetMode = mx_internal::AUTO_CONFIGURED_CHANNELSET;
  101.             mx_internal::internalSetChannelSet(ServerConfig.getChannelSet(destination));
  102.          }
  103.          if(_channelSet.connected && mx_internal::needsConfig && !mx_internal::configRequested)
  104.          {
  105.             param1.headers[CommandMessage.NEEDS_CONFIG_HEADER] = true;
  106.             mx_internal::configRequested = true;
  107.          }
  108.          _channelSet.connect(this);
  109.          if(_credentials != null)
  110.          {
  111.             channelSet.setCredentials(_credentials,this,_credentialsCharset);
  112.          }
  113.       }
  114.       
  115.       mx_internal function set needsConfig(param1:Boolean) : void
  116.       {
  117.          var cs:ChannelSet = null;
  118.          var value:Boolean = param1;
  119.          if(_needsConfig != value)
  120.          {
  121.             _needsConfig = value;
  122.             if(_needsConfig)
  123.             {
  124.                cs = channelSet;
  125.                try
  126.                {
  127.                   disconnect();
  128.                }
  129.                finally
  130.                {
  131.                   mx_internal::internalSetChannelSet(cs);
  132.                }
  133.             }
  134.          }
  135.       }
  136.       
  137.       public function logout() : void
  138.       {
  139.          _credentials = null;
  140.          if(channelSet)
  141.          {
  142.             channelSet.logout(this);
  143.          }
  144.       }
  145.       
  146.       [Bindable(event="propertyChange")]
  147.       public function get id() : String
  148.       {
  149.          return _id;
  150.       }
  151.       
  152.       public function set destination(param1:String) : void
  153.       {
  154.          var _loc2_:String = null;
  155.          var _loc3_:PropertyChangeEvent = null;
  156.          if(param1 == null || param1.length == 0)
  157.          {
  158.             _loc2_ = resourceManager.getString("messaging","emptyDestinationName",[param1]);
  159.             throw new InvalidDestinationError(_loc2_);
  160.          }
  161.          if(_destination != param1)
  162.          {
  163.             if(_channelSetMode == mx_internal::AUTO_CONFIGURED_CHANNELSET && channelSet != null)
  164.             {
  165.                channelSet.disconnect(this);
  166.                channelSet = null;
  167.             }
  168.             _loc3_ = PropertyChangeEvent.createUpdateEvent(this,"destination",_destination,param1);
  169.             _destination = param1;
  170.             dispatchEvent(_loc3_);
  171.             if(Log.isInfo())
  172.             {
  173.                _log.info("\'{0}\' {2} set destination to \'{1}\'.",id,_destination,_agentType);
  174.             }
  175.          }
  176.       }
  177.       
  178.       mx_internal function get channelSetMode() : int
  179.       {
  180.          return _channelSetMode;
  181.       }
  182.       
  183.       public function acknowledge(param1:AcknowledgeMessage, param2:IMessage) : void
  184.       {
  185.          var mpiutil:MessagePerformanceUtils = null;
  186.          var ackMsg:AcknowledgeMessage = param1;
  187.          var msg:IMessage = param2;
  188.          if(Log.isInfo())
  189.          {
  190.             _log.info("\'{0}\' {2} acknowledge of \'{1}\'.",id,msg.messageId,_agentType);
  191.          }
  192.          if(Log.isDebug() && channelSet != null && channelSet.currentChannel != null && channelSet.currentChannel.mpiEnabled)
  193.          {
  194.             try
  195.             {
  196.                mpiutil = new MessagePerformanceUtils(ackMsg);
  197.                _log.debug(mpiutil.prettyPrint());
  198.             }
  199.             catch(e:Error)
  200.             {
  201.                _log.debug("Could not get message performance information for: " + msg.toString());
  202.             }
  203.          }
  204.          if(ackMsg.headers[AcknowledgeMessage.ERROR_HINT_HEADER])
  205.          {
  206.             delete ackMsg.headers[AcknowledgeMessage.ERROR_HINT_HEADER];
  207.          }
  208.          if(mx_internal::configRequested)
  209.          {
  210.             mx_internal::configRequested = false;
  211.             ServerConfig.mx_internal::updateServerConfigData(ackMsg.body as ConfigMap);
  212.             mx_internal::needsConfig = false;
  213.             if(_pendingConnectEvent)
  214.             {
  215.                channelConnectHandler(_pendingConnectEvent);
  216.             }
  217.             _pendingConnectEvent = null;
  218.          }
  219.          if(clientId == null)
  220.          {
  221.             if(ackMsg.clientId != null)
  222.             {
  223.                mx_internal::setClientId(ackMsg.clientId);
  224.             }
  225.             else
  226.             {
  227.                flushClientIdWaitQueue();
  228.             }
  229.          }
  230.          dispatchEvent(MessageAckEvent.createEvent(ackMsg,msg));
  231.       }
  232.       
  233.       mx_internal function internalSetChannelSet(param1:ChannelSet) : void
  234.       {
  235.          var _loc2_:PropertyChangeEvent = null;
  236.          if(_channelSet != param1)
  237.          {
  238.             if(_channelSet != null)
  239.             {
  240.                _channelSet.disconnect(this);
  241.             }
  242.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"channelSet",_channelSet,param1);
  243.             _channelSet = param1;
  244.             if(_channelSet != null)
  245.             {
  246.                if(_credentials)
  247.                {
  248.                   _channelSet.setCredentials(_credentials,this,_credentialsCharset);
  249.                }
  250.                _channelSet.connect(this);
  251.             }
  252.             dispatchEvent(_loc2_);
  253.          }
  254.       }
  255.       
  256.       public function fault(param1:ErrorMessage, param2:IMessage) : void
  257.       {
  258.          if(Log.isError())
  259.          {
  260.             _log.error("\'{0}\' {2} fault for \'{1}\'.",id,param2.messageId,_agentType);
  261.          }
  262.          _ignoreFault = false;
  263.          mx_internal::configRequested = false;
  264.          if(param1.headers[ErrorMessage.RETRYABLE_HINT_HEADER])
  265.          {
  266.             delete param1.headers[ErrorMessage.RETRYABLE_HINT_HEADER];
  267.          }
  268.          if(clientId == null)
  269.          {
  270.             if(param1.clientId != null)
  271.             {
  272.                mx_internal::setClientId(param1.clientId);
  273.             }
  274.             else
  275.             {
  276.                flushClientIdWaitQueue();
  277.             }
  278.          }
  279.          dispatchEvent(MessageFaultEvent.createEvent(param1));
  280.          if(param1.faultCode == "Client.Authentication" && authenticated && channelSet != null && channelSet.currentChannel != null)
  281.          {
  282.             channelSet.currentChannel.mx_internal::setAuthenticated(false);
  283.             if(channelSet.currentChannel.mx_internal::loginAfterDisconnect)
  284.             {
  285.                reAuthorize(param2);
  286.                _ignoreFault = true;
  287.             }
  288.          }
  289.       }
  290.       
  291.       public function set requestTimeout(param1:int) : void
  292.       {
  293.          var _loc2_:PropertyChangeEvent = null;
  294.          if(_requestTimeout != param1)
  295.          {
  296.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"requestTimeout",_requestTimeout,param1);
  297.             _requestTimeout = param1;
  298.             dispatchEvent(_loc2_);
  299.          }
  300.       }
  301.       
  302.       public function disconnect() : void
  303.       {
  304.          if(!_disconnectBarrier)
  305.          {
  306.             _disconnectBarrier = true;
  307.             if(_channelSetMode == mx_internal::AUTO_CONFIGURED_CHANNELSET)
  308.             {
  309.                mx_internal::internalSetChannelSet(null);
  310.             }
  311.             else if(_channelSet != null)
  312.             {
  313.                _channelSet.disconnect(this);
  314.             }
  315.          }
  316.       }
  317.       
  318.       public function set id(param1:String) : void
  319.       {
  320.          var _loc2_:PropertyChangeEvent = null;
  321.          if(_id != param1)
  322.          {
  323.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"id",_id,param1);
  324.             _id = param1;
  325.             dispatchEvent(_loc2_);
  326.          }
  327.       }
  328.       
  329.       public function set channelSet(param1:ChannelSet) : void
  330.       {
  331.          mx_internal::internalSetChannelSet(param1);
  332.          _channelSetMode = mx_internal::MANUALLY_ASSIGNED_CHANNELSET;
  333.       }
  334.       
  335.       [Bindable(event="propertyChange")]
  336.       public function get clientId() : String
  337.       {
  338.          return _clientId;
  339.       }
  340.       
  341.       protected function setConnected(param1:Boolean) : void
  342.       {
  343.          var _loc2_:PropertyChangeEvent = null;
  344.          if(_connected != param1)
  345.          {
  346.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"connected",_connected,param1);
  347.             _connected = param1;
  348.             dispatchEvent(_loc2_);
  349.             mx_internal::setAuthenticated(param1 && Boolean(channelSet) && channelSet.authenticated,_credentials);
  350.          }
  351.       }
  352.       
  353.       mx_internal function setClientId(param1:String) : void
  354.       {
  355.          var _loc2_:PropertyChangeEvent = null;
  356.          if(_clientId != param1)
  357.          {
  358.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"clientId",_clientId,param1);
  359.             _clientId = param1;
  360.             flushClientIdWaitQueue();
  361.             dispatchEvent(_loc2_);
  362.          }
  363.       }
  364.       
  365.       public function setCredentials(param1:String, param2:String, param3:String = null) : void
  366.       {
  367.          var _loc4_:String = null;
  368.          var _loc5_:Base64Encoder = null;
  369.          if(param1 == null && param2 == null)
  370.          {
  371.             _credentials = null;
  372.             _credentialsCharset = null;
  373.          }
  374.          else
  375.          {
  376.             _loc4_ = param1 + ":" + param2;
  377.             _loc5_ = new Base64Encoder();
  378.             if(param3 == Base64Encoder.CHARSET_UTF_8)
  379.             {
  380.                _loc5_.encodeUTFBytes(_loc4_);
  381.             }
  382.             else
  383.             {
  384.                _loc5_.encode(_loc4_);
  385.             }
  386.             _credentials = _loc5_.drain();
  387.             _credentialsCharset = param3;
  388.          }
  389.          if(channelSet != null)
  390.          {
  391.             channelSet.setCredentials(_credentials,this,_credentialsCharset);
  392.          }
  393.       }
  394.       
  395.       public function channelDisconnectHandler(param1:ChannelEvent) : void
  396.       {
  397.          if(Log.isWarn())
  398.          {
  399.             _log.warn("\'{0}\' {1} channel disconnected.",id,_agentType);
  400.          }
  401.          setConnected(false);
  402.          if(_remoteCredentials != null)
  403.          {
  404.             _sendRemoteCredentials = true;
  405.          }
  406.          dispatchEvent(param1);
  407.       }
  408.       
  409.       public function setRemoteCredentials(param1:String, param2:String, param3:String = null) : void
  410.       {
  411.          var _loc4_:String = null;
  412.          var _loc5_:Base64Encoder = null;
  413.          if(param1 == null && param2 == null)
  414.          {
  415.             _remoteCredentials = "";
  416.             _remoteCredentialsCharset = null;
  417.          }
  418.          else
  419.          {
  420.             _loc4_ = param1 + ":" + param2;
  421.             _loc5_ = new Base64Encoder();
  422.             if(param3 == Base64Encoder.CHARSET_UTF_8)
  423.             {
  424.                _loc5_.encodeUTFBytes(_loc4_);
  425.             }
  426.             else
  427.             {
  428.                _loc5_.encode(_loc4_);
  429.             }
  430.             _remoteCredentials = _loc5_.drain();
  431.             _remoteCredentialsCharset = param3;
  432.          }
  433.          _sendRemoteCredentials = true;
  434.       }
  435.       
  436.       mx_internal function get needsConfig() : Boolean
  437.       {
  438.          return _needsConfig;
  439.       }
  440.       
  441.       public function hasPendingRequestForMessage(param1:IMessage) : Boolean
  442.       {
  443.          return false;
  444.       }
  445.       
  446.       [Bindable(event="propertyChange")]
  447.       public function get authenticated() : Boolean
  448.       {
  449.          return _authenticated;
  450.       }
  451.       
  452.       [Bindable(event="propertyChange")]
  453.       public function get requestTimeout() : int
  454.       {
  455.          return _requestTimeout;
  456.       }
  457.       
  458.       public function initialized(param1:Object, param2:String) : void
  459.       {
  460.          this.id = param2;
  461.       }
  462.       
  463.       final protected function flushClientIdWaitQueue() : void
  464.       {
  465.          if(_clientIdWaitQueue != null)
  466.          {
  467.             if(clientId != null)
  468.             {
  469.                while(_clientIdWaitQueue.length > 0)
  470.                {
  471.                   internalSend(_clientIdWaitQueue.shift() as IMessage);
  472.                }
  473.             }
  474.             if(_clientIdWaitQueue.length > 0)
  475.             {
  476.                internalSend(_clientIdWaitQueue.shift() as IMessage);
  477.             }
  478.             else
  479.             {
  480.                _clientIdWaitQueue = null;
  481.             }
  482.          }
  483.       }
  484.       
  485.       final protected function assertCredentials(param1:String) : void
  486.       {
  487.          var _loc2_:ErrorMessage = null;
  488.          if(_credentials != null && _credentials != param1)
  489.          {
  490.             _loc2_ = new ErrorMessage();
  491.             _loc2_.faultCode = "Client.Authentication.Error";
  492.             _loc2_.faultString = "Credentials specified do not match those used on underlying connection.";
  493.             _loc2_.faultDetail = "Channel was authenticated with a different set of credentials than those used for this agent.";
  494.             dispatchEvent(MessageFaultEvent.createEvent(_loc2_));
  495.          }
  496.       }
  497.       
  498.       [Bindable(event="propertyChange")]
  499.       public function get channelSet() : ChannelSet
  500.       {
  501.          return _channelSet;
  502.       }
  503.       
  504.       public function channelConnectHandler(param1:ChannelEvent) : void
  505.       {
  506.          _disconnectBarrier = false;
  507.          if(mx_internal::needsConfig)
  508.          {
  509.             if(Log.isInfo())
  510.             {
  511.                _log.info("\'{0}\' {1} waiting for configuration information.",id,_agentType);
  512.             }
  513.             _pendingConnectEvent = param1;
  514.          }
  515.          else
  516.          {
  517.             if(Log.isInfo())
  518.             {
  519.                _log.info("\'{0}\' {1} connected.",id,_agentType);
  520.             }
  521.             setConnected(true);
  522.             dispatchEvent(param1);
  523.          }
  524.       }
  525.       
  526.       mx_internal function internalSetCredentials(param1:String) : void
  527.       {
  528.          _credentials = param1;
  529.       }
  530.       
  531.       public function channelFaultHandler(param1:ChannelFaultEvent) : void
  532.       {
  533.          if(Log.isWarn())
  534.          {
  535.             _log.warn("\'{0}\' {1} channel faulted with {2} {3}",id,_agentType,param1.faultCode,param1.faultDetail);
  536.          }
  537.          if(!param1.channel.connected)
  538.          {
  539.             setConnected(false);
  540.             if(_remoteCredentials != null)
  541.             {
  542.                _sendRemoteCredentials = true;
  543.             }
  544.          }
  545.          dispatchEvent(param1);
  546.       }
  547.       
  548.       protected function internalSend(param1:IMessage, param2:Boolean = true) : void
  549.       {
  550.          var _loc3_:String = null;
  551.          if(param1.clientId == null && param2 && clientId == null)
  552.          {
  553.             if(_clientIdWaitQueue != null)
  554.             {
  555.                _clientIdWaitQueue.push(param1);
  556.                return;
  557.             }
  558.             _clientIdWaitQueue = [];
  559.          }
  560.          if(param1.clientId == null)
  561.          {
  562.             param1.clientId = clientId;
  563.          }
  564.          if(requestTimeout > 0)
  565.          {
  566.             param1.headers[AbstractMessage.REQUEST_TIMEOUT_HEADER] = requestTimeout;
  567.          }
  568.          if(_sendRemoteCredentials)
  569.          {
  570.             if(!(param1 is CommandMessage && CommandMessage(param1).operation == CommandMessage.TRIGGER_CONNECT_OPERATION))
  571.             {
  572.                param1.headers[AbstractMessage.REMOTE_CREDENTIALS_HEADER] = _remoteCredentials;
  573.                param1.headers[AbstractMessage.REMOTE_CREDENTIALS_CHARSET_HEADER] = _remoteCredentialsCharset;
  574.                _sendRemoteCredentials = false;
  575.             }
  576.          }
  577.          if(channelSet != null)
  578.          {
  579.             if(!connected && _channelSetMode == mx_internal::MANUALLY_ASSIGNED_CHANNELSET)
  580.             {
  581.                _channelSet.connect(this);
  582.             }
  583.             if(channelSet.connected && mx_internal::needsConfig && !mx_internal::configRequested)
  584.             {
  585.                param1.headers[CommandMessage.NEEDS_CONFIG_HEADER] = true;
  586.                mx_internal::configRequested = true;
  587.             }
  588.             channelSet.send(this,param1);
  589.          }
  590.          else
  591.          {
  592.             if(destination.length <= 0)
  593.             {
  594.                _loc3_ = resourceManager.getString("messaging","destinationNotSet");
  595.                throw new InvalidDestinationError(_loc3_);
  596.             }
  597.             initChannelSet(param1);
  598.             if(channelSet != null)
  599.             {
  600.                channelSet.send(this,param1);
  601.             }
  602.          }
  603.       }
  604.       
  605.       mx_internal function setAuthenticated(param1:Boolean, param2:String) : void
  606.       {
  607.          var _loc3_:PropertyChangeEvent = null;
  608.          if(_authenticated != param1)
  609.          {
  610.             _loc3_ = PropertyChangeEvent.createUpdateEvent(this,"authenticated",_authenticated,param1);
  611.             _authenticated = param1;
  612.             dispatchEvent(_loc3_);
  613.             if(param1)
  614.             {
  615.                assertCredentials(param2);
  616.             }
  617.          }
  618.       }
  619.       
  620.       protected function reAuthorize(param1:IMessage) : void
  621.       {
  622.          disconnect();
  623.          internalSend(param1);
  624.       }
  625.    }
  626. }
  627.  
  628.