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);
        }
Example #2
0
 /// <summary>
 /// Utility function for creating a PooledTask Instance of RTask
 /// </summary>
 /// <param name="filename">Name of repository R Script executed on the pooled task</param>
 /// <param name="directory">Directory in the repository where the R Script is located</param>
 /// <param name="author">Author of the repository R Script</param>
 /// <param name="version">Optional version of the R Script</param>
 /// <param name="options">Specification of options for the pooled task</param>
 /// <returns>PooledTask instance</returns>
 /// <remarks></remarks>
 public static RTask pooledTask(String filename,
                                String directory,
                                String author,
                                String version,
                                PooledTaskOptions options)
 {
     return(new PooledTask(filename, directory, author, version, options));
 }
Example #3
0
 /// <summary>
 /// Constructor for specifying a a Pooled Task
 /// </summary>
 /// <param name="filename">Name of repository R Script executed on the pooled task</param>
 /// <param name="directory">Directory in the repository where the R Script is located</param>
 /// <param name="author">Author of the repository R Script</param>
 /// <param name="version">Optional version of the R Script</param>
 /// <param name="options">Specification of options for the pooled task</param>
 /// <remarks></remarks>
 public PooledTask(String filename,
                   String directory,
                   String author,
                   String version,
                   PooledTaskOptions options)
 {
     m_filename  = filename;
     m_directory = directory;
     m_author    = author;
     m_version   = version;
     m_options   = options;
 }
 /// <summary>
 /// Constructor for specifying a a Pooled Task
 /// </summary>
 /// <param name="filename">Name of repository R Script executed on the pooled task</param>
 /// <param name="directory">Directory in the repository where the R Script is located</param>
 /// <param name="author">Author of the repository R Script</param>
 /// <param name="version">Optional version of the R Script</param>
 /// <param name="options">Specification of options for the pooled task</param>
 /// <remarks></remarks>
 public PooledTask(String filename,
                    String directory,
                    String author,
                    String version,
                    PooledTaskOptions options)
 {
     m_filename = filename;
     m_directory = directory;
     m_author = author;
     m_version = version;
     m_options = options;
 }
        /*
         * RTaskAppSimulator method.
         */
        public void simulateApp(RBroker rBroker)
        {
            /*
             * 2. Submit task(s) to RBroker for execution.
             */

            Console.WriteLine("About to simulate " +
                    SIMULATE_TOTAL_TASK_COUNT + " tasks at a rate of " +
                    SIMULATE_TASK_RATE_PER_MINUTE + " tasks per minutes.");

            simulationStartTime = System.Environment.TickCount;

            for(int tasksPushedToBroker = 0;
                    tasksPushedToBroker<SIMULATE_TOTAL_TASK_COUNT;
                    tasksPushedToBroker++)
            {
                try {

                    /*
                     * 1. Prepare RTask for real-time scoring.
                     *
                     * In this example, we pass along a unique
                     * customer ID with each RTask. In a real-world
                     * application the input parameters on each RTask
                     * will vary depending on need, such as customer
                     * database record keys and supplimentary parameter
                     * data to facilitate the scoring.
                     */

                    PooledTaskOptions taskOptions = new PooledTaskOptions();
                    taskOptions.routputs.Add("score");
                    taskOptions.rinputs.Add(RDataFactory.createNumeric("customerid", tasksPushedToBroker));

                    RTask rTask = RTaskFactory.pooledTask(Program.TUTORIAL_RTSCORE_SCRIPT,
                                                Program.TUTORIAL_REPO_DIRECTORY,
                                                Program.TUTORIAL_REPO_OWNER,
                                                null, taskOptions);

                    RTaskToken taskToken = rBroker.submit(rTask);
                    Console.WriteLine("Submitted task " + rTask + "\n");

                    /*
                     * If further tasks need to be pushed to broker
                     * then delay for staggeredLoadInterval to simulate
                     * control of task flow rate.
                     */
                    if(tasksPushedToBroker < (SIMULATE_TOTAL_TASK_COUNT - 1))
                    {
                        try {

                            if(SIMULATE_TASK_RATE_PER_MINUTE != 0L)
                            {
                                int staggerLoadInterval = 60 / SIMULATE_TASK_RATE_PER_MINUTE;
                                Thread.Sleep(staggerLoadInterval * 1000);
                            }

                        }
                        catch(Exception iex)
                        {
                            Console.WriteLine("Runtime exception=" + iex.ToString());
                        }
                    }
                }
                catch(Exception ex)
                {
                    Console.WriteLine("Runtime exception=" + ex.ToString());
                }
            }
        }
        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;
        }
Example #7
0
 /// <summary>
 /// Constructor for specifying a a Pooled Task
 /// </summary>
 /// <param name="externalURL">URL that represents an R Script executed on the pooled task</param>
 /// <param name="hasURL">Boolean specifying that a URL will be use to execute on the pooled task</param>
 /// <param name="options">Specification of options for the background task</param>
 /// <remarks></remarks>
 public PooledTask(String externalURL, Boolean hasURL, PooledTaskOptions options)
 {
     m_external = externalURL;
     m_options  = options;
 }
Example #8
0
 /// <summary>
 /// Constructor for specifying a a Pooled Task
 /// </summary>
 /// <param name="code">R code to be executed on the pooled task</param>
 /// <param name="options">Specification of options for the pooled task</param>
 /// <remarks></remarks>
 public PooledTask(String code, PooledTaskOptions options)
 {
     m_code    = code;
     m_options = options;
 }
Example #9
0
 /// <summary>
 /// Utility function for creating a PooledTask Instance of RTask
 /// </summary>
 /// <param name="externalURL">URL that represents an R Script executed on the pooled task</param>
 /// <param name="hasURL">Boolean specifying that a URL will be use to execute on the pooled task</param>
 /// <param name="options">Specification of options for the background task</param>
 /// <returns>PooledTask instance</returns>
 /// <remarks></remarks>
 public static RTask pooledTask(String externalURL, Boolean hasURL, PooledTaskOptions options)
 {
     return(new PooledTask(externalURL, hasURL, options));
 }
Example #10
0
 /// <summary>
 /// Utility function for creating a PooledTask Instance of RTask
 /// </summary>
 /// <param name="codeBlock">R code to be executed on the pooled task</param>
 /// <param name="options">Specification of options for the pooled task</param>
 /// <returns>PooledTask instance</returns>
 /// <remarks></remarks>
 public static RTask pooledTask(String codeBlock, PooledTaskOptions options)
 {
     return(new PooledTask(codeBlock, options));
 }
        /*
         * RTaskAppSimulator method.
         */

        public void simulateApp(RBroker rBroker)
        {
            /*
             * 2. Submit task(s) to RBroker for execution.
             */

            Console.WriteLine("About to simulate " +
                              SIMULATE_TOTAL_TASK_COUNT + " tasks at a rate of " +
                              SIMULATE_TASK_RATE_PER_MINUTE + " tasks per minutes.");

            simulationStartTime = System.Environment.TickCount;

            for (int tasksPushedToBroker = 0;
                 tasksPushedToBroker < SIMULATE_TOTAL_TASK_COUNT;
                 tasksPushedToBroker++)
            {
                try {
                    /*
                     * 1. Prepare RTask for real-time scoring.
                     *
                     * In this example, we pass along a unique
                     * customer ID with each RTask. In a real-world
                     * application the input parameters on each RTask
                     * will vary depending on need, such as customer
                     * database record keys and supplimentary parameter
                     * data to facilitate the scoring.
                     */

                    PooledTaskOptions taskOptions = new PooledTaskOptions();
                    taskOptions.routputs.Add("score");
                    taskOptions.rinputs.Add(RDataFactory.createNumeric("customerid", tasksPushedToBroker));

                    RTask rTask = RTaskFactory.pooledTask(Program.TUTORIAL_RTSCORE_SCRIPT,
                                                          Program.TUTORIAL_REPO_DIRECTORY,
                                                          Program.TUTORIAL_REPO_OWNER,
                                                          null, taskOptions);

                    RTaskToken taskToken = rBroker.submit(rTask);
                    Console.WriteLine("Submitted task " + rTask + "\n");

                    /*
                     * If further tasks need to be pushed to broker
                     * then delay for staggeredLoadInterval to simulate
                     * control of task flow rate.
                     */
                    if (tasksPushedToBroker < (SIMULATE_TOTAL_TASK_COUNT - 1))
                    {
                        try {
                            if (SIMULATE_TASK_RATE_PER_MINUTE != 0L)
                            {
                                int staggerLoadInterval = 60 / SIMULATE_TASK_RATE_PER_MINUTE;
                                Thread.Sleep(staggerLoadInterval * 1000);
                            }
                        }
                        catch (Exception iex)
                        {
                            Console.WriteLine("Runtime exception=" + iex.ToString());
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Runtime exception=" + ex.ToString());
                }
            }
        }
 /// <summary>
 /// Constructor for specifying a a Pooled Task
 /// </summary>
 /// <param name="externalURL">URL that represents an R Script executed on the pooled task</param>
 /// <param name="hasURL">Boolean specifying that a URL will be use to execute on the pooled task</param>
 /// <param name="options">Specification of options for the background task</param>
 /// <remarks></remarks>
 public PooledTask(String externalURL, Boolean hasURL, PooledTaskOptions options)
 {
     m_external = externalURL;
     m_options = options;
 }
 /// <summary>
 /// Constructor for specifying a a Pooled Task
 /// </summary>
 /// <param name="code">R code to be executed on the pooled task</param>
 /// <param name="options">Specification of options for the pooled task</param>
 /// <remarks></remarks>
 public PooledTask(String code, PooledTaskOptions options)
 {
     m_code = code;
     m_options = options;
 }