home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / messaging / ChannelSet.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  33.9 KB  |  1,072 lines
  1. package mx.messaging
  2. {
  3.    import flash.errors.IllegalOperationError;
  4.    import flash.events.EventDispatcher;
  5.    import flash.events.TimerEvent;
  6.    import flash.utils.Dictionary;
  7.    import flash.utils.Timer;
  8.    import mx.core.mx_internal;
  9.    import mx.events.PropertyChangeEvent;
  10.    import mx.messaging.channels.NetConnectionChannel;
  11.    import mx.messaging.config.ServerConfig;
  12.    import mx.messaging.errors.NoChannelAvailableError;
  13.    import mx.messaging.events.ChannelEvent;
  14.    import mx.messaging.events.ChannelFaultEvent;
  15.    import mx.messaging.events.MessageEvent;
  16.    import mx.messaging.events.MessageFaultEvent;
  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.resources.IResourceManager;
  22.    import mx.resources.ResourceManager;
  23.    import mx.rpc.AsyncToken;
  24.    import mx.rpc.events.AbstractEvent;
  25.    import mx.rpc.events.FaultEvent;
  26.    import mx.rpc.events.ResultEvent;
  27.    import mx.utils.Base64Encoder;
  28.    
  29.    use namespace mx_internal;
  30.    
  31.    public class ChannelSet extends EventDispatcher
  32.    {
  33.       private var _shouldHunt:Boolean;
  34.       
  35.       private var _connected:Boolean;
  36.       
  37.       private var _hasRequestedClusterEndpoints:Boolean;
  38.       
  39.       private var _clustered:Boolean;
  40.       
  41.       private var _channels:Array;
  42.       
  43.       private var _hunting:Boolean;
  44.       
  45.       private var _authenticated:Boolean;
  46.       
  47.       private var _pendingMessages:Dictionary;
  48.       
  49.       private var _authAgent:AuthenticationAgent;
  50.       
  51.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  52.       
  53.       private var _initialDestinationId:String;
  54.       
  55.       private var _credentials:String;
  56.       
  57.       private var _reconnectTimer:Timer = null;
  58.       
  59.       private var _credentialsCharset:String;
  60.       
  61.       private var _shouldBeConnected:Boolean;
  62.       
  63.       private var _connecting:Boolean;
  64.       
  65.       private var _channelIds:Array;
  66.       
  67.       private var _configured:Boolean;
  68.       
  69.       private var _currentChannel:Channel;
  70.       
  71.       private var _currentChannelIndex:int;
  72.       
  73.       private var _pendingSends:Array;
  74.       
  75.       private var _messageAgents:Array;
  76.       
  77.       private var _channelFailoverURIs:Object;
  78.       
  79.       public function ChannelSet(param1:Array = null, param2:Boolean = false)
  80.       {
  81.          super();
  82.          _clustered = param2;
  83.          _connected = false;
  84.          _connecting = false;
  85.          _currentChannelIndex = -1;
  86.          if(param1 != null)
  87.          {
  88.             _channelIds = param1;
  89.             _channels = new Array(_channelIds.length);
  90.             _configured = true;
  91.          }
  92.          else
  93.          {
  94.             _channels = [];
  95.             _configured = false;
  96.          }
  97.          _hasRequestedClusterEndpoints = false;
  98.          _hunting = false;
  99.          _messageAgents = [];
  100.          _pendingMessages = new Dictionary();
  101.          _pendingSends = [];
  102.          _shouldBeConnected = false;
  103.          _shouldHunt = true;
  104.       }
  105.       
  106.       [Bindable(event="propertyChange")]
  107.       public function get connected() : Boolean
  108.       {
  109.          return _connected;
  110.       }
  111.       
  112.       public function login(param1:String, param2:String, param3:String = null) : AsyncToken
  113.       {
  114.          var _loc7_:String = null;
  115.          var _loc8_:Base64Encoder = null;
  116.          if(authenticated)
  117.          {
  118.             throw new IllegalOperationError("ChannelSet is already authenticated.");
  119.          }
  120.          if(_authAgent != null && _authAgent.state != AuthenticationAgent.LOGGED_OUT_STATE)
  121.          {
  122.             throw new IllegalOperationError("ChannelSet is in the process of logging in or logging out.");
  123.          }
  124.          if(param3 != Base64Encoder.CHARSET_UTF_8)
  125.          {
  126.          }
  127.          param3 = null;
  128.          var _loc4_:String = null;
  129.          if(param1 != null && param2 != null)
  130.          {
  131.             _loc7_ = param1 + ":" + param2;
  132.             _loc8_ = new Base64Encoder();
  133.             if(param3 == Base64Encoder.CHARSET_UTF_8)
  134.             {
  135.                _loc8_.encodeUTFBytes(_loc7_);
  136.             }
  137.             else
  138.             {
  139.                _loc8_.encode(_loc7_);
  140.             }
  141.             _loc4_ = _loc8_.drain();
  142.          }
  143.          var _loc5_:CommandMessage = new CommandMessage();
  144.          _loc5_.operation = CommandMessage.LOGIN_OPERATION;
  145.          _loc5_.body = _loc4_;
  146.          if(param3 != null)
  147.          {
  148.             _loc5_.headers[CommandMessage.CREDENTIALS_CHARSET_HEADER] = param3;
  149.          }
  150.          _loc5_.destination = "auth";
  151.          var _loc6_:AsyncToken = new AsyncToken(_loc5_);
  152.          if(_authAgent == null)
  153.          {
  154.             _authAgent = new AuthenticationAgent(this);
  155.          }
  156.          _authAgent.registerToken(_loc6_);
  157.          _authAgent.state = AuthenticationAgent.LOGGING_IN_STATE;
  158.          send(_authAgent,_loc5_);
  159.          return _loc6_;
  160.       }
  161.       
  162.       private function hunt() : Boolean
  163.       {
  164.          var _loc1_:String = null;
  165.          if(_channels.length == 0)
  166.          {
  167.             _loc1_ = resourceManager.getString("messaging","noAvailableChannels");
  168.             throw new NoChannelAvailableError(_loc1_);
  169.          }
  170.          if(++_currentChannelIndex >= _channels.length)
  171.          {
  172.             _currentChannelIndex = -1;
  173.             return false;
  174.          }
  175.          if(_currentChannelIndex > 0)
  176.          {
  177.             _hunting = true;
  178.          }
  179.          if(mx_internal::configured)
  180.          {
  181.             if(_channels[_currentChannelIndex] != null)
  182.             {
  183.                _currentChannel = _channels[_currentChannelIndex];
  184.             }
  185.             else
  186.             {
  187.                _currentChannel = ServerConfig.getChannel(_channelIds[_currentChannelIndex],_clustered);
  188.                _currentChannel.setCredentials(_credentials);
  189.                _channels[_currentChannelIndex] = _currentChannel;
  190.             }
  191.          }
  192.          else
  193.          {
  194.             _currentChannel = _channels[_currentChannelIndex];
  195.          }
  196.          if(_channelFailoverURIs != null && _channelFailoverURIs[_currentChannel.id] != null)
  197.          {
  198.             _currentChannel.failoverURIs = _channelFailoverURIs[_currentChannel.id];
  199.          }
  200.          return true;
  201.       }
  202.       
  203.       public function get clustered() : Boolean
  204.       {
  205.          return _clustered;
  206.       }
  207.       
  208.       public function disconnect(param1:MessageAgent) : void
  209.       {
  210.          var _loc2_:Array = null;
  211.          var _loc3_:int = 0;
  212.          var _loc4_:int = 0;
  213.          var _loc5_:int = 0;
  214.          var _loc6_:int = 0;
  215.          var _loc7_:int = 0;
  216.          var _loc8_:PendingSend = null;
  217.          if(param1 == null)
  218.          {
  219.             _loc2_ = _messageAgents.slice();
  220.             _loc3_ = int(_loc2_.length);
  221.             _loc4_ = 0;
  222.             while(_loc4_ < _loc3_)
  223.             {
  224.                _loc2_[_loc4_].disconnect();
  225.                _loc4_++;
  226.             }
  227.             if(_authAgent != null)
  228.             {
  229.                _authAgent.state = AuthenticationAgent.SHUTDOWN_STATE;
  230.                _authAgent = null;
  231.             }
  232.          }
  233.          else
  234.          {
  235.             _loc5_ = param1 != null ? int(_messageAgents.indexOf(param1)) : -1;
  236.             if(_loc5_ != -1)
  237.             {
  238.                _messageAgents.splice(_loc5_,1);
  239.                removeEventListener(ChannelEvent.CONNECT,param1.channelConnectHandler);
  240.                removeEventListener(ChannelEvent.DISCONNECT,param1.channelDisconnectHandler);
  241.                removeEventListener(ChannelFaultEvent.FAULT,param1.channelFaultHandler);
  242.                if(connected || _connecting)
  243.                {
  244.                   param1.channelDisconnectHandler(ChannelEvent.createEvent(ChannelEvent.DISCONNECT,_currentChannel,false));
  245.                }
  246.                else
  247.                {
  248.                   _loc6_ = int(_pendingSends.length);
  249.                   _loc7_ = 0;
  250.                   while(_loc7_ < _loc6_)
  251.                   {
  252.                      _loc8_ = PendingSend(_pendingSends[_loc7_]);
  253.                      if(_loc8_.agent == param1)
  254.                      {
  255.                         _pendingSends.splice(_loc7_,1);
  256.                         _loc7_--;
  257.                         _loc6_--;
  258.                         delete _pendingMessages[_loc8_.message];
  259.                      }
  260.                      _loc7_++;
  261.                   }
  262.                }
  263.                if(_messageAgents.length == 0)
  264.                {
  265.                   _shouldBeConnected = false;
  266.                   if(connected)
  267.                   {
  268.                      disconnectChannel();
  269.                   }
  270.                }
  271.                if(param1.mx_internal::channelSetMode == MessageAgent.mx_internal::AUTO_CONFIGURED_CHANNELSET)
  272.                {
  273.                   param1.mx_internal::internalSetChannelSet(null);
  274.                }
  275.             }
  276.          }
  277.       }
  278.       
  279.       public function set channels(param1:Array) : void
  280.       {
  281.          var _loc5_:String = null;
  282.          var _loc6_:int = 0;
  283.          var _loc7_:int = 0;
  284.          if(mx_internal::configured)
  285.          {
  286.             _loc5_ = resourceManager.getString("messaging","cannotAddWhenConfigured");
  287.             throw new IllegalOperationError(_loc5_);
  288.          }
  289.          var _loc2_:Array = _channels.slice();
  290.          var _loc3_:int = int(_loc2_.length);
  291.          var _loc4_:int = 0;
  292.          while(_loc4_ < _loc3_)
  293.          {
  294.             removeChannel(_loc2_[_loc4_]);
  295.             _loc4_++;
  296.          }
  297.          if(param1 != null && param1.length > 0)
  298.          {
  299.             _loc6_ = int(param1.length);
  300.             _loc7_ = 0;
  301.             while(_loc7_ < _loc6_)
  302.             {
  303.                addChannel(param1[_loc7_]);
  304.                _loc7_++;
  305.             }
  306.          }
  307.       }
  308.       
  309.       public function addChannel(param1:Channel) : void
  310.       {
  311.          var _loc2_:String = null;
  312.          if(param1 == null)
  313.          {
  314.             return;
  315.          }
  316.          if(mx_internal::configured)
  317.          {
  318.             _loc2_ = resourceManager.getString("messaging","cannotAddWhenConfigured");
  319.             throw new IllegalOperationError(_loc2_);
  320.          }
  321.          if(clustered && param1.id == null)
  322.          {
  323.             _loc2_ = resourceManager.getString("messaging","cannotAddNullIdChannelWhenClustered");
  324.             throw new IllegalOperationError(_loc2_);
  325.          }
  326.          if(_channels.indexOf(param1) != -1)
  327.          {
  328.             return;
  329.          }
  330.          _channels.push(param1);
  331.          if(_credentials)
  332.          {
  333.             param1.setCredentials(_credentials,null,_credentialsCharset);
  334.          }
  335.       }
  336.       
  337.       public function send(param1:MessageAgent, param2:IMessage) : void
  338.       {
  339.          var _loc3_:AcknowledgeMessage = null;
  340.          var _loc4_:CommandMessage = null;
  341.          if(connected)
  342.          {
  343.             if(param2 is CommandMessage && CommandMessage(param2).operation == CommandMessage.TRIGGER_CONNECT_OPERATION)
  344.             {
  345.                _loc3_ = new AcknowledgeMessage();
  346.                _loc3_.clientId = param1.clientId;
  347.                _loc3_.correlationId = param2.messageId;
  348.                param1.acknowledge(_loc3_,param2);
  349.                return;
  350.             }
  351.             if(!_hasRequestedClusterEndpoints && clustered)
  352.             {
  353.                _loc4_ = new CommandMessage();
  354.                if(param1 is AuthenticationAgent)
  355.                {
  356.                   _loc4_.destination = initialDestinationId;
  357.                }
  358.                else
  359.                {
  360.                   _loc4_.destination = param1.destination;
  361.                }
  362.                _loc4_.operation = CommandMessage.CLUSTER_REQUEST_OPERATION;
  363.                _currentChannel.mx_internal::sendClusterRequest(new ClusterMessageResponder(_loc4_,this));
  364.                _hasRequestedClusterEndpoints = true;
  365.             }
  366.             _currentChannel.send(param1,param2);
  367.          }
  368.          else
  369.          {
  370.             if(_pendingMessages[param2] == null)
  371.             {
  372.                _pendingMessages[param2] = true;
  373.                _pendingSends.push(new PendingSend(param1,param2));
  374.             }
  375.             if(!_connecting)
  376.             {
  377.                if(_currentChannel == null || _currentChannelIndex == -1)
  378.                {
  379.                   hunt();
  380.                }
  381.                if(_currentChannel is NetConnectionChannel)
  382.                {
  383.                   if(_reconnectTimer == null)
  384.                   {
  385.                      _reconnectTimer = new Timer(1,1);
  386.                      _reconnectTimer.addEventListener(TimerEvent.TIMER,reconnectChannel);
  387.                      _reconnectTimer.start();
  388.                   }
  389.                }
  390.                else
  391.                {
  392.                   connectChannel();
  393.                }
  394.             }
  395.          }
  396.       }
  397.       
  398.       public function logout(param1:MessageAgent = null) : AsyncToken
  399.       {
  400.          var _loc2_:int = 0;
  401.          var _loc3_:int = 0;
  402.          var _loc4_:CommandMessage = null;
  403.          var _loc5_:AsyncToken = null;
  404.          var _loc6_:int = 0;
  405.          var _loc7_:int = 0;
  406.          _credentials = null;
  407.          if(param1 == null)
  408.          {
  409.             if(_authAgent != null && (_authAgent.state == AuthenticationAgent.LOGGING_OUT_STATE || _authAgent.state == AuthenticationAgent.LOGGING_IN_STATE))
  410.             {
  411.                throw new IllegalOperationError("ChannelSet is in the process of logging in or logging out.");
  412.             }
  413.             _loc2_ = int(_messageAgents.length);
  414.             _loc3_ = 0;
  415.             while(_loc3_ < _loc2_)
  416.             {
  417.                _messageAgents[_loc3_].internalSetCredentials(null);
  418.                _loc3_++;
  419.             }
  420.             _loc2_ = int(_channels.length);
  421.             _loc3_ = 0;
  422.             while(_loc3_ < _loc2_)
  423.             {
  424.                if(_channels[_loc3_] != null)
  425.                {
  426.                   _channels[_loc3_].internalSetCredentials(null);
  427.                }
  428.                _loc3_++;
  429.             }
  430.             _loc4_ = new CommandMessage();
  431.             _loc4_.operation = CommandMessage.LOGOUT_OPERATION;
  432.             _loc4_.destination = "auth";
  433.             _loc5_ = new AsyncToken(_loc4_);
  434.             if(_authAgent == null)
  435.             {
  436.                _authAgent = new AuthenticationAgent(this);
  437.             }
  438.             _authAgent.registerToken(_loc5_);
  439.             _authAgent.state = AuthenticationAgent.LOGGING_OUT_STATE;
  440.             send(_authAgent,_loc4_);
  441.             return _loc5_;
  442.          }
  443.          _loc6_ = int(_channels.length);
  444.          _loc7_ = 0;
  445.          while(_loc7_ < _loc6_)
  446.          {
  447.             if(_channels[_loc7_] != null)
  448.             {
  449.                _channels[_loc7_].logout(param1);
  450.             }
  451.             _loc7_++;
  452.          }
  453.          return null;
  454.       }
  455.       
  456.       public function set clustered(param1:Boolean) : void
  457.       {
  458.          var _loc2_:Array = null;
  459.          var _loc3_:int = 0;
  460.          var _loc4_:int = 0;
  461.          var _loc5_:String = null;
  462.          if(_clustered != param1)
  463.          {
  464.             if(param1)
  465.             {
  466.                _loc2_ = channelIds;
  467.                _loc3_ = int(_loc2_.length);
  468.                _loc4_ = 0;
  469.                while(_loc4_ < _loc3_)
  470.                {
  471.                   if(_loc2_[_loc4_] == null)
  472.                   {
  473.                      _loc5_ = resourceManager.getString("messaging","cannotSetClusteredWithdNullChannelIds");
  474.                      throw new IllegalOperationError(_loc5_);
  475.                   }
  476.                   _loc4_++;
  477.                }
  478.             }
  479.             _clustered = param1;
  480.          }
  481.       }
  482.       
  483.       public function get channelIds() : Array
  484.       {
  485.          var _loc1_:Array = null;
  486.          var _loc2_:int = 0;
  487.          var _loc3_:int = 0;
  488.          if(_channelIds != null)
  489.          {
  490.             return _channelIds;
  491.          }
  492.          _loc1_ = [];
  493.          _loc2_ = int(_channels.length);
  494.          _loc3_ = 0;
  495.          while(_loc3_ < _loc2_)
  496.          {
  497.             if(_channels[_loc3_] != null)
  498.             {
  499.                _loc1_.push(_channels[_loc3_].id);
  500.             }
  501.             else
  502.             {
  503.                _loc1_.push(null);
  504.             }
  505.             _loc3_++;
  506.          }
  507.          return _loc1_;
  508.       }
  509.       
  510.       [Bindable(event="propertyChange")]
  511.       public function get authenticated() : Boolean
  512.       {
  513.          return _authenticated;
  514.       }
  515.       
  516.       private function connectChannel() : void
  517.       {
  518.          if(!connected && !_connecting)
  519.          {
  520.             _connecting = true;
  521.             _currentChannel.connect(this);
  522.             _currentChannel.addEventListener(MessageEvent.MESSAGE,messageHandler);
  523.          }
  524.       }
  525.       
  526.       private function reconnectChannel(param1:TimerEvent) : void
  527.       {
  528.          _reconnectTimer.stop();
  529.          _reconnectTimer.removeEventListener(TimerEvent.TIMER,reconnectChannel);
  530.          _reconnectTimer = null;
  531.          connectChannel();
  532.       }
  533.       
  534.       mx_internal function get channelFailoverURIs() : Object
  535.       {
  536.          return _channelFailoverURIs;
  537.       }
  538.       
  539.       mx_internal function get configured() : Boolean
  540.       {
  541.          return _configured;
  542.       }
  543.       
  544.       public function setCredentials(param1:String, param2:MessageAgent, param3:String = null) : void
  545.       {
  546.          _credentials = param1;
  547.          var _loc4_:int = int(_channels.length);
  548.          var _loc5_:int = 0;
  549.          while(_loc5_ < _loc4_)
  550.          {
  551.             if(_channels[_loc5_] != null)
  552.             {
  553.                _channels[_loc5_].setCredentials(_credentials,param2,param3);
  554.             }
  555.             _loc5_++;
  556.          }
  557.       }
  558.       
  559.       private function messageHandler(param1:MessageEvent) : void
  560.       {
  561.          dispatchEvent(param1);
  562.       }
  563.       
  564.       protected function setConnected(param1:Boolean) : void
  565.       {
  566.          var _loc2_:PropertyChangeEvent = null;
  567.          if(_connected != param1)
  568.          {
  569.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"connected",_connected,param1);
  570.             _connected = param1;
  571.             dispatchEvent(_loc2_);
  572.             mx_internal::setAuthenticated(param1 && Boolean(currentChannel) && currentChannel.authenticated,_credentials,false);
  573.          }
  574.       }
  575.       
  576.       public function get currentChannel() : Channel
  577.       {
  578.          return _currentChannel;
  579.       }
  580.       
  581.       private function disconnectChannel() : void
  582.       {
  583.          _connecting = false;
  584.          _currentChannel.removeEventListener(MessageEvent.MESSAGE,messageHandler);
  585.          _currentChannel.disconnect(this);
  586.       }
  587.       
  588.       public function get channels() : Array
  589.       {
  590.          return _channels;
  591.       }
  592.       
  593.       public function set initialDestinationId(param1:String) : void
  594.       {
  595.          _initialDestinationId = param1;
  596.       }
  597.       
  598.       private function dispatchRPCEvent(param1:AbstractEvent) : void
  599.       {
  600.          param1.mx_internal::callTokenResponders();
  601.          dispatchEvent(param1);
  602.       }
  603.       
  604.       public function channelDisconnectHandler(param1:ChannelEvent) : void
  605.       {
  606.          _connecting = false;
  607.          setConnected(false);
  608.          if(_shouldBeConnected && !param1.reconnecting && !param1.rejected)
  609.          {
  610.             if(_shouldHunt && hunt())
  611.             {
  612.                param1.reconnecting = true;
  613.                dispatchEvent(param1);
  614.                if(_currentChannel is NetConnectionChannel)
  615.                {
  616.                   if(_reconnectTimer == null)
  617.                   {
  618.                      _reconnectTimer = new Timer(1,1);
  619.                      _reconnectTimer.addEventListener(TimerEvent.TIMER,reconnectChannel);
  620.                      _reconnectTimer.start();
  621.                   }
  622.                }
  623.                else
  624.                {
  625.                   connectChannel();
  626.                }
  627.             }
  628.             else
  629.             {
  630.                dispatchEvent(param1);
  631.                faultPendingSends(param1);
  632.             }
  633.          }
  634.          else
  635.          {
  636.             dispatchEvent(param1);
  637.             if(param1.rejected)
  638.             {
  639.                faultPendingSends(param1);
  640.             }
  641.          }
  642.          _shouldHunt = true;
  643.       }
  644.       
  645.       public function removeChannel(param1:Channel) : void
  646.       {
  647.          var _loc3_:String = null;
  648.          if(mx_internal::configured)
  649.          {
  650.             _loc3_ = resourceManager.getString("messaging","cannotRemoveWhenConfigured");
  651.             throw new IllegalOperationError(_loc3_);
  652.          }
  653.          var _loc2_:int = int(_channels.indexOf(param1));
  654.          if(_loc2_ > -1)
  655.          {
  656.             _channels.splice(_loc2_,1);
  657.             if(_currentChannel != null && _currentChannel == param1)
  658.             {
  659.                if(connected)
  660.                {
  661.                   _shouldHunt = false;
  662.                   disconnectChannel();
  663.                }
  664.                _currentChannel = null;
  665.                _currentChannelIndex = -1;
  666.             }
  667.          }
  668.       }
  669.       
  670.       public function channelConnectHandler(param1:ChannelEvent) : void
  671.       {
  672.          var _loc3_:PendingSend = null;
  673.          var _loc4_:CommandMessage = null;
  674.          var _loc5_:AcknowledgeMessage = null;
  675.          _connecting = false;
  676.          _connected = true;
  677.          while(_pendingSends.length > 0)
  678.          {
  679.             _loc3_ = PendingSend(_pendingSends.shift());
  680.             delete _pendingMessages[_loc3_.message];
  681.             _loc4_ = _loc3_.message as CommandMessage;
  682.             if(_loc4_ != null)
  683.             {
  684.                if(_loc4_.operation == CommandMessage.TRIGGER_CONNECT_OPERATION)
  685.                {
  686.                   _loc5_ = new AcknowledgeMessage();
  687.                   _loc5_.clientId = _loc3_.agent.clientId;
  688.                   _loc5_.correlationId = _loc4_.messageId;
  689.                   _loc3_.agent.acknowledge(_loc5_,_loc4_);
  690.                   continue;
  691.                }
  692.                if(!_loc3_.agent.mx_internal::configRequested && _loc3_.agent.mx_internal::needsConfig && _loc4_.operation == CommandMessage.CLIENT_PING_OPERATION)
  693.                {
  694.                   _loc4_.headers[CommandMessage.NEEDS_CONFIG_HEADER] = true;
  695.                   _loc3_.agent.mx_internal::configRequested = true;
  696.                }
  697.             }
  698.             send(_loc3_.agent,_loc3_.message);
  699.          }
  700.          if(_hunting)
  701.          {
  702.             param1.reconnecting = true;
  703.             _hunting = false;
  704.          }
  705.          dispatchEvent(param1);
  706.          var _loc2_:PropertyChangeEvent = PropertyChangeEvent.createUpdateEvent(this,"connected",false,true);
  707.          dispatchEvent(_loc2_);
  708.       }
  709.       
  710.       public function get initialDestinationId() : String
  711.       {
  712.          return _initialDestinationId;
  713.       }
  714.       
  715.       public function connect(param1:MessageAgent) : void
  716.       {
  717.          if(param1 != null && _messageAgents.indexOf(param1) == -1)
  718.          {
  719.             _shouldBeConnected = true;
  720.             _messageAgents.push(param1);
  721.             param1.mx_internal::internalSetChannelSet(this);
  722.             addEventListener(ChannelEvent.CONNECT,param1.channelConnectHandler);
  723.             addEventListener(ChannelEvent.DISCONNECT,param1.channelDisconnectHandler);
  724.             addEventListener(ChannelFaultEvent.FAULT,param1.channelFaultHandler);
  725.             if(connected)
  726.             {
  727.                param1.channelConnectHandler(ChannelEvent.createEvent(ChannelEvent.CONNECT,_currentChannel,false,false,connected));
  728.             }
  729.          }
  730.       }
  731.       
  732.       public function channelFaultHandler(param1:ChannelFaultEvent) : void
  733.       {
  734.          if(param1.channel.connected)
  735.          {
  736.             dispatchEvent(param1);
  737.          }
  738.          else
  739.          {
  740.             _connecting = false;
  741.             setConnected(false);
  742.             if(_shouldBeConnected && !param1.reconnecting && !param1.rejected)
  743.             {
  744.                if(hunt())
  745.                {
  746.                   param1.reconnecting = true;
  747.                   dispatchEvent(param1);
  748.                   if(_currentChannel is NetConnectionChannel)
  749.                   {
  750.                      if(_reconnectTimer == null)
  751.                      {
  752.                         _reconnectTimer = new Timer(1,1);
  753.                         _reconnectTimer.addEventListener(TimerEvent.TIMER,reconnectChannel);
  754.                         _reconnectTimer.start();
  755.                      }
  756.                   }
  757.                   else
  758.                   {
  759.                      connectChannel();
  760.                   }
  761.                }
  762.                else
  763.                {
  764.                   dispatchEvent(param1);
  765.                   faultPendingSends(param1);
  766.                }
  767.             }
  768.             else
  769.             {
  770.                dispatchEvent(param1);
  771.                if(param1.rejected)
  772.                {
  773.                   faultPendingSends(param1);
  774.                }
  775.             }
  776.          }
  777.       }
  778.       
  779.       mx_internal function setAuthenticated(param1:Boolean, param2:String, param3:Boolean = true) : void
  780.       {
  781.          var _loc4_:PropertyChangeEvent = null;
  782.          var _loc5_:MessageAgent = null;
  783.          var _loc6_:int = 0;
  784.          if(_authenticated != param1)
  785.          {
  786.             _loc4_ = PropertyChangeEvent.createUpdateEvent(this,"authenticated",_authenticated,param1);
  787.             _authenticated = param1;
  788.             if(param3)
  789.             {
  790.                _loc6_ = 0;
  791.                while(_loc6_ < _messageAgents.length)
  792.                {
  793.                   _loc5_ = MessageAgent(_messageAgents[_loc6_]);
  794.                   _loc5_.mx_internal::setAuthenticated(param1,param2);
  795.                   _loc6_++;
  796.                }
  797.             }
  798.             dispatchEvent(_loc4_);
  799.          }
  800.       }
  801.       
  802.       private function faultPendingSends(param1:ChannelEvent) : void
  803.       {
  804.          var _loc2_:PendingSend = null;
  805.          var _loc3_:IMessage = null;
  806.          var _loc4_:ErrorMessage = null;
  807.          var _loc5_:ChannelFaultEvent = null;
  808.          while(_pendingSends.length > 0)
  809.          {
  810.             _loc2_ = _pendingSends.shift() as PendingSend;
  811.             _loc3_ = _loc2_.message;
  812.             delete _pendingMessages[_loc3_];
  813.             _loc4_ = new ErrorMessage();
  814.             _loc4_.correlationId = _loc3_.messageId;
  815.             _loc4_.headers[ErrorMessage.RETRYABLE_HINT_HEADER] = true;
  816.             _loc4_.faultCode = "Client.Error.MessageSend";
  817.             _loc4_.faultString = resourceManager.getString("messaging","sendFailed");
  818.             if(param1 is ChannelFaultEvent)
  819.             {
  820.                _loc5_ = param1 as ChannelFaultEvent;
  821.                _loc4_.faultDetail = _loc5_.faultCode + " " + _loc5_.faultString + " " + _loc5_.faultDetail;
  822.                if(_loc5_.faultCode == "Channel.Authentication.Error")
  823.                {
  824.                   _loc4_.faultCode = _loc5_.faultCode;
  825.                }
  826.             }
  827.             else
  828.             {
  829.                _loc4_.faultDetail = resourceManager.getString("messaging","cannotConnectToDestination");
  830.             }
  831.             _loc4_.rootCause = param1;
  832.             _loc2_.agent.fault(_loc4_,_loc3_);
  833.          }
  834.       }
  835.       
  836.       mx_internal function authenticationSuccess(param1:AuthenticationAgent, param2:AsyncToken, param3:AcknowledgeMessage) : void
  837.       {
  838.          var _loc8_:int = 0;
  839.          var _loc9_:int = 0;
  840.          var _loc4_:CommandMessage = CommandMessage(param2.message);
  841.          var _loc5_:* = _loc4_.operation == CommandMessage.LOGIN_OPERATION;
  842.          var _loc6_:String = _loc5_ ? String(_loc4_.body) : null;
  843.          if(_loc5_)
  844.          {
  845.             _credentials = _loc6_;
  846.             _loc8_ = int(_messageAgents.length);
  847.             _loc9_ = 0;
  848.             while(_loc9_ < _loc8_)
  849.             {
  850.                _messageAgents[_loc9_].internalSetCredentials(_loc6_);
  851.                _loc9_++;
  852.             }
  853.             _loc8_ = int(_channels.length);
  854.             _loc9_ = 0;
  855.             while(_loc9_ < _loc8_)
  856.             {
  857.                if(_channels[_loc9_] != null)
  858.                {
  859.                   _channels[_loc9_].internalSetCredentials(_loc6_);
  860.                }
  861.                _loc9_++;
  862.             }
  863.             param1.state = AuthenticationAgent.LOGGED_IN_STATE;
  864.             currentChannel.mx_internal::setAuthenticated(true);
  865.          }
  866.          else
  867.          {
  868.             param1.state = AuthenticationAgent.SHUTDOWN_STATE;
  869.             _authAgent = null;
  870.             disconnect(param1);
  871.             currentChannel.mx_internal::setAuthenticated(false);
  872.          }
  873.          var _loc7_:ResultEvent = ResultEvent.createEvent(param3.body,param2,param3);
  874.          dispatchRPCEvent(_loc7_);
  875.       }
  876.       
  877.       public function disconnectAll() : void
  878.       {
  879.          disconnect(null);
  880.       }
  881.       
  882.       public function get messageAgents() : Array
  883.       {
  884.          return _messageAgents;
  885.       }
  886.       
  887.       mx_internal function set channelFailoverURIs(param1:Object) : void
  888.       {
  889.          var _loc4_:Channel = null;
  890.          _channelFailoverURIs = param1;
  891.          var _loc2_:int = int(_channels.length);
  892.          var _loc3_:int = 0;
  893.          while(_loc3_ < _loc2_)
  894.          {
  895.             _loc4_ = _channels[_loc3_];
  896.             if(_loc4_ == null)
  897.             {
  898.                break;
  899.             }
  900.             if(_channelFailoverURIs[_loc4_.id] != null)
  901.             {
  902.                _loc4_.failoverURIs = _channelFailoverURIs[_loc4_.id];
  903.             }
  904.             _loc3_++;
  905.          }
  906.       }
  907.       
  908.       mx_internal function authenticationFailure(param1:AuthenticationAgent, param2:AsyncToken, param3:ErrorMessage) : void
  909.       {
  910.          var _loc4_:MessageFaultEvent = MessageFaultEvent.createEvent(param3);
  911.          var _loc5_:FaultEvent = FaultEvent.createEventFromMessageFault(_loc4_,param2);
  912.          param1.state = AuthenticationAgent.SHUTDOWN_STATE;
  913.          _authAgent = null;
  914.          disconnect(param1);
  915.          dispatchRPCEvent(_loc5_);
  916.       }
  917.       
  918.       override public function toString() : String
  919.       {
  920.          var _loc1_:String = "[ChannelSet ";
  921.          var _loc2_:uint = 0;
  922.          while(_loc2_ < _channels.length)
  923.          {
  924.             if(_channels[_loc2_] != null)
  925.             {
  926.                _loc1_ += _channels[_loc2_].id + " ";
  927.             }
  928.             _loc2_++;
  929.          }
  930.          return _loc1_ + "]";
  931.       }
  932.    }
  933. }
  934.  
  935. import mx.core.mx_internal;
  936. import mx.logging.Log;
  937. import mx.messaging.messages.AcknowledgeMessage;
  938. import mx.messaging.messages.ErrorMessage;
  939. import mx.messaging.messages.IMessage;
  940. import mx.rpc.AsyncToken;
  941.  
  942. use namespace mx_internal;
  943.  
  944. class AuthenticationAgent extends MessageAgent
  945. {
  946.    public static const LOGGED_OUT_STATE:int = 0;
  947.    
  948.    public static const LOGGING_IN_STATE:int = 1;
  949.    
  950.    public static const LOGGED_IN_STATE:int = 2;
  951.    
  952.    public static const LOGGING_OUT_STATE:int = 3;
  953.    
  954.    public static const SHUTDOWN_STATE:int = 4;
  955.    
  956.    private var _state:int = 0;
  957.    
  958.    private var tokens:Object = {};
  959.    
  960.    public function AuthenticationAgent(param1:ChannelSet)
  961.    {
  962.       super();
  963.       _log = Log.getLogger("ChannelSet.AuthenticationAgent");
  964.       _agentType = "authentication agent";
  965.       this.channelSet = param1;
  966.    }
  967.    
  968.    public function get state() : int
  969.    {
  970.       return _state;
  971.    }
  972.    
  973.    public function registerToken(param1:AsyncToken) : void
  974.    {
  975.       tokens[param1.message.messageId] = param1;
  976.    }
  977.    
  978.    public function set state(param1:int) : void
  979.    {
  980.       _state = param1;
  981.       if(param1 == SHUTDOWN_STATE)
  982.       {
  983.          tokens = null;
  984.       }
  985.    }
  986.    
  987.    override public function acknowledge(param1:AcknowledgeMessage, param2:IMessage) : void
  988.    {
  989.       var _loc4_:AsyncToken = null;
  990.       if(state == SHUTDOWN_STATE)
  991.       {
  992.          return;
  993.       }
  994.       var _loc3_:Boolean = Boolean(param1.headers[AcknowledgeMessage.ERROR_HINT_HEADER]);
  995.       super.acknowledge(param1,param2);
  996.       if(!_loc3_)
  997.       {
  998.          _loc4_ = tokens[param2.messageId];
  999.          delete tokens[param2.messageId];
  1000.          channelSet.mx_internal::authenticationSuccess(this,_loc4_,param1 as AcknowledgeMessage);
  1001.       }
  1002.    }
  1003.    
  1004.    override public function fault(param1:ErrorMessage, param2:IMessage) : void
  1005.    {
  1006.       if(state == SHUTDOWN_STATE)
  1007.       {
  1008.          return;
  1009.       }
  1010.       super.fault(param1,param2);
  1011.       var _loc3_:AsyncToken = tokens[param2.messageId];
  1012.       delete tokens[param2.messageId];
  1013.       channelSet.mx_internal::authenticationFailure(this,_loc3_,param1 as ErrorMessage);
  1014.    }
  1015. }
  1016.  
  1017. class PendingSend
  1018. {
  1019.    public var agent:MessageAgent;
  1020.    
  1021.    public var message:IMessage;
  1022.    
  1023.    public function PendingSend(param1:MessageAgent, param2:IMessage)
  1024.    {
  1025.       super();
  1026.       this.agent = param1;
  1027.       this.message = param2;
  1028.    }
  1029. }
  1030.  
  1031. class ClusterMessageResponder extends MessageResponder
  1032. {
  1033.    private var _channelSet:ChannelSet;
  1034.    
  1035.    public function ClusterMessageResponder(param1:IMessage, param2:ChannelSet)
  1036.    {
  1037.       super(null,param1);
  1038.       _channelSet = param2;
  1039.    }
  1040.    
  1041.    override protected function resultHandler(param1:IMessage) : void
  1042.    {
  1043.       var _loc2_:Object = null;
  1044.       var _loc3_:Array = null;
  1045.       var _loc4_:int = 0;
  1046.       var _loc5_:int = 0;
  1047.       var _loc6_:Object = null;
  1048.       var _loc7_:Object = null;
  1049.       if(param1.body != null && param1.body is Array)
  1050.       {
  1051.          _loc2_ = {};
  1052.          _loc3_ = param1.body as Array;
  1053.          _loc4_ = int(_loc3_.length);
  1054.          _loc5_ = 0;
  1055.          while(_loc5_ < _loc4_)
  1056.          {
  1057.             _loc6_ = _loc3_[_loc5_];
  1058.             for(_loc7_ in _loc6_)
  1059.             {
  1060.                if(_loc2_[_loc7_] == null)
  1061.                {
  1062.                   _loc2_[_loc7_] = [];
  1063.                }
  1064.                _loc2_[_loc7_].push(_loc6_[_loc7_]);
  1065.             }
  1066.             _loc5_++;
  1067.          }
  1068.          _channelSet.mx_internal::channelFailoverURIs = _loc2_;
  1069.       }
  1070.    }
  1071. }
  1072.