private void ForwardOrDelay(ByteString payload)
{
if (InboundThrottleMode is Blackhole)
{
// Do nothing
}
else
{
if (!ThrottledMessages.Any())
{
var tokens = payload.Length;
var res = InboundThrottleMode.TryConsumeTokens(MonotonicClock.GetNanos(), tokens);
var newBucket = res.Item1;
var success = res.Item2;
if (success)
{
InboundThrottleMode = newBucket;
UpstreamListener.Notify(new InboundPayload(payload));
}
else
{
ThrottledMessages.Enqueue(payload);
ScheduleDequeue(InboundThrottleMode.TimeToAvailable(MonotonicClock.GetNanos(), tokens));
}
}
else
{
ThrottledMessages.Enqueue(payload);
}
}
}
/// <summary>
/// Create a new TaskClient instance to send data to connections (tcp) or to a remote host (udp)
/// </summary>
/// <param name="remoteEndPoint">(Default) remote endpoint to connect or send data to</param>
/// <param name="protocol">TCP or UDP protocol for client socket supported</param>
public Client(IPEndPoint remoteEndPoint, ProtocolType protocol, ThrottleMode mode = ThrottleMode.NoThrottle)
{
if (protocol == ProtocolType.Tcp)
{
this.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
else if (protocol == ProtocolType.Udp)
{
this.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
}
else
{
throw new Exception("Only TCP and UDP protocol allowed");
}
this.RemoteEndPoint = remoteEndPoint;
this._disconnectLock = new Object();
this.buffer = new byte[8192];
this.Download = new Throttle(); // 100 kbsp
this.Upload = new Throttle();
this.ThrottleMode = mode;
this.OnClientConnected = (s, e) => { };
this.OnClientDisconnected = (s, e) => { };
this.OnClientDataReceived = (s, e) => { };
}
public Throttle(int cost, TimeSpan per, int maximumBurst, Func <T, int> costCalculation, ThrottleMode mode)
{
_cost = cost;
_per = per;
_maximumBurst = maximumBurst;
_costCalculation = costCalculation;
_mode = mode;
}
private bool Throttle(ThrottleTransportAdapter.Direction direction, ThrottleMode mode)
{
var rootBAddress = new Address("akka", "systemB", "localhost", RootB.Address.Port.Value);
var transport =
Sys.AsInstanceOf <ExtendedActorSystem>().Provider.AsInstanceOf <RemoteActorRefProvider>().Transport;
var task = transport.ManagementCommand(new SetThrottle(rootBAddress, direction, mode));
task.Wait(TimeSpan.FromSeconds(3));
return(task.Result);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="cost">TBD</param>
/// <param name="per">TBD</param>
/// <param name="maximumBurst">TBD</param>
/// <param name="costCalculation">TBD</param>
/// <param name="mode">TBD</param>
public Throttle(int cost, TimeSpan per, int maximumBurst, Func <T, int> costCalculation, ThrottleMode mode)
{
_maximumBurst = maximumBurst;
_costCalculation = costCalculation;
_mode = mode;
// There is some loss of precision here because of rounding, but this only happens if nanosBetweenTokens is very
// small which is usually at rates where that precision is highly unlikely anyway as the overhead of this stage
// is likely higher than the required accuracy interval.
_ticksBetweenTokens = per.Ticks / cost;
}
/// <summary>
/// Create a new VirtualClient instance by Activator.CreateInstance
/// </summary>
/// <param name="client"><see cref="System.Net.Sockets.Socket"/> of VirtualClient</param>
/// <param name="assignedMemory">Assigned memory for overlapped IO events</param>
/// <param name="id">Client ID</param>
public VirtualClient(Socket client, byte[] assignedMemory, int id, ThrottleMode mode = AsyncTCPLib.ThrottleMode.NoThrottle)
{
this.Socket = client;
this.buffer = assignedMemory;
this.Id = id;
this._disconnectLock = new Object();
this.IsConnected = true;
this.RemoteEndPoint = (IPEndPoint)this.Socket.RemoteEndPoint;
this.Download = new Throttle(); // 100 kbsp
this.Upload = new Throttle();
this.ThrottleMode = mode;
this.OnClientDisconnected = (s, e) => { };
this.OnClientDataReceived = (s, e) => { };
}
void Update()
{
Throttle = Input.GetAxisRaw(ThrottleCommand) * (InvertThrottle ? -1 : 1);
Yaw = Input.GetAxisRaw(YawCommand) * (InvertYaw ? -1 : 1);
Pitch = Input.GetAxisRaw(PitchCommand) * (InvertPitch ? -1 : 1);
Roll = Input.GetAxisRaw(RollCommand) * (InvertRoll ? -1 : 1);
Triggered = Input.GetAxisRaw(RightTriggerCommand) > 0;
if ((Input.GetAxisRaw(ThrottleModeCommand) > 0) && !ThrottleModePressed)
{
switch (CurrentThrottleMode)
{
case ThrottleMode.None:
CurrentThrottleMode = ThrottleMode.LockHeight; break;
case ThrottleMode.LockHeight:
CurrentThrottleMode = ThrottleMode.None; break;
}
ThrottleModePressed = true;
}
ThrottleModePressed = (Input.GetAxisRaw(ThrottleModeCommand) == 0) && (ThrottleModePressed);
}
/// <summary>
/// Creates a new SetThrottle message.
/// </summary>
/// <param name="address">The address of the throttle.</param>
/// <param name="direction">The direction of the throttle.</param>
/// <param name="mode">The mode of the throttle.</param>
public SetThrottle(Address address, ThrottleTransportAdapter.Direction direction, ThrottleMode mode)
{
_address = address;
_direction = direction;
_mode = mode;
}
private void InitializeFSM()
{
When(ThrottlerState.WaitExposedHandle, @event =>
{
if (@event.FsmEvent is ThrottlerManager.Handle && @event.StateData is Uninitialized)
{
// register to downstream layer and wait for origin
OriginalHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self));
return
(GoTo(ThrottlerState.WaitOrigin)
.Using(
new ExposedHandle(
@event.FsmEvent.AsInstanceOf <ThrottlerManager.Handle>().ThrottlerHandle)));
}
return(null);
});
When(ThrottlerState.WaitOrigin, @event =>
{
if (@event.FsmEvent is InboundPayload && @event.StateData is ExposedHandle)
{
var b = @event.FsmEvent.AsInstanceOf <InboundPayload>().Payload;
ThrottledMessages.Enqueue(b);
var origin = PeekOrigin(b);
if (origin != null)
{
Manager.Tell(new ThrottlerManager.Checkin(origin, @event.StateData.AsInstanceOf <ExposedHandle>().Handle));
return(GoTo(ThrottlerState.WaitMode));
}
return(Stay());
}
return(null);
});
When(ThrottlerState.WaitMode, @event =>
{
if (@event.FsmEvent is InboundPayload)
{
var b = @event.FsmEvent.AsInstanceOf <InboundPayload>().Payload;
ThrottledMessages.Enqueue(b);
return(Stay());
}
if (@event.FsmEvent is ThrottleMode && @event.StateData is ExposedHandle)
{
var mode = @event.FsmEvent.AsInstanceOf <ThrottleMode>();
var exposedHandle = @event.StateData.AsInstanceOf <ExposedHandle>().Handle;
InboundThrottleMode = mode;
try
{
if (mode is Blackhole)
{
ThrottledMessages = new Queue <ByteString>();
exposedHandle.Disassociate();
return(Stop());
}
else
{
AssociationHandler.Notify(new InboundAssociation(exposedHandle));
var self = Self;
exposedHandle.ReadHandlerSource.Task.ContinueWith(
r => new ThrottlerManager.Listener(r.Result),
TaskContinuationOptions.ExecuteSynchronously)
.PipeTo(self);
return(GoTo(ThrottlerState.WaitUpstreamListener));
}
}
finally
{
Sender.Tell(SetThrottleAck.Instance);
}
}
return(null);
});
When(ThrottlerState.WaitUpstreamListener, @event =>
{
if (@event.FsmEvent is InboundPayload)
{
var b = @event.FsmEvent.AsInstanceOf <InboundPayload>();
ThrottledMessages.Enqueue(b.Payload);
return(Stay());
}
if (@event.FsmEvent is ThrottlerManager.Listener)
{
UpstreamListener = @event.FsmEvent.AsInstanceOf <ThrottlerManager.Listener>().HandleEventListener;
Self.Tell(new Dequeue());
return(GoTo(ThrottlerState.Throttling));
}
return(null);
});
When(ThrottlerState.WaitModeAndUpstreamListener, @event =>
{
if (@event.FsmEvent is ThrottlerManager.ListenerAndMode)
{
var listenerAndMode = @event.FsmEvent.AsInstanceOf <ThrottlerManager.ListenerAndMode>();
UpstreamListener = listenerAndMode.HandleEventListener;
InboundThrottleMode = listenerAndMode.Mode;
Self.Tell(new Dequeue());
return(GoTo(ThrottlerState.Throttling));
}
if (@event.FsmEvent is InboundPayload)
{
var b = @event.FsmEvent.AsInstanceOf <InboundPayload>();
ThrottledMessages.Enqueue(b.Payload);
return(Stay());
}
return(null);
});
When(ThrottlerState.Throttling, @event =>
{
if (@event.FsmEvent is ThrottleMode)
{
var mode = @event.FsmEvent.AsInstanceOf <ThrottleMode>();
InboundThrottleMode = mode;
if (mode is Blackhole)
{
ThrottledMessages = new Queue <ByteString>();
}
CancelTimer(DequeueTimerName);
if (ThrottledMessages.Any())
{
ScheduleDequeue(InboundThrottleMode.TimeToAvailable(MonotonicClock.GetNanos(), ThrottledMessages.Peek().Length));
}
Sender.Tell(SetThrottleAck.Instance);
return(Stay());
}
if (@event.FsmEvent is InboundPayload)
{
ForwardOrDelay(@event.FsmEvent.AsInstanceOf <InboundPayload>().Payload);
return(Stay());
}
if (@event.FsmEvent is Dequeue)
{
if (ThrottledMessages.Any())
{
var payload = ThrottledMessages.Dequeue();
UpstreamListener.Notify(new InboundPayload(payload));
InboundThrottleMode = InboundThrottleMode.TryConsumeTokens(MonotonicClock.GetNanos(),
payload.Length).Item1;
if (ThrottledMessages.Any())
{
ScheduleDequeue(InboundThrottleMode.TimeToAvailable(MonotonicClock.GetNanos(), ThrottledMessages.Peek().Length));
}
}
return(Stay());
}
return(null);
});
WhenUnhandled(@event =>
{
// we should always set the throttling mode
if (@event.FsmEvent is ThrottleMode)
{
InboundThrottleMode = @event.FsmEvent.AsInstanceOf <ThrottleMode>();
Sender.Tell(SetThrottleAck.Instance);
return(Stay());
}
if (@event.FsmEvent is Disassociated)
{
return(Stop()); // not notifying the upstream handler is intentional: we are relying on heartbeating
}
if (@event.FsmEvent is FailWith)
{
var reason = @event.FsmEvent.AsInstanceOf <FailWith>().FailReason;
if (UpstreamListener != null)
{
UpstreamListener.Notify(new Disassociated(reason));
}
return(Stop());
}
return(null);
});
if (Inbound)
{
StartWith(ThrottlerState.WaitExposedHandle, Uninitialized.Instance);
}
else
{
OriginalHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self));
StartWith(ThrottlerState.WaitModeAndUpstreamListener, Uninitialized.Instance);
}
}
private void throttleModeChanged(ThrottleMode newMode, bool active, bool setTarget = true)
{
accelCtrl.skipDerivative = true;
speedCtrl.skipDerivative = true;
if (!active)
{
accelCtrl.Clear();
speedCtrl.Clear();
}
else
{
switch (newMode)
{
case ThrottleMode.Speed:
if (setTarget)
speedCtrl.SetPoint = vessel.srfSpeed;
targetSpeed = speedCtrl.SetPoint;
break;
case ThrottleMode.Autoland:
if (setTarget)
speedCtrl.SetPoint = getAutoLandSpeed();
targetSpeed = speedCtrl.SetPoint;
break;
case ThrottleMode.Acceleration:
if (setTarget)
accelCtrl.SetPoint = vesselData.acceleration;
targetSpeed = accelCtrl.SetPoint;
break;
}
}
ThrtActive = active;
CurrentThrottleMode = newMode;
}
public void SetThrottle(bool active, bool setTarget, ThrottleMode mode, double target)
{
if (setTarget)
{
switch (mode)
{
case ThrottleMode.Direct:
currentThrottlePct = Utils.Clamp(target / 100, 0, 1);
Vessel.ctrlState.mainThrottle = (float)currentThrottlePct;
if (ReferenceEquals(Vessel, FlightGlobals.ActiveVessel))
FlightInputHandler.state.mainThrottle = (float)currentThrottlePct;
break;
case ThrottleMode.Acceleration:
target /= Utils.speedUnitTransform(units, Vessel.speedOfSound);
AsstList.Acceleration.GetAsst(this).UpdateSetpoint(target, true, vesModule.vesselData.acceleration);
break;
case ThrottleMode.Speed:
target /= Utils.speedUnitTransform(units, Vessel.speedOfSound);
AsstList.Speed.GetAsst(this).UpdateSetpoint(target, true, Vessel.srfSpeed);
break;
}
}
throttleModeChanged(mode, active, !setTarget);
}
private void throttleModeChanged(ThrottleMode newMode, bool active, bool setTarget = true)
{
AsstList.Acceleration.GetAsst(this).skipDerivative = true;
AsstList.Speed.GetAsst(this).skipDerivative = true;
if (!active)
{
AsstList.Acceleration.GetAsst(this).Clear();
AsstList.Speed.GetAsst(this).Clear();
}
else
{
bPause = false;
switch (newMode)
{
case ThrottleMode.Speed:
if (setTarget)
AsstList.Speed.GetAsst(this).UpdateSetpoint(Vessel.srfSpeed);
targetSpeed = (AsstList.Speed.GetAsst(this).target_setpoint * Utils.speedUnitTransform(units, Vessel.speedOfSound)).ToString("0.00");
break;
case ThrottleMode.Acceleration:
if (setTarget)
AsstList.Acceleration.GetAsst(this).UpdateSetpoint(vesModule.vesselData.acceleration);
targetSpeed = (AsstList.Acceleration.GetAsst(this).target_setpoint * Utils.speedUnitTransform(units, Vessel.speedOfSound)).ToString("0.00");
break;
case ThrottleMode.Direct:
if (setTarget)
currentThrottlePct = Vessel.ctrlState.mainThrottle;
targetSpeed = (currentThrottlePct * 100).ToString("0.00");
break;
}
}
ThrtActive = active;
CurrentThrottleMode = newMode;
}
public void SetThrottle(bool active, bool setTarget, ThrottleMode mode, double target)
{
if (active && setTarget)
{
switch (mode)
{
case ThrottleMode.Direct:
currentThrottlePct = Utils.Clamp(target / 100, 0, 1);
vesModule.vesselRef.ctrlState.mainThrottle = (float)currentThrottlePct;
if (ReferenceEquals(vesModule.vesselRef, FlightGlobals.ActiveVessel))
FlightInputHandler.state.mainThrottle = (float)currentThrottlePct;
break;
case ThrottleMode.Acceleration:
AsstList.Acceleration.GetAsst(this).SetPoint = vesModule.vesselData.acceleration;
AsstList.Acceleration.GetAsst(this).BumplessSetPoint = target;
break;
case ThrottleMode.Speed:
AsstList.Speed.GetAsst(this).SetPoint = vesModule.vesselRef.srfSpeed;
AsstList.Speed.GetAsst(this).BumplessSetPoint = target;
break;
}
}
throttleModeChanged(mode, active, !setTarget);
}
