private void onShutDown()
{
this.serviceProvider
.GetService <ILogger>()?.logMessage("Sensor is going down ... ");
ServiceConfiguration config = ServiceConfiguration.Instance;
IMessageBroker broker = serviceProvider.GetService <IMessageBroker>();
IDataCacheManager cache = serviceProvider.GetService <IDataCacheManager>();
for (int sensorIndex = config.sensorsRange.From;
sensorIndex < config.sensorsRange.To;
sensorIndex++)
{
string sensorName = config.sensorNamePrefix + sensorIndex;
var newEvent = new SensorLifetimeEvent(
config.serviceId,
LifetimeStages.Shutdown,
sensorName,
config.hostIP,
config.listeningPort,
cache.GetLastReadIndex(sensorName));
var res = broker.PublishLifetimeEvent(newEvent).Result;
}
// next line will unregister this sensor using sensorRegistry restAPI
// it is not necessary because sensor is gonna be unregistered once
// registry receives it's lifetime event with shutdown 'flag'
// result is not used (potential exception is handled inside the method)
// bool unregResult = this.unregisterSensors();
}
public SensorController(ILogger logger, IDataCacheManager dataCache)
{
this.logger = logger;
this.dataCache = dataCache;
this.config = ServiceConfiguration.Instance;
}
/// <summary>
/// Inicializa a isntancia.
/// </summary>
/// <param name="parameters">Parametros de configuração.</param>
public void Init(System.Collections.IDictionary parameters)
{
var manager = parameters["manager"] as IDataCacheManager;
var downloader = parameters["downloader"] as IDataEntryDownloader;
var repository = parameters["repository"] as IDataEntriesRepository;
var logger = parameters["logger"] as Colosoft.Logging.ILogger;
var typeSchema = parameters["typeSchema"] as Colosoft.Data.Schema.ITypeSchema;
var cacheLoaderObserver = parameters["cacheLoaderObserver"] as ICacheLoaderObserver;
manager.Require("manager").NotNull();
downloader.Require("downloader").NotNull();
repository.Require("repository").NotNull();
typeSchema.Require("typeSchema").NotNull();
logger.Require("logger").NotNull();
_manager = manager;
_downloader = downloader;
_repository = repository;
_logger = logger;
_typeSchema = typeSchema;
if (cacheLoaderObserver != null)
{
_observer += cacheLoaderObserver;
}
downloader.DownloadCompleted += Downloader_DownloadCompleted;
downloader.ProgressChanged += Downloader_ProgressChanged;
}
public MemoryDataStoreProvider(IDataCacheManager cacheManager
, ILogger <MemoryDataStoreProvider> logger
)
{
_cacheManager = cacheManager ?? throw new ArgumentNullException(nameof(cacheManager));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// Inicializa a instancia com os parametros informados.
/// </summary>
/// <param name="parameters">Dicionário com os parametros de inicialização.</param>
public void Init(System.Collections.IDictionary parameters)
{
var sourceContext = parameters["sourceContext"] as ISourceContext;
var manager = parameters["manager"] as IDataCacheManager;
var logger = parameters["logger"] as Colosoft.Logging.ILogger;
var typeSchema = parameters["typeSchema"] as Colosoft.Data.Schema.ITypeSchema;
var cacheLoaderObserver = parameters["cacheLoaderObserver"] as ICacheLoaderObserver;
var typesMetadata = parameters["typesMetadata"] as IList <ITypeMetadata>;
sourceContext.Require("sourceContext").NotNull();
manager.Require("manager").NotNull();
if (typesMetadata == null)
{
typeSchema.Require("typeSchema").NotNull();
}
logger.Require("logger").NotNull();
_sourceContext = sourceContext;
_manager = manager;
_logger = logger;
_typeSchema = typeSchema;
_typesMetadata = typesMetadata;
_started = false;
if (cacheLoaderObserver != null)
{
_observer += cacheLoaderObserver;
}
}
public ValuesController(
IDataCacheManager cacheManager
, ILogger <ValuesController> logger)
{
_logger = logger;
_cacheManager = cacheManager;
}
public ExternalSubscriberHandler(IExternalSubscriptionsManager externalSubscriptionsManager
, IDataCacheManager cacheManger
, ILogger <ExternalSubscriberHandler> logger
)
{
_IExternalSubscriptionsManager = externalSubscriptionsManager;
_IDataCacheManager = cacheManger;
_logger = logger;
}
public StoreSensorDataRequestHandler(
IDataCacheManager cache,
IMessageBroker broker)
{
this.cache = cache;
this.broker = broker;
this.config = ServiceConfiguration.Instance;
}
public DataStoreTest(
IDataStoreManager dataStoreManager,
IDataCacheManager dataCacheManager,
ILogger <DataStoreTest> logger)
{
_dataStoreManager = dataStoreManager;
_dataCacheManager = dataCacheManager;
_logger = logger;
}
/// <summary>
/// Registra todas as classes contidas no namespace do assembly informado.
/// </summary>
/// <param name="dataCacheManager"></param>
/// <param name="assembly"></param>
/// <param name="nameSpace"></param>
/// <returns></returns>
public static IDataCacheManager RegisterNamespace(this IDataCacheManager dataCacheManager, System.Reflection.Assembly assembly, string nameSpace)
{
dataCacheManager.Require("dataCacheManager").NotNull();
assembly.Require("assembly").NotNull();
nameSpace.Require("nameSpace").NotNull().NotEmpty();
foreach (var i in assembly.GetTypes())
{
if (i.Namespace.IndexOf(nameSpace) == 0)
{
dataCacheManager.Register(i);
}
}
return(dataCacheManager);
}
public static IDataCacheManager GetCacheManagerInstance()
{
if (dataCacheManager == null)
{
lock (locker)
{
if (dataCacheManager == null)
{
dataCacheManager = new DataCacheManager();
}
}
}
return(dataCacheManager);
}
internal HistoryDataMultiTimeframeCache(IDataCacheManager dataCacheManager)
{
_dataCacheManager = dataCacheManager;
_barStore = new Dictionary <string, Dictionary <string, HistoryBarCache> >();
_lastBarUseStore = new List <LastUse>();
//_tickStore = new Dictionary<string, List<Bar>>();
_lastTickUseStore = new List <LastUse>();
_locker = new object();
var cleanupTimer = new Timer();
cleanupTimer.Elapsed += CleanupTimerElapsed;
cleanupTimer.Interval = 1000 * 60 * 10; // 10 min
cleanupTimer.Enabled = true;
cleanupTimer.Start();
}
/// <summary>
///
/// </summary>
public void ClearCacheData()
{
_dataCacheManager = null;
_ins = null;
}
public RegistrationService(ILogger logger,
IDataCacheManager dataCache)
{
this.logger = logger;
this.dataCache = dataCache;
}
