Exportar (0) Imprimir
Expandir Tudo

Gerenciamento de Ativos com os Serviços de Mídia SDK para .NET

Atualizado: julho de 2014

Este tópico mostra como realizar as seguintes tarefas de gerenciamento do Serviços de Mídia:

noteObservação
Para escrever código para gerenciar ativos existentes do Serviços de Mídia, primeiro você deve ter uma referência para o contexto do servidor do Serviços de Mídia, conforme descrito no tópico Conectando-se aos Serviços de Mídia com o SDK dos Serviços de Mídia para .NET. O objeto de contexto é representado pela variável _context nos exemplos de código a seguir.

Uma tarefa frequente é obter uma referência a um ativo existente no Serviços de Mídia. O exemplo de código a seguir mostra como você pode obter uma referência de ativo do conjunto do Assets sobre o objeto de contexto de servidor, com base em uma Id de ativo.

O exemplo de código a seguir usa uma consulta Linq para obter uma referência a um objeto existente do IAsset.

static IAsset GetAsset(string assetId)
{
    // Use a LINQ Select query to get an asset.
    var assetInstance =
        from a in _context.Assets
        where a.Id == assetId
        select a;
    // Reference the asset as an IAsset.
    IAsset asset = assetInstance.FirstOrDefault();

    return asset;
}

Ao trabalhar com tarefas de processamento em código do Serviços de Mídia, muitas vezes você precisa obter uma referência a um trabalho existente com base em uma ID. O exemplo de código a seguir mostra como obter uma referência a um objeto IJob da coleção Jobs.

WarningAviso
Você pode precisar obter uma referência de trabalho ao iniciar um trabalho de codificação de longa duração e precisar verificar o status do trabalho em um thread. Em casos como esse, quando o método retorna de um thread, você precisa recuperar uma referência atualizada para um trabalho.

static IJob GetJob(string jobId)
{
    // Use a Linq select query to get an updated 
    // reference by Id. 
    var jobInstance =
        from j in _context.Jobs
        where j.Id == jobId
        select j;
    // Return the job reference as an Ijob. 
    IJob job = jobInstance.FirstOrDefault();

    return job;
}

À medida que aumenta o número de ativos que você tem no armazenamento, é útil listar seus ativos. O exemplo de código a seguir mostra como percorrer o conjunto do Assets no objeto de contexto de servidor. Com cada ativo, o exemplo de código também grava alguns de seus valores de propriedade para o console. Por exemplo, cada ativo pode conter muitos arquivos de mídia. O exemplo de código grava todos os arquivos associados a cada ativo.

noteObservação
Para ver todas as informações de ativos exibidas no console, você pode definir um ponto de interrupção no Visual Studio na chave de fechamento do método de exemplo. Caso contrário, o console será fechado antes que você possa ver os dados. Uma opção é gravar em um arquivo todas as informações de ativos listadas. O projeto suplementar mostra como gravar a lista de ativos para um arquivo em um método que lista ativos semelhantes a este exemplo de código.


static void ListAssets()
{
    string waitMessage = "Building the list. This may take a few "
        + "seconds to a few minutes depending on how many assets "
        + "you have."
        + Environment.NewLine + Environment.NewLine
        + "Please wait..."
        + Environment.NewLine;
    Console.Write(waitMessage);

    // Create a Stringbuilder to store the list that we build. 
    StringBuilder builder = new StringBuilder();

    foreach (IAsset asset in _context.Assets)
    {
        // Display the collection of assets.
        builder.AppendLine("");
        builder.AppendLine("******ASSET******");
        builder.AppendLine("Asset ID: " + asset.Id);
        builder.AppendLine("Name: " + asset.Name);
        builder.AppendLine("==============");
        builder.AppendLine("******ASSET FILES******");

        // Display the files associated with each asset. 
        foreach (IAssetFile fileItem in asset.AssetFiles)
        {
            builder.AppendLine("Name: " + fileItem.Name);
            builder.AppendLine("Size: " + fileItem.ContentFileSize);
            builder.AppendLine("==============");
        }
    }

    // Display output in console.
    Console.Write(builder.ToString());
}

Uma tarefa relacionada importante é listar ativos com seu trabalho associado no Serviços de Mídia. O exemplo de código a seguir mostra como listar cada objeto IJob e, para cada trabalho, exibe propriedades sobre o trabalho, todas as tarefas relacionadas, todos os ativos de entrada e de saída. O código nesse exemplo pode ser útil para muitas outras tarefas. Por exemplo, se você desejar listar os ativos de saída de um ou mais trabalhos de codificação que executou anteriormente, esse código mostra como acessar os ativos de saída. Quando tiver uma referência a um ativo de saída, você poderá fornecer o conteúdo a outros usuários ou aplicativos baixando-o ou fornecendo URLs. Para obter mais informações sobre as opções para o fornecimento de ativos, consulte Entregando ativos com o SDK de Serviços de Mídia para .NET.

// List all jobs on the server, and for each job, also list 
// all tasks, all input assets, all output assets.
static void ListJobsAndAssets()
{
    string waitMessage = "Building the list. This may take a few "
        + "seconds to a few minutes depending on how many assets "
        + "you have."
        + Environment.NewLine + Environment.NewLine
        + "Please wait..."
        + Environment.NewLine;
    Console.Write(waitMessage);

    // Create a Stringbuilder to store the list that we build. 
    StringBuilder builder = new StringBuilder();

    foreach (IJob job in _context.Jobs)
    {
        // Display the collection of jobs on the server.
        builder.AppendLine("");
        builder.AppendLine("******JOB*******");
        builder.AppendLine("Job ID: " + job.Id);
        builder.AppendLine("Name: " + job.Name);
        builder.AppendLine("State: " + job.State);
        builder.AppendLine("Order: " + job.Priority);
        builder.AppendLine("==============");


        // For each job, display the associated tasks (a job  
        // has one or more tasks). 
        builder.AppendLine("******TASKS*******");
        foreach (ITask task in job.Tasks)
        {
            builder.AppendLine("Task Id: " + task.Id);
            builder.AppendLine("Name: " + task.Name);
            builder.AppendLine("Progress: " + task.Progress);
            builder.AppendLine("Configuration: " + task.Configuration);
            if (task.ErrorDetails != null)
            {
                builder.AppendLine("Error: " + task.ErrorDetails);
            }
            builder.AppendLine("==============");
        }

        // For each job, display the list of input media assets.
        builder.AppendLine("******JOB INPUT MEDIA ASSETS*******");
        foreach (IAsset inputAsset in job.InputMediaAssets)
        {

            if (inputAsset != null)
            {
                builder.AppendLine("Input Asset Id: " + inputAsset.Id);
                builder.AppendLine("Name: " + inputAsset.Name);
                builder.AppendLine("==============");
            }
        }

        // For each job, display the list of output media assets.
        builder.AppendLine("******JOB OUTPUT MEDIA ASSETS*******");
        foreach (IAsset theAsset in job.OutputMediaAssets)
        {
            if (theAsset != null)
            {
                builder.AppendLine("Output Asset Id: " + theAsset.Id);
                builder.AppendLine("Name: " + theAsset.Name);
                builder.AppendLine("==============");
            }
        }

    }

    // Display output in console.
    Console.Write(builder.ToString());
}

No Serviços de Mídia, você pode definir uma política de acesso para um ativo ou seus arquivos. Uma política de acesso define as permissões para um arquivo ou um ativo (o tipo de acesso e a duração). Em seu código do Serviços de Mídia, normalmente você define uma política de acesso criando um objeto IAccessPolicy e associando-o a um ativo existente. Em seguida, você cria um objeto ILocator, o que lhe permite fornecer acesso direto aos ativos no Serviços de Mídia. O projeto do Visual Studio que acompanha esta série de documentação contém vários exemplos de código que mostram como criar e atribuir políticas de acesso e localizadores a ativos.

O exemplo de código a seguir mostra como listar todas as políticas de acesso no servidor e mostra o tipo de permissões associadas a cada um. Outra forma útil de exibir as políticas de acesso é listar todos os objetos ILocator no servidor e, em seguida, para cada localizador, você pode listar sua política de acesso associada usando sua propriedade AccessPolicy.

static void ListAllPolicies()
{
    foreach (IAccessPolicy policy in _context.AccessPolicies)
    {
        Console.WriteLine("");
        Console.WriteLine("Name:  " + policy.Name);
        Console.WriteLine("ID:  " + policy.Id);
        Console.WriteLine("Permissions: " + policy.Permissions);
        Console.WriteLine("==============");

    }
}

Um localizador é uma URL que fornece um caminho direto para acessar um recurso, juntamente com permissões para o ativo, conforme definido pela política de acesso associada do localizador. Cada ativo pode ter um conjunto de objetos ILocator associados a ele em sua propriedade Locators. O contexto de servidor também tem um conjunto Locators que contém todos os localizadores.

O exemplo de código a seguir lista todos os localizadores no servidor. Para cada localizador, ele mostra a Id da política de ativo e acesso relacionada. Ele também exibe o tipo de permissões, a data de expiração e o caminho completo para o ativo.

noteObservação
Um caminho de localizador para um ativo é apenas uma URL de base para o ativo. Para criar um caminho direto para arquivos individuais para os quais um usuário ou aplicativo pode navegar, seu código deve adicionar o caminho de arquivo específico ao caminho do localizador. Para obter mais informações sobre como fazer isso, consulte o tópico Entregando ativos com o SDK de Serviços de Mídia para .NET.

static void ListAllLocators()
{
    foreach (ILocator locator in _context.Locators)
    {
        Console.WriteLine("***********");
        Console.WriteLine("Locator Id: " + locator.Id);
        Console.WriteLine("Locator asset Id: " + locator.AssetId);
        Console.WriteLine("Locator access policy Id: " + locator.AccessPolicyId);
        Console.WriteLine("Access policy permissions: " + locator.AccessPolicy.Permissions);
        Console.WriteLine("Locator expiration: " + locator.ExpirationDateTime);
        // The locator path is the base or parent path (with included permissions) to access  
        // the media content of an asset. To create a full URL to a specific media file, take 
        // the locator path and then append a file name and info as needed.  
        Console.WriteLine("Locator base path: " + locator.Path);
        Console.WriteLine("");
    }
}


O exemplo a seguir exclui um ativo.

static void DeleteAsset( IAsset asset)
{
    // delete the asset
    asset.Delete();

    // Verify asset deletion
    if (GetAsset(asset.Id) == null)
        Console.WriteLine("Deleted the Asset");

}

Para excluir um trabalho, você deve verificar o estado do trabalho, conforme indicado na propriedade State. Trabalhos que foram concluídos ou cancelados podem ser excluídos, enquanto os trabalhos que estão em alguns outros estados, como enfileirado, agendado ou em processamento, devem ser cancelados primeiro e, em seguida, podem ser excluídos.

O exemplo de código a seguir mostra um método para excluir um trabalho, verificando os estados de trabalhos e excluindo quando o estado é concluído ou cancelado. Esse código depende da seção anterior deste tópico para obter uma referência a um trabalho: Obter uma referência de trabalho.

static void DeleteJob(string jobId)
{
    bool jobDeleted = false;

    while (!jobDeleted)
    {
        // Get an updated job reference.  
        IJob job = GetJob(jobId);

        // Check and handle various possible job states. You can 
        // only delete a job whose state is Finished, Error, or Canceled.   
        // You can cancel jobs that are Queued, Scheduled, or Processing,  
        // and then delete after they are canceled.
        switch (job.State)
        {
            case JobState.Finished:
            case JobState.Canceled:
            case JobState.Error:
                // Job errors should already be logged by polling or event 
                // handling methods such as CheckJobProgress or StateChanged.
                // You can also call job.DeleteAsync to do async deletes.
                job.Delete();
                Console.WriteLine("Job has been deleted.");
                jobDeleted = true;
                break;
            case JobState.Canceling:
                Console.WriteLine("Job is cancelling and will be deleted "
                    + "when finished.");
                Console.WriteLine("Wait while job finishes canceling...");
                Thread.Sleep(5000);
                break;
            case JobState.Queued:
            case JobState.Scheduled:
            case JobState.Processing:
                job.Cancel();
                Console.WriteLine("Job is scheduled or processing and will "
                    + "be deleted.");
                break;
            default:
                break;
        }

    }
}


O exemplo de código a seguir mostra como obter uma referência a uma política de acesso baseada em uma Id de política e excluir a política.

static void DeleteAccessPolicy(string existingPolicyId)
{
    // To delete a specific access policy, get a reference to the policy.  
    // based on the policy Id passed to the method.
    var policyInstance =
            from p in _context.AccessPolicies
            where p.Id == existingPolicyId
            select p;
    IAccessPolicy policy = policyInstance.FirstOrDefault();

    policy.Delete();

}


Consulte também

Mostrar:
© 2014 Microsoft