TFS
Compilando e validando aplicativos da Windows Store com o Team Foundation Service
Disponível na versão final desde outubro de 2012, o Team Foundation Service, a versão em nuvem do Visual Studio Team Foundation Server (TFS), oferece uma variedade de recursos que podem ajudá-lo a entregar software de qualidade. E não é um grande salto imaginar que o software que você está pensando desenvolver provavelmente se destinará ao Windows 8.
Você pode estar imaginando se pode combinar a força dos dois produtos, usar o Team Foundation Service para compilar aplicativos da Windows Store. Infelizmente, isso não é possível diretamente, devido a algumas limitações que abordarei posteriormente neste artigo. No entanto, também mostrarei as etapas necessárias para contornar esse problema e ajudá-lo a validar os aplicativos da Windows Store durante o processo de compilação.
Primeiro, vamos dar uma olhada rápida no Team Foundation Service.
Visão geral do Serviço do Team Foundation
Como um serviço baseado em nuvem, o Team Foundation Service permite aos desenvolvedores acessar os recursos oferecidos pelo TFS sem o incômodo de ter de instalar e gerenciá-lo. Inscreva-se (gratuitamente) em bit.ly/ZusqUY e você está pronto para prosseguir.
Entre os serviços oferecidos pelo produto, você provavelmente se concentrará em três recursos principais para desenvolver e entregar software de alta qualidade:
Gerenciamento de código-fonte Você pode usar o recurso de controle de código-fonte com suas ferramentas atuais e linguagens preferidas. Virtualmente, qualquer tipo de arquivo (C#, C++, HTML, PHP, Java e outros) pode ser manipulado pelo controlador de código-fonte. Se você usa um IDE como o Visual Studio ou Eclipse, pode continuar a usá-lo para desenvolver seus aplicativos e fazer o check-in de seus arquivos no controle de código-fonte.
A arquitetura do controlador de código-fonte fornece um espaço de trabalho local que armazena uma cópia local do código-fonte. No modo desconectado, todas as modificações são executadas nesse espaço de trabalho. Ao reconectar, você simplesmente faz o check-in de seu código para enviá-lo ao servidor, mantendo o histórico completo de todas as versões para que você possa controlar e reverter alterações.
Colaboração O Team Foundation Service permite aos desenvolvedores trabalhar melhor juntos, principalmente com uma ferramenta chamada de quadro de tarefas. O quadro de tarefas é acessado de qualquer navegador moderno que permita criar dashboards personalizados. Use o quadro de tarefas para gerenciar informações sobre itens de trabalho, status de compilação, resultados de testes e assim por diante, como mostrado na Figura 1.
.png "Sample Dashboard for Team Foundation Service")
Figura 1 Dashboard de exemplo do Team Foundation Service
Serviço de Compilação Ainda na versão de demonstração no momento da elaboração desse artigo, o Serviço de Compilação é baseado no Team Build, que é parte do TFS 2010, e fornece compilação automatizada na nuvem.
Todos os recursos padrão do Team Build podem ser usados pelo Serviço de Compilação, incluindo integração contínua, compilações noturnas e compilações de check-in controlado. Além disso, o modelo de compilação que ele usa é totalmente personalizável. Há até mesmo um modelo “pronto para continuar” para fazer implantação contínua no Windows Azure (você pode fazer check-in de código no controle de código-fonte e ver suas atualizações nos sites do Windows Azure).
O Serviço de Compilação é hospedado em um servidor de compilação implantado com o Windows Server 2008 R2, Team Build, Visual Studio 2010 or posterior, e mais (consulte a lista completa de softwares requeridos e opções na parte inferior desta página: bit.ly/12Sf99Z). A configuração padrão é boa para a maioria dos aplicativos, exceto os aplicativos da Windows Store. Como pode ser visto na Figura 2, os aplicativos da Windows Store precisam ser compilados no Windows 8 (ou Windows Server 2012) e eles não estão instalados no servidor de compilação.
.png "Building Windows Store Apps on Team Foundation Service Is Not Possible out of the Box")
Figura 2 Compilar aplicativos da Windows Store no Team Foundation Service não é possível diretamente
Portanto, como observado anteriormente, compilar aplicativos da Windows Store no Team Foundation Service não é possível diretamente Mas, como poderá ser visto, há uma solução alternativa. Essencialmente, a alternativa consiste em instalar um computador Windows 8 que se tornará um novo agente de compilação, dedicado aos aplicativos da Windows Store, para o Team Foundation Service. Mostrarei como implementá-lo.
Compilando aplicativos da Windows Store com o Team Foundation Service
Vejamos as etapas necessárias para compilar aplicativos da Windows Store usando o Team Foundation Service.
Instalando o Serviço de Compilação Primeiro, você precisa de uma máquina executando o Windows 8. Pode ser tanto uma máquina física quanto virtual (VM); não é importante desde que a máquina seja acessível da Internet. Em seguida, instale o TFS 2012 nessa máquina. Observe que instalar o TFS não significa que ele estará configurado e pronto para usar. A única razão pela qual você está o instalando é poder configurar o Serviço de Compilação. Não é necessário obter um Team Foundation Application Server, pois você já tem o do Team Foundation Service.
Depois do Serviço de Compilação instalado, você pode configurá-lo usando uma coleção de projetos de equipe dedicada. Nesse caso, como você não irá configurar outros componentes do TFS e deseja realmente usar o Team Foundation Service, especifique a coleção de projetos de equipe disponível com sua conta do Team Foundation Service e conclua a configuração, como mostrado na Figura 3.
.png "Installing the Team Foundation Build Service in a Dedicated Team Projects Collection")
Figura 3 Instalando o Serviço de compilação do Team Foundation em uma coleção de projetos de equipe dedicada
Configurando o Serviço de Compilação Para a próxima parte, você precisa entender algumas noções básicas sobre o TFS e sua arquitetura de compilação.
Cada TFS tem um conjunto de controladores de compilação dedicados. Um controlador de compilação é o ponto de extremidade que receberá a solicitação de compilação e a executará usando agentes de compilação dedicados. O agente de compilação faz o trabalho mais importante da compilação: Ele obtém arquivos do controle de código-fonte, compila o código, executa testes de unidade e assim por diante.
O Team Foundation Service vem com um controlador de compilação dedicado, o controlador de compilação hospedado, assim você pode pensar que apenas tem de criar um novo agente para ser executado com esse controlador. Infelizmente, não é possível anexar um agente de compilação localmente a um controlador de compilação hospedado. Você precisa escolher um outro controlador de compilação ou criar um novo.
Para simplificar, vamos criar um novo, como mostrado na Figura 4.
.png "Creating a New Build Controller")
Figura 4 Criando um novo controlador de compilação
Depois que o controlador estiver em funcionamento, a próxima etapa será configurar um novo agente dedicado à compilação de aplicativos da Windows Store. Criar um novo agente de compilação é tão simples como clicar no link Novo Agente e preencher os campos. Em um ambiente de produção real, você pode ter mais agentes para seu controlador de compilação, assim, para ter certeza de que os aplicativos da Windows Store sejam compilados apenas por agentes que executam o Windows 8, adicione uma marca dedicada como mostrado na Figura 5. Isso não é obrigatório, mas ao criar a definição de compilação posteriormente, você poderá especificar essa marca para garantir que apenas esse agente será usado no processo de compilação.
.png "Creating a New Build Agent")
Figura 5 Criando um novo agente de compilação
Antes de avançar para a próxima parte, você precisa ir para as propriedades do Serviço de Compilação e configurá-lo para ser executado interativamente. Essa etapa não é mandatória se desejar apenas compilar aplicativos da Windows Store. Mas se desejar validar seus aplicativos, o Team Foundation Service e o Serviço de Compilação precisarão instalar e iniciá-los na máquina de compilação. Isso não pode ser feito se o Serviço de Compilação não estiver configurado para ser executado interativamente.
Na página Compilações do Visual Studio Team Explorer, clique em Ações e, em seguida, em Gerenciar Controladores de Compilação para abrir um janela que mostra uma lista de todos os controladores de compilação (com seus agentes dedicados) instalados. Se a configuração foi bem-sucedida, você deverá ver seu novo controlador e agente.
Preparando o agente de compilação para executar testes de unidade Se o computador que hospeda o agente de compilação for usado para executar testes de unidade, há duas outras etapas que precisam ser executadas. Primeira, uma licença de desenvolvedor do Windows 8 deve ser instalada no computador. As licenças de desenvolvedor são gratuitas, elas precisam ser renovadas a cada 30 dias (ou 90 dias, se você tem uma conta da Windows Store), e você pode ter quantas forem necessárias se já tiver uma conta da Microsoft. Há duas formas de adquirir uma licença de desenvolvedor. Em sua máquina de compilação, crie um aplicativo da Windows Store, que abre uma caixa de diálogo na qual você pode obter uma licença válida. Se não deseja criar um aplicativo falso em sua máquina de compilação, você pode executar o seguinte comando do Windows PowerShell para obter a mesma caixa de diálogo:
C:\PS> Show-WindowsDeveloperLicenseRegistration
Depois de obter a licença de desenvolvedor, você precisa gerar e instalar um certificado de teste de unidade (do projeto de código que contém os testes de unidade que deseja executar) no agente de compilação. Para esta etapa, gere um pacote de aplicativo na máquina do desenvolvedor. No Visual Studio, clique em Armazenar | Criar Pacote do Aplicativo. Isso cria uma pasta que contém o aplicativo da Windows Store (em um arquivo com a extensão .appx) e seu certificado.
Para instalar o certificado na máquina de compilação, abra um prompt de comando como administrador e insira o seguinte comando:
certutil -addstore root certificate_file
Observe que certificate_file é o caminho para o arquivo do certificado.
Compilando aplicativos da Windows Store Uma vez que o controlador e o agente estejam em execução, compilar aplicativos da Windows Store é o mesmo que compilar outros tipos de aplicativos. Você só precisa configurar uma nova definição de compilação e especificar que deseja usar o novo controlador de compilação que acabou de configurar. Para garantir que o processo de compilação use o agente de compilação em execução no Windows 8, na guia Processo da definição de compilação, selecione a marca indicada quando você criou o agente de compilação (consulte a Figura 6).
.png "Creating the Build Process Using the Specified Tag")
Figura 6 Criando o processo de compilação usando a marca especificada
Depois disso feito, enfileirar uma nova compilação usando a definição de compilação que acabou de criar inicia-a e, graças à marca especificada, você pode ter certeza de que a compilação é executada usando o agente correto, portanto, não falhará.
Como pode ser visto, compilar um aplicativo da Windows Store usando o Team Foundation Service é muito fácil e extremamente poderoso, e você pode ainda personalizar totalmente o processo de compilação. No entanto, ainda há um problema. Mesmo que a compilação tenha êxito, não significa que o aplicativo será executado corretamente ou mesmo que será aprovado em todas as etapas básicas de validação. Em seguida, explicarei como você pode validar o aplicativo e como indicar aos usuários (através do relatório de compilação) se a validação foi aprovada ou reprovada.
Validando aplicativos da Windows Store durante o Team Build
Como provavelmente você sabe, para ser publicado na Windows Store, um aplicativo deve ser certificado. Ou seja, ele deve ser aprovado nas etapas de validação necessárias. Você pode validar seus aplicativos durante o processo de compilação. Isso pode ser executado facilmente simplesmente adicionado um evento pós-compilação, que irá iniciar o Kit de Certificação de Aplicativos para Windows (ACK) para validar o aplicativo. Mas, diretamente, a validação não notifica os usuários sobre os resultados. Mostrarei como ampliar o processo de compilação para incluir essa etapa.
Para integrar a execução do ACK durante o processo de compilação, você só precisa modificar o arquivo do seu projeto para adicionar o seguinte PostPackageEvent:
<Target Name="PostPackageEvent" AfterTargets="_GenerateAppxPackage">
<Exec Command=""$(TargetPlatformSdkPath)App Certification Kit\appcert.exe" reset"/>
<Exec Command=""$(TargetPlatformSdkPath)\App Certification Kit\appcert.exe" test
-apptype windowsstoreapp -AppxPackagePath "$(FinalAppxPackage)" –reportoutputpath
"$(outdir)\ValidationResult.xml"" />
<Exec Command="copy "$(userprofile)\appdata\Local\Microsoft\appcertkit\
ValidationResult.htm" "$(outdir)\ValidationResult.htm""/>
</Target>
Quando executado, o código criará o arquivo ValidationResult.html, que contém os resultados da validação executada pelo ACK. Se estiver conectado ao servidor de compilação quando a compilação for executada, você verá que o aplicativo é iniciado para ser validado pelo ACK. Isso é normal; o aplicativo será instalado, validado e então removido automaticamente quando o teste for concluído. Lembre-se de que você configurou o Serviço de Compilação para ser executado de forma interativa, que é o que permite ao aplicativo ser instalado e executado. Se não tivesse feito isso, um erro teria ocorrido durante a compilação.
O processo de compilação em si não é afetado pelos resultados da validação, portanto, os usuários precisam poder verificar os resultados do teste para saber se o aplicativo tem erros de validação. Felizmente, você pode melhorar o relatório de compilação para permitir aos usuários saber se a validação encontrou qualquer erro. Vamos ver como personalizar o relatório da compilação para integrar os resultados da validação da ferramenta ACK.
Personalizando o relatório de compilação O ACK cria um arquivo HTML e um XML e os salva na pasta escolhida. Você pode usar esse arquivo XML para criar uma atividade de fluxo de trabalho personalizado que irá modificar o relatório de compilação para notificar os usuários sobre os resultados da validação.
O código para criar essa atividade é bastante simples. Ele localiza o arquivo XML (que contém os resultados da validação), lê o arquivo para encontrar o valor do atributo “OVERALL_RESULT” e retorna esse valor. A Figura 7 mostra o código que cria a atividade CheckWackResultsActivity.
Figura 7 CheckWackResultsActivity
[BuildActivity(HostEnvironmentOption.All)]
public sealed class CheckWackResultsActivity : CodeActivity<bool>
{
[RequiredArgument]
public InArgument<string> DropLocation { get; set; }
[RequiredArgument]
public InArgument<string> WackResultsFilename { get; set; }
[RequiredArgument]
public InArgument<string> WackReportFilename { get; set; }
public OutArgument<string> WackReportFilePath { get; set; }
// If your activity returns a value, derive from CodeActivity<TResult>
// and return the value from the Execute method.
protected override bool Execute(CodeActivityContext context)
{
string dropLocation = context.GetValue(this.DropLocation);
string wackResultsFilename =
context.GetValue(this.WackResultsFilename);
string wackReportFilename = context.GetValue(this.WackReportFilename);
var dropLocationFiles = Directory.GetFiles(dropLocation, "*.*",
SearchOption.AllDirectories);
if (dropLocationFiles.Any())
{
var resultFile = dropLocationFiles.FirstOrDefault(
f => Path.GetFileName(f).ToLowerInvariant() ==
wackResultsFilename.ToLowerInvariant());
if (!string.IsNullOrWhiteSpace(resultFile))
{
var xDocument = XDocument.Load(resultFile);
var reportElement = xDocument.Element("REPORT");
if (reportElement != null)
{
var resultAttribute = reportElement.Attribute("OVERALL_RESULT");
if (resultAttribute != null)
{
context.SetValue(this.WackReportFilePath,
Path.GetDirectoryName(resultFile));
var validationResult = resultAttribute.Value;
// Fail or Pass
if (validationResult.ToLowerInvariant() == "fail")
{
return false;
}
return true;
}
}
}
throw new InvalidOperationException(
"Unable to find the Windows App Certification Kit results file!");
}
else
{
throw new InvalidOperationException(
"There are no files in the drop location!");
}
throw new InvalidOperationException(
"Unknow error while checking the content of the Windows App
Certification Kit results file!");
}
}
Por padrão, as atividades de compilação são executadas em agentes de compilação. Mas pode haver alguns cenários em que você deseje que a atividade seja executada logo na primeira etapa, mesmo antes de iniciar a compilação, ou como a última etapa antes que a compilação seja concluída. Para esse tipo de flexibilidade, você precisa que a atividade seja executada no controlador, não no agente. Isso pode ser feito usando o atributo BuildActivityAttribute, que considera como argumento o valor de enumeração HostEnvironmentOption.All (como pode ser visto na Figura 7). Observe que se você não usar a opção HostEnvironmentOption correta, obterá um erro durante o processo de compilação.
A classe CheckWackResultsActivity é herdeira de CodeActivity<bool> de modo que seu valor de resultado possa ser usado para exibir a mensagem correta no relatório de compilação. Para exibir esta mensagem, é possível usar uma nova atividade disponível no TFS 2012: WriteCustomSummaryInfo. Essa atividade é muito útil se desejar adicionar uma mensagem ao relatório de compilação porque, em vez de adicionar texto simples, ela permite que você adicione uma categoria dedicada ao relatório de compilação.
Você precisa especificar as seguintes propriedades:
- Message, que é o texto a ser exibido no relatório
- SectionDisplayName, que corresponde ao cabeçalho da seção
- SectionKey, o valor exclusivo da seção
- SectionPriority, que define a posição da nova seção no relatório (0 é a mais alta prioridade e as seções padrão começam em 100)
Portanto, usando a nova atividade e WriteCustomSummaryInfo, sou capaz de modificar o processo de compilação para verificar os resultados da validação e adicionar uma nova seção no relatório de compilação. A Figura 8 mostra o código XAML do processo de compilação modificado.
Figura 8 O processo de compilação modificado
<Sequence DisplayName="Windows 8" sap2010:WorkflowViewState.IdRef="Sequence_4">
<Sequence.Variables>
<Variable x:TypeArguments="x:Boolean" Name="WackToolRanSuccessfully" />
<Variable x:TypeArguments="x:String" Name="WackReportFilePath" />
</Sequence.Variables>
<c:CheckWackResultsActivity DropLocation="[DropLocation]"
sap2010:WorkflowViewState.IdRef="CheckWackResultsActivity_3"
Result="[WackToolRanSuccessfully]"
WackReportFilePath="[WackReportFilePath]"
WackReportFilename="ValidationResult.html"
WackResultsFilename="ValidationResult.xml" />
<If Condition="[Not WackToolRanSuccessfully]"
sap2010:WorkflowViewState.IdRef="If_4">
<If.Then>
<Sequence sap2010:WorkflowViewState.IdRef="Sequence_6">
<mtbwa:WriteCustomSummaryInformation
sap2010:WorkflowViewState.IdRef=
"WriteCustomSummaryInformation_2"
Message="["Windows App Certification Kit ran with errors.
Click [here](" & WackReportFilePath & ") to
access the folder containing the report."]"
SectionDisplayName="Windows 8" SectionKey="Windows8"
SectionPriority="75"
mva:VisualBasic.Settings=
"Assembly references and imported namespaces
serialized as XML namespaces" />
<mtbwa:WriteBuildError
sap2010:WorkflowViewState.IdRef="WriteBuildError_1"
Message="Windows App Certification Kit ran with errors." />
<mtbwa:SetBuildProperties
CompilationStatus=
"[Microsoft.TeamFoundation.Build.Client.BuildPhaseStatus.Failed]"
DisplayName="Set Status and CompilationStatus to Failed"
sap2010:WorkflowViewState.IdRef="SetBuildProperties_1"
mtbwt:BuildTrackingParticipant.Importance=
"Low" PropertiesToSet="CompilationStatus" />
</Sequence>
</If.Then>
<If.Else>
<mtbwa:WriteCustomSummaryInformation
sap2010:WorkflowViewState.IdRef="WriteCustomSummaryInformation_1"
Message="["Windows App Certification Kit ran with success.
Click [here](" & WackReportFilePath & ") to
access the folder containing the report."]"
SectionDisplayName="Windows 8" SectionKey="Windows8"
SectionPriority="75"
mva:VisualBasic.Settings=
"Assembly references and imported namespaces
serialized as XML namespaces" />
</If.Else>
</If>
</Sequence>
Observe na Figura 8 que se a validação falhar, o status da compilação é definido como “Failed” para impedir que o processo de compilação continue. Isso não é mandatório e pode ser removido se preferir que o processo de compilação sempre seja concluído, independentemente dos resultados da validação.
Agora, cada vez que uma compilação é disparada, o relatório de compilação exibe uma nova seção, dedicada ao Windows 8, que mostra o resultado da validação (consulte a Figura 9).
.png "The New Section in the Build Report Showing Validation Results")
Figura 9 A nova seção no relatório de compilação mostrando os resultados da validação
Usando WriteCustomSummaryInfo, o relatório de compilação pode ser aprimorado somente com texto e links. Se uma modificação mais complexa for necessária (por exemplo, adicionar uma imagem), você pode ainda aplicar as técnicas usadas com o TFS 2010.
Há muitas possibilidades para personalizar o modelo do processo de compilação dos aplicativos da Windows Store, e a boa notícia é que tais personalizações são praticamente as mesmas tanto para o Team Foundation Service quanto para o TFS local.
Thomas Lebrun é líder técnico na Infinite Square, um parceiro francês da Microsoft que trabalha em tecnologias incluindo o Windows 8/Windows Phone, Team Foundation Server, SharePoint e outras. Autor de dois livros em francês sobre o Windows Presentation Foundation e o padrão Model-View-ViewModel, Lebrun também faz palestras com frequência em eventos franceses. Acompanhe seu blog em blog.thomaslebrun.net e siga-o no Twitter em twitter.com/thomas_lebrun.
Agradecemos ao seguinte especialista técnico pela revisão deste artigo: Chris Patterson (Microsoft)