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