/// <summary>
/// Opens the topology instance in client mode.
/// </summary>
/// <param name="router">The message router to be used by the cluster.</param>
/// <param name="clusterEP">The cluster's logical endpoint.</param>
/// <param name="args">Topology implementation specific parameters (ignored for this implementation).</param>
/// <remarks>
/// </remarks>
public virtual void OpenClient(MsgRouter router, MsgEP clusterEP, ArgCollection args)
{
if (!clusterEP.IsLogical)
{
throw new ArgumentException(TopologyHelper.ClusterEPNotLogicalMsg);
}
if (!router.EnableP2P)
{
SysLog.LogWarning(NoP2PMsg);
}
this.router = router;
this.instanceID = Helper.NewGuid();
this.clusterEP = clusterEP;
this.broadcastEP = new MsgEP(clusterEP, "*");
this.instanceEP = null;
this.isClient = true;
ArgCollection argsCopy;
argsCopy = args.Clone();
argsCopy["topology-type"] = TopologyHelper.SerializeType(this.GetType());
serialized = argsCopy.ToString();
OnLogicalChange(); // Forces the initial load of the instance EPs
}
/// <summary>
/// Opens the topology instance in server mode.
/// </summary>
/// <param name="router">The message router to be used by the cluster.</param>
/// <param name="dynamicScope">The dynamic scope name.</param>
/// <param name="target">The target object whose dynamic message handlers are to be registered (or <c>null</c>).</param>
/// <param name="clusterEP">The cluster's logical endpoint.</param>
/// <param name="args">Topology implementation specific parameters (ignored for this implementation).</param>
/// <remarks>
/// <para>
/// This method also registers the dynamic message handlers that case-insensitvely
/// match the dynamicScope parameter passed that are found within the
/// target object passed with the router's message dispatcher, after performing
/// any necessary munging of their message endpoints. This is done by
/// matching the dynamicScope parameter passed against the <see cref="MsgHandler.DynamicScope" />
/// property in the <see cref="MsgHandler" /> attribute tagging the message handler.
/// </para>
/// <para>
/// The matching message handler endpoints will be set to clusterEP.
/// </para>
/// </remarks>
public virtual void OpenServer(MsgRouter router, string dynamicScope, MsgEP clusterEP, object target, ArgCollection args)
{
if (!clusterEP.IsLogical)
{
throw new ArgumentException(TopologyHelper.ClusterEPNotLogicalMsg);
}
if (!router.EnableP2P)
{
SysLog.LogWarning(NoP2PMsg);
}
this.router = router;
this.instanceID = Helper.NewGuid();
this.clusterEP = clusterEP;
this.broadcastEP = new MsgEP(clusterEP, "*");
this.instanceEP = new MsgEP(clusterEP, Helper.NewGuid().ToString());
this.isClient = false;
if (target != null)
{
router.Dispatcher.AddTarget(target, dynamicScope, this, null);
}
OnLogicalChange(); // Forces the initial load of the instance EPs
}
private int cbRecv; // Bytes to receive
/// <summary>
/// Constructor.
/// </summary>
/// <param name="router">The associated message router.</param>
public TcpChannel(MsgRouter router)
{
this.router = router;
this.sock = null;
this.routerEP = null;
this.remoteEP = null;
this.localEP = null;
this.connected = false;
this.initProcessed = false;
this.lastAccess = SysTime.Now;
this.isUplink = false;
this.isDownlink = false;
this.isP2P = false;
this.sending = false;
this.sendMsg = null;
this.sendQueue = new PriorityQueue <Msg>();
this.onSend = new AsyncCallback(OnSend);
this.sendBuf = null;
this.sendPos = 0;
this.cbSend = 0;
this.onReceive = new AsyncCallback(OnReceive);
this.recvHeader = false;
this.recvBuf = null;
this.recvPos = 0;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="router">The associated router.</param>
/// <param name="routeTTL">The lifetime of an unrenewed route.</param>
public PhysicalRouteTable(MsgRouter router, TimeSpan routeTTL)
{
this.router = router;
this.routerEP = router.RouterEP;
this.routeTTL = routeTTL;
this.routes = new Dictionary <string, PhysicalRoute>();
}
/// <summary>
/// Initializes a server side session.
/// </summary>
/// <param name="router">The associated message router.</param>
/// <param name="sessionMgr">The associated session manager.</param>
/// <param name="ttl">Session time-to-live.</param>
/// <param name="msg">The message that triggered this session.</param>
/// <param name="target">The dispatch target instance.</param>
/// <param name="method">The dispatch method.</param>
/// <param name="sessionInfo">
/// The session information associated with the handler or <c>null</c>
/// to use session defaults.
/// </param>
public virtual void InitServer(MsgRouter router, ISessionManager sessionMgr, TimeSpan ttl, Msg msg, object target,
MethodInfo method, SessionHandlerInfo sessionInfo)
{
if (sessionInfo == null)
{
sessionInfo = SessionHandlerInfo.Default;
}
this.isClient = false;
this.router = router;
this.sessionMgr = sessionMgr;
this.sessionID = msg._SessionID;
this.isAsync = sessionInfo.IsAsync;
this.isRunning = true;
this.startTime = SysTime.Now;
this.finishTime = DateTime.MaxValue;
this.ttd = startTime + ttl;
this.ttl = ttl;
this.serverInitMsg = msg;
this.clientEP = msg._FromEP;
this.target = target;
this.method = method;
this.sessionInfo = sessionInfo != null ? sessionInfo : defSessionInfo;
this.cachedReply = null;
msg._Session = (ISession)this;
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="operation">Specifies how the message should be interpreted.</param>
/// <param name="timestamp">The time (UTC) when the delivery was completed successfully or was aborted.</param>
/// <param name="targetEP">The original target or cluster endpoint.</param>
/// <param name="confirmEP">The confirmation endpoint (or <c>null</c>).</param>
/// <param name="query">The query message.</param>
/// <param name="topologyID">The globally unique cluster topology provider instance ID or <see cref="Guid.Empty" />.</param>
/// <param name="topologyInfo">The serialized cluster itopology nformation (or <c>null</c>).</param>
/// <param name="topologyParam">The serialized topology parameter (or <c>null</c>).</param>
/// <param name="exception">The exception for failed deliveries or queries.</param>
/// <param name="response">The response message (or <c>null</c>).</param>
public DeliveryMsg(DeliveryOperation operation, DateTime timestamp, MsgEP targetEP, MsgEP confirmEP, Msg query,
Guid topologyID, string topologyInfo, string topologyParam, Exception exception, Msg response)
{
this.Operation = operation;
this.Timestamp = timestamp;
this.TargetEP = targetEP;
this.ConfirmEP = confirmEP;
this.TopologyID = topologyID;
this.TopologyInfo = topologyInfo;
this.TopologyParam = topologyParam;
this.Exception = exception;
this.query = query;
this.response = response;
// Serialize the query and responses to the message blob
EnhancedBlockStream es = new EnhancedBlockStream();
try
{
Msg.Save(es, query);
if (response != null)
{
Msg.Save(es, response);
}
base._Data = es.ToArray();
}
finally
{
es.Close();
}
}
/// <summary>
/// Private constructor for initializing <b>client side</b> sessions.
/// </summary>
/// <param name="router">The message router.</param>
/// <param name="serverEP">The server endpoint.</param>
/// <param name="direction">The transfer direction.</param>
/// <param name="stream">The input or output stream.</param>
private StreamTransferSession(MsgRouter router, MsgEP serverEP, TransferDirection direction, EnhancedStream stream)
{
ReliableTransferHandler handler;
reliableSession = router.CreateReliableTransferSession();
reliableSession.SessionHandler =
handler = new ReliableTransferHandler(reliableSession);
handler.BeginTransferEvent += new ReliableTransferDelegate(OnBeginTransfer);
handler.EndTransferEvent += new ReliableTransferDelegate(OnEndTransfer);
if (direction == TransferDirection.Upload)
{
handler.SendEvent += new ReliableTransferDelegate(OnSend);
}
else
{
handler.ReceiveEvent += new ReliableTransferDelegate(OnReceive);
}
this.router = router;
this.serverEP = serverEP;
this.direction = direction;
this.args = null;
this.stream = stream;
this.started = false;
this.closed = false;
this.streamClosed = false;
this.arTransfer = null;
this.simError = false;
this.simCancel = false;
this.delay = 0;
}
/// <summary>
/// Initializes an instance by loading settings from the application
/// configuration using the specified configuration key prefix.
/// </summary>
/// <param name="keyPrefix">The fully qualified configuration key prefix.</param>
/// <param name="defClusterBaseEP">The default cluster <b>ClusterBaseEP</b> setting.</param>
/// <exception cref="ArgumentException">Thrown if the required <b>ClusterBaseEP</b> setting was not found.</exception>
public ClusterMemberSettings(string keyPrefix, MsgEP defClusterBaseEP)
{
var config = new Config(keyPrefix);
this.ClusterBaseEP = config.Get("ClusterBaseEP", (string)defClusterBaseEP);
if (this.ClusterBaseEP == null)
{
throw new ArgumentException(string.Format("[{0}ClusterBaseEP] configuration setting is required.", config.KeyPrefix));
}
this.Mode = config.Get <ClusterMemberMode>("Mode", ClusterMemberMode.Normal);
if (this.Mode == ClusterMemberMode.Unknown)
{
throw new ArgumentException(string.Format("[{0}Mode] cannot be [Unknown].", config.KeyPrefix));
}
this.MasterBroadcastInterval = config.Get("MasterBroadcastInterval", this.MasterBroadcastInterval);
this.SlaveUpdateInterval = config.Get("SlaveUpdateInterval", this.SlaveUpdateInterval);
this.ElectionInterval = config.Get("ElectionInterval", this.ElectionInterval);
this.MissingMasterCount = config.Get("MissingMasterCount", this.MissingMasterCount);
this.MissingSlaveCount = config.Get("MissingSlaveCount", this.MissingSlaveCount);
this.MasterBkInterval = config.Get("MasterBkInterval", this.MasterBkInterval);
this.SlaveBkInterval = config.Get("SlaveBkInterval", this.SlaveBkInterval);
this.BkInterval = config.Get("BkInterval", this.BkInterval);
}
/// <summary>
/// Opens the topology instance in server mode.
/// </summary>
/// <param name="router">The message router to be used by the cluster.</param>
/// <param name="dynamicScope">The dynamic scope name.</param>
/// <param name="target">The target object whose dynamic message handlers are to be registered (or <c>null</c>).</param>
/// <param name="clusterEP">The cluster's logical endpoint.</param>
/// <param name="args">Topology implementation specific parameters.</param>
/// <remarks>
/// <para>
/// This method also registers the dynamic message handlers that case-insensitvely
/// match the dynamicScope parameter passed that are found within the
/// target object passed with the router's message dispatcher, after performing
/// any necessary munging of their message endpoints. This is done by
/// matching the dynamicScope parameter passed against the <see cref="MsgHandler.DynamicScope" />
/// property in the <see cref="MsgHandler" /> attribute tagging the message handler.
/// </para>
/// <para>
/// The matching message handler endpoints will be set to clusterEP.
/// </para>
/// </remarks>
public virtual void OpenServer(MsgRouter router, string dynamicScope, MsgEP clusterEP, object target, ArgCollection args)
{
string arg;
int index;
if (!clusterEP.IsLogical)
{
throw new ArgumentException(TopologyHelper.ClusterEPNotLogicalMsg);
}
this.router = router;
this.instanceID = Helper.NewGuid();
this.clusterEP = clusterEP;
this.broadcastEP = new MsgEP(clusterEP, "*");
this.isClient = false;
GetServiceInstances(clusterEP, args);
arg = args["this-instance"];
if (arg == null || !int.TryParse(arg, out index) || index < 0 || index >= instances.Length)
{
throw new ArgumentException("[this-instance] topology argument is not a valid index into the instances array.");
}
instanceEP = instances[index];
if (target != null)
{
router.Dispatcher.AddTarget(target, dynamicScope, this, null);
}
}
public void MsgEP_Physical_GetParent()
{
Assert.AreEqual("physical://foo.com:70", MsgEP.Parse("physical://foo.com:70/bar").GetPhysicalParent().ToString());
Assert.AreEqual("physical://foo.com:70", MsgEP.Parse("physical://foo.com:70/bar").GetPhysicalParent().ToString());
Assert.AreEqual("physical://foo.com:70/bar", MsgEP.Parse("physical://foo.com:70/bar/foobar").GetPhysicalParent().ToString());
Assert.IsNull(MsgEP.Parse("physical://foo.com:70").GetPhysicalParent());
}
private bool closed = false; // True if the transaction has completed
/// <summary>
/// Constructs a <see cref="MsgRequestContext" /> for transactions that are not within a session.
/// </summary>
/// <param name="router">The <see cref="MsgRouter" />.</param>
/// <param name="requestMsg">The request <see cref="Msg" />.</param>
/// <exception cref="ArgumentException">Thrown if the message passed does not have all of the headers necessary to be a request.</exception>
internal MsgRequestContext(MsgRouter router, Msg requestMsg)
{
if (router == null)
{
throw new ArgumentNullException("router");
}
if (requestMsg._FromEP == null)
{
throw new ArgumentException("Message cannot be a request: Null [_FromEP] header.", "requestMsg");
}
if (requestMsg._SessionID == Guid.Empty)
{
throw new ArgumentException("Message cannot be a request: Empty [_SessionID] header.", "requestMsg");
}
this.router = router;
this.session = null;
this.FromEP = requestMsg._FromEP.Clone();
this.SessionID = requestMsg._SessionID;
#if TRACE
this.TraceName = requestMsg.GetType().Name;
#else
this.TraceName = "(trace disabled)";
#endif
}
public void Msg_Clone_RouteAdvertiseMsg()
{
RouterAdvertiseMsg msgIn, msgOut;
Msg.ClearTypes();
Msg.LoadTypes(Assembly.GetExecutingAssembly());
msgOut = new RouterAdvertiseMsg(MsgEP.Parse("physical://root.com:80/hub/leaf"), "appname", "appdescription", new MsgRouterInfo(new Version(1000, 0)), 10, 20, Helper.NewGuid(), false, true);
msgOut._FromEP = MsgEP.Parse("physical://root.com:80/hub/leaf?c=mcast://1.2.3.4:57");
msgIn = (RouterAdvertiseMsg)msgOut.Clone();
Assert.AreEqual("physical://root.com:80/hub/leaf", msgIn.RouterEP.ToString());
Assert.AreEqual("appname", msgIn.AppName);
Assert.AreEqual("appdescription", msgIn.AppDescription);
Assert.AreEqual(new Version(1000, 0), msgIn.RouterInfo.ProtocolVersion);
Assert.AreEqual(IPAddress.Parse("1.2.3.4"), msgIn.IPAddress);
Assert.AreEqual(10, msgIn.UdpPort);
Assert.AreEqual(20, msgIn.TcpPort);
Assert.AreEqual(msgOut.LogicalEndpointSetID, msgIn.LogicalEndpointSetID);
Assert.IsFalse(msgIn.ReplyAdvertise);
Assert.IsTrue(msgIn.DiscoverLogical);
Assert.IsTrue(msgIn.RouterInfo.IsP2P);
TestBaseCloning(msgOut);
}
/// <summary>
/// Shallow copies the base fields from the source message to this instance.
/// </summary>
/// <param name="source">The source message.</param>
/// <param name="regenMsgID">
/// Pass as <c>true</c> to renegerate the <see cref="_MsgID" /> property if the
/// source message ID property is not empty.
/// </param>
/// <remarks>
/// Use this in overriden <see cref="Clone" /> method implementations
/// to ensure that the base message fields are copied properly.
/// </remarks>
protected virtual void CopyBaseFields(Msg source, bool regenMsgID)
{
this.version = source.version;
this.flags = source.flags;
this.ttl = source.ttl;
this.toEP = source.toEP;
this.fromEP = source.fromEP;
this.receiptEP = source.receiptEP;
this.sessionID = source.sessionID;
this.token = source.token;
if (source.msgID == Guid.Empty)
{
this.msgID = Guid.Empty;
}
else if (regenMsgID)
{
this.msgID = Helper.NewGuid();
}
else
{
this.msgID = source.msgID;
}
if (source.extHeaders != null)
{
this.extHeaders = source.extHeaders.Clone();
}
}
public void Msg_Clone_HubAdvertiseMsg()
{
HubAdvertiseMsg msgIn, msgOut;
Msg.ClearTypes();
Msg.LoadTypes(Assembly.GetExecutingAssembly());
msgOut = new HubAdvertiseMsg(MsgEP.Parse("physical://root.com:80/hub/leaf"), "appname", "appdescription", new MsgRouterInfo(new Version(1000, 0)), Helper.NewGuid());
msgOut._FromEP = MsgEP.Parse("physical://root.com:80/hub/leaf?c=tcp://1.2.3.4:57");
Assert.AreEqual(Guid.Empty, msgOut._MsgID);
msgIn = (HubAdvertiseMsg)msgOut.Clone();
Assert.AreEqual("physical://root.com:80/hub/leaf", msgIn.HubEP.ToString());
Assert.AreEqual("appname", msgIn.AppName);
Assert.AreEqual("appdescription", msgIn.AppDescription);
Assert.AreEqual(new Version(1000, 0), msgIn.RouterInfo.ProtocolVersion);
Assert.AreEqual(IPAddress.Parse("1.2.3.4"), msgIn.IPAddress);
Assert.AreEqual(57, msgIn.TcpPort);
Assert.AreEqual(msgOut.LogicalEndpointSetID, msgIn.LogicalEndpointSetID);
Assert.AreEqual(Guid.Empty, msgIn._MsgID);
msgOut._MsgID = Helper.NewGuid();
msgIn = (HubAdvertiseMsg)msgOut.Clone();
Assert.AreNotEqual(Guid.Empty, msgIn._MsgID);
TestBaseCloning(msgOut);
}
public void OnMsg(LeafSettingsMsg msg)
{
using (TimedLock.Lock(this.SyncRoot))
{
if (advertiseTime != msg.AdvertiseTime)
{
advertiseTime = msg.AdvertiseTime;
lastAdvertise = SysTime.Now;
}
if (msg.HubIPAddress != null && msg.HubTcpPort != 0)
{
if (hubIPAddress != msg.HubIPAddress || hubTcpPort != msg.HubTcpPort)
{
hubChannelEP = new ChannelEP(Transport.Tcp, new IPEndPoint(msg.HubIPAddress, msg.HubTcpPort));
}
}
else
{
hubChannelEP = null;
}
hubEP = msg.HubEP;
hubIPAddress = msg.HubIPAddress;
hubUdpPort = msg.HubUdpPort;
hubTcpPort = msg.HubTcpPort;
if (msg.DiscoverLogical)
{
SendLogicalAdvertiseMsgs(msg.HubEP);
}
}
}
public void MsgEP_Compare()
{
Assert.AreEqual(0, MsgEP.Compare("logical://test/*", "logical://test/*"));
Assert.AreEqual(0, MsgEP.Compare("logical://aa", "logical://AA"));
Assert.AreEqual(-1, MsgEP.Compare("logical://aa", "logical://bb"));
Assert.AreEqual(+1, MsgEP.Compare("logical://BB", "logical://aa"));
}
/// <summary>
/// Updates a message's target endpoint and status. This is typically used
/// for moving an expired message to a dead letter queue.
/// </summary>
/// <param name="persistID">The provider specific ID of the message.</param>
/// <param name="targetEP">The new message target endpoint.</param>
/// <param name="deliveryTime">The new message delivery time.</param>
/// <param name="expireTime">The new message expiration time.</param>
/// <param name="status">The new <see cref="DeliveryStatus" />.</param>
public void Modify(object persistID, MsgEP targetEP, DateTime deliveryTime, DateTime expireTime, DeliveryStatus status)
{
using (TimedLock.Lock(this))
{
if (messages == null)
{
throw new ObjectDisposedException(this.GetType().Name);
}
Guid msgID = (Guid)persistID;
QueuedMsgInfo msgInfo;
QueuedMsg msg;
if (messages.TryGetValue(msgID, out msgInfo))
{
msgInfo.TargetEP = targetEP;
msgInfo.DeliveryTime = deliveryTime;
msgInfo.ExpireTime = expireTime;
msgInfo.Status = status;
msg = (QueuedMsg)msgInfo.ProviderData;
msg.TargetEP = targetEP;
msg.ExpireTime = expireTime;
}
}
}
public void MsgQueueEngineSettings_Load()
{
try
{
MsgQueueEngineSettings settings;
Config.SetConfig(@"
§ion Engine
QueueMap[0] = logical://test1
QueueMap[1] = logical://test2
FlushInterval = 1s
DeadLetterTTL = 2s
MaxDeliveryAttempts = 3
KeepAliveInterval = 4s
SessionTimeout = 5s
BkTaskInterval = 6s
&endsection
".Replace('&', '#'));
settings = MsgQueueEngineSettings.LoadConfig("Engine");
CollectionAssert.AreEqual(new MsgEP[] { MsgEP.Parse("logical://test1"), MsgEP.Parse("logical://test2") }, settings.QueueMap);
Assert.AreEqual(TimeSpan.FromSeconds(1), settings.FlushInterval);
Assert.AreEqual(TimeSpan.FromSeconds(2), settings.DeadLetterTTL);
Assert.AreEqual(3, settings.MaxDeliveryAttempts);
Assert.AreEqual(TimeSpan.FromSeconds(4), settings.KeepAliveInterval);
Assert.AreEqual(TimeSpan.FromSeconds(5), settings.SessionTimeout);
Assert.AreEqual(TimeSpan.FromSeconds(6), settings.BkTaskInterval);
}
finally
{
Config.SetConfig(null);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="senderEP">The sender instance endpoint.</param>
/// <param name="command">The command string.</param>
public ClusterMemberMsg(MsgEP senderEP, string command)
{
base._Set("sender", (string)senderEP);
base._Set("cmd", command);
base._Set("caps", (int)ClusterMemberProtocolCaps.Current);
base._Set("flags", (int)ClusterMemberMsgFlag.None);
}
/// <summary>
/// Constructs a <see cref="MsgRequestContext" /> for transactions that are within a session.
/// </summary>
/// <param name="session">The <see cref="DuplexSession" />.</param>
/// <param name="query">The request <see cref="Msg" />.</param>
/// <exception cref="ArgumentException">Thrown if the message passed does not have all of the headers necessary to be a request.</exception>
internal MsgRequestContext(DuplexSession session, Msg query)
{
if (session == null)
{
throw new ArgumentNullException("session");
}
if (query._FromEP == null)
{
throw new ArgumentException("Message cannot be a request: Null [_FromEP] header.", "requestMsg");
}
if (query._SessionID == Guid.Empty)
{
throw new ArgumentException("Message cannot be a request: Empty [_SessionID] header.", "requestMsg");
}
this.Header = query._ExtensionHeaders[MsgHeaderID.DuplexSession];
if (this.Header == null)
{
throw new ArgumentException("Message is not a DuplexSession query.", "requestMsg");
}
this.router = session.Router;
this.session = session;
this.FromEP = query._FromEP.Clone();
this.SessionID = query._SessionID;
#if TRACE
this.TraceName = query.GetType().Name;
#else
this.TraceName = "(trace disabled)";
#endif
}
public void MsgDispatcherLogical_DynamicEP()
{
MsgDispatcher dispatcher;
MsgRouter router;
ChannelEP target;
dispatcher = new MsgDispatcher();
router = new MsgRouter(dispatcher);
router.Dispatcher.AddTarget(this, "foo", new Munger(), null);
router.RouterEP = MsgEP.Parse("physical://foo.com/" + Helper.NewGuid().ToString());
router.Start(IPAddress.Any, null, new IPEndPoint(IPAddress.Any, 0), new IPEndPoint(IPAddress.Any, 0), 5, TimeSpan.FromSeconds(60));
target = new ChannelEP(Transport.Udp, router.UdpEP);
try
{
Clear();
router.Transmit(target, new _DispatchMsg1("logical://MungedDynamic"));
Thread.Sleep(DispatchWait);
Assert.IsTrue(dispatchDynamic);
}
finally
{
router.Stop();
}
}
/// <summary>
/// Reads the member status from a stream.
/// </summary>
/// <param name="input">The input stream.</param>
public ClusterMemberStatus(EnhancedStream input)
{
properties = input.ReadProperties(StringComparer.OrdinalIgnoreCase);
try
{
string v;
if (!properties.TryGetValue("_state", out v))
{
this.State = ClusterMemberState.Unknown;
}
else
{
this.State = (ClusterMemberState)Enum.Parse(typeof(ClusterMemberState), v);
}
}
catch
{
this.State = ClusterMemberState.Unknown;
}
this.Mode = this.Settings.Mode;
this.InstanceEP = properties["_instance-ep"];
this.MachineName = properties["_machine-name"];
this.ProtocolCaps = (ClusterMemberProtocolCaps)int.Parse(properties["_caps"]);
}
private bool hostStarted; // Indicates whether call to ChannelHost.Start() is current
//---------------------------------------------------------------------
// Implementation
/// <summary>
/// Constructor.
/// </summary>
/// <param name="context">The <see cref="BindingContext" /> holding the information necessary to construct the channel stack.</param>
/// <exception cref="InvalidOperationException">Thrown if problems were found with the binding parameters.</exception>
internal LillTekChannelListener(BindingContext context)
{
this.maxAcceptedChannels = ServiceModelHelper.MaxAcceptedChannels; // $todo(jeff.lill): Hardcoded
bkTaskInterval = ServiceModelHelper.DefaultBkTaskInterval; // This too
this.context = context;
this.uri = GetListenUri(context);
this.ep = ServiceModelHelper.ToMsgEP(uri);
this.onBkTask = new AsyncCallback(OnBkTask);
this.sessionMode = false;
this.hostStarted = false;
// Initialize the message encoder factory from the binding context if
// one was specified. Use the binary message encoding factory otherwise.
if (context.BindingParameters.FindAll <MessageEncodingBindingElement>().Count > 1)
{
throw new InvalidOperationException("Multiple MessageEncodingBindingElements were found in the BindingParameters of the BindingContext.");
}
MessageEncodingBindingElement element = context.BindingParameters.Find <MessageEncodingBindingElement>();
if (element != null)
{
messageEncoderFactory = element.CreateMessageEncoderFactory();
}
else
{
messageEncoderFactory = new BinaryMessageEncodingBindingElement().CreateMessageEncoderFactory();
}
}
/// <summary>
/// Constructs a MsgTrack instance from the parameters passed.
/// </summary>
/// <param name="routerEP">The target router's physical endpoint.</param>
/// <param name="logicalEndpointSetID">
/// The logical endpoint set ID if the message is being sent at a logical
/// endpoint on the targeted router, null otherwise.
/// </param>
/// <param name="msgID">The forwarded message's GUID.</param>
/// <param name="ttd">
/// The time (SYS) beyond which we'll consider that we've detected a dead
/// router if we haven't seen a valid <see cref="ReceiptMsg" />.
/// </param>
public MsgTrack(MsgEP routerEP, Guid logicalEndpointSetID, Guid msgID, DateTime ttd)
{
this.RouterEP = routerEP;
this.LogicalEndpointSetID = logicalEndpointSetID;
this.MsgID = msgID;
this.TTD = ttd;
}
public void ReliableMessengerMsgs_DeliveryMsg_Serialize()
{
DeliveryMsg msgIn, msgOut;
EnhancedStream es = new EnhancedMemoryStream();
DateTime now = Helper.UtcNowRounded;
Guid id = Helper.NewGuid();
PropertyMsg query;
PropertyMsg response;
Msg.ClearTypes();
Msg.LoadTypes(Assembly.GetExecutingAssembly());
query = new PropertyMsg();
query["hello"] = "world";
response = new PropertyMsg();
response["foo"] = "bar";
msgOut = new DeliveryMsg(DeliveryOperation.Attempt, now, "logical://foo", "logical://bar", query, id,
"clusterInfo", "clusterParam", new TimeoutException("Timeout"), response);
Msg.Save(es, msgOut);
es.Seek(0, SeekOrigin.Begin);
msgIn = (DeliveryMsg)Msg.Load(es);
Assert.IsNotNull(msgIn);
Assert.AreEqual(DeliveryOperation.Attempt, msgIn.Operation);
Assert.AreEqual(now, msgIn.Timestamp);
Assert.AreEqual(MsgEP.Parse("logical://foo"), msgIn.TargetEP);
Assert.AreEqual(MsgEP.Parse("logical://bar"), msgIn.ConfirmEP);
Assert.IsInstanceOfType(msgIn.Query, typeof(PropertyMsg));
Assert.AreEqual("world", ((PropertyMsg)msgIn.Query)["hello"]);
Assert.AreEqual(id, msgIn.TopologyID);
Assert.AreEqual("clusterInfo", msgIn.TopologyInfo);
Assert.AreEqual("clusterParam", msgIn.TopologyParam);
Assert.IsInstanceOfType(msgIn.Exception, typeof(TimeoutException));
Assert.AreEqual("Timeout", msgIn.Exception.Message);
Assert.IsInstanceOfType(msgIn.Response, typeof(PropertyMsg));
Assert.AreEqual("bar", ((PropertyMsg)msgIn.Response)["foo"]);
msgOut = new DeliveryMsg(DeliveryOperation.Confirmation, now, "logical://foo", null, query, id,
null, null, new ArgumentException("Test"), null);
es.SetLength(0);
Msg.Save(es, msgOut);
es.Seek(0, SeekOrigin.Begin);
msgIn = (DeliveryMsg)Msg.Load(es);
Assert.IsNotNull(msgIn);
Assert.AreEqual(DeliveryOperation.Confirmation, msgIn.Operation);
Assert.AreEqual(now, msgIn.Timestamp);
Assert.AreEqual(MsgEP.Parse("logical://foo"), msgIn.TargetEP);
Assert.IsNull(msgIn.ConfirmEP);
Assert.IsInstanceOfType(msgIn.Query, typeof(PropertyMsg));
Assert.AreEqual("world", ((PropertyMsg)msgIn.Query)["hello"]);
Assert.AreEqual(id, msgIn.TopologyID);
Assert.IsNull(msgIn.TopologyInfo);
Assert.IsNull(msgIn.TopologyParam);
Assert.IsInstanceOfType(msgIn.Exception, typeof(SessionException));
Assert.AreEqual("Test", msgIn.Exception.Message);
Assert.IsNull(msgIn.Response);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="routerEP">Physical endpoint of the sending router.</param>
/// <param name="routerInfo">The sending router's capability information.</param>
/// <param name="isUplink"><c>true</c> if the sender side is an uplink.</param>
/// <param name="listenPort">The listening port.</param>
public TcpInitMsg(MsgEP routerEP, MsgRouterInfo routerInfo, bool isUplink, int listenPort)
{
this._Flags = MsgFlag.Priority;
this.RouterEP = routerEP;
this.RouterInfo = routerInfo;
this.IsUplink = isUplink;
this.ListenPort = listenPort;
}
private MsgEP instanceEP; // Endpoint of the connected sentinel instance.
/// <summary>
/// Constructor.
/// </summary>
/// <param name="router">The application message router to be used for communications.</param>
/// <param name="serviceEP">The sentinel service endpoint.</param>
public Sentinel(MsgRouter router, MsgEP serviceEP)
{
Global.RegisterMsgTypes();
this.router = router;
this.serviceEP = serviceEP;
this.instanceEP = null;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="senderEP">The sender instance endpoint.</param>
/// <param name="protocolCaps">Indicates the sender's protocol implementation capabilities.</param>
/// <param name="command">The command string.</param>
/// <param name="data">The message BLOB data.</param>
public ClusterMemberMsg(MsgEP senderEP, ClusterMemberProtocolCaps protocolCaps, string command, byte[] data)
{
base._Set("sender", (string)senderEP);
base._Set("cmd", command);
base._Set("caps", (int)protocolCaps);
base._Set("flags", (int)ClusterMemberMsgFlag.None);
base._Data = data;
}
public void MsgEP_Logical_EscapeInput()
{
MsgEP ep;
ep = MsgEP.Parse("logical://root%20node/hub%20node/leaf%20node");
Assert.IsTrue(ep.IsLogical);
CollectionAssert.AreEqual(new string[] { "root node", "hub node", "leaf node" }, ep.Segments);
}
/// <summary>
/// Initializes the channel endpoints of the message's FROM
/// endpoint, creating the endpoint object if necessary.
/// </summary>
/// <param name="fromChannelEP">The channel endpoint.</param>
public void _SetFromChannel(ChannelEP fromChannelEP)
{
if (this.fromEP == null)
{
this.fromEP = new MsgEP(fromChannelEP);
}
this.fromEP.ChannelEP = fromChannelEP;
}
