Production Queue Manager (.NET)

The Production Queue contains all production jobs currently running in your Relativity environment. For general information, see Production Queue on the RelativityOne Documentation site.

The Production Queue Manager API exposes methods used to cancel a single or multiple production jobs, to retry multiple jobs, or to set the priority for them. You can identify the jobs for canceling or retrying by mass operation token or Artifact ID.

You can also use the Production Queue Manager API through REST. For more information, see Production Queue Manager (REST).

See these related pages:

The Relativity.Productions.Client contains this API. For compatibility and package installation instructions, see Download the SDKs and NuGet packages.

Fundamentals for the Production Queue Manager API

The Production Queue Manager API contains the following methods and classes.

The Production Queue Manager API exposes the following methods on the Services.<VersionNumber>.IProductionQueueManager interface:

The Production Queue Manager API contains multiple methods that take objects instantiated from the ProductionJobRef class. This class has the following properties:

  • JobID - the Artifact ID of a production job.
  • ProductionID - the Artifact ID of a production.
  • WorkspaceID - the Artifact ID of the workspace that contains the production.

Cancel a production job

Use the CancelJobAsync() method to cancel a single production job. Pass a ProductionJobRef object with the following properties to this method:

  • WorkspaceID - the Artifact ID of the workspace containing the production job.
  • ProductionID - the Artifact ID of the production.
public partial class Example
{
    public async Task CancelJob_Example()
    {
        var userEmail = "user@test.com"; // User login
        var password = "abc123456!"; // User password
 
        var relativityRestUri = "http://localhost/relativity.rest/api";
 
        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
        ServiceFactorySettings settings = new ServiceFactorySettings(
            new Uri(relativityRestUri),
            usernamePasswordCredentials);
        ServiceFactory serviceFactory = new ServiceFactory(settings);
 
        using (IProductionQueueManager productionQueueManager = serviceFactory.CreateProxy<IProductionQueueManager>())
        {
            try
            {
                var jobRef = new ProductionJobRef
                {
                    WorkspaceID = 123,
                    ProductionID = 456
                };
                CancelJobResult result = await productionQueueManager.CancelJobAsync(jobRef);
 
                // Do something, like display results
                if (result.CancelSuccessfullySent)
                {
                    Console.WriteLine("Successfully canceled job ID {0} for production ID {1} in workspace ID {2}",
                        result.JobID, result.ProductionID, result.WorkspaceID);
                }
                else
                {
                    Console.WriteLine("Error(s) occurred when canceling job ID {0} for production ID {1} in workspace ID {2}",
                        result.JobID, result.ProductionID, result.WorkspaceID);
                    Console.WriteLine("Errors: {0}", string.Join("; ", result.Errors));
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

Cancel production jobs by mass operation token

Use the MassCancelAsync() method to cancel a collection of production jobs by using mass operation token. This token is a GUID that represents the collection of jobs.

public partial class Example
{
    public async Task MassCancel_Example()
    {
        string databaseToken = "1e51ae24-bbcb-4b61-aafb-1f91859d9891"; // GUID representing the collection of selected production jobs for the mass operation
 
        var userEmail = "user@test.com"; // User login
        var password = "abc123456!"; // User password
 
        var relativityRestUri = "http://localhost/relativity.rest/api";
 
        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
        ServiceFactorySettings settings = new ServiceFactorySettings(
            new Uri(relativityRestUri),
            usernamePasswordCredentials);
        ServiceFactory serviceFactory = new ServiceFactory(settings);
 
        using (IProductionQueueManager productionQueueManager = serviceFactory.CreateProxy<IProductionQueueManager>())
        {
            try
            {
                MassProductionQueueResult result =
                    await productionQueueManager.MassCancelAsync(databaseToken);
 
                // Do something, like display information about result of the mass operation.
                Console.WriteLine("Out of {0} jobs requested to cancel, {1} were successful.",
                    result.TotalJobsRequested,
                    result.TotalJobsSuccessful);
                Console.WriteLine("Errors for the overall mass operation: {0}",
                    string.Join("; ", result.Errors));
                foreach (ProductionQueueResult jobResult in result.ProductionQueueResults)
                {
                    if (jobResult.RequestSent)
                    {
                        Console.WriteLine("Successfully canceled job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                    }
                    else
                    {
                        Console.WriteLine("Error(s) occurred when canceling job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                        Console.WriteLine("Errors: {0}", string.Join("; ", jobResult.Errors));
                    }
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

Cancel production jobs by ID

Use the MassCancelProductionJobsAsync() method to cancel multiple production jobs by production ID. Pass a list of ProductionJobRef objects with the following properties to this method:

  • WorkspaceID - the Artifact ID of the workspace containing the production job.
  • ProductionID - the Artifact ID of the production. 
public partial class Example
{
    public async Task MassCancelProductionJobs_Example()
    {
        var userEmail = "user@test.com"; // User login
        var password = "abc123456!"; // User password
 
        var relativityRestUri = "http://localhost/relativity.rest/api";
 
        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
        ServiceFactorySettings settings = new ServiceFactorySettings(
            new Uri(relativityRestUri),
            usernamePasswordCredentials);
        ServiceFactory serviceFactory = new ServiceFactory(settings);
 
        using (IProductionQueueManager productionQueueManager = serviceFactory.CreateProxy<IProductionQueueManager>())
        {
            try
            {
                List<ProductionJobRef> productionJobRefs = new List<ProductionJobRef>
                {
                    new ProductionJobRef
                    {
                        WorkspaceID = 100,
                        ProductionID = 200
                    },
                    new ProductionJobRef
                    {
                        WorkspaceID = 101,
                        ProductionID = 201
                    }
                };
                MassCancelResult result =
                    await productionQueueManager.MassCancelProductionJobsAsync(productionJobRefs);
 
                // Do something, like display results
                Console.WriteLine("Out of {0} jobs requested to cancel, {1} were successful.",
                    result.NumberOfJobsRequestedForCancel,
                    result.NumberOfJobsCancelWasRequestedSuccessfully);
                Console.WriteLine("Errors for the overall mass operation: {0}",
                    string.Join("; ", result.Errors));
                foreach (CancelJobResult jobResult in result.CancelJobResults)
                {
                    if (jobResult.CancelSuccessfullySent)
                    {
                        Console.WriteLine("Successfully canceled job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                    }
                    else
                    {
                        Console.WriteLine("Error(s) occurred when canceling job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                        Console.WriteLine("Errors: {0}", string.Join("; ", jobResult.Errors));
                    }
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

Set the priority on production jobs

Use the MassPrioritizeAsync() method to set the priority on a collection of production jobs in the queue by using a mass operation token. This token is a GUID that represents the collection of jobs.

Pass the following arguments to this method:

  • databaseToken - a GUID representing a collection of production jobs in the queue.
  • priority - an integer value representing the new priority to assign to the jobs.
public partial class Example
{
    public async Task MassPrioritize_Example()
    {
        string databaseToken = "1e51ae24-bbcb-4b61-aafb-1f91859d9891"; // GUID representing the collection of selected production jobs for the mass operation
        int priority = 10; // New priority value to assign to selected production jobs

        var userEmail = "user@test.com"; // User login
        var password = "abc123456!"; // User password

        var relativityRestUri = "http://localhost/relativity.rest/api";

        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
        ServiceFactorySettings settings = new ServiceFactorySettings(
            new Uri(relativityRestUri),
            usernamePasswordCredentials);
        ServiceFactory serviceFactory = new ServiceFactory(settings);

        using (IProductionQueueManager productionQueueManager = serviceFactory.CreateProxy<IProductionQueueManager>())
        {
            try
            {
                MassProductionQueueResult result =
                    await productionQueueManager.MassPrioritizeAsync(databaseToken, priority);

                // Do something, like display information about result of the mass operation.
                Console.WriteLine("Out of {0} jobs requested to prioritize, {1} were successful.",
                    result.TotalJobsRequested,
                    result.TotalJobsSuccessful);
                Console.WriteLine("Errors for the overall mass operation: {0}",
                    string.Join("; ", result.Errors));
                foreach (ProductionQueueResult jobResult in result.ProductionQueueResults)
                {
                    if (jobResult.RequestSent)
                    {
                        Console.WriteLine("Successfully set priority for job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                    }
                    else
                    {
                        Console.WriteLine("Error(s) occurred when setting priority for job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                        Console.WriteLine("Errors: {0}", string.Join("; ", jobResult.Errors));
                    }
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

Retry production jobs by mass operation token

Use the MassRetryAsync() method to rerun multiple production jobs by using a mass operation token. This token is a GUID that represents the collection of jobs.

Pass a GUID representing a collection of production jobs that you want to retry to this method.

public partial class Example
{
    public async Task MassRetry_Example()
    {
        string databaseToken = "1e51ae24-bbcb-4b61-aafb-1f91859d9891"; // GUID representing the collection of selected production jobs for the mass operation
 
        var userEmail = "user@test.com"; // User login
        var password = "abc123456!"; // User password
 
        var relativityRestUri = "http://localhost/relativity.rest/api";
 
        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
        ServiceFactorySettings settings = new ServiceFactorySettings(
            new Uri(relativityRestUri),
            usernamePasswordCredentials);
        ServiceFactory serviceFactory = new ServiceFactory(settings);
 
        using (IProductionQueueManager productionQueueManager = serviceFactory.CreateProxy<IProductionQueueManager>())
        {
            try
            {
                MassProductionQueueResult result =
                    await productionQueueManager.MassRetryAsync(databaseToken);
 
                // Do something, like display information about result of the mass operation.
                Console.WriteLine("Out of {0} jobs requested to retry, {1} were successful.",
                    result.TotalJobsRequested,
                    result.TotalJobsSuccessful);
                Console.WriteLine("Errors for the overall mass operation: {0}",
                    string.Join("; ", result.Errors));
                foreach (ProductionQueueResult jobResult in result.ProductionQueueResults)
                {
                    if (jobResult.RequestSent)
                    {
                        Console.WriteLine("Successfully retried job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                    }
                    else
                    {
                        Console.WriteLine("Error(s) occurred when retrying job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                        Console.WriteLine("Errors: {0}", string.Join("; ", jobResult.Errors));
                    }
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}

Retry production jobs by ID

Use the RetryProductionJobsAsync() method to rerun multiple production jobs by ID. Pass a list of ProductionJobRef objects with the following properties to this method:

  • WorkspaceID - the Artifact ID of the workspace containing the production job.
  • ProductionID - the Artifact ID of the production job. 
public partial class Example
{
    public async Task RetryProductionJobs_Example()
    {
        var userEmail = "user@test.com"; // User login
        var password = "abc123456!"; // User password
 
        var relativityRestUri = "http://localhost/relativity.rest/api";
 
        var usernamePasswordCredentials = new UsernamePasswordCredentials(userEmail, password);
        ServiceFactorySettings settings = new ServiceFactorySettings(
            new Uri(relativityRestUri),
            usernamePasswordCredentials);
        ServiceFactory serviceFactory = new ServiceFactory(settings);
 
        using (IProductionQueueManager productionQueueManager = serviceFactory.CreateProxy<IProductionQueueManager>())
        {
            try
            {
                List<ProductionJobRef> productionJobRefs = new List<ProductionJobRef>
                {
                    new ProductionJobRef
                    {
                        WorkspaceID = 100,
                        ProductionID = 200
                    },
                    new ProductionJobRef
                    {
                        WorkspaceID = 101,
                        ProductionID = 201
                    }
                };
                MassRetryResult result =
                    await productionQueueManager.RetryProductionJobsAsync(productionJobRefs);
 
                // Do something, like display results
                Console.WriteLine("Out of {0} jobs requested to retry, {1} were successful.",
                    result.NumberOfJobsRequestedForRetry,
                    result.NumberOfJobsRetryWasRequestedSuccessfully);
                Console.WriteLine("Errors for the overall mass operation: {0}",
                    string.Join("; ", result.Errors));
                foreach (RetryJobResult jobResult in result.RetryJobResults)
                {
                    if (jobResult.RetrySuccessfullySent)
                    {
                        Console.WriteLine("Successfully retried job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                    }
                    else
                    {
                        Console.WriteLine("Error(s) occurred when retrying job ID {0} for production ID {1} in workspace ID {2}",
                            jobResult.JobID, jobResult.ProductionID, jobResult.WorkspaceID);
                        Console.WriteLine("Errors: {0}", string.Join("; ", jobResult.Errors));
                    }
                }
            }
            catch (ValidationException e)
            {
                // Log validation exception details
                Console.WriteLine("There were validation errors: {0}", e.Message);
            }
            catch (ServiceException es)
            {
                // Log service exception details
                Console.WriteLine("There were errors: {0}", es.Message);
            }
        }
    }
}