public static ProjectExecutionOptions translate(
PooledTaskOptions taskOptions)
{
ProjectExecutionOptions options = null;
if (taskOptions != null)
{
options = new ProjectExecutionOptions();
/*
* PooledTaskOptions to ProjectExecutionOptions.
*/
options.rinputs = taskOptions.rinputs;
options.csvrinputs = taskOptions.csvrinputs;
if (taskOptions.preloadWorkspace != null)
{
options.preloadWorkspace = new ProjectPreloadOptions();
options.preloadWorkspace.filename = taskOptions.preloadWorkspace.filename;
options.preloadWorkspace.directory = taskOptions.preloadWorkspace.directory;
options.preloadWorkspace.author = taskOptions.preloadWorkspace.author;
options.preloadWorkspace.version = taskOptions.preloadWorkspace.version;
}
if (taskOptions.preloadDirectory != null)
{
options.preloadDirectory = new ProjectPreloadOptions();
options.preloadDirectory.filename = taskOptions.preloadDirectory.filename;
options.preloadDirectory.directory = taskOptions.preloadDirectory.directory;
options.preloadDirectory.author = taskOptions.preloadDirectory.author;
options.preloadDirectory.version = taskOptions.preloadDirectory.version;
}
options.preloadByDirectory = taskOptions.preloadByDirectory;
options.graphicsDevice = taskOptions.graphicsDevice;
options.graphicsWidth = taskOptions.graphicsWidth;
options.graphicsHeight = taskOptions.graphicsHeight;
options.echooff = taskOptions.echooff;
options.consoleoff = taskOptions.consoleoff;
options.routputs = taskOptions.routputs;
options.encodeDataFramePrimitiveAsVector = taskOptions.encodeDataFramePrimitiveAsVector;
options.nan = taskOptions.nan;
options.infinity = taskOptions.infinity;
if (taskOptions.storageOptions != null)
{
options.storageOptions = new ProjectStorageOptions();
options.storageOptions.directory = taskOptions.storageOptions.directory;
options.storageOptions.files = taskOptions.storageOptions.files;
options.storageOptions.newVersion = taskOptions.storageOptions.newVersion;
options.storageOptions.objects = taskOptions.storageOptions.objects;
options.storageOptions.published = taskOptions.storageOptions.published;
options.storageOptions.workspace = taskOptions.storageOptions.workspace;
}
}
return(options);
}
/// <summary>
/// Implementation of the refresh method on RBroker interface
/// /// </summary>
/// <param name="config">Pooled Broker Configuration object</param>
/// <remarks></remarks>
public new void refresh(RBrokerConfig config)
{
if (!status().isIdle)
{
throw new Exception("RBroker is not idle, refresh not permitted.");
}
if (!(config is PooledBrokerConfig))
{
throw new Exception("PooledTaskBroker refresh requires PooledBrokerConfig.");
}
PooledBrokerConfig pooledConfig = (PooledBrokerConfig)config;
try
{
/*
* Temporarily disable RBroker to permit
* configuration refresh.
*/
Interlocked.Exchange(ref m_refreshingConfig, 1);
ProjectExecutionOptions options = ROptionsTranslator.migrate(pooledConfig.poolCreationOptions);
foreach (Object resourceToken in m_resourceTokenPool)
{
RProject rProject = (RProject)resourceToken;
/*
* Recycle project to remove all existing
* workspace objects and directory files.
*/
rProject.recycle();
/*
* Execute code to cause workspace and directory
* preloads and adoptions to take place.
*/
rProject.executeCode("# Refresh project on PooledTaskBroker.", options);
}
}
catch (Exception rex)
{
throw new Exception("RBroker refresh failed with unexpected error=" + rex.ToString());
}
finally
{
/*
* Re-enabled RBroker following
* configuration refresh.
*/
Interlocked.Exchange(ref m_refreshingConfig, 0);
}
}
public static ProjectExecutionOptions migrate(PoolCreationOptions poolOptions)
{
ProjectExecutionOptions options = null;
if (poolOptions != null)
{
options = new ProjectExecutionOptions();
/*
* PoolCreationOptions to ProjectExecutionOptions.
*/
options.rinputs = poolOptions.rinputs;
if (poolOptions.preloadWorkspace != null)
{
options.preloadWorkspace = new ProjectPreloadOptions();
options.preloadWorkspace.filename = poolOptions.preloadWorkspace.filename;
options.preloadWorkspace.directory = poolOptions.preloadWorkspace.directory;
options.preloadWorkspace.author = poolOptions.preloadWorkspace.author;
options.preloadWorkspace.version = poolOptions.preloadWorkspace.version;
}
if (poolOptions.preloadDirectory != null)
{
options.preloadDirectory = new ProjectPreloadOptions();
options.preloadDirectory.filename = poolOptions.preloadDirectory.filename;
options.preloadDirectory.directory = poolOptions.preloadDirectory.directory;
options.preloadDirectory.author = poolOptions.preloadDirectory.author;
options.preloadDirectory.version = poolOptions.preloadDirectory.version;
}
options.preloadByDirectory = poolOptions.preloadByDirectory;
}
return(options);
}
/// <summary>
/// Run the acutal discrete task using Project API
/// </summary>
/// <returns>Results of the pooled task</returns>
/// <remarks></remarks>
public RTaskResult call()
{
RTaskResult taskResult = null;
long timeOnCall = 0L;
//long timeOnServer = 0L;
try
{
ProjectExecutionOptions options = ROptionsTranslator.translate(m_task.options);
long startTime = Environment.TickCount;
RProjectExecution execResult = m_rProject.executeScript(m_task.filename,
m_task.directory,
m_task.author,
m_task.version,
options);
timeOnCall = Environment.TickCount - startTime;
String generatedConsole = execResult.about().console;
List <String> generatedPlots = new List <String>();
if (execResult.about().results != null)
{
foreach (RProjectResult result in execResult.about().results)
{
generatedPlots.Add(result.about().url);
}
}
List <String> generatedFiles = new List <String>();
if (execResult.about().artifacts != null)
{
foreach (RProjectFile artifact in execResult.about().artifacts)
{
generatedFiles.Add(artifact.about().url);
}
}
List <RData> generatedObjects = execResult.about().workspaceObjects;
List <String> storedFiles = new List <String>();
if (execResult.about().repositoryFiles != null)
{
foreach (RRepositoryFile repoFile in execResult.about().repositoryFiles)
{
storedFiles.Add(repoFile.about().url);
}
}
taskResult = new RTaskResultImpl(execResult.about().id,
RTaskType.POOLED,
true,
execResult.about().timeCode,
execResult.about().timeTotal,
timeOnCall, null,
false,
generatedConsole,
generatedPlots,
generatedFiles,
generatedObjects,
storedFiles);
}
catch (Exception ex)
{
//if(ex.getCause() instanceof InterruptedException)
//{
try
{
/*
* If RTaskToken.cancel() raises InterruptedException
* then ensure any corresponding execution on RProject is
* also cancelled.
*/
m_rProject.interruptExecution();
}
catch (Exception iex)
{
throw new Exception("Project cancel Exception occurred: " + iex.ToString());
}
//}
taskResult = new RTaskResultImpl(null,
RTaskType.POOLED,
false,
0L,
0L,
0L, ex);
}
finally
{
/*
* Callback to PooledTaskBroker to release
* RProject back into pool for other tasks.
*/
m_rBroker.callback(m_task, taskResult);
}
return(taskResult);
}
