/// <summary>
/// Create a producer.
/// </summary>
public IProducer <TMessage> CreateProducer <TMessage>(ProducerOptions <TMessage> options)
{
ThrowIfDisposed();
ICompressorFactory?compressorFactory = null;
if (options.CompressionType != CompressionType.None)
{
var compressionType = (Internal.PulsarApi.CompressionType)options.CompressionType;
compressorFactory = CompressionFactories.CompressorFactories().SingleOrDefault(f => f.CompressionType == compressionType);
if (compressorFactory is null)
{
throw new CompressionException($"Support for {compressionType} compression was not found");
}
}
var producer = new Producer <TMessage>(ServiceUrl, options, _processManager, _exceptionHandler, _connectionPool, compressorFactory);
if (options.StateChangedHandler is not null)
{
_ = StateMonitor.MonitorProducer(producer, options.StateChangedHandler);
}
return(producer);
}
internal DataSourceUpdatesImpl(
IDataStore store,
IDataStoreStatusProvider dataStoreStatusProvider,
TaskExecutor taskExecutor,
Logger baseLogger,
TimeSpan?outageLoggingTimeout
)
{
_store = store;
_dataStoreStatusProvider = dataStoreStatusProvider;
_taskExecutor = taskExecutor;
_log = baseLogger.SubLogger(LogNames.DataSourceSubLog);
_dependencyTracker = new DependencyTracker();
_outageTracker = outageLoggingTimeout.HasValue ?
new DataSourceOutageTracker(_log, outageLoggingTimeout.Value) : null;
var initialStatus = new DataSourceStatus
{
State = DataSourceState.Initializing,
StateSince = DateTime.Now,
LastError = null
};
_status = new StateMonitor <DataSourceStatus, StateAndError>(initialStatus, MaybeUpdateStatus, _log);
}
public IHttpActionResult PutStateMonitor(long id, StateMonitor stateMonitor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != stateMonitor.stateMonitorId)
{
return(BadRequest());
}
try
{
smCrud.updateStateMonitor(stateMonitor, db);
}
catch (DbUpdateConcurrencyException)
{
if (!StateMonitorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.OK));
}
/// <summary>
/// Create a consumer.
/// </summary>
public IConsumer CreateConsumer(ConsumerOptions options)
{
ThrowIfDisposed();
var correlationId = Guid.NewGuid();
var executor = new Executor(correlationId, _processManager, _exceptionHandler);
var subscribe = new CommandSubscribe
{
ConsumerName = options.ConsumerName,
InitialPosition = (CommandSubscribe.InitialPositionType)options.InitialPosition,
PriorityLevel = options.PriorityLevel,
ReadCompacted = options.ReadCompacted,
Subscription = options.SubscriptionName,
Topic = options.Topic,
Type = (CommandSubscribe.SubType)options.SubscriptionType
};
var messagePrefetchCount = options.MessagePrefetchCount;
var batchHandler = new BatchHandler(true);
var decompressorFactories = CompressionFactories.DecompressorFactories();
var factory = new ConsumerChannelFactory(correlationId, _processManager, _connectionPool, executor, subscribe, messagePrefetchCount, batchHandler, decompressorFactories);
var stateManager = new StateManager <ConsumerState>(ConsumerState.Disconnected, ConsumerState.Closed, ConsumerState.ReachedEndOfTopic, ConsumerState.Faulted);
var consumer = new Consumer(correlationId, ServiceUrl, options.SubscriptionName, options.Topic, _processManager, new NotReadyChannel(), executor, stateManager);
if (options.StateChangedHandler is not null)
{
_ = StateMonitor.MonitorConsumer(consumer, options.StateChangedHandler);
}
var process = new ConsumerProcess(correlationId, stateManager, factory, consumer, options.SubscriptionType == SubscriptionType.Failover);
_processManager.Add(process);
process.Start();
return(consumer);
}
/// <summary>
/// Create a reader.
/// </summary>
public IReader CreateReader(ReaderOptions options)
{
ThrowIfDisposed();
var correlationId = Guid.NewGuid();
var executor = new Executor(correlationId, _processManager, _exceptionHandler);
var subscribe = new CommandSubscribe
{
ConsumerName = options.ReaderName,
Durable = false,
ReadCompacted = options.ReadCompacted,
StartMessageId = options.StartMessageId.ToMessageIdData(),
Subscription = $"Reader-{Guid.NewGuid():N}",
Topic = options.Topic
};
var messagePrefetchCount = options.MessagePrefetchCount;
var batchHandler = new BatchHandler(false);
var decompressorFactories = CompressionFactories.DecompressorFactories();
var factory = new ConsumerChannelFactory(correlationId, _processManager, _connectionPool, executor, subscribe, messagePrefetchCount, batchHandler, decompressorFactories);
var stateManager = new StateManager <ReaderState>(ReaderState.Disconnected, ReaderState.Closed, ReaderState.ReachedEndOfTopic, ReaderState.Faulted);
var reader = new Reader(correlationId, ServiceUrl, options.Topic, _processManager, new NotReadyChannel(), executor, stateManager);
if (options.StateChangedHandler is not null)
{
_ = StateMonitor.MonitorReader(reader, options.StateChangedHandler);
}
var process = new ReaderProcess(correlationId, stateManager, factory, reader);
_processManager.Add(process);
process.Start();
return(reader);
}
/// <summary>
/// Create a producer.
/// </summary>
public IProducer CreateProducer(ProducerOptions options)
{
ThrowIfDisposed();
ICompressorFactory?compressorFactory = null;
if (options.CompressionType != CompressionType.None)
{
var compressionType = (Internal.PulsarApi.CompressionType)options.CompressionType;
compressorFactory = CompressionFactories.CompressorFactories().SingleOrDefault(f => f.CompressionType == compressionType);
if (compressorFactory is null)
{
throw new CompressionException($"Support for {compressionType} compression was not found");
}
}
var correlationId = Guid.NewGuid();
var executor = new Executor(correlationId, _processManager, _exceptionHandler);
var factory = new ProducerChannelFactory(correlationId, _processManager, _connectionPool, executor, options, compressorFactory);
var stateManager = new StateManager <ProducerState>(ProducerState.Disconnected, ProducerState.Closed, ProducerState.Faulted);
var producer = new Producer(correlationId, ServiceUrl, options.Topic, options.InitialSequenceId, _processManager, new NotReadyChannel(), executor, stateManager);
if (options.StateChangedHandler is not null)
{
_ = StateMonitor.MonitorProducer(producer, options.StateChangedHandler);
}
var process = new ProducerProcess(correlationId, stateManager, factory, producer);
_processManager.Add(process);
process.Start();
return(producer);
}
/// <summary>
/// retrieves specific state monitor in database
/// </summary>
/// <param name="id"></param>
/// <param name="db"></param>
/// <returns>state monitor</returns>
public StateMonitor selectStateMonitor(long id, STATE_MONITOR_DBEntities db)
{
StateMonitor stateMonitor =
(from stateMonitors in db.StateMonitors
join stateMonitorMetric in db.StateMonitorMetrics on stateMonitors.stateMonitorId equals stateMonitorMetric.stateMonitorId
join state in db.States on stateMonitorMetric.stateMonitorMetricId equals state.stateMonitorMetricId
where (stateMonitors.stateMonitorId == id)
select stateMonitors).FirstOrDefault();
return(stateMonitor);
}
internal DataStoreUpdatesImpl(TaskExecutor taskExecutor, Logger log)
{
_taskExecutor = taskExecutor;
var initialStatus = new DataStoreStatus
{
Available = true,
RefreshNeeded = false
};
_status = new StateMonitor <DataStoreStatus, DataStoreStatus>(initialStatus, MaybeUpdate, log);
}
public IHttpActionResult GetStateMonitor(long id)
{
StateMonitor stateMonitor = smCrud.selectStateMonitor(id, db);
if (stateMonitor == null)
{
return(NotFound());
}
return(Ok(stateMonitor));
}
public IHttpActionResult PostStateMonitor(StateMonitor stateMonitor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
smCrud.insertStateMonitor(stateMonitor, db);
return(CreatedAtRoute("DefaultApi", new { id = stateMonitor.stateMonitorId }, stateMonitor));
}
private STATE_MONITOR_DBEntities insertMetrics(StateMonitor newStateMonitor, STATE_MONITOR_DBEntities db)
{
foreach (StateMonitorMetric stateMonitorMetric in newStateMonitor.StateMonitorMetrics)
{
deleteStates(stateMonitorMetric.stateMonitorMetricId, db);
insertStates(stateMonitorMetric, db);
stateMonitorMetric.stateMonitorId = newStateMonitor.stateMonitorId;
db.StateMonitorMetrics.Add(stateMonitorMetric);
}
return(db);
}
public IHttpActionResult DeleteStateMonitor(long id)
{
StateMonitor stateMonitor = db.StateMonitors.Find(id);
if (stateMonitor == null)
{
return(NotFound());
}
smCrud.deleteStateMonitor(id, db);
return(Ok(stateMonitor));
}
public void TestMethod1()
{
var monitor = new StateMonitor();
Assert.IsNotNull(monitor);
monitor.State.PrintState();
monitor.ChangeColor(Colors.Green);
monitor.ShouldBlink(false);
monitor.State.PrintState();
monitor.ShouldBlink(true);
monitor.State.PrintState();
monitor.ChangeColor(Colors.Red);
monitor.ShouldBlink(false);
monitor.State.PrintState();
}
/// <summary>
/// deletes state monitor from database
/// </summary>
/// <param name="id"></param>
/// <param name="db"></param>
/// <returns></returns>
public void deleteStateMonitor(long id, STATE_MONITOR_DBEntities db)
{
//PS: Uncomment these two commented lines for changing behaviour from inactivation to real deletion
//deleteChildren(id, db);
StateMonitor stateMonitor =
(from stateMonitors in db.StateMonitors
join stateMonitorMetric in db.StateMonitorMetrics on stateMonitors.stateMonitorId equals stateMonitorMetric.stateMonitorId
join state in db.States on stateMonitorMetric.stateMonitorMetricId equals state.stateMonitorMetricId
where stateMonitors.stateMonitorId == id
select stateMonitors).FirstOrDefault();
stateMonitor.status = "inactive";
//db.StateMonitors.Remove(stateMonitor);
db.SaveChanges();
}
/// <summary>
/// updates state monitor from database
/// </summary>
/// <param name="id"></param>
/// <param name="db"></param>
/// <returns></returns>
public void updateStateMonitor(StateMonitor newStateMonitor, STATE_MONITOR_DBEntities db)
{
updateChildren(newStateMonitor, db);
StateMonitor stateMonitor =
(from stateMonitors in db.StateMonitors
where stateMonitors.stateMonitorId == newStateMonitor.stateMonitorId
select stateMonitors).FirstOrDefault();
stateMonitor.thingType = newStateMonitor.thingType;
stateMonitor.thingLvl = newStateMonitor.thingLvl;
stateMonitor.thingName = newStateMonitor.thingName;
stateMonitor.thingId = newStateMonitor.thingId;
stateMonitor.status = newStateMonitor.status;
db.SaveChanges();
}
internal DataSourceUpdateSinkImpl(
FlagDataManager dataStore,
bool isConfiguredOffline,
TaskExecutor taskExecutor,
Logger log
)
{
_dataStore = dataStore;
_taskExecutor = taskExecutor;
var initialStatus = new DataSourceStatus
{
State = isConfiguredOffline ? DataSourceState.SetOffline : DataSourceState.Initializing,
StateSince = DateTime.Now,
LastError = null
};
_status = new StateMonitor <DataSourceStatus, StateAndError>(initialStatus, MaybeUpdateStatus, log);
}
/// <summary>
/// Create a reader.
/// </summary>
public IReader CreateReader(ReaderOptions options)
{
ThrowIfDisposed();
var correlationId = Guid.NewGuid();
var executor = new Executor(correlationId, _processManager, _exceptionHandler);
var factory = new ReaderChannelFactory(correlationId, _processManager, _connectionPool, executor, options);
var stateManager = new StateManager <ReaderState>(ReaderState.Disconnected, ReaderState.Closed, ReaderState.ReachedEndOfTopic, ReaderState.Faulted);
var reader = new Reader(correlationId, options.Topic, _processManager, new NotReadyChannel(), executor, stateManager);
if (options.StateChangedHandler is not null)
{
_ = StateMonitor.MonitorReader(reader, options.StateChangedHandler);
}
var process = new ReaderProcess(correlationId, stateManager, factory, reader);
_processManager.Add(process);
process.Start();
return(reader);
}
/// <summary>
/// The BeginMonitoring
/// </summary>
/// <param name="interval">The <see cref="int"/></param>
/// <returns>The <see cref="Task"/></returns>
public static async Task BeginMonitoring(int interval, MODE mode)
{
var _recipients = ConfigurationManager.AppSettings["To"].ToString();
var _resources = ConfigurationManager.AppSettings["resources"];
_resources = String.IsNullOrEmpty(_resources) ? "https://www.google.com" : _resources;
List <Resource> resources = new List <Resource>();
var urls = _resources.Split(',').ToList();
urls.ForEach(s =>
{
Resource r = new ResourceFactory().GetResource(s);
if (r.Exist())
{
resources.Add(r);
}
else
{
Console.WriteLine("Unrecognizable resource: {0} . Please verify config file", string.Concat(r.Name, "@", r.GetAbsoluteUri()));
}
});
try
{
StateMonitor sm = new StateMonitor(_interval, resources, mode);
await sm.Init();
}
catch (System.AggregateException ex)
{
Console.WriteLine("Program Crashed because of " + ex.Data);
IList <State> st = new List <State>();
st.Add(new State()
{
Status = ex.StackTrace
});
st.ToList().ForEach(x =>
{
_logger.Log(x, x.Status);
});
}
}
/// <summary>
/// Create a producer.
/// </summary>
public IProducer CreateProducer(ProducerOptions options)
{
ThrowIfDisposed();
var correlationId = Guid.NewGuid();
var executor = new Executor(correlationId, _processManager, _exceptionHandler);
var factory = new ProducerChannelFactory(correlationId, _processManager, _connectionPool, executor, options);
var stateManager = new StateManager <ProducerState>(ProducerState.Disconnected, ProducerState.Closed, ProducerState.Faulted);
var producer = new Producer(correlationId, options.Topic, options.InitialSequenceId, _processManager, new NotReadyChannel(), executor, stateManager);
if (options.StateChangedHandler is not null)
{
_ = StateMonitor.MonitorProducer(producer, options.StateChangedHandler);
}
var process = new ProducerProcess(correlationId, stateManager, factory, producer);
_processManager.Add(process);
process.Start();
return(producer);
}
void OpenHost()
{
try
{
_subscriptionId = Client.Subscribe(tbListenerUri.Text);
StateMonitor stateMonitor = new StateMonitor();
stateMonitor.StateUpdated += stateMonitor_StateUpdated;
stateMonitor.ConnectionClosed += logReceiver_ConnectionClosed;
_listenerHost = new ServiceHost(stateMonitor, new Uri(tbListenerUri.Text));
ServiceEndpoint endpoint =
_listenerHost.AddServiceEndpoint(typeof(StateReportReceiverSoap), _custombindingSoap12, string.Empty);
_listenerHost.Open();
Invoke(new Action(() => { btnMonitor.Text = "Stop"; }));
}
catch (Exception exc)
{
ShowError(exc);
}
}
public static async Task BeginMonitoring(int interval)
{
List <Resource> resources = new List <Resource>();
var urls = System.Configuration.ConfigurationManager.AppSettings["resources"].Split(',').ToList();
urls.ForEach(s => resources.Add(new ResourceFactory().GetResource(s)));
try {
StateMonitor sm = new StateMonitor(_interval, resources);
await sm.Init();
}
catch (System.AggregateException ex)
{
Console.WriteLine("Program Crashed because of " + ex.Data);
IList <State> st = new List <State>();
st.Add(new State()
{
Status = ex.StackTrace
});
// StateLogger.SendAlertNotification(st, "*****@*****.**");
}
}
public Success(bool blink, Colors colors, StateMonitor stateMonitor)
{
this.blink = blink;
this.color = colors;
this.StateMonitor = stateMonitor;
}
public StateDeltasGroupManager2(StateMonitor sm)
{
mysm = sm;// Instance = this;
CurrentStateGroup = new PowerUpStateGroup(sm, this);
}
public PowerUpStateGroup(StateMonitor sm, StateDeltasGroupManager2 sd)
{
this.sm = sm;
this.sd = sd;
}
private STATE_MONITOR_DBEntities updateChildren(StateMonitor newStateMonitor, STATE_MONITOR_DBEntities db)
{
deleteMetrics(newStateMonitor.stateMonitorId, db);
insertMetrics(newStateMonitor, db);
return(db);
}
/// <summary>
/// inserts a new state monitor in database
/// </summary>
/// <param name="stateMonitor"></param>
/// <param name="db"></param>
/// <returns></returns>
public void insertStateMonitor(StateMonitor stateMonitor, STATE_MONITOR_DBEntities db)
{
db.StateMonitors.Add(stateMonitor);
db.SaveChanges();
}
