private HttpNodeJSService CreateHttpNodeJSService(IOptions <OutOfProcessNodeJSServiceOptions> outOfProcessNodeHostOptionsAccessor = null,
IHttpContentFactory httpContentFactory = null,
IEmbeddedResourcesService embeddedResourcesService = null,
IFileWatcherFactory fileWatcherFactory = null,
IMonitorService monitorService = null,
ITaskService taskService = null,
IHttpClientService httpClientService = null,
IJsonService jsonService = null,
INodeJSProcessFactory nodeProcessFactory = null,
ILogger <HttpNodeJSService> logger = null)
{
if (logger == null)
{
Mock <ILogger <HttpNodeJSService> > mockLogger = _mockRepository.Create <ILogger <HttpNodeJSService> >();
logger = mockLogger.Object;
}
return(new HttpNodeJSService(outOfProcessNodeHostOptionsAccessor,
httpContentFactory,
embeddedResourcesService,
fileWatcherFactory,
monitorService,
taskService,
httpClientService,
jsonService,
nodeProcessFactory,
logger));
}
public MeropsMonitor(AppHost appHost, RpcConfig config)
{
//var factory = new RpcClientFactory(null, null);
_client = appHost.ClientFactory.GetInstance<IMonitorService>(config?.Monitor.Address);
// ReSharper disable once UnusedVariable
var writeTask = WriteLogsAsync();
}
public EkranController(IUserService userService,
IUserRoleService userRoleService,
IEkranService ekranService,
IEkranIcerikService ekranIcerikService,
IEkranTasarimIcerikService ekranTasarimIcerikService,
IEkranTasarimService ekranTasarimService,
IMonitorService monitorService,
ICihazService cihazService,
ICihazDurumService cihazDurumService,
IKonumService konumService,
IGrupService grupService,
IYayinEkranService yayinEkranService
)
{
_userService = userService;
_userRoleService = userRoleService;
_ekranService = ekranService;
_ekranIcerikService = ekranIcerikService;
_ekranTasarimService = ekranTasarimService;
_monitorService = monitorService;
_cihazService = cihazService;
_cihazDurumService = cihazDurumService;
_konumService = konumService;
_grupService = grupService;
_ekranTasarimIcerikService = ekranTasarimIcerikService;
_yayinEkranService = yayinEkranService;
}
/// <summary>
/// Creates a <see cref="HttpNodeJSService"/>.
/// </summary>
/// <param name="outOfProcessNodeJSServiceOptionsAccessor"></param>
/// <param name="httpContentFactory"></param>
/// <param name="embeddedResourcesService"></param>
/// <param name="fileWatcherFactory"></param>
/// <param name="monitorService"></param>
/// <param name="taskService"></param>
/// <param name="httpClientService"></param>
/// <param name="jsonService"></param>
/// <param name="nodeJSProcessFactory"></param>
/// <param name="logger"></param>
public HttpNodeJSService(IOptions <OutOfProcessNodeJSServiceOptions> outOfProcessNodeJSServiceOptionsAccessor,
IHttpContentFactory httpContentFactory,
IEmbeddedResourcesService embeddedResourcesService,
IFileWatcherFactory fileWatcherFactory,
IMonitorService monitorService,
ITaskService taskService,
IHttpClientService httpClientService,
IJsonService jsonService,
INodeJSProcessFactory nodeJSProcessFactory,
ILogger <HttpNodeJSService> logger) :
base(nodeJSProcessFactory,
logger,
outOfProcessNodeJSServiceOptionsAccessor,
embeddedResourcesService,
fileWatcherFactory,
monitorService,
taskService,
typeof(HttpNodeJSService).GetTypeInfo().Assembly,
SERVER_SCRIPT_NAME)
{
_httpClientService = httpClientService;
_jsonService = jsonService;
_logger = logger;
_httpContentFactory = httpContentFactory;
}
private void DoStartService(IMonitorService serviceImpl)
{
Uri baseAdress = new Uri("http://0.0.0.0:8033/OpenEngSB/DotNet/Service");
_selfHost = new ServiceHost(serviceImpl, baseAdress);
_selfHost.AddServiceEndpoint(typeof(IMonitorService), new WSDualHttpBinding(), "MonitorService");
ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
_selfHost.Description.Behaviors.Add(smb);
foreach (var b in _selfHost.Description.Behaviors)
{
if (b is ServiceDebugBehavior)
{
((ServiceDebugBehavior)b).IncludeExceptionDetailInFaults = true;
break;
}
}
_selfHost.Open();
}
public ConsistencyCheckHandler(ILog log, IMonitorService monitorService) :
base(nameof(ConsistencyCheckHandler), monitorService.MonitorInterval, log)
{
_log = log;
_monitorService = monitorService;
_initialCall = true;
}
public MeropsMonitor(AppHost appHost, RpcConfig config)
{
//var factory = new RpcClientFactory(null, null);
_client = appHost.ClientFactory.GetInstance <IMonitorService>(config?.Monitor.Address);
// ReSharper disable once UnusedVariable
var writeTask = WriteLogsAsync();
}
private static ComponentDto GetComponent(
IMonitorService <TMonitor> monitorService)
{
return(new ComponentDto(
monitorService.ComponentIdentifier,
monitorService.ComponentName));
}
public MainWindow()
{
var container = new Container();
container.Register <IConfigService, ConfigService>();
container.Register <IScreenColorService, ScreenColorService>();
container.Register <IMonitorService, MonitorService>();
container.Verify();
_configService = container.GetInstance <IConfigService>();
_temperatureService = container.GetInstance <IScreenColorService>();
_monitorService = container.GetInstance <IMonitorService>();
Monitors = new ObservableCollection <Monitor>(_monitorService.GetMonitors());
SelectedMonitor = Monitors.FirstOrDefault();
bool exists = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location)).Length > 1;
if (exists) //If this program already has an instance
{
try
{
NamedPipeClientStream pipeStream = new NamedPipeClientStream(".", "instance", PipeDirection.Out, PipeOptions.None);
pipeStream.Connect();
Environment.Exit(0);
}
catch (TimeoutException oEx)
{
Debug.WriteLine(oEx.Message);
}
}
else //If the program is not already running
{
_pipeServer = new NamedPipeServerStream("instance", PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
_pipeServer.BeginWaitForConnection(WaitForConnectionCallBack, _pipeServer);
}
AssignKeyToConfigCommand = new RelayCommand(AssignKeyToConfig);
SaveConfigCommand = new RelayCommand(SaveConfig);
DeleteConfigCommand = new RelayCommand(DeleteConfig);
MoveConfigUpCommand = new RelayCommand(MoveConfigUp);
MoveConfigDownCommand = new RelayCommand(MoveConfigDown);
RefreshMonitorsCommand = new RelayCommand(RefreshMonitors);
_notifyIcon.Icon = Properties.Resources.icon;
_notifyIcon.Click += NotifyIconOnClick;
_notifyIcon.Visible = true;
SystemEvents.SessionSwitch += SystemEventsOnSessionSwitch;
SystemEvents.UserPreferenceChanging += SystemEvents_UserPreferenceChanging;
SystemEvents.PaletteChanged += SystemEvents_PaletteChanged;
SystemEvents.DisplaySettingsChanged += SystemEvents_DisplaySettingsChanged;
InitializeComponent();
}
public AddViewModel(IMonitorService monitor)
{
_monitorService = monitor;
_name = new ValidatableObject <string>();
_url = new ValidatableObject <string>();
addValidations();
}
public static void StartService(IMonitorService serviceImpl)
{
if (_me == null)
{
_me = new CommunicationService();
_me.DoStartService(serviceImpl);
}
}
public CommonManager(
ILogger <CommonManager> Logger,
IMonitorService IMonitorService,
ICacheHelper ICacheHelper
)
{
logger = Logger;
monitorService = IMonitorService;
cacheHelper = ICacheHelper;
}
public void TestInitializer()
{
_monitorsDbSet = Substitute.For <IDbSet <Monitor> >();
_uow = Substitute.For <IUnitOfWork2>();
_uow.GetDbSet <Monitor>().Returns(_monitorsDbSet);
_monitorService = new MonitorService(_uow);
}
public WatchDogTests()
{
_monitorService = Substitute.For <IMonitorService>();
_monitorServiceFactory = Substitute.For <IMonitorServiceFactory>();
_monitorServiceFactory.Create(Arg.Any <string>()).Returns(_monitorService);
_kernel = new StandardKernel();
_kernel.Bind <IMonitorServiceFactory>().ToConstant(_monitorServiceFactory).InSingletonScope();
_kernel.Bind <IFileSystemWatchDog>().To <FileSystemWatchDog>().InTransientScope();
}
public IDisposable Subscribe(IObserver <FileChangedEventArgs> observer)
{
IMonitorService monitorService = _monitorServiceFactory.Create(_filePath);
monitorService.IncludeSubDirectories = _includeSubDir;
monitorService.Created += (s, evt) => Notify(observer, evt);
monitorService.Deleted += (s, evt) => Notify(observer, evt);
monitorService.Renamed += (s, evt) => Notify(observer, evt);
monitorService.Modified += (s, evt) => Notify(observer, evt);
return(monitorService);
}
/// <inheritdoc />
public StorageMonitorService(
IOptions <StorageMonitorOptions> options,
ILogger <StorageMonitorService> logger,
IMonitorService monitors,
IMountService mountService)
: base(options)
{
this.Monitors = monitors;
this.Logger = logger;
this.MountService = mountService;
}
public CozunurlukController(ICihazService cihazService,
IUserService userService,
ICozunurlukService cozunurlukService,
IKonumService konumService,
IMonitorService monitorService)
{
_cihazService = cihazService;
_userService = userService;
_monitorService = monitorService;
_konumService = konumService;
_cozunurlukService = cozunurlukService;
}
public CihazDurumController(ICihazService cihazService,
IUserService userService,
ICihazDurumService cihazDurumService,
IKonumService konumService,
IMonitorService monitorService)
{
_cihazService = cihazService;
_userService = userService;
_monitorService = monitorService;
_konumService = konumService;
_cihazDurumService = cihazDurumService;
}
public DiscoveryHostedService(
IRegistrationService registrationService,
IMonitorService monitorService,
ILogger <DiscoveryHostedService> logger,
IConfiguration configuration)
{
_registrationService = registrationService;
_monitorService = monitorService;
_logger = logger;
_configuration = configuration;
_hasSuccessfulRegistration = false;
_hasSuccessfulHeartBeat = false;
}
public MainViewModel()
{
try
{
_business = ServiceLocator.Current.GetInstance <IBusiness>();
_mailService = ServiceLocator.Current.GetInstance <IMailService>();
_monitorService = ServiceLocator.Current.GetInstance <IMonitorService>();
_watchdogService = ServiceLocator.Current.GetInstance <IWatchdogService>();
_faxService = ServiceLocator.Current.GetInstance <IFaxService>();
if (_faxService != null)
{
_faxService.EinsatzCreated += (sender, e) => DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
faxService_EinsatzCreated(sender, e);
});
}
_decoderService = ServiceLocator.Current.GetInstance <IDecoderService>();
if (_decoderService != null)
{
_decoderService.StatusChanged += (sender, e) => DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
switch (e.Number)
{
case 1:
DecoderStatus1 = Settings.Default.Decoder1_Mode +
(Settings.Default.Decoder1_Mode == DecoderMode.OFF
? ""
: $"[{e.Status}]");
break;
case 2:
DecoderStatus2 = Settings.Default.Decoder2_Mode +
(Settings.Default.Decoder2_Mode == DecoderMode.OFF
? ""
: $"[{e.Status}]");
break;
}
});
}
#if DEBUG
IsAdminMode = true;
#endif
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
public MonitorController(ICihazService cihazService,
IUserRoleService userRoleService,
IUserService userService,
IGrupService grupService,
ICozunurlukService cozunurlukService,
IKonumService konumService,
IMonitorService monitorService)
{
_cihazService = cihazService;
_userRoleService = userRoleService;
_userService = userService;
_monitorService = monitorService;
_konumService = konumService;
_cozunurlukService = cozunurlukService;
_grupService = grupService;
}
/// <summary>
/// Creates an <see cref="OutOfProcessNodeJSService"/> instance.
/// </summary>
/// <param name="nodeProcessFactory"></param>
/// <param name="logger"></param>
/// <param name="optionsAccessor"></param>
/// <param name="embeddedResourcesService"></param>
/// <param name="fileWatcherFactory"></param>
/// <param name="monitorService"></param>
/// <param name="taskService"></param>
/// <param name="serverScriptAssembly"></param>
/// <param name="serverScriptName"></param>
protected OutOfProcessNodeJSService(INodeJSProcessFactory nodeProcessFactory,
ILogger logger,
IOptions <OutOfProcessNodeJSServiceOptions> optionsAccessor,
IEmbeddedResourcesService embeddedResourcesService,
IFileWatcherFactory fileWatcherFactory,
IMonitorService monitorService,
ITaskService taskService,
Assembly serverScriptAssembly,
string serverScriptName) :
this(nodeProcessFactory, logger, optionsAccessor, embeddedResourcesService, serverScriptAssembly, serverScriptName)
{
_fileWatcherFactory = fileWatcherFactory;
_monitorService = monitorService;
_taskService = taskService;
(_trackInvokeTasks, _trackedInvokeTasks, _invokeTaskCreationCountdown) = InitializeFileWatching();
}
public MonitorServiceTests()
{
var contextMock = new Mock <IHubContext <MonitorHub> >();
contextMock.Setup(x => x.Clients)
.Returns(() => new Mock <IHubClients>().Object);
contextMock.Setup(x => x.Groups)
.Returns(() => new Mock <IGroupManager>().Object);
contextMock.Setup(x => x.Clients.Group(_channel))
.Returns(() => new Mock <IClientProxy>().Object);
var context = contextMock.Object;
context.Groups.AddToGroupAsync("0", _channel);
_monitorService = new MonitorService <object>(context);
}
private ExposedHttpNodeJSService CreateHttpNodeJSService(IOptions <OutOfProcessNodeJSServiceOptions> outOfProcessNodeHostOptionsAccessor = null,
IHttpContentFactory httpContentFactory = null,
IEmbeddedResourcesService embeddedResourcesService = null,
IFileWatcherFactory fileWatcherFactory = null,
IMonitorService monitorService = null,
ITaskService taskService = null,
IHttpClientService httpClientService = null,
IJsonService jsonService = null,
INodeJSProcessFactory nodeProcessFactory = null,
ILogger <HttpNodeJSService> logger = null,
StringBuilder loggerStringBuilder = null)
{
if (logger == null)
{
// Log output
if (loggerStringBuilder != null)
{
var services = new ServiceCollection();
services.AddLogging(lb =>
{
lb.
AddProvider(new StringBuilderProvider(loggerStringBuilder)).
AddFilter <StringBuilderProvider>((LogLevel LogLevel) => LogLevel >= LogLevel.Trace);
});
logger = services.BuildServiceProvider().GetRequiredService <ILogger <HttpNodeJSService> >();
}
else
{
Mock <ILogger <HttpNodeJSService> > mockLogger = _mockRepository.Create <ILogger <HttpNodeJSService> >();
logger = mockLogger.Object;
}
}
return(new ExposedHttpNodeJSService(outOfProcessNodeHostOptionsAccessor,
httpContentFactory,
embeddedResourcesService,
fileWatcherFactory,
monitorService,
taskService,
httpClientService,
jsonService,
nodeProcessFactory,
logger));
}
private async Task DoServiceWork()
{
while (!cts.IsCancellationRequested)
{
try
{
IMonitorService monitorService = null;
var delay = await monitorService.PerformMonitorAsync();
await Task.Delay(delay);
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
await Task.Delay(1000);
}
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
IMonitorService monitor,
NewWebsocekthandler websocketHandler,
IProcessManager processManager,
IApplicationLifetime applicationLifetime
)
{
applicationLifetime.ApplicationStopping.Register(() => {
System.Console.WriteLine("kill all");
processManager.KillAll();
});
monitor.Run();
app.UseWebSockets();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseWebpackDevMiddleware(new WebpackDevMiddlewareOptions {
HotModuleReplacement = true,
ReactHotModuleReplacement = true
});
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseMiddleware <ServeWebsocketMiddleware>();
app.UseStaticFiles();
app.UseMvc(routes => {
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
routes.MapSpaFallbackRoute(
name: "spa-fallback",
defaults: new { controller = "Home", action = "Index" });
});
}
public AlarmWindow(Einsatz _einsatz)
{
monitorService = ServiceLocator.Current.GetInstance <IMonitorService>();
InitializeComponent();
//Set time when window should be closed
CloseTime = DateTime.Now.Add(Settings.Default.Monitor_AlarmTime);
var _viewModel = new AlarmViewModel(_einsatz);
_viewModel.CloseRequested += (sender, e) => { Close(); };
DataContext = _viewModel;
Loaded += AlarmWindow_Loaded;
Closing += AlarmWindow_Closing;
//Add to alarmWindowList
monitorService.AddAlarmWindow(this);
}
public RebootService(IMonitorService monitorService)
{
try
{
_monitorService = monitorService;
_rebootTimer = new Timer();
_rebootTimer.AutoReset = false;
_rebootTimer.Elapsed += (sender, e) => DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
rebootTimer_Elapsed(sender, e);
});
Logger.WriteDebug(MethodBase.GetCurrentMethod(), "Initialize");
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Creates an <see cref="HttpNodeJSService"/>.
/// </summary>
/// <param name="outOfProcessNodeJSServiceOptionsAccessor">The <see cref="OutOfProcessNodeJSServiceOptions"/> accessor.</param>
/// <param name="httpNodeJSServiceOptionsAccessor">The <see cref="HttpNodeJSServiceOptions"/> accessor.</param>
/// <param name="httpContentFactory">The factory for creating <see cref="HttpContent"/>s.</param>
/// <param name="embeddedResourcesService">The service for retrieving NodeJS Http server scripts.</param>
/// <param name="fileWatcherFactory">The service for creating <see cref="IFileWatcher"/>s</param>
/// <param name="monitorService">The service for lock-based thread synchronization.</param>
/// <param name="taskService">The service for utilizing tasks.</param>
/// <param name="httpClientService">The service for utilizing <see cref="HttpClient"/>.</param>
/// <param name="jsonService">The service for JSON serialization and deserialization.</param>
/// <param name="nodeJSProcessFactory">The factory for creating <see cref="NodeJSProcess"/>s.</param>
/// <param name="logger">The logger for the instance.</param>
public HttpNodeJSService(IOptions <OutOfProcessNodeJSServiceOptions> outOfProcessNodeJSServiceOptionsAccessor,
IOptions <HttpNodeJSServiceOptions> httpNodeJSServiceOptionsAccessor,
IHttpContentFactory httpContentFactory,
IEmbeddedResourcesService embeddedResourcesService,
IFileWatcherFactory fileWatcherFactory,
IMonitorService monitorService,
ITaskService taskService,
IHttpClientService httpClientService,
IJsonService jsonService,
INodeJSProcessFactory nodeJSProcessFactory,
ILogger <HttpNodeJSService> logger) :
base(nodeJSProcessFactory,
logger,
outOfProcessNodeJSServiceOptionsAccessor,
embeddedResourcesService,
fileWatcherFactory,
monitorService,
taskService,
typeof(HttpNodeJSService).GetTypeInfo().Assembly,
#if NETCOREAPP3_1 || NET5_0_OR_GREATER
httpNodeJSServiceOptionsAccessor.Value.Version == HttpVersion.Version20 ? HTTP20_SERVER_SCRIPT_NAME : HTTP11_SERVER_SCRIPT_NAME)
public ExposedHttpNodeJSService(IOptions <OutOfProcessNodeJSServiceOptions> outOfProcessNodeJSServiceOptionsAccessor,
IHttpContentFactory httpContentFactory,
IEmbeddedResourcesService embeddedResourcesService,
IFileWatcherFactory fileWatcherFactory,
IMonitorService monitorService,
ITaskService taskService,
IHttpClientService httpClientService,
IJsonService jsonService,
INodeJSProcessFactory nodeJSProcessFactory,
ILogger <HttpNodeJSService> logger) :
base(outOfProcessNodeJSServiceOptionsAccessor,
httpContentFactory,
embeddedResourcesService,
fileWatcherFactory,
monitorService,
taskService,
httpClientService,
jsonService,
nodeJSProcessFactory,
logger)
{
}
public MainViewModel(IMonitorService monitorService, IHotKeyService hotKeyService, ISettingsProvider settingsProvider,
IStartupService startupService, IDialogService dialogService)
{
var monitors = monitorService.GetPhysicalMonitors();
Monitor = new MonitorViewModel(monitors.First(), monitorService);
Monitor.BrightnessChanged += OnBrightnessChanged;
Settings = new SettingsViewModel(settingsProvider, dialogService);
Settings.SettingsChanged += OnSettingsChanged;
MouseWheelCommand = new RelayCommand <MouseWheelEventArgs>(OnMouseWheelScroll);
ShowWindowCommand = new RelayCommand(ShowWindow);
ExitApplicationCommand = new RelayCommand(ExitApplication);
IncreaseBrightnessCommand = new RelayCommand(IncreaseBrightness);
DecreaseBrightnessCommand = new RelayCommand(DecreaseBrightness);
_settingsProvider = settingsProvider;
_startupService = startupService;
_startupService.RunAppOnStartup(Settings.RunOnStartUp);
_hotKeyManager = new HotKeyManagerViewModel(hotKeyService, this);
_dialogService = dialogService;
}
public MonitorController(IMonitorService monitor)
{
_monitor = monitor;
}
public AppEngine(IMonitorService monitorService)
{
_monitorService = monitorService;
}
