/// <summary> /// cloneTask override method for PooledTaskBroker. /// </summary> /// <remarks></remarks> protected override RTask cloneTask(RTask genesis) { PooledTask source = (PooledTask)genesis; PooledTask clone = null; if (source.code != "") { clone = new PooledTask(source.code, source.options); } else { clone = new PooledTask(source.filename, source.directory, source.author, source.version, source.options); } if (source.external != "") { clone.external = source.external; } clone.setToken(source.getToken()); return(clone); }
static public void Execute() { try { /* * 1. Create RBroker instance using RBrokerFactory. * * This example creates a DiscreteTaskBroker. */ DiscreteBrokerConfig brokerConfig = new DiscreteBrokerConfig(Program.DEPLOYR_ENDPOINT); RBroker rBroker = RBrokerFactory.discreteTaskBroker(brokerConfig); /* * 2. Register RTaskListener for asynchronous * notifications on RTask completion. */ SampleTaskBrokerListener sampleListeners = new SampleTaskBrokerListener(rBroker); rBroker.addTaskListener(sampleListeners); rBroker.addBrokerListener(sampleListeners); /* * 3. Define RTask * * This example creates a DiscreteTask that will * execute an R script, /testuser/tutorial-rbroker/5SecondNoOp. */ RTask rTask = RTaskFactory.discreteTask(Program.TUTORIAL_NOOP_SCRIPT, Program.TUTORIAL_REPO_DIRECTORY, Program.TUTORIAL_REPO_OWNER, "", null); /* * 4. Submit RTask to RBroker for execution. * * The RTaskToken is returned immediately. You can * use the token to track the progress of RTask * and/or block while waiting for a result. * * However, in this example we are going to allow * the RTaskListener handle the result so * there is nothing further for us to do here after * we submit the RTask. */ RTaskToken rTaskToken = rBroker.submit(rTask); Console.WriteLine("DiscreteProfiling: submitted " + rTask + " for execution on RBroker."); } catch (Exception tex) { Console.WriteLine("DiscreteProfiling: ex=" + tex.ToString()); } }
/** * Prints {@link com.revo.deployr.client.broker.RTaskResult} * to console output. */ public static void printRTaskResult(RTask task, RTaskResult result, String error) { Console.WriteLine("\nTask: " + task); if(error != null) { Console.WriteLine("Status[fail]: cause=" + error); } else { switch(result.getType()) { case RTaskType.DISCRETE: if(result.isSuccess()) { Console.WriteLine("Status[ok]: [ code : " + result.getTimeOnCode() + " , server : " + result.getTimeOnServer() + " , call : " + result.getTimeOnCall() + " ]"); } else { Console.WriteLine("Status[fail]: cause=" + result.getFailure()); } break; case RTaskType.POOLED: if(result.isSuccess()) { Console.WriteLine("Status[ok]: [ code : " + result.getTimeOnCode() + " , server : " + result.getTimeOnServer() + " , call : " + result.getTimeOnCall() + " ]"); } else { Console.WriteLine("Status[fail]: cause=" + result.getFailure()); } break; case RTaskType.BACKGROUND: if(result.isSuccess()) { Console.WriteLine("Status[ok]: [ server : " + result.getTimeOnServer() + " , call : " + result.getTimeOnCall() + " ]"); } else { Console.WriteLine("Status[fail]: cause=" + result.getFailure()); } break; } } }
public async Task UpdateTask(int id, RTask task) { RTask UpdatedTask = await taskRepository.UpdateTaskById(id, task); if (UpdatedTask != null) { await taskRepository.SaveChanges(); } }
public void onTaskError(RTask rTask, String error) { Console.WriteLine("BackgroundBasics: onTaskError: " + rTask + ", error: " + error); if (m_rBroker != null) { m_rBroker.shutdown(); Console.WriteLine("BackgroundBasics: rBroker has been shutdown."); } }
/** * Prints {@link com.revo.deployr.client.broker.RTaskResult} * to console output. */ public static void printRTaskResult(RTask task, RTaskResult result, String error) { Console.WriteLine("\nTask: " + task); if (error != null) { Console.WriteLine("Status[fail]: cause=" + error); } else { switch (result.getType()) { case RTaskType.DISCRETE: if (result.isSuccess()) { Console.WriteLine("Status[ok]: [ code : " + result.getTimeOnCode() + " , server : " + result.getTimeOnServer() + " , call : " + result.getTimeOnCall() + " ]"); } else { Console.WriteLine("Status[fail]: cause=" + result.getFailure()); } break; case RTaskType.POOLED: if (result.isSuccess()) { Console.WriteLine("Status[ok]: [ code : " + result.getTimeOnCode() + " , server : " + result.getTimeOnServer() + " , call : " + result.getTimeOnCall() + " ]"); } else { Console.WriteLine("Status[fail]: cause=" + result.getFailure()); } break; case RTaskType.BACKGROUND: if (result.isSuccess()) { Console.WriteLine("Status[ok]: [ server : " + result.getTimeOnServer() + " , call : " + result.getTimeOnCall() + " ]"); } else { Console.WriteLine("Status[fail]: cause=" + result.getFailure()); } break; } } }
public void onTaskCompleted(RTask rTask, RTaskResult rTaskResult) { Console.WriteLine("DiscreteAsynchronous: onTaskCompleted: " + rTask.ToString() + ", result: " + rTaskResult.getTimeOnCall()); if (m_rBroker != null) { m_rBroker.shutdown(); Console.WriteLine("DiscreteAsynchronous: rBroker has been shutdown."); } }
/// <summary> /// Implementation of the submit method on RBroker interface. /// Allows applications to submit a new Task for execution. /// </summary> /// <param name="task">RTask to be submitted for execution as a discrete task</param> /// <param name="priority">priority of task. If TRUE, then task has a high priority</param> /// <returns>RTaskToken for this RTask</returns> /// <remarks></remarks> public new RTaskToken submit(RTask task, Boolean priority) { DiscreteTask discreteTask = (DiscreteTask)task; if (m_rUser == null && discreteTask.external != "") { throw new Exception("External script task execution not permitted on anonymous broker."); } return(submit(task, priority)); }
/// <summary> /// createBrokerWorker override method for PooledTaskBroker. /// </summary> /// <remarks></remarks> protected override RBrokerWorker createBrokerWorker(RTask task, long taskIndex, Boolean isPriorityTask, Object resourceToken, RBrokerEngine brokerEngine) { return(new PooledTaskWorker((PooledTask)task, taskIndex, isPriorityTask, (RProject)resourceToken, brokerEngine)); }
public async Task <IActionResult> UpdateTask(int taskId, RTask task) { try { await taskService.UpdateTask(taskId, task); return(Ok()); } catch (Exception e) { return(BadRequest(e.Message)); } }
/// <summary> /// createBrokerWorker override method for BackgroundTaskBroker. /// </summary> /// <remarks></remarks> protected override RBrokerWorker createBrokerWorker(RTask task, long taskIndex, Boolean isPriorityTask, Object resourceToken, RBrokerEngine brokerEngine) { return(new BackgroundTaskWorker((BackgroundTask)task, taskIndex, isPriorityTask, m_rUser, (int)resourceToken, (RBroker)brokerEngine)); }
/// <summary> /// Returns a resource token for the task back to the token pool. /// /// </summary> /// <param name="task">RTask submitted for execution as a background task</param> /// <param name="result">RTaskResult containing the results of the completed task</param> /// <remarks></remarks> public override void callback(RTask task, RTaskResult result) { Object obj; m_taskResourceTokenMap.TryGetValue(task, out obj); int resourceToken = (int)obj; Boolean added = m_resourceTokenPool.TryAdd(resourceToken); if(!added) { throw new Exception("BackgroundTaskBroker: callback, project could not be added back to pool, ???????."); } }
/// <summary> /// createBrokerWorker override method for DiscreteTaskBroker. /// </summary> /// <remarks></remarks> protected override RBrokerWorker createBrokerWorker(RTask task, long taskIndex, Boolean isPriorityTask, Object resourceToken, RBrokerEngine brokerEngine) { return(new DiscreteTaskWorker((DiscreteTask)task, taskIndex, isPriorityTask, m_rClient, (int)resourceToken, (RBroker)brokerEngine)); }
/// <summary> /// Returns a resource token for the task back to the token pool. /// /// </summary> /// <param name="task">RTask submitted for execution as a background task</param> /// <param name="result">RTaskResult containing the results of the completed task</param> /// <remarks></remarks> public override void callback(RTask task, RTaskResult result) { Object obj; m_taskResourceTokenMap.TryGetValue(task, out obj); int resourceToken = (int)obj; Boolean added = m_resourceTokenPool.TryAdd(resourceToken); if (!added) { throw new Exception("BackgroundTaskBroker: callback, project could not be added back to pool, ???????."); } }
public async Task <RTask> AddTaskInProject(string userId, int projectId, RTask newTask) { if (newTask != null) { newTask.CreatorId = userId; newTask.ProjectId = projectId; await taskRepository.SaveTask(newTask); await taskRepository.SaveChanges(); return(newTask); } throw new NullReferenceException("task must be valid"); }
// public async Task<bool> DeleteTask(int taskId) // { // if (await IsTaskExist(taskId)) // { // await checkPointService.DeleteCheckPointByParentTask(taskId); // var task = await taskRepository.DeleteTaskById(taskId); // await sessionService.DeleteSessionByTask(taskId); // await attachmentService.DeleteAttachmentByTask(taskId); // await commentService.DeleteCommentByTask(taskId); // await taskRepository.RemoveUserTaksbyTask(taskId); // return await taskRepository.SaveChanges(); // } // return false; // } // public async Task<bool> DeleteTaskByTeam(int teamId) // { // var Rtasks = await taskRepository.GetTasksByTeam(teamId); // if(Rtasks.Count().Equals(0)) // { // return false; // } // foreach(RTask rTask in Rtasks) // { // await DeleteTask(rTask.Id); // } // return true; // } public async Task <int> AddNewSubTask(string userId, int parentCheckpointId, RTask task) { if (!await checkpointRepository.IsCheckpointExist(parentCheckpointId)) { throw new Exception("checkpoint not exist"); } task.ParentCheckPointId = parentCheckpointId; task.CreatorId = userId; await taskRepository.SaveTask(task); await taskRepository.SaveChanges(); return(task.Id); }
public async Task <IActionResult> AddTaskInTeam(int teamId, RTask task) { try { return(Ok(await taskService.AddTaskInTeam(userService.GetUserId(), teamId, task))); } catch (NullReferenceException e) { return(BadRequest(e.Message)); } catch (Exception e) { return(NotFound(e.Message)); } }
public async Task <IActionResult> AddTaskInProject(int projectId, RTask task) { try { var newTask = await taskService.AddTaskInProject(userService.GetUserId(), projectId, task); return(Ok(newTask)); } catch (NullReferenceException e) { return(BadRequest(e.Message)); } catch (Exception e) { return(NotFound(e.Message)); } }
/* * RTaskAppSimulator method. */ public void simulateApp(RBroker rBroker) { /* * 1. Prepare RTask(s) for simulation. * * In the example we will simply simulate the execution * a fixed number of RTask. * * Note, this is a somewhat artificial demo as we are * executing the same RTask SIMULATE_TOTAL_TASK_COUNT * times. You can experiment by modifying the * implementation to execute a range of RTask of * your own choosing. */ RTask rTask = RTaskFactory.discreteTask(Program.TUTORIAL_NOOP_SCRIPT, Program.TUTORIAL_REPO_DIRECTORY, Program.TUTORIAL_REPO_OWNER, "", null); /* * 2. Loop submitting SIMULATE_TOTAL_TASK_COUNT * task(s) to RBroker for execution. */ simulationStartTime = System.Environment.TickCount; for (int tasksPushedToBroker = 0; tasksPushedToBroker < SIMULATE_TOTAL_TASK_COUNT; tasksPushedToBroker++) { try { RTaskToken taskToken = rBroker.submit(rTask); Console.WriteLine("simulateApp: submitted task " + rTask + " for execution on RBroker."); } catch (Exception ex) { Console.WriteLine("simulateApp: ex=" + ex.ToString()); } } }
//not completed public async Task <RTask> DeleteTaskById(int taskId) { RTask task = await context.Tasks.Include(t => t.DependantTasks) .Where(t => t.Id == taskId) .FirstOrDefaultAsync(); foreach (var dependantTask in task.DependantTasks) { await DeleteTaskById(dependantTask.Id); } if (task != null) { context.Tasks.Remove(task); } return(task); }
public async Task <int> AddTaskInTeam(string userId, int teamId, RTask newTask) { if (!await teamRepository.IsTeamExist(teamId)) { throw new Exception("team not exist"); } if (newTask != null) { if (DateTime.Compare(newTask.PlannedStartDate, newTask.PlannedEndDate) >= 0) { throw new DateTimeException(newTask.PlannedStartDate.Date.ToString(), newTask.PlannedEndDate.Date.ToString()); } newTask.CreatorId = userId; newTask.TeamId = teamId; await taskRepository.SaveTask(newTask); await taskRepository.SaveChanges(); } return(newTask.Id); }
/// <summary> /// cloneTask override method for DiscreteTaskBroker. /// </summary> /// <remarks></remarks> protected override RTask cloneTask(RTask genesis) { DiscreteTask source = (DiscreteTask)genesis; DiscreteTask clone = null; if (source.external != "") { String externalURL = source.external; clone = new DiscreteTask(externalURL, source.options); } else { clone = new DiscreteTask(source.filename, source.directory, source.author, source.version, source.options); } clone.setToken(source.getToken()); return(clone); }
/// <summary> /// Returns a resource token for the task back to the token pool. /// </summary> /// <param name="task">RTask submitted for execution as a background task</param> /// <param name="result">RTaskResult containing the results of the completed task</param> /// <remarks></remarks> public override void callback(RTask task, RTaskResult result) { Object obj; m_taskResourceTokenMap.TryGetValue(task, out obj); RProject rProject = (RProject)obj; /* * Check for Grid Exception */ Boolean bGridException = false; Exception failure = result.getFailure(); if (failure != null) { if (failure.GetType() == typeof(HTTPRestException)) { HTTPRestException ex = (HTTPRestException)failure; if (ex.errorCode >= 910 || ex.errorCode ==403) { bGridException = true; } } } if (bGridException == true) { /* * On detection of an RGridException drop the RProject from * the pool so further tasks are not directed to that RProject. * We achieve this by simply not adding the RProject back to the * resourceTokenPool on this callback. * * We then need to adjust the parallelTaskLimit so the RBroker * will report the new (smaller) pool size on * RBroker.maxConcurrency() calls. */ if (m_taskListener != null) { /* * When asynchronous listener in use, failed task * executions due to slot or grid failures can be * automatically resubmitted for execution by the RBroker. * * When RTaskResult.repeatTask is enabled the * RBrokerEngine.RBrokerListenerManager will skip * calling taskListener.onTaskCompleted(task, result). * This prevents a client application from seeing * (or having to handle) temporary slot or grid related * failures on RTasks. */ RTaskResultImpl resultImpl = (RTaskResultImpl)result; resultImpl.repeatTask = true; /* * Now re-submit for execution using the priority * queue to expedite processing. */ try { submit(task, true); } catch (Exception tex) { throw new Exception("PooledTaskBroker: callback, task re-submission ex=" + tex.ToString()); } } int resizedPoolSize = (int)Interlocked.Decrement(ref m_parallelTaskLimit); if (m_brokerListener != null) { Exception rbex; if (resizedPoolSize == 0) { rbex = new Exception("DeployR grid failure detected, pool no longer operational, advise RBroker shutdown."); } else { rbex = new Exception("DeployR grid failure detected, pool size auto-adjusted, max concurrency now " + resizedPoolSize + "."); } m_brokerListener.onRuntimeError(rbex.Message); } } else { if (rProject != null) { Boolean added = m_resourceTokenPool.TryAdd(rProject); if (!added) { throw new Exception("PooledTaskBroker: callback, project could not be added back to pool?"); } } else { throw new Exception("PooledTaskBroker: callback, task does not have matching project?"); } } }
/* * RBrokerAsyncListener methods. */ public void onTaskCompleted(RTask rTask, RTaskResult rTaskResult) { RBrokerStatsHelper.printRTaskResult(rTask, rTaskResult, null); Console.WriteLine("onTaskCompleted: " + rTask + ", score " + ((RNumeric)rTaskResult.getGeneratedObjects()[0]).Value); }
/// <summary> /// createBrokerWorker override method for BackgroundTaskBroker. /// </summary> /// <remarks></remarks> protected override RBrokerWorker createBrokerWorker(RTask task, long taskIndex, Boolean isPriorityTask, Object resourceToken, RBrokerEngine brokerEngine) { return new BackgroundTaskWorker((BackgroundTask) task, taskIndex, isPriorityTask, m_rUser, (int) resourceToken, (RBroker) brokerEngine); }
/// <summary> /// Implementation of the submit method on RBroker interface. /// Allows applications to submit a new Task for execution. /// </summary> /// <param name="task">RTask to be submitted for execution as a background task</param> /// <param name="priority">priority of task. If TRUE, then task has a high priority</param> /// <returns>RTaskToken for this RTask</returns> /// <remarks></remarks> public new RTaskToken submit(RTask task, Boolean priority) { return submit(task, priority); }
/// <summary> /// Implementation of RBroker Interface 'submit' method /// </summary> /// <param name="task">RTask submitted to the RBroker for execution</param> /// <returns>RTaskToken reference</returns> /// <remarks></remarks> public RTaskToken submit(RTask task) { return submit(task, false); }
public void onTaskError(RTask rTask, String error) { Console.WriteLine("DiscreteProfiling: onTaskError: " + rTask + ", error: " + error); RBrokerStatsHelper.printRTaskResult(rTask, null, error); }
/// <summary> /// Asynchronous callback notification when a TaskToken is returned to the pool. /// </summary> /// <param name="task">The RTask instance</param> /// <param name="future">The Operating System task reference</param> /// <remarks></remarks> public void onTask(RTask task, Task<RTaskResult> future) { m_future = future; }
public void onTaskError(RTask rTask, String error) { Console.WriteLine("DiscreteAsynchronous: onTaskError: " + rTask + ", error: " + error); }
internal RTaskTokenImpl(RTask task) { m_task = task; }
/// <summary> /// Asynchronous callback notification when a TaskToken is returned to the pool. /// </summary> /// <param name="task">The RTask instance</param> /// <param name="future">The Operating System task reference</param> /// <remarks></remarks> public void onTask(RTask task, Task <RTaskResult> future) { m_future = future; }
internal RTaskTokenImpl(RTask task, Task <RTaskResult> future) { m_task = task; m_future = future; }
public void onTaskCompleted(RTask rTask, RTaskResult rTaskResult) { Console.WriteLine("onTaskCompleted: " + rTask + ", result: " + rTaskResult); /* * Retrieve Job identifier from RTaskResult. */ String jobID = rTaskResult.getID(); Console.WriteLine("onTaskCompleted: " + rTask + ", background Job ID: " + jobID); if(m_rBroker != null) { /* * Important: * * To handle the results of a Background RTask you * must transition from using the RBroker Framework * API to using the .NET Client Library API. */ RUser rUser = m_rBroker.owner(); if(rUser != null) { try { RJob rJob = rUser.queryJob(jobID); Console.WriteLine("onTaskCompleted: " +rTask + ", rJob: " + rJob); /* * Next handle the result of the RJob as appropriate. * In this example, simly cancel and delete the job. */ try { rJob.cancel(); } catch(Exception cex) { Console.WriteLine("rJob.cancel ex=" + cex.ToString()); } try { rJob.delete(); } catch(Exception dex) { Console.WriteLine("rJob.delete ex=" + dex.ToString()); } } catch(Exception jex) { Console.WriteLine("rUser.queryJob ex=" + jex.ToString()); } } m_rBroker.shutdown(); Console.WriteLine("BackgroundBasics: rBroker has been shutdown."); } }
/// <summary> /// cloneTask method that must be implemented by /// concrete implementation of RBrokerEngine. /// /// Responsible for cloning an RTask. /// </summary> /// <remarks></remarks> protected abstract RTask cloneTask(RTask genesis);
public void onTaskError(RTask rTask, String error) { Console.WriteLine("BackgroundBasics: onTaskError: " + rTask + ", error: " + error); if(m_rBroker != null) { m_rBroker.shutdown(); Console.WriteLine("BackgroundBasics: rBroker has been shutdown."); } }
// not working public async Task <RTask> UpdateTaskById(int taskId, RTask task) { var newTask = await context.Tasks .Include(t => t.ChildCheckPoints) .Where(t => t.Id == taskId).SingleOrDefaultAsync(); if (newTask != null) { if (task.Name != null) { newTask.Name = task.Name; } if (task.Description != null) { newTask.Description = task.Description; } if (!(DateTime.Compare(task.PlannedStartDate, new DateTime(1, 1, 1)) == 0)) { Console.WriteLine("planned start date ==============>" + task.PlannedStartDate); newTask.PlannedStartDate = task.PlannedStartDate; } if (!(DateTime.Compare(task.PlannedEndDate, new DateTime(1, 1, 1)) == 0)) { Console.WriteLine("planned end date ==============>" + task.PlannedEndDate); newTask.PlannedEndDate = task.PlannedEndDate; } if (task.ChildCheckPoints != null) { foreach (var c in task.ChildCheckPoints) { if (c.Id == 0) { c.ParentRTaskId = taskId; await context.CheckPoints.AddAsync(c); } else { var checkpointNeededToUpdate = await context .CheckPoints .Where(checkpoint => checkpoint.Id == c.Id) .SingleOrDefaultAsync(); if (checkpointNeededToUpdate == null) { throw new Exception(" checkpoints not exist"); } if (c.CheckpointText != null) { checkpointNeededToUpdate.CheckpointText = c.CheckpointText; } if (c.Description != null) { checkpointNeededToUpdate.Description = c.Description; } if (c.Percentage != 0) { checkpointNeededToUpdate.Percentage = c.Percentage; } } } } return(newTask); } return(null); }
/// <summary> /// createBrokerWorker override method for PooledTaskBroker. /// </summary> /// <remarks></remarks> protected override RBrokerWorker createBrokerWorker(RTask task, long taskIndex, Boolean isPriorityTask, Object resourceToken, RBrokerEngine brokerEngine) { return new PooledTaskWorker((PooledTask) task, taskIndex, isPriorityTask, (RProject) resourceToken, brokerEngine); }
/// <summary> /// cloneTask override method for BackgroundTaskBroker. /// </summary> /// <remarks></remarks> protected override RTask cloneTask(RTask genesis) { BackgroundTask source = (BackgroundTask) genesis; BackgroundTask clone = null; if(source.code != "") { clone = new BackgroundTask(source.name, source.description, source.code, source.options); } else { clone = new BackgroundTask(source.name, source.description, source.filename, source.directory, source.author, source.version, source.options); } if(source.external != "") { clone.external = source.external; } clone.setToken(source.getToken()); return clone; }
public void onTaskCompleted(RTask rTask, RTaskResult rTaskResult) { Console.WriteLine("DiscreteProfiling: onTaskCompleted: " + rTask + ", result: " + rTaskResult.getTimeOnCall()); RBrokerStatsHelper.printRTaskResult(rTask, rTaskResult, null); }
/* * RBrokerAsyncListener methods. */ public void onTaskCompleted(RTask rTask, RTaskResult rTaskResult) { RBrokerStatsHelper.printRTaskResult(rTask, rTaskResult, null); }
/// <summary> /// createBrokerWorker override method for DiscreteTaskBroker. /// </summary> /// <remarks></remarks> protected override RBrokerWorker createBrokerWorker(RTask task, long taskIndex, Boolean isPriorityTask, Object resourceToken, RBrokerEngine brokerEngine) { return new DiscreteTaskWorker((DiscreteTask) task, taskIndex, isPriorityTask, m_rClient, (int) resourceToken, (RBroker) brokerEngine); }
public void onTaskError(RTask rTask, String error) { RBrokerStatsHelper.printRTaskResult(rTask, null, error); }
static public void Execute() { RBroker rBroker = null; try { /* * 1. Create RBroker instance using RBrokerFactory. * * This example creates a DiscreteTaskBroker. */ DiscreteBrokerConfig brokerConfig = new DiscreteBrokerConfig(Program.DEPLOYR_ENDPOINT); rBroker = RBrokerFactory.discreteTaskBroker(brokerConfig); /* * 2. Define RTask * * This example creates a DiscreteTask that will * execute an R script, /testuser/tutorial-rbroker/5SecondNoOp. */ RTask rTask = RTaskFactory.discreteTask(Program.TUTORIAL_NOOP_SCRIPT, Program.TUTORIAL_REPO_DIRECTORY, Program.TUTORIAL_REPO_OWNER, "", null); /* * 3. Submit RTask to RBroker for execution. * * Note, unlike an RClient.executeScript call or * an RProject.executeScript call the RBroker.submit * call is non-blocking. * * The RTaskToken is returned immediately. You can * use the token to track the progress of RTask * and/or block while waiting for a result. */ RTaskToken rTaskToken = rBroker.submit(rTask); Console.WriteLine("DiscreteBlocking: submitted " + rTask + " for execution on RBroker."); /* * 4. Demonstrate blocking for an RTask result. * * The call to getResult() will either return * an RTaskResult or raise an Exception. An Exception * indicates the RTask failed to complete and why. */ RTaskResult rTaskResult = rTaskToken.getResult(); Console.WriteLine("DiscreteBlocking: " + rTask + " completed, result=" + rTaskResult.getTimeOnCall()); } catch (Exception tex) { Console.WriteLine("DiscreteBlocking: error=" + tex.ToString()); } finally { /* * Final Step: Shutdown RBroker to release * all associated resources, connections. */ if (rBroker != null) { rBroker.shutdown(); Console.WriteLine("DiscreteBlocking: rBroker has been shutdown."); } } }
public void onTaskCompleted(RTask rTask, RTaskResult rTaskResult) { Console.WriteLine("onTaskCompleted: " + rTask + ", result: " + rTaskResult); /* * Retrieve Job identifier from RTaskResult. */ String jobID = rTaskResult.getID(); Console.WriteLine("onTaskCompleted: " + rTask + ", background Job ID: " + jobID); if (m_rBroker != null) { /* * Important: * * To handle the results of a Background RTask you * must transition from using the RBroker Framework * API to using the .NET Client Library API. */ RUser rUser = m_rBroker.owner(); if (rUser != null) { try { RJob rJob = rUser.queryJob(jobID); Console.WriteLine("onTaskCompleted: " + rTask + ", rJob: " + rJob); /* * Next handle the result of the RJob as appropriate. * In this example, simly cancel and delete the job. */ try { rJob.cancel(); } catch (Exception cex) { Console.WriteLine("rJob.cancel ex=" + cex.ToString()); } try { rJob.delete(); } catch (Exception dex) { Console.WriteLine("rJob.delete ex=" + dex.ToString()); } } catch (Exception jex) { Console.WriteLine("rUser.queryJob ex=" + jex.ToString()); } } m_rBroker.shutdown(); Console.WriteLine("BackgroundBasics: rBroker has been shutdown."); } }
static public void Execute() { try { /* * 1. Create RBroker instance using RBrokerFactory. * * This example creates a BackgroundTaskBroker. */ RAuthentication rAuth = new RBasicAuthentication(Program.AUTH_USER_NAME, Program.AUTH_PASSWORD); BackgroundBrokerConfig brokerConfig = new BackgroundBrokerConfig(Program.DEPLOYR_ENDPOINT, rAuth); RBroker rBroker = RBrokerFactory.backgroundTaskBroker(brokerConfig); /* * 2. Register RTaskListener for asynchronous * notifications on RTask completion. */ BackgroundTaskListener myTaskListener = new BackgroundTaskListener(rBroker); rBroker.addTaskListener(myTaskListener); /* * 3. Define RTask * * This example creates a BackgroundTask that will * execute an artibrary block of R code. */ String rCode = "x <- rnorm(100)"; RTask rTask = RTaskFactory.backgroundTask("Example Background RTask", "Example background RTask.", rCode, null); /* * 4. Submit RTask to RBroker for execution. * * The RTaskToken is returned immediately. You can * use the token to track the progress of RTask * and/or block while waiting for a result. * * However, in this example we are going to allow * the RTaskListener handle the result so * there is nothing further for us to do here after * we submit the RTask. */ RTaskToken rTaskToken = rBroker.submit(rTask); Console.WriteLine("Submitted " + rTask + " for execution on RBroker."); /* * 4. Block until all tasks are complete, and shutdown has been called */ rBroker.waitUntilShutdown(); } catch (Exception tex) { Console.WriteLine("Runtime exception=" + tex.ToString()); } }
/// <summary> /// cloneTask override method for DiscreteTaskBroker. /// </summary> /// <remarks></remarks> protected override RTask cloneTask(RTask genesis) { DiscreteTask source = (DiscreteTask) genesis; DiscreteTask clone = null; if(source.external != "") { String externalURL = source.external; clone = new DiscreteTask(externalURL, source.options); } else { clone = new DiscreteTask(source.filename, source.directory, source.author, source.version, source.options); } clone.setToken(source.getToken()); return clone; }
/// <summary> /// Callback for RBrokerWorker. Must be implemented by /// concrete implementation of RBrokerEngine. /// /// Responsible for adding an engineResourceToken /// back into the RBrokerEngine resourceTokenPool, /// making the token available for use by another /// RTask. /// </summary> /// <param name="task">RTask reference</param> /// <param name="result">RTaskResult reference</param> /// <remarks></remarks> public abstract void callback(RTask task, RTaskResult result);
/// <summary> /// Implementation of the submit method on RBroker interface. /// Allows applications to submit a new Task for execution. /// </summary> /// <param name="task">RTask to be submitted for execution as a discrete task</param> /// <param name="priority">priority of task. If TRUE, then task has a high priority</param> /// <returns>RTaskToken for this RTask</returns> /// <remarks></remarks> public new RTaskToken submit(RTask task, Boolean priority) { DiscreteTask discreteTask = (DiscreteTask) task; if(m_rUser == null && discreteTask.external != "") { throw new Exception("External script task execution not permitted on anonymous broker."); } return submit(task, priority); }
/// <summary> /// Implementation of RBroker Interface 'submit' method /// </summary> /// <param name="task">RTask submitted to the RBroker for execution</param> /// <param name="priority">Boolean indicating this is a high priority task</param> /// <returns>RTaskToken reference</returns> /// <remarks></remarks> public RTaskToken submit(RTask task, Boolean priority) { if(Interlocked.Read(ref m_refreshingConfig) == 1) { Console.WriteLine("RTask submissions temporarily disabled while RBroker configuration refreshes."); } try { /* * We clone the incoming RTask into a new instance of * RTask to ensure RTask is unique so it can be used * as a key inside the taskTokenListenerMap. * * How could the value of RTask param not be unique? * * For example, RBrokerAppSimulator apps frequently * create a single RTask instance and submit it many times * to simulate load. */ RTask clonedTask = cloneTask(task); Boolean added = false; if(priority) { added = m_pendingHighPriorityQueue.TryAdd(clonedTask); } else { added = m_pendingLowPriorityQueue.TryAdd(clonedTask); } if(!added) { throw new Exception("Broker at capacity ( " + MAX_TASK_QUEUE_SIZE + " ), rejecting task " + clonedTask); } RTaskToken rTaskToken = new RTaskTokenImpl(task); /* * RTask now on pending[High,Low]PriorityQueue, * appending associated RTaskToken to end of * liveTaskTokens. */ m_liveTaskTokens.Add(rTaskToken); /* * Register RTask and associated RTaskToken here. * Once RTask has been submitted to Executor and * Future for task exists, we will make an * RTaskToken.onTask callback to register Future * on token. */ m_taskTokenListenerMap.TryAdd(clonedTask, rTaskToken); return rTaskToken; } catch(Exception rex) { throw new Exception("RBroker: submit failed, cause: " + rex.ToString()); } }
public async Task SaveTask(RTask task) { await context.Tasks.AddAsync(task); }
/// <summary> /// createBrokerWorker method that must be implemented by /// concrete implementation of RBrokerEngine. /// /// Responsible for creating a RBrokerWorker for a task. /// </summary> /// <remarks></remarks> protected abstract RBrokerWorker createBrokerWorker(RTask task, long taskIndex, Boolean isPriorityTask, Object resourceToken, RBrokerEngine brokerEngine);
internal RTaskTokenImpl(RTask task, Task<RTaskResult> future) { m_task = task; m_future = future; }