/// <summary>
/// ExecuteAsync
/// </summary>
/// <param name="context"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
protected override async Task <Action <NativeActivityContext> > ExecuteAsync(NativeActivityContext context, CancellationToken cancellationToken)
{
var interval = Interval.Get(context);
var number = Number.Get(context);
var logging = Logging.Get(context);
var logDirectory = LogDirectory.Get(context);
if (String.IsNullOrEmpty(logDirectory))
{
logDirectory = System.Environment.CurrentDirectory;
}
MonitorProcess mi = new MonitorProcess(interval, number, logging, logDirectory);
return((ctx) => {
// Schedule child activities
if (Body != null)
{
ctx.ScheduleAction <IObjectContainer>(Body, _objectContainer, OnCompleted, OnFaulted);
}
// Outputs
});
}
void initMonit()
{
MonitorProcess monitor_process = new MonitorProcess();
monitor_process.Process_Event += new MonitorProcess.Event_Handler(on_Process_Event);
monitor_process.Process_Exit += new MonitorProcess.Event_Handler(On_Process_Exit);
monitor_process.run();
}
public static MonitorProcess AsMonitorProcess(this HashEntry[] hashEntry, RedisKey monitorId)
{
HashEntry processName = hashEntry.FirstOrDefault(x => x.Name == nameof(MonitorDetails.ProcessName));
HashEntry lifeTime = hashEntry.FirstOrDefault(x => x.Name == nameof(MonitorDetails.IntervalTime));
HashEntry subscribers = hashEntry.FirstOrDefault(x => x.Name == nameof(MonitorDetails.Subscribers));
HashEntry dateOfCreation = hashEntry.FirstOrDefault(x => x.Name == nameof(MonitorDetails.DateOfCreation));
HashEntry lastCheckIn = hashEntry.FirstOrDefault(x => x.Name == nameof(MonitorDetails.LastCheckIn));
HashEntry isDown = hashEntry.FirstOrDefault(x => x.Name == nameof(MonitorDetails.IsDown));
try {
MonitorProcess result = new MonitorProcess {
Id = Guid.Parse(monitorId.ToString()),
MonitorDetails = new MonitorDetails {
ProcessName = processName.Value.HasValue ? Convert.ToString(processName.Value) : String.Empty,
IntervalTime = lifeTime.Value.HasValue ? Convert.ToInt32(lifeTime.Value) : 0,
Subscribers = subscribers.Value.HasValue ? JsonConvert.DeserializeObject <string[]>(Convert.ToString(subscribers.Value)) : new string[] { },
DateOfCreation = dateOfCreation.Value.HasValue ? JsonConvert.DeserializeObject <DateTime>(dateOfCreation.Value) : DateTime.MinValue,
LastCheckIn = lastCheckIn.Value.HasValue ? JsonConvert.DeserializeObject <DateTime>(lastCheckIn.Value) : DateTime.MinValue,
IsDown = isDown.Value.HasValue ? Convert.ToBoolean(isDown.Value) : false
}
};
return(result);
} catch {
return(new MonitorProcess());
}
}
/// <summary>
/// ExecuteAync
/// </summary>
/// <param name="context"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var process = Process.Get(context);
MonitorProcess.SetOrder(process);
// Outputs
return((ctx) => {
});
}
public static HashEntry[] ConvertMonitorToHashEntry(this MonitorProcess monitor)
{
var processName = new HashEntry(nameof(monitor.MonitorDetails.ProcessName), monitor.MonitorDetails.ProcessName);
var lifeTime = new HashEntry(nameof(monitor.MonitorDetails.IntervalTime), monitor.MonitorDetails.IntervalTime);
var subscribers = new HashEntry(nameof(monitor.MonitorDetails.Subscribers), JsonConvert.SerializeObject(monitor.MonitorDetails.Subscribers));
var dateOfCreation = new HashEntry(nameof(monitor.MonitorDetails.DateOfCreation), JsonConvert.SerializeObject(monitor.MonitorDetails.DateOfCreation));
var checkedLastTime = new HashEntry(nameof(monitor.MonitorDetails.LastCheckIn), JsonConvert.SerializeObject(monitor.MonitorDetails.LastCheckIn));
var isDown = new HashEntry(nameof(monitor.MonitorDetails.IsDown), monitor.MonitorDetails.IsDown.ToString());
return(new HashEntry[] { processName, lifeTime, subscribers, dateOfCreation, checkedLastTime, isDown });
}
private static void PrepareThreads(CancellationTokenSource cancelTokenSource)
{
string name = $"Monitor";
MonitorProcess m = new MonitorProcess(name);
monitors.Add(m);
var task = Task.Factory.StartNew(() => m.Run(cancelTokenSource), cancelTokenSource.Token,
TaskCreationOptions.LongRunning, TaskScheduler.Default);
tasks.Add(task);
}
public async void InitWindow()
{
//Check if regedit is set up
Regedit.CheckRegedit();
await MonitorProcess.InitMonitoringAsync(this);
//Wait for the app to check for update
if (await Update.CheckUpdate(this) == null)
{
//Once it's done, fill the listview with videos
await FillList();
}
}
public static JObject GetResultJson(this MonitorProcess monitor, HostString host, String scheme, PathString path)
{
var pathValue = path.HasValue ? path.Value : String.Empty;
var hostValue = host.HasValue ? host.Value : String.Empty;
if (!pathValue.EndsWith("/"))
{
pathValue += "/";
}
var checkInUrl = scheme + "://" + hostValue + pathValue + monitor.Id.ToString() + "/checkin";
var result = new { monitorid = monitor.Id, checkinurl = checkInUrl };
return(JObject.FromObject(result));
}
/// <summary>
/// ExecuteAsync
/// </summary>
/// <param name="context"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Inputs
var process = Process.Get(context);
var ret = MonitorProcess.GetMonitoredValue(process);
ulong[] eachCpu = { ret[MonitorItem.SystemEachCpu00to07], ret[MonitorItem.SystemEachCpu08to15], ret[MonitorItem.SystemEachCpu16to23], ret[MonitorItem.SystemEachCpu24to31] };
int cpuCount = Environment.ProcessorCount;
if (cpuCount > MonitorProcess.MAX_CPU_COUNT)
{
cpuCount = MonitorProcess.MAX_CPU_COUNT;
}
float[] eachCpuArray = new float[cpuCount];
for (int i = 0; i < cpuCount; i++)
{
ulong cpuValue = eachCpu[i >> 2];
eachCpuArray[i] = (float)(cpuValue & 0xFF);
eachCpu[i >> 2] = eachCpu[i >> 2] >> 8;
}
// Outputs
return((ctx) => {
RawValue.Set(ctx, ret);
SystemTotalCpu.Set(ctx, (float)ret[MonitorItem.SystemTotalCpu] / 100F);
SystemTotalCpuMA.Set(ctx, (float)ret[MonitorItem.SystemTotalCpuMA] / 100F);
SystemEachCpu.Set(ctx, eachCpuArray);
SystemTotalPhysicalMemory.Set(ctx, ret[MonitorItem.SystemTotalPhysicalMemory]);
SystemAvailablePhisycalMemory.Set(ctx, ret[MonitorItem.SystemAvailablePhisycalMemory]);
SystemTotalVirtualMemory.Set(ctx, ret[MonitorItem.SystemTotalVirtualMemory]);
SystemAvilableVirtualMemory.Set(ctx, ret[MonitorItem.SystemAvilableVirtualMemory]);
ProcessWorkingSet.Set(ctx, ret[MonitorItem.ProcessWorkingSet]);
ProcessWorkingSetMA.Set(ctx, ret[MonitorItem.ProcessWorkingSetMA]);
ProcessPrivateMemorySize.Set(ctx, ret[MonitorItem.ProcessPrivateMemorySize]);
ProcessPrivateMemorySizeMA.Set(ctx, ret[MonitorItem.ProcessPrivateMemorySizeMA]);
ProcessTotalManagedMemory.Set(ctx, ret[MonitorItem.ProcessTotalManagedMemory]);
ProcessTotalProcessorTime.Set(ctx, ret[MonitorItem.ProcessTotalProcessorTime]);
ProcessTotalProcessorTimeDelta.Set(ctx, ret[MonitorItem.ProcessTotalProcessorTimeDelta]);
ProcessResponding.Set(ctx, ret[MonitorItem.ProcessResponding] != 0 ? true : false);
ProcessRespondingCount.Set(ctx, (int)ret[MonitorItem.ProcessRespondingCount]);
});
}
private void Cleanup()
{
MonitorProcess.TerminateMonitoring();
Thread.Sleep(500);
var disposableObjects = _objectContainer.Where(o => o is IDisposable);
foreach (var obj in disposableObjects)
{
if (obj is IDisposable dispObject)
{
dispObject.Dispose();
}
}
_objectContainer.Clear();
}
private async void BtnSelect_Click(object sender, RoutedEventArgs e)
{
if (MonitorProcess.IsCSOpen())
{
await this.ShowMessageAsync(DefError, "Please close your game.");
return;
}
if (await Folders.UpdateBackground(this, WebmPlayer.Source.AbsolutePath.Replace("%20", " ")))
{
await this.ShowMessageAsync("Background changed", "Enjoy your new background !");
}
else
{
await this.ShowMessageAsync(DefError, "This application cannot work without a specified Counter-Strike Global Offensive folder.");
}
}
