Dependências entre componentes gerenciados por gravadores diferentes

Há situações em que os dados de um gravador dependem de dados gerenciados por outro gravador. Nesses casos, você deve fazer backup ou restaurar dados de ambos os gravadores.

O VSS lida com esse problema por meio da noção de uma dependência explícita do componente do gravador e da interfaceIVssWMDependency.

Um gravador adiciona uma ou mais dependências ao criar o Documento de Metadados do Gravador usando o métodoIVssCreateWriterMetadata::AddComponentDependency. O gravador passa o método o nome e o caminho lógico do componente dependente (que ele gerencia), bem como o nome e o caminho lógico e o ID de classe do gravador (o GUID que identifica a classe) do componente do qual ele depende.

Uma vez estabelecida, essa dependência informa ao solicitante que, durante qualquer operação de backup ou restauração, tanto o componente dependente quanto os destinos de suas dependências devem participar.

Um determinado componente pode ter várias dependências, o que requer que ele e todos os seus destinos dependentes participem do backup e da restauração juntos.

O componente dependente e/ou o(s) destino(s) de suas dependências podem ser incluídos explicitamente ou implicitamente em operações de backup ou restauração.

O mecanismo de dependência do componente gravador explícito não deve ser usado para criar uma dependência entre dois componentes no mesmo gravador. As regras de seleção podem fornecer a mesma funcionalidade de forma mais eficiente, sem risco de dependências circulares.

Como exemplo, IVssCreateWriterMetadata::AddComponentDependency pode ser usado para definir a dependência do componente writerData (com caminho lógico "") do gravador MyWriter no componente internetData (com um caminho lógico de "Conexões") de um gravador chamado InternetConnector com um gravador Class ID X. (Embora seja possível que vários gravadores com o mesmo ID de classe estejam no sistema simultaneamente, a confusão será evitada porque a combinação de caminho lógico e nome do componente é exclusiva no sistema em VSS.)

Um gravador adiciona várias dependências a um determinado componente simplesmente chamando IVssCreateWriterMetadata::AddComponentDependency repetido com componentes diferentes de gravadores diferentes. O número de outros componentes de que um dado componente depende pode ser encontrado examinando o cDependencies membro da estrutura VSS_COMPONENTINFO.

Um gravador ou solicitante recupera instâncias do IVssWMDependency interface com IVssWMComponent::GetDependency. O IVssWMDependency retorna o nome do componente, o caminho lógico e a ID da classe do gravador que gerencia o componente que é o destino da dependência.

O mecanismo de dependência não prescreve nenhuma ordem particular de preferência entre o componente dependente e os alvos de suas dependências. Como observado acima, tudo o que uma dependência indica é que sempre que um determinado componente é copiado ou restaurado, o componente ou componentes dos quais ele depende também devem ser copiados ou restaurados. A implementação exata da dependência fica a critério do aplicativo de backup.

Por exemplo, no caso acima, o componente writerData (caminho lógico "") depende do componente InternetConnector (caminho lógico "Conexões"). Um requerente é livre de interpretar isto de uma das seguintes formas:

• Se o componente dependente, writerData, for selecionado (implícita ou explicitamente) para backup ou restauração, o solicitante deverá selecionar (implícita ou explicitamente) o destino de sua dependência, internetData
• Se o destino de sua dependência, internetData, não estiver selecionado para backup, o componente dependente, writerData, não deverá ser selecionado.

No entanto, ao desenvolver suporte para dependências, os desenvolvedores solicitantes devem estar cientes de que não há como um gravador determinar se um de seus componentes é um destino de uma dependência.

Declarando dependências remotas

Um aplicativo distribuído é um aplicativo que pode ser configurado para usar um ou mais computadores de cada vez. Normalmente, o aplicativo é executado em um ou mais computadores do servidor de aplicativos e se comunica com (mas pode ou não ser realmente executado em) um ou mais computadores do servidor de banco de dados. Essa configuração às vezes é chamada de implantação multissistema. Muitas vezes, o mesmo aplicativo também pode ser configurado para ser executado em um único computador que executa um servidor de aplicativos e um servidor de banco de dados. Essa configuração é chamada de implantação de sistema único. Em ambas as configurações, o servidor de aplicativos e o servidor de banco de dados têm seus próprios gravadores VSS independentes.

Em uma implantação multissistema, se um componente gerenciado pelo gravador do aplicativo depender de um componente remoto gerenciado pelo gravador do servidor de banco de dados, isso será chamado de dependência remota. (Uma implantação de sistema único, em contraste, tem apenas dependências locais.)

Como exemplo de uma implantação multissistema, considere um servidor de aplicativos que usa um servidor de banco de dados SQL Server como armazenamento de dados. Os dados específicos do aplicativo, que incluem as Web Parts, os arquivos de conteúdo da Web e a metabase do IIS, residem em um ou mais computadores, chamados servidores Web front-end. O armazenamento de dados SQL real, que inclui o banco de dados Config e vários bancos de dados de conteúdo, reside em um ou mais outros computadores, chamados servidores de banco de dados back-end. Cada um dos servidores Web front-end contém o mesmo conteúdo e configuração específicos do aplicativo. Cada um dos servidores de banco de dados back-end pode hospedar qualquer um dos bancos de dados de conteúdo ou o banco de dados Config. O software do aplicativo é executado apenas nos servidores Web front-end, não nos servidores de banco de dados. Nessa configuração, o gravador VSS do aplicativo tem dependências remotas nos componentes gerenciados pelo gravador SQL.

Um gravador pode declarar uma dependência remota chamando o método AddComponentDependency, precedendo "\\RemoteComputerName\", onde RemoteComputerName é o nome do computador onde o componente remoto reside, para o caminho lógico no parâmetro wszOnLogicalPath. O valor de RemoteComputerName pode ser um endereço IP ou um nome de computador retornado pela funçãoGetComputerNameEx.

Windows Server 2003: Um gravador não pode declarar dependências remotas até o Windows Server 2003 com Service Pack 1 (SP1).

Para identificar uma dependência, um solicitante chama o GetWriterId, GetLogicalPathe GetComponentName métodos da interfaceIVssWMDependency. O solicitante deve examinar o nome do componente que GetComponentName retorna no parâmetro pbstrComponentName. Se o nome do componente começar com "\\", o solicitante deverá assumir que ele especifica uma dependência remota e que o primeiro componente após "\\" é o RemoteComputerName que foi especificado quando o gravador chamou AddComponentDependency. Se o nome do componente não começar com "\\", o solicitante deve assumir que especifica uma dependência local.

Se houver uma dependência remota, o solicitante deverá fazer backup do componente remoto quando fizer backup do componente local. Para fazer backup do componente remoto, o solicitante deve ter um agente no computador remoto e deve iniciar o backup no computador remoto.

Estruturando dependências remotas

É importante compreender que uma dependência não é um componente em si mesmo. Um componente é necessário para manter a dependência.

Os exemplos a seguir mostram duas maneiras de estruturar um conjunto de dependências.

Example 1:
    Writer 1
        Component A
            File A
            File B
            Dependency (SQL/MSDE Writer, Component X, "\")
            Dependency (SQL/MSDE Writer, Component Y, "\")

Example 2:
    Writer 2
        Component A
            File A
            File B
        Component B
            Dependency (SQL/MSDE Writer, Component X, "\")
            Dependency (SQL/MSDE Writer, Component Y, "\")

No exemplo 1, as dependências são mantidas pelo Componente A. Como apenas os componentes podem ser selecionados, não arquivos individuais, estruturar as dependências do Componente A dessa maneira exigiria que todo o componente, tanto os arquivos quanto as dependências, sempre fizessem backup e restaurassem juntos. Eles não podem ser copiados ou restaurados individualmente.

No exemplo 2, componentes separados (Componentes A e B) mantêm cada uma das dependências. Nesse caso, os dois componentes podem ser selecionados de forma independente e, portanto, backup e restauração independentes. Estruturar as dependências dessa maneira dá a um aplicativo distribuído muito mais flexibilidade no gerenciamento de suas dependências remotas.

Suporte a dependências remotas

Um solicitante pode fornecer suporte total ou parcial para dependências remotas.

Para fornecer suporte completo, o solicitante deve fazer o seguinte no momento do backup e da restauração.

No momento do backup, o solicitante deve iniciar o backup no computador front-end (local), determinar as dependências existentes e colocar em spool tarefas de backup adicionais para capturar os bancos de dados back-end. O solicitante deve aguardar até que os trabalhos de backup de back-end no computador remoto tenham sido concluídos antes de chamar os IVssBackupComponents::SetBackupSucceeded e IVssBackupComponents::BackupComplete métodos. Se o solicitante esperar até que o backup dos componentes de back-end esteja concluído antes de chamar BackupComplete , isso produzirá um backup mais facilmente recuperável para um gravador que implementa aprimoramentos adicionais — como bloqueio de topologia, por exemplo — durante o backup. O procedimento a seguir descreve o que o solicitante deve fazer:

1. No computador local, o solicitante chama os IVssBackupComponents::InitializeForBackup, IVssBackupComponents::GatherWriterMetadata, IVssBackupComponents::P repareForBackupe IVssBackupComponents::D oSnapshotSet métodos.
2. Depois que a cópia de sombra local for concluída, mas antes que o backup seja concluído, o solicitante armazena trabalhos de backup adicionais enviando uma solicitação para seu agente no computador remoto.
3. No computador remoto, o agente do solicitante executa a sequência de backup em spool chamando InitializeForBackup , GatherWriterMetadata, PrepareForBackup, DoSnapshotSet, SetBackupSucceedede BackupComplete.
4. Quando o agente do solicitante tiver concluído os trabalhos em spool no computador remoto, o solicitante concluirá a sequência de backup chamando SetBackupSucceeded e BackupComplete.

No momento da restauração, o solicitante deve iniciar a restauração envolvendo o computador front-end (local), selecionar os componentes e suas dependências a serem restaurados e, em seguida, enviar o evento PreRestore chamando o IVssBackupComponents::P reRestore método. O solicitante deve, então, colocar em spool os trabalhos de restauração de back-end no computador remoto e chamar o IVssBackupComponents::P ostRestore método quando as restaurações de back-end forem concluídas. Esse requisito dá ao gravador front-end mais controle sobre a experiência de restauração e uma melhor experiência de usuário administrador em geral. Como os backups em cada um dos sistemas não ocorrem no mesmo point-in-time, o gravador front-end precisará executar alguma limpeza dos dados de back-end. No aplicativo de exemplo discutido no precedente "Declarando dependências remotas", o gravador deve iniciar um remapeamento ou reindexação de site após a conclusão de uma restauração de um dos bancos de dados back-end. Para fazer isso, o gravador deve receber eventos no servidor front-end. O procedimento a seguir descreve o que o solicitante deve fazer:

1. No computador local, o solicitante chama IVssBackupComponents::InitializeForRestore, GatherWriterMetadataIVssBackupComponents::SetSelectedForRestore (ou IVssBackupComponentsEx::SetSelectedForRestoreEx) e PreRestore .
2. Depois que a fase PreRestore for concluída, mas antes que a fase PostRestore comece, o solicitante armazena trabalhos de restauração adicionais enviando uma solicitação ao seu agente no computador remoto.
3. No computador remoto, o agente do solicitante executa os trabalhos de restauração em spool chamando InitializeForRestore, GatherWriterMetadata, SetSelectedForRestore, PreRestore, SetFileRestoreStatus (ou SetSelectedForRestoreEx) e PostRestore .
4. Quando o agente do solicitante tiver concluído os trabalhos em spool no computador remoto, o solicitante concluirá a sequência de restauração chamando IVssBackupComponents::SetFileRestoreStatus e PostRestore.

Para fornecer suporte parcial para dependências remotas, o solicitante deve seguir dependências remotas e incluí-las como parte do backup, mas a ordenação de eventos em sistemas front-end e back-end, conforme detalhado nos dois procedimentos anteriores, não seria necessária. Para um solicitante que implementa suporte apenas parcial, o solicitante deve consultar a documentação de backup/restauração do aplicativo gravador para entender quais cenários podem ser suportados.