public static JobObject Enable(this JobObject job, IsolationLimits limits, Action <string, object> onSet = null) { if (job == null) { throw new ArgumentNullException(nameof(job)); } if (limits == null) { throw new ArgumentNullException(nameof(limits)); } job.Update(o => { if (limits.MaxMemory > 0) { o.ProcessMemoryLimit = limits.MaxMemory; onSet?.Invoke(nameof(IsolationLimits.MaxMemory), limits.MaxMemory); } if (limits.MaxCpuUsage > 0) { o.CpuRateLimit = limits.MaxCpuUsage; onSet?.Invoke(nameof(IsolationLimits.MaxCpuUsage), limits.MaxCpuUsage); } if (limits.AffinityMask != IntPtr.Zero) { o.ProcessorAffinity = limits.AffinityMask; onSet?.Invoke(nameof(IsolationLimits.AffinityMask), limits.AffinityMask); } }); return(job); }
/// <summary> /// Tries to kill the process and all child processes. /// </summary> /// <remarks> /// It's okay to call this method at any time; however, before process start and after process termination or disposing of /// this instance, it does nothing. /// </remarks> public void Kill(int exitCode) { // Notify the injected that the process is being killed m_processInjector?.OnKilled(); LogDiagnostics($"Process will be killed with exit code {exitCode}"); var processHandle = m_processHandle; if (processHandle != null && !processHandle.IsInvalid) { // Ignore result, as there is a race with regular process termination that we cannot do anything about. m_killed = true; // No job object means that we are on an old OS; let's just terminate this process (we can't reliably terminate all child processes) Analysis.IgnoreResult(Native.Processes.ProcessUtilities.TerminateProcess(processHandle, exitCode)); LogDiagnostics("DetouredProcess is killed using TerminateProcess"); } using (m_queryJobDataLock.AcquireWriteLock()) { JobObject jobObject = m_job; if (jobObject != null) { // Ignore result, as there is a race with regular shutdown. m_killed = true; Analysis.IgnoreResult(jobObject.Terminate(exitCode)); LogDiagnostics("DetouredProcess is killed via JobObject termination"); } } LogDiagnostics("Stack trace:"); LogDiagnostics(Environment.StackTrace); }
// Constructor public static JobObject CreateComponent(GameObject where, JobShopSchedulerObject jsso, int jobNum) { gameObjectRef = Instantiate(where); gameObjectRef.transform.parent = jsso.transform; JobObject job = gameObjectRef.AddComponent <JobObject>(); job.m_JobShopSchedulerObject = jsso; job.m_Tasks = new List <TaskObject>(); job.m_NumberOfTasks = 0; job.m_TotalDuration = 0; job.m_StartTime = 0; job.m_EndTime = 0; job.m_JobID = jobNum; gameObjectRef.name = "Job" + job.m_JobID; job.ColorRef = new Color( Random.Range(.25f, 1f), Random.Range(.25f, 1f), Random.Range(.25f, 1f) ); return(job); }
public ProcessTracker(IMessageTransport transport, JobObject jobObject, IProcess hostProcess, ProcessHelper processHelper) { this.transport = transport; this.jobObject = jobObject; this.hostProcess = hostProcess; this.processHelper = processHelper; }
private async Task <int> Run(HostCommandContext context, string pipeName, long maxMemory, int affinityMask, int maxCpu) { var currentProcess = SDProcess.GetCurrentProcess(); var logger = context.ServiceProvider.GetService <ILoggerFactory>().CreateLogger <HostProcessImpl>(); logger.HostProcessStart(currentProcess.Id); string name = "pihost." + currentProcess.Id; var limits = new IsolationLimits(maxMemory, maxCpu, affinityMask); if (limits.IsAnyEnabled) { s_jobObject = new JobObject(name); s_jobObject.AddProcess(currentProcess); s_jobObject.Enable(limits, (l, v) => logger.ProcessLimitSet(l, v)); } var host = new IpcServiceHostBuilder(context.ServiceProvider) .AddNamedPipeEndpoint <IHostProcess>(name, pipeName, includeFailureDetailsInResponse: true) .Build(); logger.IpcServiceHostStarting(pipeName); context.SetStartComplete(); await host.RunAsync(context.Token).ConfigureAwait(false); return(0); }
public void GuardDoesNotRetainReferenceToParentJobObject() { var st = new Stopwatch(); st.Start(); while (st.ElapsedMilliseconds < 5 * 1000) { try { using (var gJobObject = new JobObject("Global\\" + username + "-guard", true)) { break; } } catch { // retry } } Assert.False(guardProcess.HasExited); // Act this.jobObject.Dispose(); // Assert guardProcess.WaitForExit(1000); Assert.True(guardProcess.HasExited); }
public void CreateObjects() { m_JobObjects = new List <JobObject>(); m_MachineObjects = new List <MachineObject>(); for (int y = 0; y < jsd.NumMachines; y++) { m_MachineObjects.Add(MachineObject.CreateComponent(m_MachineObjectRef, this, y)); Transform machine = m_MachineObjects[y].transform.Find("Machine").GetComponent <Transform>(); machine.position = machine.position + new Vector3(10, 0, UnityEngine.Random.Range(0, 200.0f)); } for (int j = 0; j < jsd.NumJobs; j++) { JobObject currentJob = JobObject.CreateComponent(m_JobObjectRef, this, j); for (int t = 0; t < jsd.NumMachines; t++) { int machineIndex = jsd.JobTaskMachines[j][t]; int duration = jsd.JobTaskDurations[j][t]; MachineObject currentMachine = m_MachineObjects[machineIndex]; currentJob.AddTask(currentMachine, duration); } m_JobObjects.Add(currentJob); currentJob = null; } }
public ActionResult GetAllJobs(string search) { JobObject model = new JobObject(); Jobs newjobsList = new Jobs(); using (StreamReader rd = new StreamReader(@"c:\users\gontse.tauyane\documents\visual studio 2012\Projects\FlintnTinderJobApp\FlintnTinderJobApp\Jobs.json")) { string json = rd.ReadToEnd(); model = Newtonsoft.Json.JsonConvert.DeserializeObject <JobObject>(json); } //Attempting to do the search if (!String.IsNullOrEmpty(search)) { for (int i = 0; i < model.jobs.Count; i++) { if (model.jobs[i].Client.IndexOf(search, StringComparison.OrdinalIgnoreCase) != -1) { newjobsList = model.jobs[i]; } } } else { return(View(model)); } return(View(newjobsList)); }
public async Task RunAsync() { // setup a soft CPU rate limit of 10% and notification for when it is // exceeded.. var jobLimits = new JobLimits(); var jobNotifications = new JobNotifications(); jobLimits.CpuRate = new CpuRateLimit(10.0m, false); jobNotifications.CpuRate = new RateControl(RateControlInterval.Short, RateControlTolerance.Low); using (var jobObject = new JobObject(jobLimits, jobNotifications)) { // assume our working directory is the output path for the project, and that we're in // debug configuration.. jobObject.CpuRateLimitExceeded += (s, e) => { Console.WriteLine("CPU rate exceeded"); }; using (var process = jobObject.CreateProcess(new CreateProcessInfo { FileName = @"..\..\..\BusyApp\bin\Debug\BusyApp.exe" })) { await process.Exited; } } }
public void Destroy() { if (!this.isLocked) { throw new InvalidOperationException("This prison is not locked."); } Logger.Debug("Destroying prison {0}", this.ID); foreach (var cell in prisonCells) { cell.Destroy(this); } this.jobObject.TerminateProcesses(-1); this.jobObject.Dispose(); this.jobObject = null; // TODO: Should destroy delete the home directory??? // Directory.CreateDirectory(prisonRules.PrisonHomePath); this.TryStopGuard(); this.UnloadUserProfileUntilReleased(); this.DeleteUserProfile(); this.user.Delete(); SystemVirtualAddressSpaceQuotas.RemoveQuotas(new SecurityIdentifier(this.user.UserSID)); this.DeletePersistedPrirson(); }
public Container( string id, string handle, IContainerUser user, IContainerDirectory directory, IContainerPropertyService propertyService, ILocalTcpPortManager tcpPortManager, JobObject jobObject, DiskQuotaControl diskQuotaControl, IProcessRunner processRunner, IProcessRunner constrainedProcessRunner, ProcessHelper processHelper, Dictionary <string, string> defaultEnvironment, ContainerHostDependencyHelper dependencyHelper ) { this.id = id; this.handle = handle; this.user = user; this.directory = directory; this.propertyService = propertyService; this.tcpPortManager = tcpPortManager; this.jobObject = jobObject; this.diskQuotaControl = diskQuotaControl; this.processRunner = processRunner; this.constrainedProcessRunner = constrainedProcessRunner; this.processHelper = processHelper; this.dependencyHelper = dependencyHelper; this.defaultEnvironment = defaultEnvironment ?? new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); this.currentState = ContainerState.Active; }
private void InitializeJobObject() { if (this.jobObject != null) { return; } // Create the JobObject this.jobObject = new JobObject(this.user.Username); if (this.Rules.CPUPercentageLimit > 0) { this.JobObject.CPUPercentageLimit = this.Rules.CPUPercentageLimit; } if (this.Rules.TotalPrivateMemoryLimitBytes > 0) { this.JobObject.JobMemoryLimitBytes = this.Rules.TotalPrivateMemoryLimitBytes; } if (this.Rules.ActiveProcessesLimit > 0) { this.JobObject.ActiveProcessesLimit = this.Rules.ActiveProcessesLimit; } if (this.Rules.PriorityClass.HasValue) { this.JobObject.PriorityClass = this.Rules.PriorityClass.Value; } this.jobObject.KillProcessesOnJobClose = true; }
public void IsAssignedToProcess_NotAssociated() { using (var job = new JobObject()) { Assert.False(job.IsAssignedToProcess(Process.GetCurrentProcess())); } }
public void SetUILimits() { using (var job = new JobObject()) { job.SetUIRestrictions(Natives.JobObjectUILimit.ReadClipboard); } }
public void KillOnJobClose_ShouldKillProcessOnClose() { using (var job = new JobObject()) { job.SetLimits(new JobObjectLimits() { Flags = JobObjectLimitFlags.DieOnUnhandledException | JobObjectLimitFlags.KillOnJobClose, }); var psi = new ProcessStartInfo { FileName = "ping", Arguments = "127.0.0.1 -n 100", UseShellExecute = true, CreateNoWindow = true, }; using (var process = Process.Start(psi)) { Assert.False(process.WaitForExit(500)); // Ensure process is started job.AssignProcess(process); job.Close(); process.WaitForExit(); } } }
public void ProxiesToJobObject() { uint processLimit = 8765; this.Container.SetActiveProcessLimit(processLimit); JobObject.Received(1).SetActiveProcessLimit(processLimit); }
public IContainer CreateContainer(string id, string handle, IContainerUser user, IContainerDirectory directory, IContainerPropertyService propertyService, ILocalTcpPortManager tcpPortManager, JobObject jobObject, IContainerDiskQuota containerDiskQuota, IProcessRunner processRunner, IProcessRunner constrainedProcessRunner, ProcessHelper processHelper, Dictionary <string, string> defaultEnvironment, ContainerHostDependencyHelper dependencyHelper, BindMount[] bindMounts) { return(new Container( id, handle, user, directory, propertyService, tcpPortManager, jobObject, containerDiskQuota, processRunner, constrainedProcessRunner, processHelper, defaultEnvironment, dependencyHelper, bindMounts )); }
public void Dispose() { if (!m_disposed) { using (var semaphoreReleaser = m_syncSemaphore.AcquireSemaphore()) { StopWaiting(semaphoreReleaser); WaitUntilErrorAndOutputEof(true, semaphoreReleaser).GetAwaiter().GetResult(); if (m_processInjector != null) { // We may have already called Stop() in CompletionCallback, but that's okay. m_processInjector.Stop().GetAwaiter().GetResult(); m_processInjector.Dispose(); m_processInjector = null; } if (m_processHandle != null) { m_processHandle.Dispose(); m_processHandle = null; } if (m_job != null) { m_job.Dispose(); m_job = null; } } m_syncSemaphore.Dispose(); m_disposed = true; } }
/// <summary> /// Tries to kill the process and all child processes. /// </summary> /// <remarks> /// It's okay to call this method at any time; however, before process start and after process termination or disposing of /// this instance, it does nothing. /// </remarks> public void Kill(int exitCode) { // Notify the injected that the process is being killed m_processInjector?.OnKilled(); var processHandle = m_processHandle; if (processHandle != null && !processHandle.IsInvalid) { // Ignore result, as there is a race with regular process termination that we cannot do anything about. m_killed = true; // No job object means that we are on an old OS; let's just terminate this process (we can't reliably terminate all child processes) Analysis.IgnoreResult(Native.Processes.ProcessUtilities.TerminateProcess(processHandle, exitCode)); } JobObject jobObject = m_job; if (jobObject != null) { // Ignore result, as there is a race with regular shutdown. m_killed = true; Analysis.IgnoreResult(jobObject.Terminate(exitCode)); } }
public void ProxiesToJobObject() { var priority = ProcessPriorityClass.RealTime; this.Container.SetPriorityClass(priority); JobObject.Received(1).SetPriorityClass(priority); }
public void ReturnsCpuLimit() { int weight = 7; JobObject.GetJobCpuLimit().Returns(weight); Assert.Equal(weight, Container.CurrentCpuLimit()); }
public void ReturnsMemoryLimit() { ulong limitInBytes = 2048; JobObject.GetJobMemoryLimit().Returns(limitInBytes); Assert.Equal(limitInBytes, Container.CurrentMemoryLimit()); }
public void WhenManagingMultipleProcesses() { const long oneProcessPrivateMemory = 1024; TimeSpan expectedTotalKernelTime = TimeSpan.FromSeconds(2); TimeSpan expectedTotalUserTime = TimeSpan.FromSeconds(2); var expectedCpuStats = new CpuStatistics { TotalKernelTime = expectedTotalKernelTime, TotalUserTime = expectedTotalUserTime, }; var firstProcess = Substitute.For <IProcess>(); firstProcess.Id.Returns(1); firstProcess.PrivateMemoryBytes.Returns(oneProcessPrivateMemory); var secondProcess = Substitute.For <IProcess>(); secondProcess.Id.Returns(2); secondProcess.PrivateMemoryBytes.Returns(oneProcessPrivateMemory); JobObject.GetCpuStatistics().Returns(expectedCpuStats); JobObject.GetProcessIds().Returns(new int[] { 1, 2 }); ProcessHelper.GetProcesses(null).ReturnsForAnyArgs(new[] { firstProcess, secondProcess }); var metrics = Container.GetMetrics(); Assert.Equal(expectedTotalKernelTime + expectedTotalUserTime, metrics.CpuStat.TotalProcessorTime); Assert.Equal((ulong)firstProcess.PrivateMemoryBytes + (ulong)secondProcess.PrivateMemoryBytes, metrics.MemoryStat.PrivateBytes); }
public void DisposesJobObject_ThisEnsuresWeCanDeleteTheDirectory() { Container.Destroy(); JobObject.Received(1).TerminateProcessesAndWait(); JobObject.Received(1).Dispose(); }
public async Task <IActionResult> PostNewJob([FromBody] string sourceText) { ServiceEventSource.Current.ServiceMessage(this.context_, "Orchestrator param: " + sourceText); CancellationToken ct = new CancellationToken(); var jobsDictionary = await this.stateManager_.GetOrAddAsync <IReliableDictionary <Guid, JobObject> >("jobsDictionary"); var tasksQueue = await this.stateManager_.GetOrAddAsync <IReliableConcurrentQueue <MapTask> >("tasksQueue"); var allTasks = await this.stateManager_.GetOrAddAsync <IReliableDictionary <Guid, MapTask> >("allTasks"); using (ITransaction tx = this.stateManager_.CreateTransaction()) { Guid jobGuid = System.Guid.NewGuid(); JobObject job = new JobObject(jobGuid); MapTask task; int cursorPos = 0; while (cursorPos + TASK_SIZE < sourceText.Length) { int nextCursorPos = cursorPos + TASK_SIZE; while (sourceText[nextCursorPos] != ' ') { nextCursorPos--; } task = new MapTask(jobGuid, sourceText.Substring(cursorPos, nextCursorPos - cursorPos)); task.State = MapTask.StateType.InQueue; job.Tasks.Add(task.Uuid, false); await allTasks.AddAsync(tx, task.Uuid, task); await tasksQueue.EnqueueAsync(tx, task, ct); cursorPos = nextCursorPos + 1; } task = new MapTask(jobGuid, sourceText.Substring(cursorPos)); task.State = MapTask.StateType.InQueue; job.Tasks.Add(task.Uuid, false); await allTasks.AddAsync(tx, task.Uuid, task); await tasksQueue.EnqueueAsync(tx, task, ct); try { await jobsDictionary.AddAsync(tx, job.Uuid, job, TimeSpan.FromSeconds(1), ct); } catch (Exception e) { ServiceEventSource.Current.ServiceMessage(this.context_, e.Message); } await tx.CommitAsync(); return(new OkResult()); } }
public static Process ExecuteInJob(JobObject jobObject, string command, params object[] args) { var process = ExecuteWithWait(command, args); jobObject.AssignProcessToJob(process); ContinueAndWait(process); return(process); }
//Confusion, what is this for again? void LoadJob(int choice) { Debug.Log("Loading job."); JobObject loadedObjectScript = loadedJob.GetComponent <JobObject> (); loadedObjectScript.currentJob = allJobs.jobs [choice]; loadedObjectScript.jobBoard = jobBoard; }
public void SetAllJobSelectability(bool newValue) { foreach (GameObject jobObject in jobObjectList) { JobObject thisJobObject = jobObject.GetComponent <JobObject> (); thisJobObject.SetSelectability(newValue); //Debug.Log ("Set accessible."); } }
public void IsAssignedToProcess_Associated() { using var job = new JobObject(); var process = Process.GetCurrentProcess(); job.AssignProcess(process); Assert.True(job.IsAssignedToProcess(process)); }
public async Task RunAsync() { using (var jobObject = new JobObject()) { // setup some limits, we do this before starting any processes, but it's not // required.. var jobLimits = new JobLimits(); jobLimits.CpuRate = new CpuRateLimit(10.0m, false); jobLimits.Options = JobOptions.TerminateProcessesWhenJobClosed; jobLimits.ActiveProcesses = 3; jobObject.SetLimits(jobLimits); // setup a few event handlers.. jobObject.ProcessAdded += (s, e) => Console.WriteLine($"Process {e.ID} added."); jobObject.ProcessExited += (s, e) => Console.WriteLine($"Process {e.ID} exited."); jobObject.ProcessLimitExceeded += (s, e) => Console.WriteLine("Process limit exceeded."); jobObject.CpuRateLimitExceeded += (s, e) => Console.WriteLine("CPU rate limit exceeded."); // configure CPU rate notification.. var jobNotifications = new JobNotifications(); jobNotifications.CpuRate = new RateControl(RateControlInterval.Short, RateControlTolerance.Low); // start some ping processes... var cpiPing = new CreateProcessInfo { FileName = "ping.exe", ArgumentsList = { "8.8.8.8", "-t" } }; // create ping processes, directly through the JobObject, this will create the process // and associate the process with the JobObject .. for (int iIndex = 0; iIndex < 10; iIndex++) { try { using (var process = jobObject.CreateProcess(cpiPing)) Console.WriteLine($"Created Process {process.Id}"); } catch (System.ComponentModel.Win32Exception ex) when(ex.NativeErrorCode == ERROR_NOT_ENOUGH_QUOTA) { // ERROR_NOT_ENOUGH_QUOTA happens if the process cannot be assigned to the job object // because of the active process limit.. Console.WriteLine("JobObject.CreateProcess failed, due to process limit."); } } Console.WriteLine("[enter] to terminate active processes."); Console.ReadLine(); jobObject.Kill(); // wait for JobObject to become idle.. await jobObject.Idle; } }
public JobInfo CreateBulkUpsertJob(JobObject jobObject, string externalIdFieldName) { var jobInfo = new JobInfo { ContentType = ContentType.XML, Operation = Operation.upsert, JobObject = jobObject, ExternalIdFieldName = externalIdFieldName }; var jobResponse = CreateJob(jobInfo); return jobResponse; }
public void Start(int timeLimit, int memoryLimit) { try { this.jobObject = new JobObject(); this.jobObject.SetExtendedLimitInformation(PrepareJobObject.GetExtendedLimitInformation(timeLimit * 2, memoryLimit * 2)); this.jobObject.SetBasicUiRestrictions(PrepareJobObject.GetUiRestrictions()); this.jobObject.AddProcess(this.processInformation.Process); NativeMethods.ResumeThread(this.processInformation.Thread); } catch (Win32Exception) { this.Kill(); throw; } }