public void Execute()
{
List <GameEntity> arrived = new List <GameEntity>();
foreach (GameEntity gameEntity in _entites)
{
if (RunningService.RunTowards(gameEntity))
{
arrived.Add(gameEntity);
}
}
foreach (GameEntity entity in arrived)
{
if (entity.isStateRunningToEnemy)
{
entity.isStateRunningToEnemy = false;
entity.isStateAttack = true;
}
if (entity.isStateRunningFromEnemy)
{
entity.isStateRunningFromEnemy = false;
entity.isStateIdle = true;
entity.ReplaceRotation(entity.originalRotation.value);
// entity.view.gameObject.TryGetComponent<Character>(out Character character);
// character.Idle();
entity.animator.animator.SetFloat(Speed, 0.0f);
}
}
}
public async Task <bool> Stop(RunningService service, int timeToKill)
{
if (_processes.TryGetValue(service.Name, out var process))
{
return(await process.Execute(async p =>
{
using var scope = _serviceScopeFactory.CreateScope();
var error = false;
try
{
using var waiter = new ServiceStopWaiter(service.Name);
await scope.ServiceProvider.GetRequiredService <ICommandSender>().Send(new StopServiceCommand {
Name = service.Name
}).ConfigureAwait(false);
await waiter.Wait(10_000);
if (p.WaitForExit(10_000))
{
return true;
}
else
{
p.Kill();
return true;
}
}
private InstallerContext(RunningService runningService, IServiceScope serviceScope)
{
InstalledPath = runningService.InstallationPath;
ExeName = runningService.Exe;
ServiceScope = serviceScope;
ServiceName = runningService.Name;
_runningService = runningService;
}
private ServiceAccessRights GetTriggerAccess(RunningService service, NtToken token)
{
if (IgnoreTrigger)
{
return(0);
}
ServiceAccessRights granted_access = 0;
NtType type = NtType.GetTypeByType <NtEtwRegistration>();
foreach (var trigger in service.Triggers)
{
bool accessible = false;
if (trigger.TriggerType == ServiceTriggerType.NetworkEndpoint)
{
accessible = true;
}
else if (trigger is EtwServiceTriggerInformation etw_trigger)
{
if (etw_trigger.SecurityDescriptor == null)
{
WriteWarning($"Can't access ETW Security Descriptor for service {service.Name}. Running as Administrator might help.");
}
else
{
accessible = CheckForAccess(etw_trigger.SecurityDescriptor, token,
TraceAccessRights.GuidEnable, type.GenericMapping);
}
}
else if (trigger is WnfServiceTriggerInformation wnf_trigger)
{
if (wnf_trigger.Name?.SecurityDescriptor == null)
{
WriteWarning($"Can't access WNF Security Descriptor for service {service.Name}");
}
else
{
accessible = CheckForAccess(wnf_trigger.Name.SecurityDescriptor, token,
WnfAccessRights.WriteData, NtWnf.GenericMapping);
}
}
if (accessible)
{
if (trigger.Action == ServiceTriggerAction.Start)
{
granted_access |= ServiceAccessRights.Start;
}
else
{
granted_access |= ServiceAccessRights.Stop;
}
}
}
return(granted_access);
}
internal ServiceAccessCheckResult(string name, AccessMask granted_access,
SecurityDescriptor sd, TokenInformation token_info,
ServiceAccessRights trigger_granted_access,
ServiceAccessRights original_granted_access,
RunningService service)
: base(name, "Service", granted_access,
ServiceUtils.GetServiceGenericMapping(), sd,
typeof(ServiceAccessRights), false, token_info)
{
TriggerGrantedAccess = trigger_granted_access;
OriginalGrantedAccess = original_granted_access;
Service = service;
}
private async void InstallerWindow_OnLoaded(object sender, RoutedEventArgs e)
{
try
{
using var scope = _serviceScopeFactory.CreateScope();
var installerProcedure = scope.ServiceProvider.GetRequiredService <InstallerProcedure>();
if (Update)
{
installerProcedure.InitUpdate(scope.ServiceProvider);
}
else
{
installerProcedure.InitInstall(scope.ServiceProvider);
}
await _dispatcher.InvokeAsync(() => DataContext = installerProcedure);
using var context = Update ? InstallerContext.CreateFrom(RunningService, scope) : new InstallerContext(scope, Path);
await Task.Delay(2_000);
var error = await installerProcedure.Install(context);
Error = error;
if (string.IsNullOrEmpty(error))
{
await Dispatcher.InvokeAsync(() => DialogResult = true);
RunningService = context.CreateRunningService();
}
else
{
await Dispatcher.InvokeAsync(() => DialogResult = false);
}
}
catch (Exception exception)
{
Error = exception.Message;
await Dispatcher.InvokeAsync(() => DialogResult = false);
}
}
public Task <bool?> Unistall(RunningService service)
{
return(_dispatcher.InvokeAsync(() =>
{
using var scope = _scopeFactory.CreateScope();
var window = scope.ServiceProvider.GetRequiredService <UnistallWindow>();
window.Owner = _mainWindow;
window.StartEvent += async() =>
{
switch (service.ServiceStade)
{
case ServiceStade.Running:
if (await _processManager.Stop(service, 20_000))
{
return DeleteService(service, window);
}
else
{
MessageBox.Show(window, "Service Konnte nicht gestopt werden", "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
public Task <bool> Start(RunningService service)
{
if (_processes.ContainsKey(service.Name))
{
return(Task.FromResult(false));
}
try
{
var process = Process.Start(Path.Combine(service.InstallationPath, service.Exe));
process.EnableRaisingEvents = true;
_processes[service.Name] = new ProcessHolder(process);
service.ServiceStade = ServiceStade.Running;
process.Exited += (sender, args) =>
{
service.ServiceStade = ServiceStade.Ready;
if (_processes.TryRemove(service.Name, out var holder))
{
holder.Dispose();
}
};
_logger.LogInformation($"Service Started: {service.Name}");
return(Task.FromResult(true));
}
catch (Exception e)
{
_logger.LogError(e, $"{service.Name}: Error on Start Process");
service.ServiceStade = ServiceStade.Error;
return(Task.FromResult(false));
}
}
public static InstallerContext CreateFrom(RunningService runningService, IServiceScope serviceScope) => new InstallerContext(runningService, serviceScope);
public ServiceTokenEntry(RunningService service, NtToken token)
{
Service = service;
ProcessToken = token.Duplicate();
}
