/// <summary>
///
/// </summary>
public bool ClearTable <ItemType>()
where ItemType : class, IDBPersistent
{
TracerHelper.TraceEntry(typeof(ItemType).Name);
string tableName = _tablesTypeNames[typeof(ItemType)];
_clearMutex.WaitOne();
try
{
using (SQLiteConnection connection = GenerateConnection())
{
using (SQLiteCommand command = new SQLiteCommand(connection))
{
connection.Open();
command.CommandText = "DELETE FROM " + tableName;
int result = command.ExecuteNonQuery();
}
}
}
finally
{
_clearMutex.ReleaseMutex();
}
TracerHelper.TraceExit();
return(true);
}
/// <summary>
/// Prepare the object for operation. Access to this allows externals to use the 2
/// step component registration process.
/// Called to bring up a component for operation. Does not add the component
/// permanently to the platform.
/// </summary>
public bool InitializeComponent(PlatformComponent component)
{
TracerHelper.Trace(component.Name);
try
{
if (component.IsInitialized == false)
{
Arbiter.AddClient(component);
// This allows the component to persist while initializing.
component.PersistenceDataUpdatedEvent += new GeneralHelper.GenericDelegate <IDBPersistent>(HandleComponentPersistenceDataUpdatedEvent);
}
if (component.IsInitialized || component.Initialize(this))
{
return(true);
}
}
catch (Exception ex)
{
SystemMonitor.Error(string.Format("Exception occured during initializing component [{0}, {1}]", component.Name, ex.Message));
}
// Failed to initialize component.
component.PersistenceDataUpdatedEvent -= new GeneralHelper.GenericDelegate <IDBPersistent>(HandleComponentPersistenceDataUpdatedEvent);
Arbiter.RemoveClient(component);
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
public void AddExecutionEntity(ExecutionEntity entity)
{
TracerHelper.TraceEntry();
lock (this)
{
if (_pendingEntities.Count > _maxPendingExecutionItems)
{
TracerHelper.TraceError("Too many pending entities in system. Some older entities are being dropped.");
if ((DateTime.Now - _maxPendingItemsWarningShownTime) > _warningsTimeSpan)
{
_maxPendingItemsWarningShownTime = DateTime.Now;
SystemMonitor.Error("Too many pending entities in system. Some older entities are being dropped.");
}
// Loose the oldest entity in line.
_timeOutMonitor.RemoveEntity(_pendingEntities[0]);
_pendingEntities.RemoveAt(0);
}
_timeOutMonitor.AddEntity(entity);
_pendingEntities.Add(entity);
}
// Continue execution chain.
UpdatePendingExecution();
}
ResponseMessage Receive(SubscribeToOperationalStateChangesMessage message)
{
bool result = false;
lock (this)
{
if (message.Subscribe)
{// Subscribe.
TracerHelper.TraceEntry("Subscribing - " + message.TransportInfo.OriginalSenderId.Value.Id.Name);
if (_operationStateChangeSubscribers.Contains(message.TransportInfo) == false)
{
_operationStateChangeSubscribers.Add(message.TransportInfo);
result = true;
}
// Send an initial notification.
this.SendResponding(message.TransportInfo, new ChangeOperationalStateMessage(this.OperationalState, false));
}
else
{// Unsubscribe.
TracerHelper.TraceEntry("Unsubscribing - " + message.TransportInfo.OriginalSenderId.Value.Id.Name);
result = _operationStateChangeSubscribers.Remove(message.TransportInfo);
}
}
if (message.RequestResponse)
{
return(new ResponseMessage(result));
}
else
{
return(null);
}
}
void Receive(ChangeOperationalStateMessage message)
{// Result can be returned to requestor.
TracerHelper.TraceEntry();
// Make sure to compare only the *original senders* as the rest is not guaranteed to be the same,
// since remote status synchronization source is fed to class from outside.
if (message.IsRequest == false)
{ // This is a notification
if (message.TransportInfo.OriginalSenderId.Equals(_remoteStatusSynchronizationSource.OriginalSenderId))
{ // Message received from status synch source, change state to synchronize.
if (StatusSynchronizationEnabled)
{
TracerHelper.Trace(this.GetType().Name + " is following its status synchronization source to new state [" + message.OperationalState.ToString() + "].");
ChangeOperationalState(message.OperationalState);
}
else
{
TracerHelper.Trace(this.GetType().Name + " is not following its status synchronization source to new state because synchronization is disabled.");
}
}
else
{
SystemMonitor.Warning("Stat change notification received, but not from status source. Ignored.");
}
}
else
{
TracerHelper.Trace(this.GetType().Name + " is following request from " + message.TransportInfo.CurrentTransportInfo.Value.SenderID.Value.Id.Name + " to " + message.OperationalState);
bool result = OnChangeOperationalStateRequest(message.OperationalState);
SystemMonitor.CheckWarning(result, "Component [" + this.Name + "] has not changed its operational state upon request.");
}
}
/// <summary>
/// Will unsubscribe to previous one.
/// </summary>
protected bool SetRemoteStatusSynchronizationSource(TransportInfo sourceTransportInfo)
{
lock (this)
{
if (_remoteStatusSynchronizationSource != null)
{
SubscribeToOperationalStateChangesMessage message = new SubscribeToOperationalStateChangesMessage(false);
message.RequestResponse = false;
SendResponding(_remoteStatusSynchronizationSource, message);
}
_remoteStatusSynchronizationSource = sourceTransportInfo;
}
bool result = true;
if (sourceTransportInfo != null)
{
ResponseMessage response = SendAndReceiveResponding <ResponseMessage>(sourceTransportInfo,
new SubscribeToOperationalStateChangesMessage(true));
result = response != null && response.OperationResult;
}
TracerHelper.TraceEntry(this.GetType().Name + ", Remote synchronization source " + sourceTransportInfo.OriginalSenderId.Value.Id.Name + " assinged - " + result.ToString());
return(result);
}
/// <summary>
/// Change the component operational state.
/// </summary>
/// <param name="operationalState"></param>
protected void ChangeOperationalState(OperationalStateEnum operationalState)
{
OperationalStateEnum previousState;
lock (this)
{
if (operationalState == _operationalState)
{
return;
}
previousState = _operationalState;
}
TracerHelper.Trace(this.GetType().Name + " is now " + operationalState.ToString() + " has [" + _operationStateChangeSubscribers.Count + "] subscribers.");
_operationalState = operationalState;
if (OperationalStateChangedEvent != null)
{
OperationalStateChangedEvent(this, previousState);
}
// Send to monitoring subscribers.
lock (this)
{
foreach (TransportInfo info in _operationStateChangeSubscribers)
{
TracerHelper.Trace("Sending operational state [" + operationalState.ToString() + "] to [" + info.OriginalSenderId.Value.Id.Print() + "].");
this.SendResponding(info, new ChangeOperationalStateMessage(this.OperationalState, false));
}
}
}
public void ServiceIdentifiers_MatchTracerInstanceSettings()
{
const string service = "unit-test";
const string version = "1.0.0";
const string env = "staging";
var settings = new TracerSettings()
{
ServiceName = service,
ServiceVersion = version,
Environment = env
};
var tracer = TracerHelper.Create(settings);
Tracer.UnsafeSetTracerInstance(tracer);
using (var parentScope = Tracer.Instance.StartActive("parent"))
using (var childScope = Tracer.Instance.StartActive("child"))
{
Assert.Equal(service, CorrelationIdentifier.Service);
Assert.Equal(version, CorrelationIdentifier.Version);
Assert.Equal(env, CorrelationIdentifier.Env);
}
Assert.Equal(service, CorrelationIdentifier.Service);
Assert.Equal(version, CorrelationIdentifier.Version);
Assert.Equal(env, CorrelationIdentifier.Env);
}
public void LockedTracerInstanceSwap()
{
var tracerOne = TracerHelper.Create();
var tracerTwo = new LockedTracer();
TracerRestorerAttribute.SetTracer(tracerOne);
Tracer.Instance.Should().Be(tracerOne);
Tracer.Instance.TracerManager.Should().Be(tracerOne.TracerManager);
TracerRestorerAttribute.SetTracer(null);
Tracer.Instance.Should().BeNull();
// Set the locked tracer
TracerRestorerAttribute.SetTracer(tracerTwo);
Tracer.Instance.Should().Be(tracerTwo);
Tracer.Instance.TracerManager.Should().Be(tracerTwo.TracerManager);
// We test the locked tracer cannot be replaced.
#pragma warning disable CS0618 // Setter isn't actually obsolete, just should be internal
Assert.Throws <InvalidOperationException>(() => Tracer.Instance = tracerOne);
Assert.Throws <InvalidOperationException>(() => Tracer.Instance = null);
Assert.Throws <InvalidOperationException>(() => TracerManager.ReplaceGlobalManager(null, TracerManagerFactory.Instance));
Assert.Throws <InvalidOperationException>(() => TracerManager.ReplaceGlobalManager(null, new CITracerManagerFactory(CIVisibility.Settings)));
}
/// <summary>
/// Local execution. Expert to be executed locally, within the platform process
/// space and on the platforms arbiter.
/// </summary>
protected ExpertHost(string name, Type expertType)
: base(name, false)
{
TracerHelper.Trace(this.Name);
_expertType = expertType;
base.DefaultTimeOut = TimeSpan.FromSeconds(10);
}
/// <summary>
/// Name of the platform must be unique.
/// </summary>
public Platform(string name)
: base(name, false)
{
TracerHelper.TraceEntry();
Arbiter.Arbiter arbiter = new Arbiter.Arbiter("Platform");
//TracerHelper.TracingEnabled = false;
arbiter.AddClient(this);
}
/// <summary>
/// Constructor.
/// </summary>
public PlatformIndicator(string name, bool?isTradeable, bool?isScaledToQuotes, string[] resultSetNames)
: base(name, isTradeable, isScaledToQuotes, resultSetNames)
{
TracerHelper.Trace(this.Name);
_chartSeries = CreateChartSeries();
// Needs immediate initialization since it will be added to chart.
_chartSeries.Initialize(this);
}
public void One_Is_Allowed()
{
var traceContext = new TraceContext(TracerHelper.Create());
var spanContext = new SpanContext(null, traceContext, "Weeeee");
var span = new Span(spanContext, null);
var rateLimiter = new RateLimiter(maxTracesPerInterval: null);
var allowed = rateLimiter.Allowed(span);
Assert.True(allowed);
}