home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / messaging / Channel.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  25.1 KB  |  816 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.Timer;
  7.    import mx.collections.ArrayCollection;
  8.    import mx.core.IMXMLObject;
  9.    import mx.core.mx_internal;
  10.    import mx.events.PropertyChangeEvent;
  11.    import mx.logging.ILogger;
  12.    import mx.logging.Log;
  13.    import mx.messaging.config.LoaderConfig;
  14.    import mx.messaging.config.ServerConfig;
  15.    import mx.messaging.errors.InvalidChannelError;
  16.    import mx.messaging.errors.InvalidDestinationError;
  17.    import mx.messaging.events.ChannelEvent;
  18.    import mx.messaging.events.ChannelFaultEvent;
  19.    import mx.messaging.messages.AbstractMessage;
  20.    import mx.messaging.messages.CommandMessage;
  21.    import mx.messaging.messages.IMessage;
  22.    import mx.resources.IResourceManager;
  23.    import mx.resources.ResourceManager;
  24.    import mx.utils.URLUtil;
  25.    
  26.    use namespace mx_internal;
  27.    
  28.    public class Channel extends EventDispatcher implements IMXMLObject
  29.    {
  30.       public static const SMALL_MESSAGES_FEATURE:String = "small_messages";
  31.       
  32.       private static const dep:ArrayCollection = null;
  33.       
  34.       private var _failoverIndex:int;
  35.       
  36.       private var _ownsWaitGuard:Boolean = false;
  37.       
  38.       protected var _recordMessageTimes:Boolean = false;
  39.       
  40.       private var _reconnecting:Boolean = false;
  41.       
  42.       private var _authenticated:Boolean = false;
  43.       
  44.       protected var messagingVersion:Number = 1;
  45.       
  46.       private var _channelSets:Array = [];
  47.       
  48.       private var _connectTimeout:int = -1;
  49.       
  50.       mx_internal var authenticating:Boolean;
  51.       
  52.       protected var _connecting:Boolean;
  53.       
  54.       private var _connectTimer:Timer;
  55.       
  56.       protected var _recordMessageSizes:Boolean = false;
  57.       
  58.       private var _failoverURIs:Array;
  59.       
  60.       protected var _log:ILogger;
  61.       
  62.       private var _connected:Boolean = false;
  63.       
  64.       private var _smallMessagesSupported:Boolean;
  65.       
  66.       private var _primaryURI:String;
  67.       
  68.       public var enableSmallMessages:Boolean = true;
  69.       
  70.       private var _id:String;
  71.       
  72.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  73.       
  74.       private var _uri:String;
  75.       
  76.       protected var _loginAfterDisconnect:Boolean = false;
  77.       
  78.       private var _isEndpointCalculated:Boolean = false;
  79.       
  80.       private var _shouldBeConnected:Boolean;
  81.       
  82.       private var _requestTimeout:int = -1;
  83.       
  84.       private var _endpoint:String;
  85.       
  86.       protected var credentials:String;
  87.       
  88.       public function Channel(param1:String = null, param2:String = null)
  89.       {
  90.          super();
  91.          _log = Log.getLogger("mx.messaging.Channel");
  92.          _connecting = false;
  93.          _failoverIndex = -1;
  94.          this.id = param1;
  95.          _primaryURI = param2;
  96.          _shouldBeConnected = false;
  97.          this.uri = param2;
  98.          mx_internal::authenticating = false;
  99.       }
  100.       
  101.       private function shutdownConnectTimer() : void
  102.       {
  103.          if(_connectTimer != null)
  104.          {
  105.             _connectTimer.stop();
  106.             _connectTimer = null;
  107.          }
  108.       }
  109.       
  110.       [Bindable(event="propertyChange")]
  111.       public function get connected() : Boolean
  112.       {
  113.          return _connected;
  114.       }
  115.       
  116.       public function get connectTimeout() : int
  117.       {
  118.          return _connectTimeout;
  119.       }
  120.       
  121.       public function get id() : String
  122.       {
  123.          return _id;
  124.       }
  125.       
  126.       private function calculateEndpoint() : void
  127.       {
  128.          var _loc3_:String = null;
  129.          if(uri == null)
  130.          {
  131.             _loc3_ = resourceManager.getString("messaging","noURLSpecified");
  132.             throw new InvalidChannelError(_loc3_);
  133.          }
  134.          var _loc1_:String = uri;
  135.          var _loc2_:String = URLUtil.getProtocol(_loc1_);
  136.          if(_loc2_.length == 0)
  137.          {
  138.             _loc1_ = URLUtil.getFullURL(LoaderConfig.url,_loc1_);
  139.          }
  140.          if(!URLUtil.hasUnresolvableTokens())
  141.          {
  142.             _isEndpointCalculated = false;
  143.             return;
  144.          }
  145.          _loc1_ = URLUtil.replaceTokens(_loc1_);
  146.          _loc2_ = URLUtil.getProtocol(_loc1_);
  147.          if(_loc2_.length > 0)
  148.          {
  149.             _endpoint = URLUtil.replaceProtocol(_loc1_,protocol);
  150.          }
  151.          else
  152.          {
  153.             _endpoint = protocol + ":" + _loc1_;
  154.          }
  155.          _isEndpointCalculated = true;
  156.          if(Log.isInfo())
  157.          {
  158.             _log.info("\'{0}\' channel endpoint set to {1}",id,_endpoint);
  159.          }
  160.       }
  161.       
  162.       [Bindable(event="propertyChange")]
  163.       public function get reconnecting() : Boolean
  164.       {
  165.          return _reconnecting;
  166.       }
  167.       
  168.       public function get useSmallMessages() : Boolean
  169.       {
  170.          return _smallMessagesSupported && enableSmallMessages;
  171.       }
  172.       
  173.       public function set connectTimeout(param1:int) : void
  174.       {
  175.          _connectTimeout = param1;
  176.       }
  177.       
  178.       [Bindable(event="propertyChange")]
  179.       public function get authenticated() : Boolean
  180.       {
  181.          return _authenticated;
  182.       }
  183.       
  184.       protected function getMessageResponder(param1:MessageAgent, param2:IMessage) : MessageResponder
  185.       {
  186.          throw new IllegalOperationError("Channel subclasses must override " + " getMessageResponder().");
  187.       }
  188.       
  189.       public function set failoverURIs(param1:Array) : void
  190.       {
  191.          if(param1 != null)
  192.          {
  193.             _failoverURIs = param1;
  194.             _failoverIndex = -1;
  195.          }
  196.       }
  197.       
  198.       protected function internalDisconnect(param1:Boolean = false) : void
  199.       {
  200.       }
  201.       
  202.       public function setCredentials(param1:String, param2:MessageAgent = null, param3:String = null) : void
  203.       {
  204.          var _loc5_:CommandMessage = null;
  205.          var _loc4_:* = this.credentials !== param1;
  206.          if(mx_internal::authenticating && _loc4_)
  207.          {
  208.             throw new IllegalOperationError("Credentials cannot be set while authenticating or logging out.");
  209.          }
  210.          if(authenticated && _loc4_)
  211.          {
  212.             throw new IllegalOperationError("Credentials cannot be set when already authenticated. Logout must be performed before changing credentials.");
  213.          }
  214.          this.credentials = param1;
  215.          if(connected && _loc4_ && param1 != null)
  216.          {
  217.             mx_internal::authenticating = true;
  218.             _loc5_ = new CommandMessage();
  219.             _loc5_.operation = CommandMessage.LOGIN_OPERATION;
  220.             _loc5_.body = param1;
  221.             if(param3 != null)
  222.             {
  223.                _loc5_.headers[CommandMessage.CREDENTIALS_CHARSET_HEADER] = param3;
  224.             }
  225.             internalSend(new AuthenticationMessageResponder(param2,_loc5_,this,_log));
  226.          }
  227.       }
  228.       
  229.       public function get mpiEnabled() : Boolean
  230.       {
  231.          return _recordMessageSizes || _recordMessageTimes;
  232.       }
  233.       
  234.       public function set id(param1:String) : void
  235.       {
  236.          if(_id != param1)
  237.          {
  238.             _id = param1;
  239.          }
  240.       }
  241.       
  242.       protected function connectTimeoutHandler(param1:TimerEvent) : void
  243.       {
  244.          var _loc2_:String = null;
  245.          var _loc3_:ChannelFaultEvent = null;
  246.          shutdownConnectTimer();
  247.          if(!connected)
  248.          {
  249.             _shouldBeConnected = false;
  250.             _loc2_ = resourceManager.getString("messaging","connectTimedOut");
  251.             _loc3_ = ChannelFaultEvent.createEvent(this,false,"Channel.Connect.Failed","error",_loc2_);
  252.             connectFailed(_loc3_);
  253.          }
  254.       }
  255.       
  256.       protected function setFlexClientIdOnMessage(param1:IMessage) : void
  257.       {
  258.          var _loc2_:String = FlexClient.getInstance().id;
  259.          param1.headers[AbstractMessage.FLEX_CLIENT_ID_HEADER] = _loc2_ != null ? _loc2_ : FlexClient.mx_internal::NULL_FLEXCLIENT_ID;
  260.       }
  261.       
  262.       protected function flexClientWaitHandler(param1:PropertyChangeEvent) : void
  263.       {
  264.          var _loc2_:FlexClient = null;
  265.          if(param1.property == "waitForFlexClientId")
  266.          {
  267.             _loc2_ = param1.source as FlexClient;
  268.             if(_loc2_.mx_internal::waitForFlexClientId == false)
  269.             {
  270.                _loc2_.removeEventListener(PropertyChangeEvent.PROPERTY_CHANGE,flexClientWaitHandler);
  271.                _loc2_.mx_internal::waitForFlexClientId = true;
  272.                _ownsWaitGuard = true;
  273.                internalConnect();
  274.             }
  275.          }
  276.       }
  277.       
  278.       public function set useSmallMessages(param1:Boolean) : void
  279.       {
  280.          _smallMessagesSupported = param1;
  281.       }
  282.       
  283.       mx_internal function internalSetCredentials(param1:String) : void
  284.       {
  285.          this.credentials = param1;
  286.       }
  287.       
  288.       private function reconnect(param1:TimerEvent) : void
  289.       {
  290.          internalConnect();
  291.       }
  292.       
  293.       mx_internal function get realtime() : Boolean
  294.       {
  295.          return false;
  296.       }
  297.       
  298.       protected function internalConnect() : void
  299.       {
  300.       }
  301.       
  302.       public function get url() : String
  303.       {
  304.          return uri;
  305.       }
  306.       
  307.       public function get recordMessageTimes() : Boolean
  308.       {
  309.          return _recordMessageTimes;
  310.       }
  311.       
  312.       public function get uri() : String
  313.       {
  314.          return _uri;
  315.       }
  316.       
  317.       private function initializeRequestTimeout(param1:MessageResponder) : void
  318.       {
  319.          var _loc2_:IMessage = param1.message;
  320.          if(_loc2_.headers[AbstractMessage.REQUEST_TIMEOUT_HEADER] != null)
  321.          {
  322.             param1.startRequestTimeout(_loc2_.headers[AbstractMessage.REQUEST_TIMEOUT_HEADER]);
  323.          }
  324.          else if(requestTimeout > 0)
  325.          {
  326.             param1.startRequestTimeout(requestTimeout);
  327.          }
  328.       }
  329.       
  330.       public function send(param1:MessageAgent, param2:IMessage) : void
  331.       {
  332.          var _loc4_:String = null;
  333.          if(param2.destination.length == 0)
  334.          {
  335.             if(param1.destination.length == 0)
  336.             {
  337.                _loc4_ = resourceManager.getString("messaging","noDestinationSpecified");
  338.                throw new InvalidDestinationError(_loc4_);
  339.             }
  340.             param2.destination = param1.destination;
  341.          }
  342.          if(Log.isDebug())
  343.          {
  344.             _log.debug("\'{0}\' channel sending message:\n{1}",id,param2.toString());
  345.          }
  346.          param2.headers[AbstractMessage.ENDPOINT_HEADER] = id;
  347.          var _loc3_:MessageResponder = getMessageResponder(param1,param2);
  348.          initializeRequestTimeout(_loc3_);
  349.          internalSend(_loc3_);
  350.       }
  351.       
  352.       public function logout(param1:MessageAgent) : void
  353.       {
  354.          var _loc2_:CommandMessage = null;
  355.          if(connected && authenticated && credentials || mx_internal::authenticating && credentials)
  356.          {
  357.             _loc2_ = new CommandMessage();
  358.             _loc2_.operation = CommandMessage.LOGOUT_OPERATION;
  359.             internalSend(new AuthenticationMessageResponder(param1,_loc2_,this,_log));
  360.             mx_internal::authenticating = true;
  361.          }
  362.          credentials = null;
  363.       }
  364.       
  365.       public function get endpoint() : String
  366.       {
  367.          if(!_isEndpointCalculated)
  368.          {
  369.             calculateEndpoint();
  370.          }
  371.          return _endpoint;
  372.       }
  373.       
  374.       public function get protocol() : String
  375.       {
  376.          throw new IllegalOperationError("Channel subclasses must override " + "the get function for \'protocol\' to return the proper protocol " + "string.");
  377.       }
  378.       
  379.       public function get failoverURIs() : Array
  380.       {
  381.          return _failoverURIs != null ? _failoverURIs : [];
  382.       }
  383.       
  384.       final public function disconnect(param1:ChannelSet) : void
  385.       {
  386.          if(_ownsWaitGuard)
  387.          {
  388.             _ownsWaitGuard = false;
  389.             FlexClient.getInstance().mx_internal::waitForFlexClientId = false;
  390.          }
  391.          var _loc2_:int = param1 != null ? int(_channelSets.indexOf(param1)) : -1;
  392.          if(_loc2_ != -1)
  393.          {
  394.             _channelSets.splice(_loc2_,1);
  395.             removeEventListener(ChannelEvent.CONNECT,param1.channelConnectHandler,false);
  396.             removeEventListener(ChannelEvent.DISCONNECT,param1.channelDisconnectHandler,false);
  397.             removeEventListener(ChannelFaultEvent.FAULT,param1.channelFaultHandler,false);
  398.             if(connected)
  399.             {
  400.                param1.channelDisconnectHandler(ChannelEvent.createEvent(ChannelEvent.DISCONNECT,this,false));
  401.             }
  402.             if(_channelSets.length == 0)
  403.             {
  404.                _shouldBeConnected = false;
  405.                if(connected)
  406.                {
  407.                   internalDisconnect();
  408.                }
  409.             }
  410.          }
  411.       }
  412.       
  413.       public function set requestTimeout(param1:int) : void
  414.       {
  415.          _requestTimeout = param1;
  416.       }
  417.       
  418.       private function shouldAttemptFailover() : Boolean
  419.       {
  420.          return _shouldBeConnected && _failoverURIs != null && _failoverURIs.length > 0;
  421.       }
  422.       
  423.       private function setReconnecting(param1:Boolean) : void
  424.       {
  425.          var _loc2_:PropertyChangeEvent = null;
  426.          if(_reconnecting != param1)
  427.          {
  428.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"reconnecting",_reconnecting,param1);
  429.             _reconnecting = param1;
  430.             dispatchEvent(_loc2_);
  431.          }
  432.       }
  433.       
  434.       public function applySettings(param1:XML) : void
  435.       {
  436.          var _loc2_:XML = null;
  437.          var _loc3_:XMLList = null;
  438.          if(Log.isInfo())
  439.          {
  440.             _log.info("\'{0}\' channel settings are:\n{1}",id,param1);
  441.          }
  442.          if(param1.properties.length())
  443.          {
  444.             _loc2_ = param1.properties[0];
  445.             if(_loc2_["connect-timeout-seconds"].length())
  446.             {
  447.                connectTimeout = _loc2_["connect-timeout-seconds"].toString();
  448.             }
  449.             if(_loc2_["record-message-times"].length())
  450.             {
  451.                _recordMessageTimes = _loc2_["record-message-times"].toString() == "true";
  452.             }
  453.             if(_loc2_["record-message-sizes"].length())
  454.             {
  455.                _recordMessageSizes = _loc2_["record-message-sizes"].toString() == "true";
  456.             }
  457.             _loc3_ = _loc2_["serialization"];
  458.             if(_loc3_.length() > 0)
  459.             {
  460.                if(_loc3_["enable-small-messages"].toString() == "false")
  461.                {
  462.                   enableSmallMessages = false;
  463.                }
  464.             }
  465.          }
  466.       }
  467.       
  468.       protected function connectSuccess() : void
  469.       {
  470.          var _loc1_:int = 0;
  471.          var _loc2_:Array = null;
  472.          var _loc3_:int = 0;
  473.          if(_ownsWaitGuard)
  474.          {
  475.             _ownsWaitGuard = false;
  476.             FlexClient.getInstance().mx_internal::waitForFlexClientId = false;
  477.          }
  478.          shutdownConnectTimer();
  479.          _connecting = false;
  480.          if(ServerConfig.mx_internal::fetchedConfig(endpoint))
  481.          {
  482.             _loc1_ = 0;
  483.             while(_loc1_ < channelSets.length)
  484.             {
  485.                _loc2_ = ChannelSet(channelSets[_loc1_]).messageAgents;
  486.                _loc3_ = 0;
  487.                while(_loc3_ < _loc2_.length)
  488.                {
  489.                   _loc2_[_loc3_].needsConfig = false;
  490.                   _loc3_++;
  491.                }
  492.                _loc1_++;
  493.             }
  494.          }
  495.          setConnected(true);
  496.          _failoverIndex = -1;
  497.          if(Log.isInfo())
  498.          {
  499.             _log.info("\'{0}\' channel is connected.",id);
  500.          }
  501.          dispatchEvent(ChannelEvent.createEvent(ChannelEvent.CONNECT,this,reconnecting));
  502.          setReconnecting(false);
  503.       }
  504.       
  505.       public function get recordMessageSizes() : Boolean
  506.       {
  507.          return _recordMessageSizes;
  508.       }
  509.       
  510.       protected function disconnectSuccess(param1:Boolean = false) : void
  511.       {
  512.          setConnected(false);
  513.          if(Log.isInfo())
  514.          {
  515.             _log.info("\'{0}\' channel disconnected.",id);
  516.          }
  517.          if(!param1 && shouldAttemptFailover())
  518.          {
  519.             _connecting = true;
  520.             failover();
  521.          }
  522.          else
  523.          {
  524.             _connecting = false;
  525.          }
  526.          dispatchEvent(ChannelEvent.createEvent(ChannelEvent.DISCONNECT,this,reconnecting,param1));
  527.       }
  528.       
  529.       protected function setConnected(param1:Boolean) : void
  530.       {
  531.          var _loc2_:PropertyChangeEvent = null;
  532.          if(_connected != param1)
  533.          {
  534.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"connected",_connected,param1);
  535.             _connected = param1;
  536.             dispatchEvent(_loc2_);
  537.             if(!param1)
  538.             {
  539.                mx_internal::setAuthenticated(false);
  540.             }
  541.          }
  542.       }
  543.       
  544.       public function get requestTimeout() : int
  545.       {
  546.          return _requestTimeout;
  547.       }
  548.       
  549.       protected function connectFailed(param1:ChannelFaultEvent) : void
  550.       {
  551.          shutdownConnectTimer();
  552.          setConnected(false);
  553.          if(Log.isError())
  554.          {
  555.             _log.error("\'{0}\' channel connect failed.",id);
  556.          }
  557.          if(!param1.rejected && shouldAttemptFailover())
  558.          {
  559.             _connecting = true;
  560.             failover();
  561.          }
  562.          else
  563.          {
  564.             if(_ownsWaitGuard)
  565.             {
  566.                _ownsWaitGuard = false;
  567.                FlexClient.getInstance().mx_internal::waitForFlexClientId = false;
  568.             }
  569.             _connecting = false;
  570.          }
  571.          if(reconnecting)
  572.          {
  573.             param1.reconnecting = true;
  574.          }
  575.          dispatchEvent(param1);
  576.       }
  577.       
  578.       public function set uri(param1:String) : void
  579.       {
  580.          if(param1 != null)
  581.          {
  582.             _uri = param1;
  583.             calculateEndpoint();
  584.          }
  585.       }
  586.       
  587.       public function initialized(param1:Object, param2:String) : void
  588.       {
  589.          this.id = param2;
  590.       }
  591.       
  592.       mx_internal function sendClusterRequest(param1:MessageResponder) : void
  593.       {
  594.          internalSend(param1);
  595.       }
  596.       
  597.       public function set url(param1:String) : void
  598.       {
  599.          uri = param1;
  600.       }
  601.       
  602.       protected function handleServerMessagingVersion(param1:Number) : void
  603.       {
  604.          useSmallMessages = param1 >= messagingVersion;
  605.       }
  606.       
  607.       protected function internalSend(param1:MessageResponder) : void
  608.       {
  609.       }
  610.       
  611.       final public function connect(param1:ChannelSet) : void
  612.       {
  613.          var _loc5_:FlexClient = null;
  614.          var _loc2_:Boolean = false;
  615.          var _loc3_:int = int(_channelSets.length);
  616.          var _loc4_:int = 0;
  617.          while(_loc4_ < _channelSets.length)
  618.          {
  619.             if(_channelSets[_loc4_] == param1)
  620.             {
  621.                _loc2_ = true;
  622.                break;
  623.             }
  624.             _loc4_++;
  625.          }
  626.          _shouldBeConnected = true;
  627.          if(!_loc2_)
  628.          {
  629.             _channelSets.push(param1);
  630.             addEventListener(ChannelEvent.CONNECT,param1.channelConnectHandler);
  631.             addEventListener(ChannelEvent.DISCONNECT,param1.channelDisconnectHandler);
  632.             addEventListener(ChannelFaultEvent.FAULT,param1.channelFaultHandler);
  633.          }
  634.          if(connected)
  635.          {
  636.             param1.channelConnectHandler(ChannelEvent.createEvent(ChannelEvent.CONNECT,this,false,false,connected));
  637.          }
  638.          else if(!_connecting)
  639.          {
  640.             _connecting = true;
  641.             if(connectTimeout > 0)
  642.             {
  643.                _connectTimer = new Timer(connectTimeout * 1000,1);
  644.                _connectTimer.addEventListener(TimerEvent.TIMER,connectTimeoutHandler);
  645.                _connectTimer.start();
  646.             }
  647.             if(FlexClient.getInstance().id == null)
  648.             {
  649.                _loc5_ = FlexClient.getInstance();
  650.                if(!_loc5_.mx_internal::waitForFlexClientId)
  651.                {
  652.                   _loc5_.mx_internal::waitForFlexClientId = true;
  653.                   _ownsWaitGuard = true;
  654.                   internalConnect();
  655.                }
  656.                else
  657.                {
  658.                   _loc5_.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE,flexClientWaitHandler);
  659.                }
  660.             }
  661.             else
  662.             {
  663.                internalConnect();
  664.             }
  665.          }
  666.       }
  667.       
  668.       private function resetToPrimaryURI() : void
  669.       {
  670.          _connecting = false;
  671.          setReconnecting(false);
  672.          uri = _primaryURI;
  673.          _failoverIndex = -1;
  674.       }
  675.       
  676.       mx_internal function setAuthenticated(param1:Boolean) : void
  677.       {
  678.          var _loc2_:PropertyChangeEvent = null;
  679.          var _loc3_:ChannelSet = null;
  680.          var _loc4_:int = 0;
  681.          if(param1 != _authenticated)
  682.          {
  683.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"authenticated",_authenticated,param1);
  684.             _authenticated = param1;
  685.             _loc4_ = 0;
  686.             while(_loc4_ < _channelSets.length)
  687.             {
  688.                _loc3_ = ChannelSet(_channelSets[_loc4_]);
  689.                _loc3_.mx_internal::setAuthenticated(authenticated,credentials);
  690.                _loc4_++;
  691.             }
  692.             dispatchEvent(_loc2_);
  693.          }
  694.       }
  695.       
  696.       mx_internal function get loginAfterDisconnect() : Boolean
  697.       {
  698.          return _loginAfterDisconnect;
  699.       }
  700.       
  701.       private function failover() : void
  702.       {
  703.          var _loc1_:Timer = null;
  704.          ++_failoverIndex;
  705.          if(_failoverIndex + 1 <= failoverURIs.length)
  706.          {
  707.             setReconnecting(true);
  708.             uri = failoverURIs[_failoverIndex];
  709.             if(Log.isInfo())
  710.             {
  711.                _log.info("\'{0}\' channel attempting to connect to {1}.",id,endpoint);
  712.             }
  713.             _loc1_ = new Timer(1,1);
  714.             _loc1_.addEventListener(TimerEvent.TIMER,reconnect);
  715.             _loc1_.start();
  716.          }
  717.          else
  718.          {
  719.             if(Log.isInfo())
  720.             {
  721.                _log.info("\'{0}\' channel has exhausted failover options and has reset to its primary endpoint.",id);
  722.             }
  723.             resetToPrimaryURI();
  724.          }
  725.       }
  726.       
  727.       public function get channelSets() : Array
  728.       {
  729.          return _channelSets;
  730.       }
  731.       
  732.       protected function disconnectFailed(param1:ChannelFaultEvent) : void
  733.       {
  734.          _connecting = false;
  735.          setConnected(false);
  736.          if(Log.isError())
  737.          {
  738.             _log.error("\'{0}\' channel disconnect failed.",id);
  739.          }
  740.          if(reconnecting)
  741.          {
  742.             resetToPrimaryURI();
  743.             param1.reconnecting = false;
  744.          }
  745.          dispatchEvent(param1);
  746.       }
  747.    }
  748. }
  749.  
  750. import mx.core.mx_internal;
  751. import mx.logging.ILogger;
  752. import mx.logging.Log;
  753. import mx.messaging.events.ChannelFaultEvent;
  754. import mx.messaging.messages.CommandMessage;
  755. import mx.messaging.messages.ErrorMessage;
  756. import mx.messaging.messages.IMessage;
  757.  
  758. use namespace mx_internal;
  759.  
  760. class AuthenticationMessageResponder extends MessageResponder
  761. {
  762.    private var _log:ILogger;
  763.    
  764.    public function AuthenticationMessageResponder(param1:MessageAgent, param2:IMessage, param3:Channel, param4:ILogger)
  765.    {
  766.       super(param1,param2,param3);
  767.       _log = param4;
  768.    }
  769.    
  770.    override protected function statusHandler(param1:IMessage) : void
  771.    {
  772.       var _loc3_:ErrorMessage = null;
  773.       var _loc4_:ChannelFaultEvent = null;
  774.       var _loc2_:CommandMessage = CommandMessage(message);
  775.       if(Log.isDebug())
  776.       {
  777.          _log.debug("{1} failure: {0}",param1.toString(),_loc2_.operation == CommandMessage.LOGIN_OPERATION ? "Login" : "Logout");
  778.       }
  779.       channel.mx_internal::authenticating = false;
  780.       channel.mx_internal::setAuthenticated(false);
  781.       if(agent != null && Boolean(agent.hasPendingRequestForMessage(message)))
  782.       {
  783.          agent.fault(ErrorMessage(param1),message);
  784.       }
  785.       else
  786.       {
  787.          _loc3_ = ErrorMessage(param1);
  788.          _loc4_ = ChannelFaultEvent.createEvent(channel,false,"Channel.Authentication.Error","warn",_loc3_.faultString);
  789.          _loc4_.rootCause = _loc3_;
  790.          channel.dispatchEvent(_loc4_);
  791.       }
  792.    }
  793.    
  794.    override protected function resultHandler(param1:IMessage) : void
  795.    {
  796.       var _loc2_:CommandMessage = message as CommandMessage;
  797.       channel.mx_internal::authenticating = false;
  798.       if(_loc2_.operation == CommandMessage.LOGIN_OPERATION)
  799.       {
  800.          if(Log.isDebug())
  801.          {
  802.             _log.debug("Login successful");
  803.          }
  804.          channel.mx_internal::setAuthenticated(true);
  805.       }
  806.       else
  807.       {
  808.          if(Log.isDebug())
  809.          {
  810.             _log.debug("Logout successful");
  811.          }
  812.          channel.mx_internal::setAuthenticated(false);
  813.       }
  814.    }
  815. }
  816.