private static int SetSignalAction(int signum, SignalAction action)
{
IntPtr handler = IntPtr.Zero;
switch (action)
{
case SignalAction.Default:
handler = _SIG_DFL;
break;
case SignalAction.Ignore:
handler = _SIG_IGN;
break;
case SignalAction.Error:
handler = _SIG_ERR;
break;
default:
throw new ArgumentException("Invalid action value.", "action");
}
IntPtr r = sys_signal(signum, handler);
if (r == _SIG_ERR)
{
return(-1);
}
return(0);
}
private static int SetSignalAction(int signum, SignalAction action)
{
IntPtr zero = IntPtr.Zero;
switch (action)
{
case SignalAction.Default:
{
zero = Stdlib._SIG_DFL;
break;
}
case SignalAction.Ignore:
{
zero = Stdlib._SIG_IGN;
break;
}
case SignalAction.Error:
{
zero = Stdlib._SIG_ERR;
break;
}
default:
{
throw new ArgumentException("Invalid action value.", "action");
}
}
if (Stdlib.sys_signal(signum, zero) == Stdlib._SIG_ERR)
{
return(-1);
}
return(0);
}
internal static void SetUnixSignalAction(Signum signal, SignalAction action)
{
// This seemingly pointless method adds some
// indirection so that we don't load `Mono.Posix`
// unless we absolutely need to.
Stdlib.SetSignalAction(signal, action);
}
public SignalState SetSignalFlag(string username, string path, SignalAction action)
{
lock (_userWorkingSignals)
{
var signal = _userWorkingSignals.FirstOrDefault(x => x.Name == path && x.Owner == username);
if (signal == null)
{
return(default(SignalState));
}
switch (action)
{
case SignalAction.StopExecution:
signal.SetSignalState(SignalState.Stopped);
RemoveSignalData(username, path);
return(SignalState.Stopped);
case SignalAction.SetSimulatedOn: signal.SetSignalState(SignalState.RunningSimulated); break;
case SignalAction.SetSimulatedOff: signal.SetSignalState(SignalState.Running); break;
case SignalAction.PauseBacktest: signal.SetSignalState(SignalState.BacktestingPaused); break;
case SignalAction.ResumeBacktest: signal.SetSignalState(SignalState.Backtesting); break;
}
return(signal.State);
}
}
/// <summary>
/// Processes a signal
/// </summary>
/// <param name="action">The action</param>
/// <returns>The signal context</returns>
public ISignalContext ProcessSignal(SignalAction action)
{
X86SignalContext context = new X86SignalContext();
// Push arguments
*--context.Stack = 0; // Context (unused)
*--context.Stack = 0x7331; // TODO: siginfo
*--context.Stack = action.SignalNumber;
// Return address of signal handling method
*--context.Stack = (int)Util.MethodToPtr(SignalAction.ReturnFromSignal);
// Backup regs so we can restore later
Memory.Memcpy(context.Sysregs, m_sysRegs, sizeof(RegsDirect));
// Modify regs to return to
m_sysRegs->ESP = (int)context.Stack;
m_sysRegs->EIP = (int)action.Sigaction.Handler;
m_sysRegs->EAX = 0;
m_sysRegs->EBX = 0;
m_sysRegs->ECX = 0;
m_sysRegs->EDX = 0;
m_sysRegs->ESI = 0;
m_sysRegs->EDI = 0;
return(context);
}
public Signal(Security security, PriceBarSize barsize, DateTime signalDate, SignalAction signalAction, double signalStrength = 0)
{
Security = security ?? throw new ArgumentNullException(nameof(security));
SignalBarSize = barsize;
SignalDate = signalDate;
SignalAction = signalAction;
SignalStrength = signalStrength;
}
/// <summary>
/// Clones this signal handler
/// </summary>
/// <returns></returns>
public SignalAction Clone()
{
SignalAction clone = new SignalAction(SignalNumber);
clone.Sigaction.Flags = Sigaction.Flags;
clone.Sigaction.Mask = Sigaction.Mask;
clone.Sigaction.Handler = Sigaction.Handler;
return(clone);
}
public void SendFlagState(string username, string signalName, SignalAction action, SignalState state)
{
Send(new SignalActionSettedRequest
{
Username = username,
Action = action,
SignalName = signalName,
State = state
});
}
/// <summary>
/// Processes a signal
/// </summary>
/// <param name="action">The action</param>
/// <returns>The signal context</returns>
public void ProcessSignal(SignalAction action)
{
while (m_currentSignalContext != null)
{
Tasking.Yield();
}
m_signalMutex.Lock();
m_currentSignalContext = Context.ProcessSignal(action);
m_signalMutex.Unlock();
}
internal static DS.SignalAction ToDsSignalAction(SignalAction action)
{
if (Enum.IsDefined(typeof(DS.SignalAction), (int)action))
{
return((DS.SignalAction)action);
}
else
{
throw new NotSupportedException($"Signal action '{action}' is not supported on server side");
}
}
private void SignalActionSetted(string username, SignalAction action, string signalName, SignalState state)
{
var user = Core.GetUser(username);
PushResponse(new SignalActionResponse
{
User = user,
SignalName = signalName,
Action = action,
State = state
});
}
/// <summary>
/// Clones this task
/// </summary>
/// <returns>The clone</returns>
public Task Clone()
{
Task newTask = new Task(Priority, SpawnFlags.NONE);
// Clone signal handlers
for (int i = 1; i < Signals.NSIG; i++)
{
SignalAction original = m_signalActions[i];
if (original == null)
{
continue;
}
newTask.m_signalActions[i] = original.Clone();
}
newTask.Context.CloneFrom(Context);
return(newTask);
}
/// <summary>
/// Cleans up this task
/// </summary>
public void Cleanup()
{
// Cleanup child threads
Thread current = FirstThread;
while (current.NextThread != FirstThread)
{
current.Cleanup();
Heap.Free(current);
current = current.NextThread;
}
// Cleanup signals
for (int i = 0; i < Signals.NSIG; i++)
{
SignalAction action = m_signalActions[i];
if (action != null)
{
Heap.Free(action);
}
}
Heap.Free(m_signalActions);
// Cleanup virtual addresses claimed by this task
int count = m_usedAddresses.Count;
for (int i = 0; i < count; i++)
{
Heap.Free(m_usedAddresses.Item[i]);
}
m_usedAddresses.Dispose();
Heap.Free(m_usedAddresses);
// Filesystem stuff
FileDescriptors.Cleanup();
Heap.Free(FileDescriptors);
Heap.Free(m_currentDirectory);
// Context
Context.Cleanup();
Heap.Free(Context);
}
/// <summary>
/// Processes a signal
/// </summary>
/// <param name="signal">The signal</param>
/// <returns>The errorcode</returns>
public unsafe ErrorCode ProcessSignal(Signal signal)
{
if (signal <= 0 || (int)signal >= Signals.NSIG)
{
return(ErrorCode.EINVAL);
}
// Get handler, if no handler is set, use default handler
SignalAction action = m_signalActions[(int)signal];
if (action == null)
{
Signals.DefaultAction defaultAction = Signals.DefaultActions[(int)signal];
switch (defaultAction)
{
case Signals.DefaultAction.Continue:
RemoveFlag(TaskFlag.STOPPED);
break;
case Signals.DefaultAction.Stop:
AddFlag(TaskFlag.STOPPED);
// Do a task switch because the task may not run until a continue is received
Tasking.Yield();
break;
case Signals.DefaultAction.Core:
case Signals.DefaultAction.Terminate:
Console.WriteLine(Signals.SignalNames[(int)signal]);
Tasking.RemoveTaskByPID(PID);
break;
}
}
else
{
if (action.Sigaction.Handler != (void *)Signals.SIG_IGN)
{
CurrentThread.ProcessSignal(action);
}
}
return(ErrorCode.SUCCESS);
}
/// <summary>
/// Sets the signal handler of a signal
/// </summary>
/// <param name="signal">The signal</param>
/// <param name="newact">The new action</param>
/// <param name="oldact">The old action</param>
/// <returns>The errorcode</returns>
public unsafe ErrorCode SetSignalHandler(Signal signal, SignalAction.SigAction *newact, SignalAction.SigAction *oldact)
{
if (signal <= 0 || (int)signal >= Signals.NSIG)
{
return(ErrorCode.EINVAL);
}
SignalAction action = m_signalActions[(int)signal];
// If the handler is NULL, remove this action
if (newact->Handler == null)
{
m_signalActions[(int)signal] = null;
if (action != null)
{
Heap.Free(action);
}
return(ErrorCode.SUCCESS);
}
// If the action is NULL, allocate new signal action
if (action == null)
{
m_signalActions[(int)signal] = action = new SignalAction((int)signal);
}
// Copy to old action
if (oldact != null)
{
fixed(SignalAction.SigAction *ptr = &action.Sigaction)
Memory.Memcpy(oldact, ptr, sizeof(SignalAction.SigAction));
}
// Set new action
fixed(SignalAction.SigAction *ptr = &action.Sigaction)
Memory.Memcpy(ptr, newact, sizeof(SignalAction.SigAction));
return(ErrorCode.SUCCESS);
}
/// <inheritdoc />
public IList <Signal> GenerateSignals(IList <Price> prices)
{
IList <IndicatorValue> sma, diplus, diminus, diDifferences, diDifferences2;
CalculateHelper(prices, out sma, out diplus, out diminus, out diDifferences, out diDifferences2);
var adxValues = sma.Select((t, i) => new IndicatorValue {
Date = t.Date, Value = 100 * t.Value / diDifferences2[i].Value
}).ToList();
var intersections = IntersectionHelper.FindIntersections(diplus, diminus);
var signals = new List <Signal>();
foreach (var intersectionInfo in intersections)
{
SignalAction action = SignalAction.NoSignal;
// ReSharper disable once SwitchStatementMissingSomeCases
switch (intersectionInfo.IntersectionType)
{
case IntersectionType.FirstAbove:
action = SignalAction.Buy;
break;
case IntersectionType.SecondAbove:
action = SignalAction.Sell;
break;
case IntersectionType.Same:
action = SignalAction.NoSignal;
break;
}
var adx = adxValues.FirstOrDefault(v => v.Date == intersectionInfo.Date);
if (adx != null && adx.Value > AdxStrongTrendValue)
{
signals.Add(new Signal(action)
{
Date = adx.Date
});
}
}
return(signals);
}
// Define what actions to take when the event is raised.
void OnTradeBySQRSpd(object sender, IndicatorEventArgs e)
{
IndicatorSignal isig = e.IndSignal;
// Print(String.Format("{0}:OnTradeBySQRSpd triggerred {1} Bip={2}: RocHiBip={3}, RocLoBip={4}, RocMidBip={5}",
// CurrentBars[BarsInProgress], isig.SignalName, BarsInProgress, giSQRSpd.RocHighBip, giSQRSpd.RocLowBip, giSQRSpd.RocMidBip));
SignalAction sa = e.IndSignal.SignalAction;
List <PairSpread <int> > ps = null;
if (sa != null)
{
ps = sa.PairSpds;
}
int[] idxs = { ShortBip, MidLongBip, LongBip, MidShortBip }; // {BipSpyLn, BipSpySt, BipQQQLn, BipQQQSt, BipIWMLn, BipIWMSt};
if (e.IndSignal.SignalName != null && HasPositions(idxs, 2))
{
OnExitPositions(e);
}
else if (e.IndSignal.SignalName != null
//&& BarsInProgress == BipIWM
&& giSQRSpd.IsTradingTime(Times[BipIWM][0]))
{
if (ps != null)
{
// foreach(PairSpread<int> p in ps) {
// Print(String.Format("{0}:OnTradeBySQRSpd Bip={1}, Symbol1={2}, Symbol2={3}, SpdType={4}, SpreadValue={5}",
// CurrentBars[BarsInProgress], BarsInProgress,
// p.Symbol1, p.Symbol2, p.SpdType, p.SpreadValue));
// }
OnEntryPositions(e);
}
}
return;
// int q_max = GetTradeQuantity(giPctSpd.PctChgMaxBip, this.MM_ProfitFactorMax);
// int q_min = GetTradeQuantity(giPctSpd.PctChgMinBip, this.MM_ProfitFactorMin);
// //exit at 9:40 am ct
// if(isig.SignalName == giPctSpd.SignalName_ExitForOpen) {
// Print(String.Format("{0}:OnTradeByPctSpd Ex Bip={1}: MaxBip={2}, PosMax={3}, MinBip={4}, PosMin={5}",
// CurrentBars[BarsInProgress], BarsInProgress, giPctSpd.PctChgMaxBip, Positions[giPctSpd.PctChgMaxBip], giPctSpd.PctChgMinBip, Positions[giPctSpd.PctChgMinBip]));
// OnExitPositions(e);
// } else { //entry at 9:02 am ct
// Print(String.Format("{0}:OnTradeByPctSpd En Bip={1}: PctSpd={2}, MaxBip={3}, MinBip={4}",
// CurrentBar, BarsInProgress, giPctSpd.PlotPctSpd[0], giPctSpd.PctChgMaxBip, giPctSpd.PctChgMinBip));
// if(isig.TrendDir.TrendDir == TrendDirection.Up) {
// IndicatorProxy.PrintLog(true, IsLiveTrading(),String.Format("{0}:{1} Ln Bip={2}: PctSpd={3}, MaxBipQuant={4}, MinBipQuant={5}",
// CurrentBars[BarsInProgress], e.Message, BarsInProgress, giPctSpd.PlotPctSpd[0],
// q_max, q_min));
// EnterLong(giPctSpd.PctChgMaxBip, q_max, "GIPctSpd");
// EnterShort(giPctSpd.PctChgMinBip, q_min, "GIPctSpd");
// }
// else if(isig.TrendDir.TrendDir == TrendDirection.Down) {
// IndicatorProxy.PrintLog(true, IsLiveTrading(),String.Format("{0}:{1} St Bip={2}: PctSpd={3}, MaxBipQuant={4}, MinBipQuant={5}",
// CurrentBars[BarsInProgress], e.Message, BarsInProgress, giPctSpd.PlotPctSpd[0],
// q_max, q_min));
// EnterShort(giPctSpd.PctChgMaxBip, q_max, "GIPctSpd");
// EnterLong(giPctSpd.PctChgMinBip, q_min, "GIPctSpd");
// }
// }
}
/// <summary>
/// Creates a new instance of <see cref="Signal"/>
/// </summary>
/// <param name="action">The action to take</param>
public Signal(SignalAction action)
{
Action = action;
}
private void ConnectorOnSetSignalFlag(string processorID, string username, string path, SignalAction action)
{
Task.Run(() =>
{
var state = _scriptingManager.SetSignalFlag(username, path, action);
_connector.SendFlagState(username, path, action, state);
});
}
public static int SetSignalAction(RealTimeSignum rts, SignalAction action)
{
return(SetSignalAction(NativeConvert.FromRealTimeSignum(rts), action));
}
public static int SetSignalAction(Signum signal, SignalAction action)
{
return(SetSignalAction(NativeConvert.FromSignum(signal), action));
}
private static int GetSignalsCount(int daysLimitToAnd, IList <Signal> signals, Signal signal, SignalAction action)
{
var scope =
signals.Where(
item =>
item.Date <= signal.Date && item.Date >= signal.Date.AddDays(-daysLimitToAnd + 1) &&
item.Action == action).ToList();
return(scope
.Select(item => item.IndicatorType)
.Distinct()
.Count());
}
private void ProceedSignalState(string username, SignalAction action, string signalName) => SetSignalFlag?.Invoke(null, username, signalName, action);
public void RegisterSignal(SignalAction signal, Action action)
{
signal.AddAction(action);
}
