protected override TaskProcessResult RunExternalTaskProcess(ITask task, TaskExecutionSettings settings)
        {
            var parameters = task.Parameters;
            var outFile    = String.Format("{0}_{1}.txt", "out", task.TaskId);

            var process = new ExternalProcess {
                CommandPath      = ExecutablePath(@"ModelBatchTest/Model.exe"),
                Arguments        = String.Format("{0} {1} {2}", parameters["l0"], parameters["omega"], outFile),
                WorkingDirectory = LocalStoragePath
            };

            try
            {
                ExternalProcessResult processOutput = process.Run();
                return(TaskProcessResult.FromExternalProcessResult(processOutput, outFile));
            }
            catch (ExternalProcessException ex)
            {
                string outputInfo = "No program output";
                if (!string.IsNullOrEmpty(ex.StandardError) || !string.IsNullOrEmpty(ex.StandardOutput))
                {
                    outputInfo = Environment.NewLine + "stderr: " + ex.StandardError + Environment.NewLine + "stdout: " + ex.StandardOutput;
                }

                Log.Error("Failed to invoke command {0} {1}: exit code was {2}.  {3}", ex.CommandPath, ex.Arguments, ex.ExitCode, outputInfo);
            }
            catch (Exception ex)
            {
                Log.Error("Error in task processor: {0}", ex.ToString());
            }
            return(new TaskProcessResult {
                Success = TaskProcessSuccess.RetryableFailure
            });
        }
示例#2
0
        /// <summary>
        /// Executes the external process for processing the task
        /// </summary>
        /// <param name="task">The task to be processed.</param>
        /// <param name="settings">Contains information about the processing request.</param>
        /// <returns>The result of task processing.</returns>
        protected override TaskProcessResult RunExternalTaskProcess(ITask task, TaskExecutionSettings settings)
        {
            var taskParameters = BlenderParameters.FromTask(task);
            var initialFiles   = CollectFiles(LocalStoragePath);

            if (!taskParameters.Valid)
            {
                Log.Error(taskParameters.ErrorText);
                return(new TaskProcessResult
                {
                    Success = TaskProcessSuccess.PermanentFailure,
                    ProcessorOutput = "Parameter error: " + taskParameters.ErrorText,
                });
            }

            var inputFile  = LocalPath(taskParameters.JobFile);
            var outputFile = LocalPath(taskParameters.Prefix);

            string externalProcessPath = ExecutablePath(RenderPath);
            string externalProcessArgs = string.Format(CultureInfo.InvariantCulture, RenderArgs, inputFile, outputFile, taskParameters.Format, task.TaskIndex);

            Log.Info("Calling '{0}' with Args '{1}' for Task '{2}' / Job '{3}' .", RenderPath, externalProcessArgs, task.TaskId, task.JobId);
            var processResult = ExecuteProcess(externalProcessPath, externalProcessArgs);

            if (processResult == null)
            {
                return(new TaskProcessResult {
                    Success = TaskProcessSuccess.RetryableFailure
                });
            }

            var newFiles = GetNewFiles(initialFiles, LocalStoragePath);
            var result   = TaskProcessResult.FromExternalProcessResult(processResult, newFiles);

            var thumbnail = CreateThumbnail(task, newFiles);

            if (!string.IsNullOrEmpty(thumbnail))
            {
                var taskPreview = new TaskOutputFile
                {
                    FileName = thumbnail,
                    Kind     = TaskOutputFileKind.Preview
                };
                result.OutputFiles.Add(taskPreview);
            }
            return(result);
        }