public void PostAlert(OktoAlertType alertType, ulong[] args)
{
// Push message to the sequential work queue for upcall into Policy Module.
MessageAlert mAlert = new MessageAlert(alertType,args);
RcWorkItem rcWorkItem = new RcWorkItem(RcWorkItemType.Alert, mAlert, 0, null);
RcWorkQueue.Enqueue(rcWorkItem);
}
public void PostAlertMessage(byte[] buffer, int offset)
{
// Parse and push message to the sequential work queue for upcall into Policy Module.
MessageAlert mAlert = MessageAlert.CreateFromNetBytes(buffer,offset);
RcWorkItem rcWorkItem = new RcWorkItem(RcWorkItemType.Alert, mAlert, 0, null);
RcWorkQueue.Enqueue(rcWorkItem);
}
public void CallbackAlert(MessageNetAlert netAlert, NetRateControllerState state)
{
//
// Turn the network alert into an oktofs alert and post it to work item queue for dispatch to policy module.
//
//throw new NotImplementedException("OktofsRateController CallbackAlert should never get called.");
MessageAlert mAlert = MessageAlert.CreateFromNetAlert(netAlert);
Log(String.Format("netAlert {0}", netAlert));
RcWorkItem rcWorkItem = new RcWorkItem(RcWorkItemType.Alert, mAlert, 0, null);
RcWorkQueue.Enqueue(rcWorkItem);
}
/// <summary>
/// Starts the Timeout timer.
/// </summary>
/// <param name="dueTime"></param>
private void StartTimer(long millisecsFromNow, RcWorkItem context)
{
lock (LockTimer)
{
CurrentTimeoutUSecs = softTimer.TimeNowUSecs() + (millisecsFromNow * 1000);
context.TimerUSecs = CurrentTimeoutUSecs;
softTimer.RegisterTimer(CurrentTimeoutUSecs, context);
}
}
/// <summary>
/// Single thread running work queue service routine ensures sequential callbacks into Policy Module.
/// </summary>
/// <param name="workItem"></param>
private void RunRcWorkQueueItem(RcWorkItem workItem)
{
switch (workItem.Type)
{
case RcWorkItemType.SettleTimeout:
if (IsCurrentTimeout(workItem.TimerUSecs))
{
StateTransition(RateControllerState.SettleCallback);
StateTransition(RateControllerState.SampleTimeout);
}
else
{
smsg("ignore stale TO IntervalSettleExpired");
}
break;
case RcWorkItemType.SampleTimeout:
if (IsCurrentTimeout(workItem.TimerUSecs))
{
StateTransition(RateControllerState.UpdateCallback);
StateTransition(RateControllerState.SettleTimeout);
}
else
{
smsg("ignore stale TO IntervalSampleExpired");
}
break;
case RcWorkItemType.Alert:
// Note: the alert callback may (have to) adjust current RC state.
iPolicyModule.CallbackAlert((MessageAlert)workItem.Args, State);
break;
}
}
/// <summary>
/// Transitions state machine. Called from sequential work queue in response to timeouts and alerts.
/// </summary>
/// <param name="nextState"></param>
public void StateTransition(RateControllerState nextState)
{
RcWorkItem context;
lock (LockState)
{
Debug.WriteLine("StateTransition {0}=>{1}", state, nextState);
if (state.Equals(RateControllerState.Fin) ||
nextState.Equals(RateControllerState.Fin) ||
Shutdown)
{
state = RateControllerState.Fin;
return;
}
//
// Transition to new state and take the actions associated with that state.
//
switch (state)
{
case RateControllerState.Init:
Debug.Assert(nextState == RateControllerState.SettleTimeout);
state = nextState;
if (netRateController != null)
netRateController.StateTransitionNoOp(NetRateControllerState.SettleTimeout);
context = new RcWorkItem(RcWorkItemType.SettleTimeout, RateControllerState.SettleTimeout, settleMillisecs, null);
Console.WriteLine("RateController start init timer {0} millisecs", RcWorkItemType.SettleTimeout);
StartTimer(settleMillisecs, context);
break;
case RateControllerState.SettleTimeout:
Debug.Assert(nextState == RateControllerState.SettleCallback);
state = nextState;
if (netRateController != null)
netRateController.StateTransitionNoOp(NetRateControllerState.SettleCallback);
iPolicyModule.CallbackSettleTimeout();
break;
case RateControllerState.SettleCallback:
Debug.Assert(nextState == RateControllerState.SampleTimeout);
state = nextState;
if (netRateController != null)
netRateController.StateTransitionNoOp(NetRateControllerState.SampleTimeout);
context = new RcWorkItem(RcWorkItemType.SampleTimeout, RateControllerState.SampleTimeout, sampleMillisecs, null);
StartTimer(sampleMillisecs, context);
break;
case RateControllerState.SampleTimeout:
Debug.Assert(nextState == RateControllerState.UpdateCallback);
state = nextState;
if (netRateController != null)
netRateController.StateTransitionNoOp(NetRateControllerState.UpdateCallback);
iPolicyModule.CallbackControlInterval();
break;
case RateControllerState.UpdateCallback:
Debug.Assert(nextState == RateControllerState.SettleTimeout);
state = nextState;
if (netRateController != null)
netRateController.StateTransitionNoOp(NetRateControllerState.SettleTimeout);
context = new RcWorkItem(RcWorkItemType.SettleTimeout, RateControllerState.SettleTimeout, settleMillisecs, null);
StartTimer(settleMillisecs, context);
break;
}
}
}
/// <summary>
/// Called by a connection when it has received an intact and complete message in wire-format.
/// Parses the supplied byte-array to generate a typed message for processing.
/// On return from this routine the connection is free to overwrite the buffer contents.
/// /// </summary>
/// <param name="conn">Connection (think TCP to specific network agent) on which message arrived.</param>
/// <param name="buff">Buffer encoding the message.</param>
/// <param name="offset">Offset to start of message in the supplied buffer.</param>
/// <param name="length">Length of message encoding in supplied buffer</param>
public void ReceiveMessage(Connection conn, MessageTypes messageType, byte[] buff, int offset, int length)
{
bool unblock = false;
switch (messageType)
{
case MessageTypes.MessageTypeAck:
{
conn.MessageAck.InitFromNetBytes(buff, 0);
//Console.WriteLine("SendParallel rcv MessageAck({0},{1})", conn.MessageAck.SeqNo, conn.MessageAck.Result);
if (conn.MessageAck.Result != (uint)OktoResultCodes.OKTO_RESULT_SUCCESS)
{
string msg = String.Format("ACK err: conn {0} ResultCode {1} subytpe {2}",
conn.HostName, conn.MessageAck.Result, (MessageTypes)conn.MessageAck.SubType);
Console.WriteLine(msg);
}
MessageTypes AckSubType = (MessageTypes)conn.MessageAck.SubType;
unblock = DowndatePendingReplies(AckSubType, conn.MessageAck.SeqNo);
conn.BeginReceive();
break;
}
case MessageTypes.MessageTypeStatsReplyDelta:
{
MessageStatsReplyDelta mStatsDelta = MessageStatsReplyDelta.CreateFromNetBytes(conn.receiveBuffer, 0, conn, this);
//Console.WriteLine("ReceiveRaw MessageStatsReplyDelta({0},{1})", mStatsDelta.SeqNo, mStatsDelta.Result);
ulong intervalUSecs = mStatsDelta.IntervalUSecs;
foreach (KeyValuePair<ushort, FlowStats> kvp in mStatsDelta.dictFlowStats)
{
RAP rap = conn.ListRap[kvp.Key];
FlowStats flowStats = kvp.Value;
rap.SetFlowStats(flowStats);
}
unblock = DowndatePendingReplies(messageType, mStatsDelta.SeqNo);
conn.BeginReceive();
break;
}
case MessageTypes.MessageTypeNameToStringSidReply:
{
MessageVmNameToStringSidReply mNameToSidReply
= MessageVmNameToStringSidReply.CreateFromNetBytes(conn.receiveBuffer, 0);
string vmKey = conn.HostName + "." + mNameToSidReply.VmName;
lock (DictVmNameToSid)
{
if (!DictVmNameToSid.ContainsKey(vmKey))
DictVmNameToSid.Add(vmKey, mNameToSidReply.SidString);
}
unblock = DowndatePendingReplies(messageType, mNameToSidReply.SeqNo);
conn.BeginReceive();
break;
}
case MessageTypes.MessageTypeAlert:
{
MessageAlert mAlert = MessageAlert.CreateFromNetBytes(conn.receiveBuffer, 0);
//Console.WriteLine("ReceiveMessage rx alert {0}", mAlert);
// Push message to the sequential work queue for upcall into Policy Module.
RcWorkItem rcWorkItem = new RcWorkItem(RcWorkItemType.Alert, mAlert, 0, conn);
RcWorkQueue.Enqueue(rcWorkItem);
conn.BeginReceive();
break;
}
case MessageTypes.MessageTypeIoFlowStatsReply:
{
MessageIoFlowStatsReply mIoFlowStats =
MessageIoFlowStatsReply.CreateFromNetBytes(conn.receiveBuffer, 0);
foreach (IoFlowMessageParams stats in mIoFlowStats.ListParams)
conn.DictIoFlows[stats.FlowId].RapD.SetIoFlowStats(stats.ParameterString);
unblock = DowndatePendingReplies(messageType, mIoFlowStats.SeqNo);
conn.BeginReceive();
break;
}
case MessageTypes.MessageTypeNameToStringSidBatchReply:
{
MessageVmNameToStringSidBatchReply mNameToSidReply
= MessageVmNameToStringSidBatchReply.CreateFromNetBytes(conn.receiveBuffer, 0);
lock (DictVmNameToSid)
{
foreach (KeyValuePair<string, string> kvp in mNameToSidReply.DictVmNameToSid)
{
string vmKey = MakeVmKey(conn.hostName, kvp.Key);
if (!DictVmNameToSid.ContainsKey(vmKey))
{
Console.WriteLine("sidBatchReply adding ({0},{1}", vmKey, kvp.Value);
DictVmNameToSid.Add(vmKey, kvp.Value);
}
}
}
unblock = DowndatePendingReplies(messageType, mNameToSidReply.SeqNo);
conn.BeginReceive();
break;
}
default:
{
string msg = string.Format("SendParallel: unexpected message type {0}", messageType);
throw new ApplicationException(msg);
}
//break;
}
}
