Delphi Developing

CnPack IDE Wizards: Incrementando a Produtividade

2010-10-01T20:41:00.000-03:00

Recentemente foi lançado a versão 0.9.7.591 CnWizards.
Para aqueles que não conhecem o CnPack IDE Wizards, este é um plugin para Delphi/C++ Build/RAD Studio que trás um conjunto de ferramentas para melhorar a eficiência de desenvolvimento.

O changelog desde a última release trás as seguintes mudanças:

r891: [IDE] Add Support to RAD Studio 2011
r890: [Prefix Wizard] Fix a Conflict to TntFrame.
r589: [Procedure Toolbar] Add Saving and Restoring Size of Drop Down Box
r588: [IDE] Support Delphi 2011 Beta 15.0.3890.34076.
      [Procedure Toolbar] Fix a Potential Exception when Clicking Location Buttons
r587: [IDE] Support Delphi 2011 Beta 15.0.3881.33894.
     [Prefix Wizard] Change Rename Dialog BorderStyle to Sizable.
r586: [IDE] Support Delphi 2010 Beta 15.0.3875.33573.
      [Source Highlight] Fix a Position Error when Wide-char-with-single-place Exists in BDS.
r585: [F2 Rename Identifier] Fix a Position Error when Unicode Char Exists in Delphi 2009 or Up.
r584: [IDE] Support Delphi 2011 Beta 3870 33544.
      [Source Highlight] Fix a Position Error when Unicode Char Exists in Delphi 2009 or Up.
r583: [Source Highlight] Fix a Position Error for WideChar in Delphi 2009 or Above.
      [CnDebugViewer] Fix a Searching Problem, Fix a Process Name Problem when new a Window.
r582: Add support to RAD Studio 2011 beta.
r581: [Source Highlight] Optimize Support to Anonymous Method.
r580: [Source Enhancement] Add Auto Quote Match Enter Function.
r579: [Wizards] Adjust Idle Interval to Keep Performance.
r578: [Tools] Change Tools Compiler to D7 to avoid False Trojan Warning.
r577: [Editor Toolbar] Decrease CPU Usage.
r576: [Editor Wizard] Add Zoom Font Functions.
      [ASCII Chart] Fix an extension ASCII Display Problem.
r575: [Setup.exe] Try to Fix/Avoid Trojan Warning.
r574: [Replace Wizard] Add TRegExpr support.
r573: [Auto Input] Fix a little bug.
      [Script Demo] Add RegExprReplace Script.
r572: [Feed Reader] Try to fix the problem of 0 size C file.
[Script Wizard] Add support for RegExpr.
r571: [Ascii Chart] Fix a painting bug under Win7.
      [Project Backup] Fix a bug of backup path.

Eu utilizo esse plugin há pelo menos 2 anos e hoje ele já está totalmente integrado no dia-a-dia do desenvolvimento. Quando preciso trabalhar em uma IDE sem o CnWizards instalado, percebo como o RAD Studio tem muito espaço para evoluir.
Dentre as opções que o pacote possui algumas são versões melhoradas de recursos que o IDE do Delphi/C++ Builder já possui, algumas são inovações percebidas imediatamente após a instalação outras você vai descobrindo com o tempo, mas todas são de grande valia.
Devido ao grande número de ferramentas e opções de customização que esse add-in oferece é comum, de tempos em tempos, descubrir que já existe uma ferramenta para alguma tarefa que faço manualmente ou uma forma diferente e melhor de aproveitar o que já está sendo usado.
Vou dedicar esse post para descrever algumas notas dos principais recursos que esse maravilho pacote possui.

MessageBox Visual Designer

Penso que dificilmente, ao desenvolver um software, escapamos de ter que apresentar dialogs de notificações (Confirmação, Solicitação, Erro e Alerta).
As vezes utiliza-se o ShowMessage, as vezes o MessageBox do próprio delphi, outras vezes um componente de terceiro ou ainda uma solução própria.
Para auxiliar na hora de definir essas notificações, o CnWizards trás uma tool muito fácil e prática. Ela pode ser acessada através do menu CnPack ou via tecla de atalho, que por padrão vem configurada para CTRL + SHIFT + D.

Na tela você pode especificar todas as informações que o dialog irá exibir bem como visualizar o resultado através do botão Preview.
No lado direito há um painel (Return Value) que pode ser marcado e, assim, especificar que tais valores de retorno serão tratados. Assim, ao confirmar, será gerado o código fonte para a apresentação do dialog e também para o tratamento das opções de retorno.
Há também a aba Settings que trás algumas opções que definem como o código fonte deve ser gerado.

Propery Editor

String Caption Editor: Quando ativado, a propriedade "Caption" dos componentes é associado com um editor de texto (comum a outras propriedades do tipo string).

OBS: Nem todas as propriedades Caption de todos os componentes serão associados a esse editor.

Hint Editor: Esse editor é acionado através da propriedade Hint dos componentes visuais. Ele facilita bastante na hora de definir o hint que será exibido o ballon e o que será exibido na barra de status.

String List Editor: Por padrão o Delphi possui um editor default para as propriedades do tipo TStrings. Quando o editor String List do CnWizards está habilitado ele substitui o editor padrão pelo apresentado abaixo.
Esse editor é muito semelhante ao utilizado na propriedades Caption. A diferença é a presença do botão Code Editor, no lado direito.

Filename Editor: Esse editor associa um dialog de localização arquivo às propriedades cujo nome é "Filename".

Esse dialog pode ser acessado através do botão "..." situado à direita da propriedade (no Object Inspector).

Constraint Editor: Exibe os valores de cada uma das propriedades da classe TSizeConstraints diretamente ao lado do nome da propriedade, no object inspector. Evitando ter que expandir tal propriedade para conhecer os valores.

Outra ferramenta bastante prática é o editor associado à TSizeConstraints (pressione o botão "..." apresentado na imagem acima ou dê um duplo clique sobre a propriedade Constraints).

Esse dialog permite mais facilmente utilizar as dimensões atuais do componente para definir os limites de sua dimensão.
Inicialmente não ficou muito claro a vantagem de se usar dialog, já que eu poderia simplesmente copiar o valor das propriedades Height e Widht. Entretanto depois de algumas vezes que você utiliza esse editor, percebe-se que é mais fácil do que utilizar ctrl + c/ctrl + v.

Scrollbar Editor: Para as propriedades que representam as barras de scroll (vertical e horizontal), são apresentados os principais itens de sua configuração ao lado do nome da propriedade, evitando que seja necessário expandi-la para verificar.
Os itens de configurações que são exibidos, como pode ser visto na imagem abaixo, são: Visible, Tranking, Range e Position.

Font Editor: Da mesma forma que o editor do ScrollBar, não é preciso expandir as propriedades do tipo TFont para visualizar sua configuração. Isso proporciona pequenas economias de tempo em etapas de design e manutenção dos formulários.

Aling Editor: Este proporciona um pequeno incremento visual na hora de definir o tipo de alinhamento do componente, apresentando uma imagem associativa.

Component Name Editor: Esse editor está relacionado com um dos recursos mais significativos do CnWizards, que é a padronização dos prefixos utilizados nos nomes dos componentes.

Esse editor associa o dialog apresentado abaixo à propriedade "Name" dos componentes, facilitando a tarefa de atribuição do nome dos componentes.

O dialog irá utilizar o prefixo que foi anteriormente definido para o componente e irá sugerir um novo nome, caso este não esteja com o prefixo correto.
No caso de um prefixo ainda não ter sido definido para o componente selecionado, um outro dialog será apresentando antes solicitando tal informação.

Form Enhancements

Logo após a instalação você já consegue visualizar muitas mudanças tanto visuais quanto na escrita de código.
O CnWizard acrescenta duas barras de ferramentas no IDE. Uma para quando o ID está em modo de design e outro para quando o IDE está em modo de edição.
As opções abaixo referem-se às opções oferecidas para o modo de design.

Show/Hide Components: Em formulários com muitos componentes não visuais, essa opção é de muita utilidade na hora de realizar alguma manutenção. Como o próprio título sugere, a tool permite ocultar os componentes não visuais dos formulários evitando ter que arrastá-los de um campo para outro para poder acessar os demais componentes do formulário.

Display TabOrder: Quando essa opção está ativa, é apresentado um pequeno retângulo em cada um dos componentes com o respectivo valor da propriedade TabOrder. Assim, visualmente consegue-se identificar se a ordem de passagem de focus está ou não de acordo com o esperado.

Auto Set Update TabOrder in the Form: Outra tool bem útil durante a etapa de design. Com ela a propriedade TabOrder dos componentes é automaticamente setada conforme sua posição na tela.

Auto Update TabOrder after Componentes Moved: O próprio título da tool já resumo sua função. Quando ativa, o TabOrder é reajustado automaticamente sempre que um componente é movido

Locate Components in Designer: Localizado bem a direita da barra de ferramentas do CnWizards, essa ferramenta é de grande ajuda quando temos formulários com um número de componentes expressivo. Sua interface é simples e intuitiva.
Conforme é digitado no campo Find, a tool remove as entradas que não contém o texto digitado. Ao pressionar ENTER, ou o botão bem da esquerda - Locate and Select Component, o componente que está selecionado na listagem será automaticamente selecionado no formulário.

Caso o componente a ser localizado está incluso dentro de, por exemplo, um TPageControl cuja aba não está visível a tool irá automaticamente alterar a respectiva aba como ativa e selecionar o componente desejado. Entretanto, em pacotes de componentes de terceiros esse comportamento não foi verificado, ficando visível apenas as bordas de seleção na área do form onde o componente está localizado.
Mesmo assim é uma mão na roda!

Arrange the Non-Visual Components: Quando o formulário possui componentes não-visuais espalhados pelos cantos do form, uma ótima forma de organizá-los é através dessa tool. Ela apresenta um tela com opções que determinam como esses componentes devem ser alinhados e organizados dentro do form.

Se houver componentes, não-visuais, selecionados, a reorganização será aplicada somente sobre eles. Caso contrário, todos os componentes não-visuais serão movidos conforme as configurações definidas na tela acima.

Converte Selected Components to Creating Code: Logo que deparei-me com essa tool, de imediato pensei: "está aí o recurso que eu sempre tive vontade de implementar".
Como pode ser visto na imagem abaixo, a tool apresenta um dialog com o código fonte para o status atual do componente selecionado. O interessante é que só é gerado a respectiva linha de código para as propriedades que foram realmente modificadas.
A imagem abaixo mostra um exemplo utilizando um componente TButton e o código gerado está no formato C/C++ porque a tool foi utilizada em um projeto do C++ Builder. Se for um projeto Delphi, o código fonte gerado estará no padrão Object Pascal.

Um recurso extremamente útil quando há a necessidade de fazer várias alterações comportamentais/visuais nos componentes em runtime.
Quando se trata de alterar as posições dos componentes, é comum acrescentar as linhas de código com atribuições de valores aproximados para as respectivas propriedades e avaliar o resultado visualmente, ou seja, buildando e executando o software. Então se o resultado não foi satisfatório, faz-se pequenos ajustes nos valores das propriedades e novamente o sistema é buildado e executado.
Muitas vezes esse processo demanda bastante tempo. Já com essa tool, você visualmente altera o formulário para o "estado final" e gera o código dessa alteração, bastando praticamente colar as linhas dentro do método/evento desejado. Simples, não?!
Mas esse é apenas um dos muitos exemplos de uso prático desse recurso.

Copy Selected Component's Name to Clipboard: Impressionante como um recurso tão simples como esse pode facilitar tanto a vida do programador.
Esse recurso está associado com uma prática muito comum durante o designer/implementação dos formulários, que é procurar pelo componente desejado no formulário para obter seu nome.
Durante a implementação de algum método ou evento, nem sempre lembramos dos nomes dos componentes. Assim, é comum mudar o modo de exibição do IDE para design; localizar o componente a qual queremos referencia-lo; clicar no object inspector; localizar a propriedade "name"; pressionar um CTRL + C para copiar o nome do componente; voltarmos ao modo de edição; e pressionar CTRL + V.
O que essa tool faz é muito simples, apenas coloca o nome do(s) componente(s) selecionado(s) na área de transferência e retorna ao modo de edição, o que economiza alguns click de mouse e pressionamento de teclas.
Pode parecer pouco, mas quando você repete esses passos várias vezes tenho certeza que irá entender o benefício dessa tool.
Outra ponto bastante interessante é que você não precisa repetir o procedimento para cada componente, é possível você selecionar todos os componentes desejados e só então utilizar essa tool. Ela irá colocar na área de transferência o nome de cada componente acrescentando uma linha em branco entre eles.
Por padrão, a tecla de atalho CTRL + ALT + N já vem atribuída para esse recurso, que facilita ainda mais seu uso.

Select Current Form in Current Designer: Aqui temos outro recurso bem simples, mas que proporciona um melhor conforto ao lidar com o formulários. Quando selecionado ele muda o focus de design para o formulário.
Pode parecer pouco útil esse recurso e que bastaria, por exemplo, pressionar SHIFT e clicar no mesmo componente que já está selecionado, mas ao pensar em todas as vezes que acidentalmente essa ação resultou no redimencionamento ou na alteração de posição do componente, essa alternativa passar a ser bem útil.
Basta começar a usá-la que depois de um tempo você sentirá falta quando estiver trabalhando em um IDE sem esse plugin.

Lock Controls: Essa tool, quando ativada, impede o usuário de alterar tanto a posição quanto as dimensões dos componentes do formulário em focus. Em outras palavras, os componentes ficam bloqueados sendo possível somente selecioná-los.
Sem sombra de dúvida um recurso muito útil (ou você nunca deslocou um determinado componente do formulário quando na verdade só queria selecioná-lo?!).

Toggle Designer Guideline: Guidelines são aquelas linhas que ajudam no alinhamento dos componentes quando se está movendo-os. O guideline funciona como recurso "magnetic" do winamp, mas levando em consideração a posição dos outros componentes do formulário.
Mas se esse recurso não é útil ou atrapalha, você tem a opção de desabilitá-lo utilizando esse botão.

Atalhos para Alinhamento: Aqui são várias opções, mais especificamente 6, que ajudam muito tem toda a fase de criação dos formulários ou mesmo alteração/manutenção.
Essas opções ficam disponíveis quando há mais do que um componente selecionado e são destinados para realizar um determinado tipo de alinhamento. Por exemplo, o primeiro deles irá alinhar os componentes à esquerda, o segundo irá alinha-los à direita.
Note que a imagem de acada botão é bastante intuitiva e, na dúvida, basta posicionar o cursor do mouse sob eles que o hint irá descrevê-los.
Um ponto importante é que essas opções usam o primeiro componente que foi selecionado como base referencial para o alinhamento. Por exemplo, no caso do alinhamento à esquerda todos os componentes selecionados assumirão a posição esquerda (propriedade Left) do primeiro componente.

Atalhos para Espaçamento: Aqui temos mais 6 opções que também trabalham no possicionamento dos componentes, mas destinados para facilitar o trabalhano no quesito espaçamento.
Também muito intuitivos. Por exemplo, o segundo botão irá reposicionar verticalmente todos os componentes distribuindo o espaço em branco entre eles. Essa opção fica disponível quando há mais do que dois componentes selecionados e tanto o componente mais no topo quanto o mais na base do formulário não são reposicionados, mas sim os que estão entre eles.
Da mesma forma que as opções de alinhamento, há três botões que trabalham com premissa horizontal e três que trabalham com a premissa vertical.

Atalhos para Resize: São atalhos que trabalham com as propriedades Heigh e Width dos componentes. Alguns dessas opções só ficam habilitadas quando há mais do que um componente selecionado.
São igualmente simples, e dispensa maiores comentários.

Atalhos para Posicionamento: Aqui temos mais algumas opções que agilizam a tarefa de alinhar componentes.
Bastam alguns poucos clicks para entender como eles funcionam.

Editor Enhancements

Guide Lines

Esse melhoramento faz com que o IDE destaque e identifique individualmente os blocos de códigos através de cores e linhas de conexão.

As statments (if, try, for, while, begin-end, ...) que delimitam os blocos de códigos são destacadas em cores diferentes dependendo de seu nível. Além de facilitar a identificação dos trechos de código, em procedures grandes esse recurso proporciona uma segunda funcionalidade que é identificar se um bloco está ou não dentro de outro bloco sem precisar deslocar-se.
O recurso se adapta facilmente aos diversos padrões de formatação de código fonte.

Highlight Matched Brackets: Propõem uma melhora na identificação dos limites dos parênteses "()" e dos conchetes "[]" destacondo-os em cores diferenciadas.
Um exemplo prático do quão útil essa melhoria representa é em linhas de código que possuem expressões matemáticas com vários parênteses ou então em condições lógicas mais complexas.

Auto Imput Matched Bracket: Insere automaticamente um fecha conchetes ("]") quando você digita "[". O mesmo ocorre com o parênteses e chaves ("{}")..

Extented Home Key: Quando pressionamos a tecla HOME no modo de edição do IDE o cursor é deslocado para a primeira coluna da linha corrente. Com essa opção ativada, a tecla HOME passa a ter uma segunda função quando é pressionado pela segunda vez consecutiva que é posicionar o cursor no primeiro caracter válido.
Basicamente ele irá ignorar todos os espaços em branco situados na esquerda da linha.

Auto add "end" when pressing ENTER after "begin": Durante a escrita de código fonte, ao digitarmos "begin" e pressionarmos a tecla ENTER, esse recurso irá automaticamente acrescentar um "end" na linha abaixo

Tab/Shift + Tab to Ident/Unindent Selected Block: Por padrão o Delphi vem configurado para usar as combinações CTRL + I e CTRL + U para identar/retroceder identação do um bloco de código que está selecionado.
O CnWizard reconfigura essa função atribuindo essa tarefa de identação para as respectivas combinações TAB/SHIFT + TAB, as quais são mais largamente utilizadas.

F3/Shift + F3 to search the selected text: A tecla F3 passa a ser utilizada para procurar a próxima ocorrência da última pesquisa, enquanto que Shift + F3 tenta encontrar a ocorrência imediatamente acima da posição corrente do cursor.

Show Total Lines Count: Exibe o canto inferior esquerdo do editor o total de linhas da atual unit aberta. Evitando ter que deslocar-se até o final do arquivo para obter o número total de linhas que a unit possui.

Change var name: Um das opções de refacting que o RAD Studio trás é o "Rename Variable" que, ao ativá-lo, apresenta um dialog solicitando o novo nome e, após, exibe um tool panel com todas as ocorrências encontradas onde o usuário pode optar por continuar o refacturing.

Uma versão melhorada desse recurso está incluso no CnWizards e pode ser acessado pressionando a tecla F2 sobre a variável/método a qual se deseja renomear. Mas essa tecla de atalho não está limitada a apenas ao editor de código.
Em mode de design o pressionamento da tecla F2 irá exibir um dialog solicitando o novo nome do componente que está selecionado.

Tools

Uses Cleaner
Quando estamos na etapa de criação/design de formulários é normal fazermos algumas combinações e testes para encontrar os componentes mais adequados para a solução em questão. Nesse processo costuma-se acrescentar, remover e substituirmos alguns componentes por outros mais adequados.
Os componentes novos quase sempre acrescentam novas entradas de units na cláusula uses quando são dropados no form pela primeira vez. No entanto, quando removemos ou substituimos esses componentes do formulário, o Delphi não remove as respectivas units da cláusula uses e, dependendo da frenquência com que é feito essa ação, podemos chegar a ter várias referências desnecessárias.
O simples fato de instalarmos uma versão mais recente de algum pacote de componentes, por exemplo, pode tornar a referência de algumas units obsoletas.
A função dessa tool tem o objetivo justamente de fazer uma limpeza na cláusula uses, removendo todas as entradas desnecessárias.

Comments Cropper
Uma ótima ferramenta quando a intenção é distribuir/publicar código fonte.
Essa tool é um assistente destinado, principalmente, à eliminação de comentários do código fonte. Além disso o dialog trás opções bem interessantes como a eliminação de linhas em brancos duplicadas e remoção de TODOs.
A range de ação não necessariamente se aplica a apenas a corrente unit, é possível extender para até um diretório.

MSDN Help Wizard
Permite de forma prática e ágil realizar pesquisas no help MSDN, da Microsoft.
A tool disponibiliza dois atalhos. Um deles é o MSDN Toolbar (Shift + F1) que permite inserir palavras de pesquisa e, ao ser pressionado ENTER ou o botão search, é aberto no IDE a página do MSDN exibindo o resultado da pesquisa. O outro atalho, MSDN Help (Alt + F1), apenas abre no IDE a página de pesquisa do MSDN.

O MSDN Toolbar também armazena o histórico de pesquisas e pode ter o número máximo de entradas de log configurado.

Copy as HTML Format
Pense em todas as vezes que, por exemplo, ao redigir um email você copiou um trecho de código fonte e depois ficou vários minutos apenas colorindo as palavras reservadas e outros identificadores e símbolos para imitar a highlight syntaxe do Delphi.
Bom, agora não é mais preciso gastar um tempo preciso para essa tarefa. Através dessa tool o texto selecionado é posto na área de transferência incluindo também a formatação.

O CnWizard acrescenta um item no menu de contexto que é exibido em modo de edição e a imagem acima mostra onde essa opção pode ser encontrada.
Observe que muitas outras opções estão disponíveis e vale cada segundo de tempo investido para conhecer esses recursos.

Source Statistics
Coletar informações estatísticas é a proposta dessa tool.
Ao ser acessada (CnPack -> Source Statistics) um dialog semelhante ao da imagem abaixo é apresentado solicitando o ranger de arquivos a serem pesquisados.

Ao pressionar o botão "Calculate", será apresentado um dialog com informações básicas de cada unit ou a soma delas, no caso de pertencer a um projeto.

Source Templates
Particularmente utilizo muito esse recurso e tem se mostrado de extretamente útil.
O Source Templates é semelhante ao Live Templates do Delphi. No entanto ele não permite a edição de campos diretamente no editor. Em vez disso, é apresentado um dialog solicitando o conteúdo de cada um desses campos definidos no template.
O CnWizard trás um editor para gerenciar todos os templates definidos e permite, inclusive, associar uma tecla de atalho para cada template.

Um diferencial no Source Templates é o número de customizações e informações dinâmicas que se pode utilizar na criação dos template.
Na imagem acima também pode-se observar a definição de um template que utilizo para a geração do cabeçalhos de comentários nos métodos.
A quantidade de recursos utilizados no script acima é pequena, mas o suficiente para entender o que tudo se pode fazer com essa tool.
Quando ativado um dialog, igual ao apresentado abaixo, é listando todos os campos definidos no template com a opção de definir um valor/texto.
De forma geral, vejo essa tool como uma evolução do Live Template do Delphi.

Code Editor Wizard
Aqui temos um conjunto rico de opções que podemos utilizar para auxiliar as tarefas de codificação, documentação, edição, investigação, code review, ...
Cada item do menu apresentando na imagem abaixo representa um pequena ferramenta.

Vou deixar por sua conta a prazerosa tarefa de descobrir o benefício que cada um desses itens têm a oferecer.

Replace in Files
Até hoje não entendi a razão do Delphi não trazer uma ferramenta de substituição de texto que se extenda para além do arquivo corrente.
Um exemplo de uso prático é a substituição do nome de um classe, variável ou definição que é utilizado em vários arquivos. Na verdade esse é apenas um exemplo, há muitas maneiras úteis de se utilizar batch file replace.

Prefix Wizard
Em ambientes de trabalho que utilizam ferramentas de desenvolvimento baseadas em componentes, é clássico e certo a discussão em torno da padronização de prefixos para os componentes.
O que essa ferramenta faz é gerenciar a lista de prefixos de seus respectivos componentes e incentivar o desenvolvedor a adotá-los.
Toda vez que um componente é dropado no formulário, um dialog é apresentado solicitando o nome do componente. Entrentanto o próprio CnWizard já faz uma sugestão de nome acrescentando o prefixo estipulado para aquele componente.
No caso de um prefixo ainda não ter sido definido, um outro dialog é apresentado requisitando tal informação.
A imagem abaixo apresenta a tela de configuração dessa ferramenta (observe o número de customizações disponíveis).

Mas essa tool ainda reserva uma opção a mais que é o compartilhamento da lista de prefixo.
Ela permite definir a localização do arquivo na qual essas opções e a lista dos prefixos serão armazenadas, permitindo que outras estações de trabalho utilizem as mesmas configurações.
No caso de um estação acrescentar ou modificar alguma opção, imediatamente a mudança fica visível para os demais.

IDE Config Backup/Restore Tool
Pense em todas as vezes que você instalou ou reinstalou o Delphi/C++ Builder e passou um bom tempo reconfigurando o IDE para assumir a mesma condição anterior. Ou pior, depois de muito tempo descobre que esquecei de copiar um template, ou outro recursos qualquer.
É justamente para sanar esse problema que o CnWizard trás uma ferramenta capaz de fazer backup e restauração do IDE.

Conclusão
O que foi apresentado nesse artigo é uma parcela muito pequena da quantidade de ferramentas que esse pacote oferece.
O potencial de desenvolvimento que o CnPack proporciona é imenso tanto é que mesmo após 2 anos, e durante a escrita desse post, descobrir recursos que não haviam sido notados antes.
Para aqueles que desejam ler um pouquinho mais sobre os demais melhoramentos, eu indico esse documento: http://www.intitec.com/varios/Delphi_al_limite_2009.pdf
São nada menos do que 294 páginas!

Delphi XE (2011) + ZeosLib 7 + PostgreSQL 9.0

2010-09-30T17:17:00.204-03:00

Hoje instalei o recem lançado Embarcadero RAD Studio XE e gostei do que encontrei nele. Também pretendo escrever algumas notas sobre essa versão nos próximos dias.
Há algum tempo eu escrevi um pequeno passo-a-passo de como instalar o pacote de componentes ZeosLib no Delphi 2010 (http://flovato.blogspot.com/2009/10/zeoslib-for-delphi-2010.html) e hoje volto novamente a esse assunto mas com uma abordagem levemente diferente.
Também, a poucas semanas atrás, tivemos o lançamento da versão 9.0 do PostgreSQL e fiquei curioso para saber o quanto essa nova versão é suportada pelo ZeosLib.

Download
A última versão oficial, estável e disponível do ZeosDBO é a versão 6.6.6 que foi lançada em 30 de Dezembro de 2009 e oferece suporte para o Delphi 5 até Delphi 2007 (Delphi 11).
A versão 7.0 já era ansiosamente aguardada pelo público que utilizava desde o Delphi 2009 devido ao suporte UNICODE e, ainda hoje, continua em desenvolvimento e sem data certa para lançamento.
No artigo anterior foi utilizado uma revision alfa do ZeosLib 7 e, da mesma forma, iremos utilizar a revision mais recente do branch testing para o Delphi 2011 (XE).

Faça o checkout do branch de teste do ZeosLib (svn://zeos.firmos.at/zeos/branches/testing) para um diretório qualquer.
Se seu client svn for de linha de comando, abra o prompt de comandos e desloque-se até o diretório onde deseja fazer o checkout e execute o comando:
svn checkout svn://zeos.firmos.at/zeos/branches/testing.

Caso tenha instalado o Tortoise ou qualquer outro client svn, o procedimento é ainda mais fácil.

Nesse artigo o diretório D:\Delphi\Componentes\ZeosDBO2011\ será o local escolhido para o checkout, sendo utilizado como diretório base. Assim, no caso de você escolher um caminho diferente, basta reajustar as configurações no passo-a-passo de instalação para esse novo caminho.

OBS: A revision utilizada durante a escrita desse artigo foi a r822.
Além disso, se tiver dúvidas de como realizar o checkout, há uma imensa quantidade de tutoriais que explicam detalhadamente esse tema (link de pesquisa).
Por último, há a possibilidade de você baixar diretamente do sourceforge (http://sourceforge.net/projects/zeoslib/files/Zeos%20Database%20Objects/), quando assim uma release for disponibilizada.

Se tudo estiver correto, o pacote irá apresentar uma estrutura de diretórios igual ou muito semelhante ao da imagem abaixo.

Instalando o Pacote

O procedimento de instalação é bastante simples:

1. Abra o IDE do Delphi com permissões de administrador. Apesar de não ser obrigatório, deixo como uma forte recomendação em decorrência de problemas que tive em outras ocasiões.

2. No IDE do Delphi, clique na opção "Open Project" no menu "File" e vá até o subdiretório "\packages\delphi15" do local onde o foi feito o checkout do ZeosLib. Lá, abra o grupo de projetos ZeosDbo.groupproj.
OBS: O "15" nesse path identifica a versão do Delphi que, nesse caso, refere-se ao Delphi XE. Caso esteja utilizando uma outra versão, deve-se abrir o grupo de projetos correspondente a essa versão (Delphi13 = Delphi 2009; Delphi14 = Delphi 2010; Delphi15 = Delphi XE; ...).

Uma segunda dica para aqueles que já possuem o ZeosDBO 7 instalado e querem atualizá-lo, recomendo que, antes de iniciar a instalação, remova a versão atual do IDE e, após isso, delete todos os arquivos criados no último build (.dcp, .dcu, .loca, .identcache, .dsk, .map e .bpl).
Esses últimos podem ser encontrados na pasta "build" (\packages\delphi15\build). Assim, certifique-se de que essa pasta não contenha arquivos.

3. Build todos os projetos (menu Project -> Build All Projects);

Se tudo estiver OK, o Delphi irá informar a ocorrência de muitos hints e warnings durante o build dos packages. Não se preocupe, por hora vamos considerar que essas notificações não representam problemas.

Entretanto, muito provavelmente será apresentar uma mensagem de erro informando não ter encontrado um determinado arquivo fonte (Exemplo: "... [DCC Fatal Error] ZCore.dpk(51): F1026 File not found: 'ZVariant.dcu' ...").
Para corrigir isto basta apenas localizar o respectivo arquivo mencionado na mensagem de erro a partir do subdiretório "src" no local onde o checkout foi feito e acrescentar o caminho completo no Libray Path do Delphi (Menu Tools -> Options -> Environment Options -> Delphi Options -> Library).

Para evitar essa e várias outras notificações informando não ter encontrado um arquivo específico, acrescente cada um dos subdiretórios presentes no diretório raíz do ZeosLib no Library Path, como é mostrado na imagem abaixo.

Garanta que todas essas sete entradas, destacadas na imagem acima, estejam presentes no Library Path do Delphi. Especialmente a última, porque a compilação não irá emitir uma mensagem de erro se tal entrada não estiver presente. Entretanto, contribuirá com um efeito indesejado na hora de instalar o pacote de componentes.

Observe que na definição dos paths eu utilizo "$(DelphiComponents)\".

Na minha estação de trabalho há uma variável de ambiente chamada DelphiComponents que tem a finalidade de referenciar o diretório onde todos os componentes/pacotes de terceiros estão localizados.

Isso facilita a migração e uso de versões diferentes de componentes sem que seja necessário a reconfiguração dos path nos projetos ou no IDE do Delphi.

Caso não tenha ou não queira adicionar essa variável de ambiente, apenas substitua "$(DelphiComponents)\" pelo path onde o ZeosDBO está localizado (que nesse artigo é D:\Delphi\Componentes\ZeosDBO2011).

OBS: Se após acrescentar os diretórios na Library Path o Delphi continuar exibindo a mensagem de erro, basta fechá-lo e reabrí-lo. Não esqueça de reabrí-lo com permissões de administrador!

4. Instale o pacote de componentes selecionando a opção "Install" (no menu de contexto) do pacote "ZComponentDesign150.bpl";

Se ao tentar instalar o pacote "ZComponentDesign150.bpl" for apresentado uma mensagem de erro igual ao da imagem abaixo, isso significa que o Delphi não encontrou o arquivo .BPL específico.

A forma mais prática e rápida de corrigir esse problema é colocando o diretório onde tal .BPL está localizada no System Path.
Observe que ao ser buildado os pacotes do ZeosLib, será criado um diretório chamado build localizado no subdiretório ".\packages\delphi15".
Assim, basta acrescentar esse caminho (D:\Delphi\Componentes\ZeosDBO2011\packages\delphi15\build) na lista de diretórios da variável de ambiente "PATH".

OBS: Qualquer alteração nas variáveis de ambiente irá requerer fechar e abrir novamente o Delphi, para que as alterações tenham efeito.

Se ao tentar instalar o pacote "ZComponentDesign150.bpl" for apresentado uma mensagem de erro igual ou semelhante ao da imagem abaixo, muito provavelmente ocorreu um descuido na especificação dos path do ZeosDBO.

Classifico como descuido porque esse erro foi ocasionado quando estava tentando instalar o ZeosDBO que estava em um path diferente daquele referenciado no System Path e no Library Path (no IDE do Delphi).
Assim, garanta que todos os path apontem exatamente para o diretório onde o ZeosDB está localizado.

Se tudo correr bem o Delphi irá apresentar um dialog informando a lista dos componentes que foram instalados.

5. Validando a instalação do pacote
Opcionalmente, você pode confirmar se a instalação realmente está consistente verificando os pacotes de componentes instalados no Delphi.
Para isso acesse o menu Component -> Install Packages ... e localize a entrada "Zeos Database Components".

Muitos tem relatados que mesmo a instalação do pacote ter sido bem sucedida, o Delphi não mostra a paletta de componentes do ZeosDBO.
Isso ocorre porque algum dos passos acima foi pulado ou não realizado de forma correta. E, normalmente, a razão do problema reside em dois pontos:
1º. Esqueceu de acrescentar a pasta de build ($(DelphiComponents)\packages\delphi15\build) no Library Path;

2º. Não especificou a pasta de build do ZeosDBO no System Path;

Uma forma fácil de confirmar isso é digitar “set path” no prompt de comandos.

Observe que na imagem abaixo o caminho "D:\Delphi\Componentes\ZeosDBO2011\packages\delphi15\build" está presente.

Conexão com PostgreSQL 9.0
A primeira questão a ser verificada é se essa versão do ZeosDBO consegue, ao menos, conectar-se ao PostgreSQL.
Nesse ponto é assumido que você já tenha instalado o PostgreSQL 9.X.

Para esse teste básico, um novo projeto foi criado e um componente TZConnection foi dropado no formulário.

Observe na imagem ao lado que a conexão foi efetuada com sucesso sobre a própria base de dados do postgres (metadados).

Um ponto a ser destacado é que na lista de protocolos (propriedade Protocol) não há um item "postgresql-9", como esperado. Assim, a opção mais provável foi utilizar "postgresql-8".

Penso que com o tempo seja acrescentado uma opção exclusiva para a versão 9 do postgresql, já que essa introduz mudanças significativas.

A configuração do componente TZConnection no DFM é apresentado como:

  object ZConnection1: TZConnection
   Properties.Strings = (
   'codepage=UTF8'
   'client_encoding=UTF8')
   AutoCommit = False
   Connected = True
   Protocol = 'postgresql-8'
   HostName = '127.0.0.1'
   Port = 5432
   Database = 'postgres'
   User = 'postgres'
   Password = 'MinhaSenha'
   Left = 126
   Top = 16
  end

Após configurar o componente e alterar a propriedade Connected para True, pela primeira vez, uma notificação de erro igual ao da imagem abaixo foi apresentada.

Esse é um problema clássico que é resolvido de duas maneiras: 1) Copiando os devidos arquivos para a pasta do projeto; ou 2) Acrescentando o diretório onde tais arquivos se encontram no PATH do sistema.

Todas as DLLs estão localizados no subdiretório "bin" do diretório de instalação do PostgreSQL (provavelmente C:\Program Files\PostgreSQL\9.0\bin).

Como mostra a imagem acima, a solução escolhida foi acrescentar o diretório de instalação do PostgreSQL no Path do sistema para que não seja necessário ter que copiar novamente as DLLs para novos projetos que usem o ZeosDBO.
Após isso só foi necessário fechar e reabrir o Delphi e a conexão ocorreu como esperada.

Realizando consultas
Após uma conexão bem sucedida, realizei alguns testes com os componentes básicos para exibir os registros das tabelas.
Na imagem abaixo pode-se notar o componente DBGrid exibindo informações da tabela "information_schema.table".

Apesar de ter realizados alguns poucos testes básicos em modo de design, aparentemente os componentes estão funcionando bem. Não notei qualquer tipo de falha.
Para validar prováveis problemas de suportes que muitas vezes são observados em circunstâncias específicas ou após um bom tempo de uso, resolvi migrar todo um sistema desenvolvido no Delphi 2010 para o Delphi XE.
Esse sistema possui um framework de banco de dados baseado no ZeosDBO e, em teoria, buildar e executar esse sistema através do Delphi XE iria expor qualquer falta de suporte para com o PostgreSQL 9.0, já que esse framework faz uso moderado dos recurso/componentes do ZeosDBO e o sistema possui uma base de dados relativamente grande.

Migrando o sistema para o Delphi XE
Imaginei que seria mais trabalhoso, mas praticamente não foi preciso fazer muita coisa.
Ao abrir o grupo de projeto desse sistema que foi criado no Delphi 2010, o Delphi XE nem mesmo realizou qualquer tipo de conversão de formato.
O único trabalho que tive foi substituir, na cláusula require dos projetos a referência de alguns pacotes de componentes de terceiros (por exemplo: substituir tms2010 por tms2011). O que não custou mais do que 30 minutos.
Só encontrei problemas com alguns pacotes de terceiros que estavam sendo utilizados. Entretanto, para todos já havia uma versão mais recente que suportavam o Delphi XE. Assim, o trabalho real foi instalar as versões novas desses pacotes, com exceção de um deles que necessitou alguma intervenção manual.

Bom, aqui o que nos interessa é a suporte do ZeosDBO ao PostgreSQL 9.0 e em relação a isso surpreendentemente não foi necessário modificar uma linha se quer do framework de banco de dados (esse framework foi criado em 2008 com a ainda recente versão 6.6.4 do ZeosDBO!). O sistema foi buildado 100% sem qualquer problema (apenas alguns poucos hints).
O foco desse post não é a migração de sistemas para o Delphi XE, mas a experiência foi muito positiva. E encorajo qualquer um que use o Delphi 2010 para fazer esse upgrade.
Inicialmente fiquei pensando que era bom demais para ser verdade e que bastaria rodar o sistema para as cores de cabeça aparecerem. Para minha felicidade, o software executou normalmente passando com sucesso em todos os testes automatizados.

Conclusão
Tenho a total consciência que por mais amplo que seja a utilização dos componentes e das funcionalidades do ZeosDBO nesse framework de banco de dados, é precipitado concluir que a versão alfa da versão 7.0 seja totalmente compatível com o PostgreSQL 9.X, mas sinto-me tranquilo para incentivar a qualquer um que já esteja pensando em fazer algum tipo de migração/upgrade parecido para que o faça.

Quanto vale o seu site?

2010-08-20T21:32:00.000-03:00

Fugindo um pouco do tema desenvolvimento de software a qual esse blog é dedicado, dedico este post a tratar de um assunto que muitas vezes passa desapercebido, mas que para um blogueiro ou um webmaster é um dilema.
Quanto vale o seu site? Quanto vale todo o esforço despendido? Por quanto devo vender?

Quando se pensa em qual valor cobrar por um determinado site, temos muitas variáveis que entram nos custos fixos como horas trabalhadas, manutenção, divulgação, horas extras, registros, etc.
Por outro lado, para definir o valor final muitas outras variáveis entram no cálculo onde algumas não figuram na realidade de um determinado negócio, enquanto outras são os pontos chaves. Dentre esses pontos podemos citar o número de visitas que o site recebe, a popularidade, o pagerank, ...
Quando o assunto é estimar o quando um site vale, entramos em infindáveis discussões.
Para ajudar nessa tarefa temos a disposição algumas ferramentas online muito interessantes.

SmartPageRank: Uma ferramenta bastante completa que estima o valor potencial do seu site e também apresenta outras informas como tempo de domínio, Google PageRank, backlinks, páginas indexas (no Google, Yahoo, MSN, AltaVista e AllTheWeb) e tráfego.
DNScoop: Estima o valor do site através de alguns critérios (particularmente eu não obtive sucesso com alguns blogs que testei).
CubeStat: Com os links que testei, o valor estimado ficou muito distantes do que julgo real. E as informações como
BizInformation: No meu ponto de vista essa foi uma das ferramentas cujo avaliação resultou em um valor mais próximo do que considero aceitável. Entretanto essa é uma opinião bem particular e, acredito, até pouco confiável já que cada caso é um caso.
O melhor é você experimentar e tirar suas próprias conclusões.

Delphi++: Primeiras impressões

2010-08-06T20:30:00.004-03:00

Nas últimas semanas tenho lido em foruns alguns post bastante tímidos sobre um tal de Delphi++. Na maioria das vezes contendo o comentário de um ou mais membros classificando-o como fake.
Bom, resolvi ir atrás do tema para entender realmente do que se tratava e, para minha surpresa, encontrei uma nova ferramenta de desenvolvimento com uma proposta no mínimo interessante e que, ao meu entender, tem a intenção de brigar por um lugar ao sol.

Nesse artigo não irei descrever o que é o Delphi++, sua proposta nem todos os recurso que possui, mas sim comentar as primeiras impressões sobre seu IDE comparando-o com o do Delphi.

Instalação
No site oficial ++Technologies é possível fazer o download da versão beta, após registrar-se.
Essa é a primeira versão do IDE e está ainda em estágio beta (v1.0.43.b) mas é simplesmente fantástica, considerando o que ela já oferece.
Ao fazer o download notei que a instalação possua pouco menos de 12 MB. Isso fez baixar a expectativa de encontrar um boa ferramenta de desenvolvimento. E se comparar com a instalação do Delphi 2010, 12MB representa pouco mais do que nada.

A instalação é muito tranquila sem nada de diferente. Basta um Next, Next, Nex e pronto.

Inicialização
Logo na tela de abertura já se pode notar um incrível semelhança com o Delphi da Embarcadero.

Na tela de spash nenhuma informação é apresentada que dê ideia do que está sendo realizado durante o start up. E apesar da instalação ser leve, a abertura do IDE passou a impressão de não ser tão leve assim.

IDE
A semelhança com o Delphi não ficou somente somente na tela de spash, todo o IDE é muito familiar. Até mesmo a disposição dos painéis e tools.

Tool Palette
Aqui está um ponto muito interessante.
O Delphi++ conta com muitos dos componentes básicos que são oferecidos pelo Delphi, inclusive componentes para acesso a banco de dados.
O fato de ser utilizado o mesmo ícone para os componentes de mesma proposta facilita bastante sua localização.
Abaixo está a lista de todos os componentes que estão contidos em cada uma das paletas.

Não há muito o que customizar na exibição esse Tool Panel. Na verdade essa é uma característica comum a todas as Tool Panel do IDE. A interface é um tanto rígida e não há quase opções de customização.
Comparando com a Tool Palette do Delphi, o que mais senti falta é da usabilidade do Tool Palette. Enquanto que no Delphi pode-se acrescentar um componente na tela com um duplo-click sobre o componente ou com um arrasta-e-solta, no Delphi++ é requerido que vc necessariamente selecione o componente na Tool Palette e clique no formulário para dropá-lo.

Object Inspector
Na primeiras olhadas para o Object Inspector o que mais chama a atenção é colorido nos nomes das propriedades.
Diferentemente do que é feito nas versões 2009 e 2010 do Delphi, a apresentação das propriedades no Object Inspector não é agrupadas por categoria, elas são apresentadas uma abaixo a outra em ordem alfabética. Infelizmente também não há opções de rearranjamento ou reagrupamento.
Depois de um tempo, olhando com atenção percebe-se que a cor da na qual as propriedades são exibidas dependente do seu tipo. Por exemplo, observe na imagem ao lado. Todas as propriedades da cor verde são do tipo Boolean, assim como as que são do tipo Integer estão em roxo.

Em relação aos tipos de propriedades apresentadas e comparando com as apresentadas no Delphi 2010, notei que há pouquíssimas diferenças, e todas as que identifiquei se tratavam de propriedades que foram acrescentando na versão 2010.
O mesmo ocorre com os tipos de eventos.

Editor
O editor do código fonte trás muitos dos recursos originais do Delphi, inclusive utiliza as mesmas teclas de atalho para tarefas comuns (por exemplo o F12 que alterna entre o modo de design e de edição). No entanto nem tudo funciona 100% e o editor passa uma impressão de não ser muito maleável.
Nas primeiras linhas de código escrito notei que o TAB não identava o código; ainda não há um auto-complete, live-template, code parameters e outras facilidades.
Para que está acostumado com o code-completion (CTRL + Space) certamente irá sentir um pouco de desconforto. Nos release testada o popup só era apresentado após o pressionamento o ponto final (".").
A editor de design do Delphi++ também tem várias limitações. O que notei é que o usuário precisa utilizar constantemente o mouse para ajustar o focus no ponto correto. Isso dificulta muito a alternância entre o formulário e o Object Inspector durante, por exemplo, a tela de criação e design dos formulários.

Mãos a obra
Depois de analisar esses e muitos outros recursos, resolvi colocar a mão na massa e implementar alguma coisa para avaliar a linguaguem propriamente dita.
Comecei dropando alguns componentes no formulário, ajustando algumas propriedades, alinhando os componentes, acrescentei um MainMenu, inclui alguns itens no menu, ...

Quando dei um duplo-click sobre um dos itens do menu com a intenção de implementar o evento OnClick, a duas pequenas diferenças surgiram. Uma é a declaração do evento não incluir o nome da classe (algo como procedure TForm1.menuOpenOnClick ...); a segunda foi ver que em vez de TObject, o parâmetro Sender do evento é do tipo any.

var

  gFileName: string;

procedure menuOpen_OnClick(Sender: any);

var

  lFStream: TFileStream;

  lCharacter: Char;

  lBuffer: string;

  lSize: Integer;

begin

  if self:dlgOpen.Execute then

  begin

    lFStream := TFileStream.Create(self:dlgOpen.FileName, fmOpenRead);

    try

      lBuffer := '';

      while lFStream.Read(lCharacter, 1) = 1 do

        lBuffer := lBuffer + lCharacter;

      self:memFile.Lines.Text := lBuffer;

      gFileName := self:dlgOpen.FileName;

    finally

      lFStream.Free;

    end;

  end;

end;

Estava esperando visualizar uma unit com a estrutura de um arquivo pascal padrão (secões: unit, interface, type e implementation), mas tudo que se observa é a declaração dos métodos.
No método acima é a implementação do evento OnClick da opção "Open" do menu "File" que foi acrescentado no formulário.
A simples tarefa de abir um arquivo e importar seu conteúdo para um componente TMemo demandou um tempinho considerável porque a estrutura do arquivo e a bliblioteca de funções não são iguais ao do Delphi.
Inicialmente comecei tentando utilizar as funções FileOpen, FileRead e FileClose para acesso ao arquivo desejado, mas sempre era exibida uma mensagem de erro indicando que tal função não existia. Não há a cláusula "uses", para fazer a importação/referência a units.
Então, depois de um tempo notei que entre as mais de 400 classes oferecidas pelo Delphi++, TFileStream estava incluída.
Outro ponto bastante importante é que a referência para componentes do formulário não é feito digitando o nome do componente diretamente, é necessário incluir "self:".

OBS: Para aqueles que já implementaram ou tiveram algum tipo de contato com o código fonte de macros em aplicativos office, por exemplo, perceberá uma semelhança.

procedure menuNew_OnClick(Sender: any);

begin

  self:memFile.Lines.Text := '';

  gFileName := '';

end;

procedure menuSave_OnClick(Sender: any);

var

  lFStream: TFileStream;

  lSize, i: Integer;

  lText: string;

begin

  if gFileName = '' then

    if self:dlgSave.Execute then

      gFileName := self:dlgSave.FileName;

  if gFileName <> '' then

  begin

    lFStream := TFileStream.Create(gFileName, fmCreate or fmOpenWrite);

    lText := self:memFile.Lines.Text;

    lSize := Str.Len(lText);

    for i := 1 to lSize do

      lFStream.Write(lText[i], 1);

    lFStream.Free;

  end;

end;

A implementação do evento OnClick da opção "Save" do menu, também foi um pequeno desafio a parte.
Custou um tempo descobrir que a função "Length" (que retorna o número de caracteres de uma string) não existe e que em vez dela deve-se utilizar "Str.Len".
Na verdade "Str." concentra a maioria das funções de manipulação de strings. Assim como "Date." é o ponto de partida para encontrar funções de manipulação de data.

procedure menuExit_OnClick(Sender: any);

begin

  Self.Close;

end;

constructor

begin

end.

Uma divergência com relação a maioria das ferramentas de desenvolvimento é que todo o projeto é armazenado em um único arquivo e na forma binária. Se você abrir o arquivo de projeto com um editor de texto, não irá identificar o código fonte. A visualização e edição fica restrita exclusivamente ao IDE do Delphi++.

Caso deseje visualizar o projeto inteiro, pode fazer o download nesse link.

Conclusões
Ao meu ver o Delphi++ é (me desculpe o termo) uma intenção de cópia do Embarcadero RAD Studio que está em um estágio prematuro, mas que já mostra ser uma alternativa.
O IDE segue a tendência atual das ferramentas de desenvolvimento de não ser exclusivo ao suporte de uma única linguagem de programação, e isso é muito bom. Entretanto, na atual versão (1.0 beta 2) ainda há muito o que ser feito, melhorado, e a ser corrigido, para poder oferecer aos usuários um experiência adequada e um ambiente que proporcione agilidade no desenvolvimento.
A falta de documentação é outro ponto negativo que dificulta bastante os primeiros passos, mas aos que já conhecem a linguagem rapidamente resolve os impasses.
Por outro lado essa é uma conclusão comparada com o RAD Studio 2010, que é uma ferramenta madura e que tem sido constantemente evoluída desde, se não estou enganado, 1995.
Se formos considerar que o Delphi++ ainda está em fase beta, não há como desmerecer esse fabuloso trabalho, ainda mais pelo fato de que já nessa versão beta é oferecido suporte multi-plataforma (recurso previsto somente para a versão 2011 do RAD Studio, e olha lá).

No mínimo eu concluo que vale a pena acompanhar o decorrer dos fatos.

Diretivas de Compilação - WARNINGS, HINTS e MESSAGES

2010-07-16T23:13:00.001-03:00

$WARNINGS

Warnings são alertas emitidos durante a compilação que apontam para um potencial ou real problema no código fonte.
Algumas vezes, por exemplo, os warnings se referem a variáveis que foram declaradas mas que não estão sendo usadas. Esse é um caso onde não há um problema, mas mesmo assim vale a pena dar atenção para esse warning porque ele é um indício de que há espaço para tornar seu código fonte mais limpo/claro.
O ideal é nunca ter qualquer warning emitido durante a compilação.

Em certos casos o compilador emite alertas para um trecho de código do qual temos a certeza de estar correto, e que esse alerta poderia ser desconsiderado sem qualquer receio.
Para essa situação nós podemos usar a diretiva de compilação {$WARNINGS} para desabilitar a emisão dos warnings em um certo techo de código.

{$WARNINGS OFF}

// Seu código fonte

{$WARNINGS ON}

Uma outra abordagem mais recomendada para essa situação é desabilitar somente o warning específico a qual se tem ciência de não representar problema. Isso evita que outros warnings sejam desconsiderados não intencionalmente em decorrência de uma modificação futura nesse trecho de código, principalmente se o trecho de código for relativamente grande.

A sitaxe é:

{$WARN identifier OFF}

// Seu código fonte

{$WARN identifier ON}

onde "identifier" é o símbolo correspondente do warning.

Considere o exemplo abaixo:

unit uTest;

interface

  procedure MyTest; experimental;

implementation

procedure MyTest;

begin

  // Código fonte

end;

end.

Para quem não sabe "experimental" é uma palavra reservada que pode ser usada para métodos, funções, units e outros com a intenção clara de sinalizar que tal implementação está, como o próprio nome sugere, em face experimental e que deve ser cauteloso no seu uso.
Ao compilar esse exemplo será apresentado uma mensagem semelhante a essa:

[DCC Warning] Project2.dpr(13): W1003 Symbol 'MyTest' is experimental

O código de identificação desse warning, como mostra a mensagem, é 1003 e o correspondente símbolo é SYMBOL_EXPERIMENTAL. Dessa forma, caso queira anular tal alerta em um trecho de código, basta usar:

{$WARN SYMBOL_EXPERIMENTAL OFF}

// trecho de código

{$WARN SYMBOL_EXPERIMENTAL ON} 

Não tenho intenção de listar todos os símbolos pré-definidos que o Delphi possui, mas vou detalhar alguns poucos:

HIDING_MEMBER: Warning produzido quando uma descendente declara uma nova propriedade com o mesmo nome que uma propriedade do ancestral.
HIDDEN_VIRTUAL: Warning produzido quando um descendente declara um método, não especificado como override, e com o mesmo nome de um método virtual do ancestral.
HRESULT_COMPAT: Warning sobre o uso do tipo "Integer" no lugar de um HRESULT.
STRING_CONST_TRUNCED: Todos os warnings sobre instâncias na qual o compilador atribui um string literal ou um valor constante para um short string cujo tamanho é menor do que o suficiente.
SYMBOL_DEPRECATED: Habilita/desabilita todos os warnings sobre símbolos definidos como deprecated na unit corrente.
SYMBOL_EXPERIMENTAL: Habilita/desabilita todos os warnings sobre símbolos definidos como experimental na unit corrente.
SYMBOL_PLATFORM: Habilita/desabilita todos os warnings sobre símbolos definidos como platform na unit corrente.
SYMBOL_LIBRARY: Habilita/desabilita todos os warnings sobre símbolos definidos library na unit corrente.
UNIT_DEPRECATED: Habilita/desabilita todos os warnings relacionadas a units definidas como deprecated.
UNIT_EXPERIMENTAL: Habilita/desabilita todos os warnings relacionadas a units definidas como experimental.
UNIT_LIBRARY: Habilita/desabilita todos os warnings relacionadas a units definidas como library.
UNIT_PLATFORM: Habilita/desabilita todos os warnings relacionadas a units definidas como platform.
ZERO_NIL_COMPAT: Warnings sobre instâncias na qual o compilador converte o valor 0 como sendo um nil.
GARBAGE: Warnings produzidos quando há caracteres diferentes de espaços em branco após o marcador 'end.'.

Esses e todos os demais símbolos de alertas pode ser conferido na unit DCCStrs.pas, que faz parte da biblioteca do Delphi (provavelmente em %ProgramFiles%\...\sources\toolsapi\DCCStrs.pas).

Pontos importantes
Quando uma diretiva {$WARNINGS} ou {$WARN} é utilizada para alterar o estado padrão de um determinado tipo de alerta, esse estado permanece até que seja encontrada outra diretiva de mesmo tipo modificando seu estado ou até que seja encontrado o final da unit.
Uma diretiva de compilação só tem efeito dentro do contexto da unit a qual é utilizada e a partir do ponto onde estão definidas dentro do arquivo. Ao ser passado o contexto para outra unit, o estado da diretiva é revertido para sua condição padrão.

Mas se a intenção é habilitar/desabilitar um determinado warning para um projeto inteiro, como fazer?
Vejo duas formas de fazer isso. Uma usando um arquivo auxiliar e outra usando o IDE o Delphi para selecionar quais warnings devem ou não ser considerados.
A primeira solução consiste em você utilizar um arquivo contendo as opções desejadas e acrescentar uma diretiva {$INCLUDE filename} ou {$I filename} em todas as unit do projeto.
A diretiva {$INCLUDE} tem o objetivo de copiar o conteúdo de um determinado arquivo para o ponto onde ela está definida.
No entanto, essa solução não faz muito sentido em ser utilizada para um caso isolado. Faz mais sentido quando se tem um arquivo central com várias defines, constantes, ... onde este é incluído (com {$I}) em todos os arquivos do projeto.
Imagino que já devem ter visto em algum projeto, por exemplo, o uso de um arquivo Types.inc com todas as definições usadas. Esse é um bom ponto para aplicar esse caso.)

A segunda forma, mais recomendada e também mais fácil é marcar/desmarcar quais warnings deverão ou não ser emitidos no próprio IDE do Delphi.
Para isso acesse a opção do menu Project -> Options e vá até a aba "Hints and Warnings".
Bom, a partir daqui não há mais razão de detalhar os passos. O processo é bem intuitivo.

Caso queira conhecer um pouco mais sobre os tipos de mensagens de erros e warnings tratados pelo Delphi, acesse o link http://docwiki.embarcadero.com/RADStudio/en/Error_and_Warning_Messages_(Delphi)_Index.

Estados dos Alertas
Aqui está outro ponto muito importante e que nem sempre é mencionado.
O warning não possui somente dois estados (ON e OFF), mas sim três. Exatamente!
O terceiro estado é ERROR que instrui o compilador a tratar o warning como sendo um erro, ou seja, aumenta o nível de atenção daquele tipo de alerta.

{$WARN SYMBOL_EXPERIMENTAL OFF}

{$WARN SYMBOL_EXPERIMENTAL ON}

{$WARN SYMBOL_EXPERIMENTAL ERROR}

Essa opção pode ser bastante útil quando, por exemplo, há muitas ocorrências de warning no projeto e você quer dar atenção para um tipo específico.

$MESSAGES

O Delphi possui a diretiva de compilação $Message que nos permite instrumentar o código fonte de forma a salientar pontos importantes que devem ser observados quando o código for compilado.
Essa diretiva trabalha diretamente com o compilador o qual irá emitir o texto definido no corpo da definição tratando-a conforme seu nível atenção.

A sintaxe é a seguinte:

{$MESSAGE HINT|WARN|ERROR|FATAL 'Textstring'}

onde HINT|WARN|ERROR|FATAL é o nível de atenção/importância da mensagem e 'Textstring' é a mensagem que deve ser emitida pelo compilador.

O level da mensagem é opcional e, se não especificado, será assumido o valor padrão, ou seja, HINT. Já a sequência do testo é obrigatória e deve utilizar a sintaxe da string, ou seja, delimitada por aspas simples.
Destaco a importância de conhecer o significado que cada tipo de mensagem possui porque o compilador irá tratar essas mensagens da mesma forma como trata os alertas nativos.

HINT: Notificações quase sempre informativas e não incorrem risco

{$Message 'Essa mensagem é do tipo HINT'}

{$Message Hint 'Essa mensagem também é do tipo HINT'}

WARN: Notificação de alerta para um real ou potencial risco

{$Message Warn 'Essa mensagem é do tipo WARNING'}

Error: Falha de sintaxe ou semântica

{$Message Error 'Essa mensagem é do tipo ERROR'}

Fatal: Interrompe a compilação imediatamente

{$Message Fatal 'Essa mensagem é do tipo FATAL'}

$HINTS

Esse artigo tem explorado mais o lado técnico dos Warnings e Hints no Delphi do que propriamente sua utilização.
Esse é uma outra abordagem com ampla gama para exploração. Penso que poderia ser redigido um artigo enorme falando só das diversas formas de empregar, e de forma adequada, esse recurso que não é uma exclusividade do Delphi, muito pelo contrário.
Mas por enquanto iremos concluir esse texto com mais algumas notas sobre a diretiva {$HINT}.

O Delphi permite que a emissão de mensagens que são do tipo HINT possa ser habilita ou desabilitada através de:

{$HINTS ON}

// Trecho de código

{$HINTS OFF} 

Vamos utilizar um exemplo simples.

procedure Teste;

var

  a, b: Integer;

begin

  {$HINTS ON}

  a := 1;

end;

Ao compilar, será apresentado duas mensagens do tipo hint.

[DCC Hint] uTest.pas(13): H2077 Value assigned to 'a' never used

[DCC Hint] uTest.pas(11): H2164 Variable 'b' is declared but never used in 'Teste'

Agora experimente substituir a linha onde aparece {$HINTS ON} por {$HINTS OFF} e recompile o código. Irá observar que ambas as mensagens não serão mais apresentadas.
Aqui a regra é a mesma. A diretiva é relevante apenas no contexto da unit e para as linhas abaixo.

Até a próxima.

Ranking de popularidade das linguagens de programação

2010-07-12T22:37:00.000-03:00

Um assunto que frenquentemente faz parte das discussões dos grupos de desenvolvedores é o quanto uma determinada linguagem de programação está diceminada no mercado em um dado momento.
Muitas vezes embasadas em opiniões próprias ou simplesmente por questão de afinidade, a conversa tende a abordar o universo restrito ao grupo.
Mas você sabe realmente qual a porcentagem de adoção da linguaguem de programação que você utiliza?
Se você fosse investir seu tempo para aprender uma linguagem, mas gostaria que a escolha fosse consciente, por onde começar?

A tabela abaixo foi extraída na data de hoje (12-Julho-2010) do site TIOBE, que eu considero um ótimo referencial no assunto.

Position Jul 2010	Position Jul 2009	Programming Language	Ratings Jul 2010	DeltaJul 2009
1	1	Java	18.673%	-1.78%
2	2	C	18.480%	+1.16%
3	3	C++	10.469%	+0.05%
4	4	PHP	8.566%	-0.70%
5	6	C#	5.730%	+1.19%
6	5	(Visual) Basic	5.516%	-2.27%
7	7	Python	4.217%	-0.22%
8	8	Perl	3.099%	-1.10%
9	21	Objective-C	2.498%	+1.99%
10	9	JavaScript	2.432%	-1.08%
11	11	Delphi	2.323%	+0.33%
12	10	Ruby	1.982%	-0.59%
13	12	PL/SQL	0.772%	-0.12%
14	13	SAS	0.701%	-0.09%
15	15	Pascal	0.639%	-0.07%
16	17	Lisp/Scheme/Clojure	0.622%	+0.01%
17	20	MATLAB	0.581%	+0.07%
18	16	ABAP	0.548%	-0.15%
19	19	Lua	0.535%	+0.00%
20	28	PowerShell	0.493%	+0.17%

Essa tabela é apenas uma das várias tabelas e gráficos estatísticos que são disponibilizados no site TIOBE.
Além do ranking atual é possível obter um histórico de longo prazo de cada uma das linguagens de programações apresentada na tabela das 20 primeiras posições, bastando clicar sobre o link em seus nomes (coluna "Programming Language").

Vamos aproveitar e ver o histórico dos últimos 8 anos com relação ao Delphi.

Para quem é desenvolvedor Delphi a alguns anos certamente irá saber qual a versão que vez tanto sucesso para proporcionar aquele pico, em 2004. Se não sabe, acessa a página da wikipedia.

Além do TIOBE, http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html, há outros sites onde também é possível conferir quais as linguagens de programação mais cultuadas.
Aqui destaco o LangPop.com (http://www.langpop.com/) que utiliza as informações de pesquisa realizadas em sites como Google, Yahoo, Google Code e vários outros, para montar os quadros de ranking das linguagens de programação mais procuradas.
Dependendo do local onde as informações foram coletadas, o ranking fica sensivelmente diferente. Nesse site você encontra também uma tabela que é o resultado normalizado de todas as outras (com valores bem menos tendenciosos).

Até a próxima.

Segredos do ForEach

2010-07-11T23:21:00.000-03:00

Você sabe como funciona e como utilizar o ForEach no Delphi?
O suporte ao ForEach foi adicionado no Delphi 2005 e tem como finalidade oferecer uma interface de acesso aos itens das coleções (listas, filhas, filhas, array, conjuntos, vetores, ...) de forma simplificada e sem se preocupar com contadores ou com índices.

A sintaxe do ForEach é:

for item in collection do

begin

  // 

end;

Note que na sitaxe do comando aparece a palavara reservada "in", o que reforça a idéia de um laço de repetição destinado a trabalhar com conjuntos/coleções, e é exatamente essa idéia que se deve manter em mente ao utilizar esse recurso em seu código fonte.
Dependendo do tipo de coleção que se está trabalhando, o comando terá uma característica específica, mas sempre mantendo a finalidade original.

Vamos ver alguns exemplos de uso.

1. Uso em conjuntos
Esse é um dos usos mais freqüentemente encontrado nos códigos fontes e que particularmente encorajo sua adoção e emprego.
Para quem não está muito familiarizado com o uso de conjuntos, o exemplo abaixo pode parecer estranho, num primeiro momento, mas numa segunda olhada verá que é muito intuitivo.

type

  TWeekDay = (wdDomingo, wdSegunda, wdTerca, wdQuarta, wdQuinta, wdSexta, wdSabado);

  TWeek = set of TWeekDay;

const

  STRWEEKDAY: array[TWeekDay] of string =

  ('Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sab');

var

  lDay: TWeekDay;

  lWorkDays: TWeek;

begin

  lWorkDays := [wdSegunda, wdQuarta, wdSexta];

  for lDay in lWorkDays do

  begin

    ShowMessage(STRWEEKDAY[lDay]);

  end;

end;

O exemplo acima define o conjunto TWeek baseado nos dias da semana (TWeekDay) e usa essa definição para declarar a variável local lWorkDays.
Na primeira linha do bloco, nosso conjunto lWorkDays recebe a atribuição de três elementos, ou melhor, de três dias da semana e é utilizada no ForEach abaixo.
Como a coleção aqui é um conjunto, o laço de repetição do comando for ir percorrer todas as possíveis entradas do conjunto, mas somente executará as instruções do bloco quando a respectiva entrada realmente está presente no conjunto. Assim, no nosso exemplo, a função ShowMessage será chamada três vezes.
Reforço a vantagem do uso do ForEach com conjuntos porque além de intuitivo o código binário gerado é limpo, rápido e não consome recursos como o quando é utilizado com objetos.

2. Uso com strings
A utilização do ForEach com strings é um exemplo clássico do passado, mas que ao meu ver tem mais pontos negativos do que positivos.

const

  S: string = 'Using ForEach with strings';

var

  lChar: Char;

begin

  for lChar in S do

  begin

    if lChar in ['a','e','i','o','u'] then

    begin 

      // ...

    end;

  end;

end;

Como dito anteriormente, o comando terá uma particularidade que depende do tipo de coleção utilizada, mas sempre centrado na idéia de acessar os elementos da coleção.
No exemplo acima nossa coleção abrange todo o espectro do tipo Char, nativo do Delphi, e o laço de repetição executará tantas vezes quanto for o número de caracteres da string.
Em outras palavras o comando for irá percorrer toda a string, atribuindo para a variável local lChar o valor de cada caracter.
Eu desencorajo a adoção dessa prática como alternativa para percorrer strings porque o código binário gerado é, do ponto de vista de micro-otimizações, bastante oneroso por requerer a manipulação do tipo string.

3. Uso com arrays estáticos
Também podemos utilizar o laço de repetição para percorrermos arrays de forma muito semelhante ao exemplo acima.

type

  TMonthDays = array[1..31] of Boolean;

var

  lWorkedDays: TMonthDays;

  lDay: Boolean;

  lCounter: Integer;

begin

  FillMemory(@lWorkedDays, SizeOf(lWorkedDays), 0);

  lWorkedDays[1] := True;

  lWorkedDays[2] := True;

  lWorkedDays[5] := True;

  lCounter := 0;

  for lDay in lWorkedDays do

  begin

    if lDay then

      Inc(lCounter);

  end;

  ShowMessage('Sum: ' + IntToStr(lCounter));

end;

Observe que nesse nosso exemplo o índice do array não é utilizado, mas apenas o valor de cada entrada.
Aqui temos uma situação que merece um certo destaque por permitir ao código fonte um incremento na clareza e legibilidade, evitando a declaração de variáveis locais e especificando explicitamente os limites do array.
Se considerarmos uma abordagem mais clássica usando o laço for comum como, por exemplo:

var

  i: Integer;

begin

  // ...

  for i = 1 to 31 do

    // ...

corremos o risco de introduzir um bug no sistema caso os limites do array seja moificado.
Obviamente podemos evitar esse tipo de bug removendo os hard codes,

  for i = Low(TMonthDays) to High(TMonthDays) do

mas ainda assim dependeríamos do uso de uma variável como contador do laço de repetição.

4. Uso com arrays dinâmicos
Essa é uma situação levemente diferente do exemplo acima onde, em vez de termos um array com limites bem definidos, temos um array dinâmico cujo tamanho pode variar inclusive durante a execução do ForEach.
Aqui novamente estamos considerando que saber o índice atual do laço de repetição não é requerido, mas somente o valor de cada entrada do array.

var

  lWorkedDays: array of Boolean;

  lDay: Boolean;

  lCounter: Integer;

begin

  SetLength(lWorkedDays, 31);

  lWorkedDays[0] := True;

  lWorkedDays[1] := True;

  lWorkedDays[4] := True;

  lCounter := 0;

  for lDay in lWorkedDays do

  begin

    if lDay then

      Inc(lCounter);

  end;

  ShowMessage('Sum: ' + IntToStr(lCounter));

end;

Uma particularidade do array dinâmico é que a primeira entrada tem índice zero (0).
Utilizando o ForEach para percorrer o array, seja estático ou dinâmico, o limite inicial e final é tratado de forma transparente pelo compilador.

5. Usando com objetos
Esse é o último caso de uso do ForEach apresentado nesse artigo e o que merece mais atenção.
Como os tipos nativos (conjuntos, strings e arrays) o Delphi tem total conhecimento de como devem ser manipulados. Já quando a coleção é uma objeto, essa premissa não é verdadeira e, nesse caso, é você quem deve instruir o Delphi a acessar os itens do objeto de forma adequada.

Observe o exemplo abaixo.

var

  lFiles: TStrings;

  lFilename: string;

begin

  // ...

  for lFilename in lFiles do

  begin

    // ...

  end;

end;

No código acima a variável lFiles está sendo usada para armazenar uma lista de nomes de arquivos que serão tratados, e o laço de repetição irá acessar cada item dessa lista e repassar à variável local lFilename o valor do item (nesse caso, a string com o nome do arquivo).
O mesmo caso é válido para outras classes nativas do Delphi como por exemplo TTreeNode, TActionList, ...
Bom aí vem a pergunta. Como o Delphi sabe qual é a lista de elementos da minha coleção quando se trata de um objeto?
Se você for na definição da classe TStrings encontrará um método com o nome "GetEnumerator" cujo retorno é um objeto do tipo TStringsEnumerator. E é exatamente esse método que será usado pelo ForEach para acessar os elementos da lista.

Para ser mais específico, um pré-requisito para usar o ForEach com objetos (instâncias de classes) é justamente a existência e implementação do método GetEnumerator pela classe do objeto.
Se você tentar usar um objeto qualquer o próprio compilador irá notificar sobre esse requisito, apresentando uma mensagem semelhante:

[DCC Error] Unit1.pas(145): E2431 for-in statement cannot operate on collection type 'TMyList' because 'TMyList' does not contain a member for 'GetEnumerator', or it is inaccessible

Além disso, o método GetEnumerator não pode retornar qualquer valor, ele deverá retornar uma instância cuja classe possua dois métodos específicos (GetCurrent e MoveNext) que serão utilizados para instruir o ForEach a percorrer os itens do objeto.
O método GetCurrent será utilizado para retornar o valor do atual elemento da lista e o método MoveNext irá posicionar o cursor no próximo item ou retornando False quando não há mais elementos na lista.

Vamos criar um exemplo simples para ilustrar como isso é feito.

TMyList = class;

TMyListEnumerator = class

private

  FIndex: Integer;

  FMyItems: TMyList;

public

  constructor Create(ARef: TMyList);

  function GetCurrent: Integer; inline;

  function MoveNext: Boolean;

  property Current: Integer read GetCurrent;

end;

A classe TMyListEnumerator será a responsável por acessar a lista de valores de TMyList.
O layout acima é exatamente o que você precisa implementar para todas as classes a qual deseja dar suporte ao ForEach, modificando apenas o tipo de retorno de acordo com o tipo de item das classes. Por exemplo, se coleção mantém uma lista de valores de ponto flutuante, substitua a o tipo "Integer" (no layout acima) por "float".

TMyList = class

  protected

    FName: string;

    FItems: array of Integer;

  public

    destructor Destroy; override;

    function Add(const Value: Integer): Integer;

    function GetEnumerator: TMyListEnumerator;

end;

A classe TMyList é nossa coleção a qual mantém um array de valores inteiros (propriedade FItems).
Agora observe a implementação dos métodos da coleção. Nada de diferente a não ser pelo método GetEnumerator.

destructor TMyList.Destroy;

begin

  SetLength(FItems, 0);

  inherited;

end;

function TMyList.Add(const Value: Integer): Integer;

begin

  Result := Length(FItems);

  SetLength(FItems, Result + 1);

  FItems[Result] := Value;

end;

function TMyList.GetEnumerator: TMyListEnumerator;

begin

  Result := TMyListEnumerator.Create(Self);

end;

A implementação da nosso classe de enumeração não tem nada de complexo ou diferente, e o próprio código é auto explicativo.

constructor TMyListEnumerator.Create(ARef: TMyList);

begin

  inherited Create;

  FIndex := -1;

  FMyItems := ARef;

end;

function TMyListEnumerator.GetCurrent: Integer;

begin

  Result := FMyItems.FItems[FIndex];

end;

function TMyListEnumerator.MoveNext: Boolean;

begin

  Result := FIndex < (Length(FMyItems.FItems) - 1);

  if Result then

    Inc(FIndex);

end;

Caso tenha tido algum tipo de dificuldade, faça o download do projeto de exemplo (link http://rapidshare.com/files/406448596/ForEach.7z) que contém todo o código fonte utilizado nesse artigo.

Atribuindo nomes às threads

2010-06-28T01:08:00.000-03:00

Para quem trabalha com programação multi-thread sabe que a depuração do código é um tarefa bem complicada.
Percorrer o caminho inverso do fluxo de execução de uma tarefa que é intercalada por threads requer tempo de habilidade.
O Delphi 2010 trás uma novidade interessante que promete ajudar nessa árdua tarefa, agora é possível nomear as threads.
Observe a imagem abaixo:

No Delphi 2010 foi introduzido o método NameThreadForDebugging na classe TThread e é utilizado tanto para nomear quanto para renomear uma thread específica.
Sua assinatura trás dois parâmetros: AThreadName e AThreadID.
O primeiro é o nome que será dado à thread e o segundo parâmetro é o ID da thread a ser nomeada. No caso do segundo parâmetro ser omitido, ou ser -1, a operação será realizada sob a corrente thread que está rodando.
Outro detalhe é que o nome atribuído é do tipo AnsiString, ou seja, pode ser necessário um typecast explícito.

Vamos ver na prática como o recurso é aplicado.

procedure TMyThread.Execute;

var

  lThreadName: AnsiString;

begin

  {$IFDEF VER210}

  lThreadName := AnsiString(Self.ClassName + '_' + IntToStr(FCount));

  NameThreadForDebugging(lThreadName);

  {$ENDIF}

  while not Terminated do

  begin

    Sleep(300);

  end;

end;

Não se esqueça que esse método só está disponível no Delphi 2010 e, provavelmente, nas versões superiores. No caso do código fonte ser utilizado em versões anteriores, use utilize a diretiva de compilação {$IFDEF VER210} para evitar erro de compilação/compatibilidade.

Apesar desse recurso ser introduzido somente na versão 2010, existe um método que pode ser aplicado para as versões anteriores.

{$IFDEF MSWINDOWS}

procedure SetDebbugerThreadName(const AThreadName: AnsiString; const AThreadID: LongWord = $FFFFFFFF);

type

  TThreadNameInfo = record

    FType:     LongWord;  // Deve ser sempre 0x1000

    FName:     PAnsiChar; // Ponteiro para o nome da thread

    FThreadID: LongWord;  // Thread ID (-1 indica a corrente thread)

    FFlags:    LongWord;  // Não utilizado, deve ser zero.

  end;

var

  lThreadInfo: TThreadNameInfo;

begin

  lThreadInfo.FType     := $1000;

  lThreadInfo.FName     := PAnsiChar(AThreadName);

  lThreadInfo.FThreadID := AThreadID;

  lThreadInfo.FFlags    := 0;

  try

    RaiseException($406D1388, 0, SizeOf(lThreadInfo) div SizeOf(LongWord), @lThreadInfo);

  except

  end;

end;

{$ENDIF}

O uso dessa função tem exatamente o mesmo efeito que o método NameThreadForDebugging.

Um exemplo completo utilizando ambas formas pode ser baixada aqui.

Customizando o Help Insight no Delphi

2010-06-08T01:59:00.000-03:00

Recentemente li um artigo sobre Help Insight que chamou bastante minha atenção.
Acredito que todos saibam o que é ou já tiveram contato com essa funcionalidade, mas para aqueles que não estão acostumado com o nome Help Insight, esse é um recurso do IDE do Delphi que apresenta um popup com uma breve descrição sobre o identificador (classe, método, função, variável, ...) na qual o cursor do mouse está posicionado.
Também é possível invocar o Help Insight através do pressionamento das teclas CTRL + SHIFT + H.
Por padrão é apresentado nesse popup menu as seguintes informações:

Nome do identificador
Categoria do identificador (Campo, variável, método, classe, propriedade, ...)
Localização (nome da unit seguido pelo número da linha e da coluna)
Tipo (Se o identificador é string, integer, ...)

No caso do identificador ser um método, function ou procedure, a descrição é extendida apresentando também o(s) parâmetro(s) e o valor de retorno.

Isso tudo é feito automaticamente pelo IDE em tempo de edição, ou seja, nem necessitar que o código seja compilado.
O que eu não sabia, e é o objetivo desse artigo, é que o conteúdo do popup menu pode ser customizado exibindo informações mais detalhadas a respeito do identificador em questão.
Essa customização deve estar situada imediatamente acima do identificador a qual se deseja trabalhar e tem seu início demarcado através de um comentário coringa (///, três barras) seguido por uma tag XML reconhecida pelo Help Insight viewer.

As tags XML atualmente reconhecida são:

summary
param
returns
permission
remarks
comments

Agora vamos ver um exemplo prático contendo todas essas tags.

/// <summary>    Verificar se um determinado componente/field teve ou não seu conteúdo

///              alterado. O método é utilizado dentro do framework para sinalizar os

///              componentes que foram modificados durante uma operação de update.</summary>

/// <param name="FieldComp"> Registro contendo informações sobre o field/componente. </param>

/// <param name="Index">    Índice do registro dentro da lista (<c>FFieldList</c>). </param>

/// <param name="Modified">  Parâmetro de saída que deve ser setado para True/False, dependendo

///                          do status verificado pelo método. Por padrão, o parâmetro vem

///                          com o valor True. </param>

/// <returns>    O valor retornado deve significar que o método obteve sucesso ao comparar o

///              valor original com o valor atual do componente/field, ou seja, que o valor

///              do parâmetro Modified é válido.</returns>

/// <permission> Esse método é utilizado internamente apenas quando o formulário está em estado

///              de alteração de registro. A implementação original trás suporte para os

///              componentes mais comumente utilizados, entretanto, em caso de customização ou

///              extenção do suporte a outros componentes, esse método pode sempre ser

///              reimplementado nos formulários filhos. </permission>

/// <remarks>    Originalmente esse método foi concebido para ser utilizado pelo framework como

///              um serviço. Assim, evite chamá-lo diretamente a menos que saiba com exatidão

///              o que está fazendo. </remarks>

/// <comments>  Caso necessite reimplementar o método, é recomendado que faça uma chamada à

///              implementação da classe pai (Exemplo: Result := inherited;). </comments>

Observe que foi utilizado também as tags <c> e </c>. Essas tags delimitam um área de texto que será formatada no estilo de código fonte do Delphi (por padrão, Courier New).
O resultado é:

Convenhamos que se você está navegando pelo código, um help assim é muito, mas muito mais útil do que simplesmente visualizar a assinatura do identificador (padrão do Delphi), certo? Além do mais, você não precisa se deslocar até a definição/implementação/declaração do identificador para obter maiores detalhes, o que quase sempre resulta na interrupção da linha de raciocínio durante alguma investigação.
Uma outra vantagem que notei sobre a utilização do Help Insigh é poder ter dois tipos de documentação a respeito de um método sobre dois pontos de vista.
Deixa eu exemplificar. Observe o código fonte abaixo.

unit Unit1;

interface

uses

  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

  Dialogs;

type

  TForm1 = class(TForm)

  private

    { Private declarations }

  protected

    function FieldIsModified(var FieldComp: TFieldItem; const Index: Integer; out Modified: Boolean): Boolean; virtual;

  public

  end;

var

  Form1: TForm1;

implementation

{$R *.dfm}

{ TForm1 }

{_/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\

  Definition.: Protected          Strict [ ]     Virtual/Override [X]     Event [ ]

  Ojective...:

  Usefulness.:

  Parameters.: [ I ] FieldComp =

               [ I ] Index     =

               [ O ] Modified  =

  Result.....:

  Comments...:

_/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\__/-\}

function TForm1.FieldIsModified(var FieldComp: TFieldItem; const Index: Integer; out Modified: Boolean): Boolean;

begin

  // ...

end;

end.

Creio que a prática mais comum de documentação de código seja a inclusão de comentários imediatamente acima da implementação dos métodos/funções (como apresentando no exemplo acima), ficando a área de interface da unit com apenas as definições.

O código fonte acima contém a estrutura do bloco de comentário que costumo utilizar para documentar um método ou uma function (removi o texto para ficar mais fácil sua visualização). As informações que acrescento nesse bloco estão relacionadas principalmente com seu funcionamento, com sua dependência perante a solução como um todo e com cuidados que devem ser tomados na sua utilização.
Quando penso no Help Inside, penso em um ponto de vista onde saber como é o funcionamento interno de um método não é tão importante, naquele momento, quanto saber o que o método faz, suas entradas e suas saídas. Assim, quando digo que o Help Insight proporciona um segundo tipo de comentários é justamente a possibilidade de documentar o código fonte sob uma perspectiva mais focada no conceito do que em detalhes intrínsecos ao funcionamento.

Apesar de muito útil, fique um tanto desconfortável com relação a legibilidade (ou melhor, à falta de legibilidade) que a estrutura de definição das tags causa ao layout da classe.
Por exemplo, se você possui um classe com vários métodos e propriedades. Acrescentar um help insigh para cada definição irá dinimuir a visão do todo por exigir constante deslocamento entre as linhas para navegar pela classe (aqui o layout struct do Delphi se mostrou ainda mais útil).
Fiz alguns testes e notei que o IDE aceita a utilização de REGIONS para delimitar a área do Help Insight, o que pareceu uma forma bem razoável para resolver ou, no mínimo, minimizar a área visível ocupada.

Um segundo ponto com relação a legibilidade é que não há uma formatação específica para as tags.
a) É possível escrever a descrição de uma tag utilizando multi-linhas ou em apenas uma única linha que o conteúdo será apresentado igualmente no popup;
b) Pode-se acrescentar espaços vários espaços em brancos, mas os excedentes serão ignorados (assim como em HTML);
c) Qualquer quebra de linha será ignorada, o que dá margem para formatar melhor o texto na unit, mas na hora de exibir o popup, as frases serão concatenadas em um único parágrafo.
Isso faz com que não seja possível escrever um pequeno trecho de código, por exemplo.

Em outras palavras, fiquei com a impressão que é mais legível ler as descrições do popup do que diretamente do código fonte.
Caso deseje analisar o código fonte completo da unit criada durante a escrita desse artigo, faça o download nesse link.

A última dica é para aqueles de desejam alterar a saída do popup para um layout mais adequado ou apenas queiram fazer pequenos incrementos. Nesse caso basta editar o arquivo HelpInsight.xsl (sub-diretório ObjRepos do diretório de instalação do RAD Studio, para mim é C:\Program Files\Embarcadero\RAD Studio\7.0\ObjRepos). Lá você encontrará também outras opções não descrita nesse artigo.

Boa sorte.

Delphi strings (O que, quando e como) - Otimizações

2010-05-15T17:23:00.000-03:00

As versões mais recentes do Delphi oferecem pelo menos 4 tipos de strings. Cada uma delas com características e comportamentos próprios, tendo sua aplicabilidade destinada a situações diferentes.
Esse artigo está dividido em duas partes. A primeira irá descrever esses quatro tipos de strings e suas características; a segunda etapa é composta por análises de situações comuns na programação e que constituem oportunidades para um otimizações.

Breve Histórico

ShortString
Este é um tipo de string oriundo das primeiras versões do Delphi e herdado do Turbo Pascal, que possuia este como o único tipo de string.
A menos que uma alocação manual seja feita, o tipo ShortString reside na stack e não na heap e, do ponto de vista de alocação de memória, tem o mesmo comportameto que os tipos básicos alocados estaticamente (integer, boolean, char, recors, enum, ...).
Quando o tipo ShortString é utilizado o Delphi pré-aloca um bloco de 256 bytes e utiliza o primeiro byte (AStr[0]) para armazenar o tamanho 'utilizado'.

var

  AStr: ShortString;

Você também pode especificar um tamanho máximo para as strings, mas esse valor não pode passar 255.

var

  s: string[50];

  e: string[256]; // error

PChar
A limitação de 255 bytes para string representa um fator crítico para aplicações do mundo real.
No Delphi 1 foi introduzido o tipo PChar que era um tipo semelhante ao "char *" da linguagem C. Entretanto, devido a segmentação da memória do Windows ser de 16-bits, o tipo PChar estava limitado a 65535 bytes (64 KB).
Diferentemente do tipo ShortString, PChar não possui um "campo" destinado a armazenar o tamanho da string, mas possui um terminador "null".

Long String (AnsiString)
No Delphi 2 foi introduzido o tipo AnsiString com a finalidade de prover uma forma eficiente e rápida de trabalhar com strings grandes (32-bits). Agora era possível manipular strings com até 2 GB.
Comparando a estrutura do tipo AnsiString podemos dizer que ele é uma "forma híbrida" dos tipos PChar e ShortString. Uma porque ele utiliza um terminador "null" para indicar o final da string (igual ao PChar) e, segundo, porque adota um campo para armazenar o tamanho da string e o primeiro caracter inicia na posição 1.

var

  s: AnsiString;

Observe o mapa de memória da variável s, além do campo "Lenght" esse tipo de sring mantém um outro campo, "RefCount". Resumidamente, esse campo é incrementado sempre que a variável é referencida. Isso permite ao Delphi gerenciar o tempo de vida da string, liberando a memória quando a string não mais é utilizada.

WideString
WideString foi o último tipo de string adicionado à famíla Delphi, mais precisamente, introduzido na versão 6. No entanto, somente a partir da versão 2009 é que se tornou o tipo padrão de string.
A finalidade do tipo WideString é o suporte a caracteres Unicode e a diferença reside no fato de que cada caracter WideString é representado por 2 bytes e não 1, como em AnsiString.

var

  s: WideString;

O tipo String

No Delphi, o tipo string não é nada mais do que um alias para ShortString, PChar, AnsiString ou WideString, dependendo da versão do Delphi que for utilizado.
Por exemplo, no Delphi 7 o tipo string é equivalente a AnsiString; já no Delphi 2009 e, mas recentemente, no Delphi 2010, string é equivalente a WideString.
O uso do tipo string deve ser aplicado com um pouco de cautela, principalmente se retro-compatibilidade ou portabilidade for uma das necessidades do código fonte produzido.
Tomamos por exemplo o lançamento do Delphi 2009, que trouxe aos usuários o desafio da migração do código fonte de manipulação de strings para o formato wide.

Semântica e comportamento

Para o correto uso das string é necessário entender sua semântica e seu comportamento.

a) Exemplo 1
Lembre-se, o tipo ShortString pre-aloca 256 bytes e operações de atribuição resultarão em cópia do conteúdo fonte.

var

  s: ShortString;

  b: ShortString;

begin

        ...

  s := 'Teste';

  b := s;     // O conteúdo de 's' é copiado para 'b'

  s[1] := 'X' // A variável 'b' ainda contém 'Teste'

b) Exemplo 2
O tipo PChar está frequentemente associado a alocação dinânimica e atribuições somente copiam o ponteiro do destino, não o conteúdo.

var

  s: PChar;

  b: PChar;

begin

        ...

  s := 'Teste';

  b := s;     // A variável 'b' aponta para 's'

  s[0] := 'X' // Tanto 's' quanto 'b' contém 'Xeste'

c) Exemplo 3
Tanto o tipo AnsiString quanto WideString são semelhantes ao tipo PChar quando uma atribuição direta é feita, ou seja, somente é copiado o ponteiro do destino. Além disso, AnsiString e WideString possuem um campo RefCount (usado para saber quando a string não é mais utilizada) que, na atribuição direta, é incrementado..
Observe o exemplo baixo.

var

  s: AnsiString;

  b: AnsiString;

begin

        ...

  s := 'Teste';

  b := s;     // Ambas apontam para a mesma área de memória e

              //o campo "RefCount' é incrementado.

d) Exemplo 4
Vamos tomar o mesmo exemplo anterior, mas com uma linha a mais de código.

var

  s: AnsiString;

  b: AnsiString;

begin

        ...

  s := 'Teste';

  b := s;      // b recebe o ponteiro de 's'e o RefCount é incrementado.

  s[1] := 'X'; // Faz uma cópia de 'b' com o primeiro byte modificado e

               //decrementa o RefCount de 'b'.

Vamos detalhar o trabalho realizado pelo Delphi em cada uma das linhas ilustrando as estruturas em memória.

Step 1)

  s := 'Teste';

É feito a alocação de memória para armazena a string. O campo "Lenght" é setado para 5 (que é o número de caracteres da string) e o campo "RefCount" é setado para 1.
A variável 's' passa a apontar para o início da string.

Step 2)

  b := s;

Observe que a linha de código acima simplesmente copiou o ponteiro da variável 's' para a variável 'b' e incrementou o campo 'RefCount', ou seja, abas as variáveis estão apontando para a mesma área de memória.

Step 3)

  s[1] := 'X';

Aqui a alteração de um simples byte resultou e várias instruções.
Pelo fato do "RefCount" ser superior a 1, ou seja, por haver mais do que uma referência, foi realizada a alocação de uma nova string; copiado o conteúdo da string original; setado 1 para o "RefCount"; alterado o primeiro byte para 'X'; atribuído o ponteiro da nova string para a variável 's'.
Por último, o 'RefCount' da string original é decrementado.

Otimizações no uso de strings

Uso de parâmetros do tipo const
A plavrava reservada "const" é um modificador usado para definir algo como estático, que não muda. E quando associadas com parâmetros do tipo string, há um incremento no desempenho que pode ser perceptível, dependendo da intensidade de uso.
Vamos tomar como base uma função simples.

function GetStrSize(s: string): Integer;

begin

  Result := Length(s);

end;;

Aqui o parâmetro "s" irá incondicionalmente incrementar o campo "RefCount" da string a qual ele está referenciando antes de iniciar a execução da primeira linha de código da função.
Pode parecer um tarefa simples e pouco honerosa para o sistema, mas é totalmente desnecessária porque o parâmetro é somente utilizado para leitura e nunca para escrita.
Uma código fonte mais eficiente, nesse caso, é facilmente obtido apenas especificando o parâmetro como "constante".

function GetStrSize2(const s: string): Integer;

begin

  Result := Length(s);

end;

A boa notícia é que as otimizações implementada nos compiladores mais recentes já detectam esse tipo de situação e geram um código final mais eficiente.

Evitando retorno do tipo string
Quando você for codificar uma função na qual é pretendido retornar uma string modificada da que é passada por parâmetro, é aconselhado que seja feito através do próprio parâmetro. A menos, é claro, que você necessite do valor original.

function AddChar(const s: string): string;

begin

  Result := s + '*';

end;

O exemplo acima, como pode ser notado, apenas acrescenta um caracter no final da string passa por parâmetro.
Já a função abaixo faz a mesma coisa, mas retorna a nova string através do próprio parâmetro.

procedure AddChar2(var s: string);

begin

  s := s + '*';

end;

Tanto o modificador "const" da primeira função quanto o modificador "var" da segunda função fazem com que não seja necessário o incremento do "RefCount". Entretanto a segunda função é mais eficiente porque não requer que a string do parâmetro seja duplicada, porque a concatenação é feita diretamente na string original.

Postergando condicionais de comparação de string
Uma situação bem corriqueira no dia-a-dia, principalmente quando se está trabalhando com algum tipo de parser, é codificar testes condicionais com mais do que uma validação onde há comparações string.

var

  lFailed: Boolean;

  lText: string;

begin

  ...

  if (lText = '') and (not lFailed) then

  ...

end;

No exemplo acima o primeiro teste do "if" faz uma comparação entre string e o segundo é uma comparação que envolve uma variável booleana.
Sabendo que uma comparação entre string é uma tarefa "onerosa" para o processador, o mais sensato é alterarmos a ordem das condições de forma que os testes mais simples sejam atendidos primeiros. Isso evita, nesse nosso exemplo, uma comparação de string desnecessária quando a variável lFailed for False.
Esse é um tipo de Boas Práticas de Programação pode ser extentido para casos de forma geral que exigam um processamento extra.

Redundância de chamadas
Por mais otimizado que a biblioteca do Delphi esteja, a chamada a uma função de manipulação de string sempre impõem alguma penalidade se comparado com operações simples, e evitar chamadas desnecessárias ou redundantes certamente é um cuidado bem vindo.

O código abaixo é um pequeno trecho retirado de uma método de validação de email. Podemos notar o uso repetido e redundante da função "Pos".

function IsValidEmail(const EMail: string): Boolean;

begin

  ...

  if (Pos('@', EMail) <> 0) and (Pos('.', EMail) <> 0) then

  begin

    if (Pos('@', EMail) = 1) or (Pos('@', EMail) = Length(EMail)) or

        (Pos('.', EMail) = 1) or (Pos('.', EMail) = Length(EMail)) or (Pos(' ', EMail) = 0) then

      Result := False

  ...

Esse é um exemplo simples que utiliza funções específicas para tratamento de strings, mas o problema não é exclusivo e estende-se para qualquer outro tipo de redundância.

function IsValidEmail(const EMail: string): Boolean;

var

  lPos_Dot: Integer;

  lPos_Arroba: Integer;

begin

  ...

  lPos_Dot := Pos('.', EMail);

  lPos_Arroba := Pos('@', EMail);

  if (lPos_Arroba <> 0) and (lPos_Dot <> 0) then

  begin

    if (lPos_Arroba = 1) or (lPos_Arroba = Length(EMail)) or

       (lPos_Dot = 1) or (lPos_Dot = Length(EMail)) or (Pos(' ', EMail) = 0) then 

      Result := False 

  ...

A simples adição de duas variáveis locais evitou quatro chamadas desnecessárias à função "Pos".

Verificando se uma string está vazia
Existem muitas maneiras de conferir se uma string é ou não vazia, mas você sabe qual delas é a mais eficiente?
Abaixo eu apresento três das formas mais freqüentemente empregadas.

var

  lMyStr: string;

begin

  lMyStr := Caption;

  if lMyStr = '' then

    lMyStr := 'Maneira mais eficiente';

  if Length(lMyStr) = 0 then

    lMyStr := 'Maneira menos eficiente';

  if lMyStr[1] = '' then

    lMyStr := 'Forma desaconselhada';

Para entender melhor a verdadeira razão do primeiro if conter a forma mais adequada de verificar se um string está ou não vazia, vou postar o código assemble gerado pelo compilador. Mesmo você não estando familiarizado com a linguagem assembly, tenho certeza que será fácil o entendimento.

O código gerado pelo compilador é apresentado logo abaixo da linha do código fonte respectiva e cada um dos if acima está destacado em uma cor diferente.

fuStrTest.pas.127: if lMyStr = '' then

07992023 837DFC00         cmp dword ptr [ebp-$04],$00

07992027 750D             jnz $07992036

fuStrTest.pas.128: lMyStr := 'Maneira mais eficiente';

07992029 8D45FC           lea eax,[ebp-$04]

0799202C BADC209907       mov edx,$079920dc

07992031 E842F0FFFF       call $07991078

fuStrTest.pas.129: if Length(lMyStr) = 0 then

07992036 8D45FC           lea eax,[ebp-$04]

07992039 E822F0FFFF       call $07991060

0799203E E83DF0FFFF       call $07991080

07992043 85C0             test eax,eax

07992045 750D             jnz $07992054

fuStrTest.pas.130: lMyStr := 'Maneira menos eficiente';

07992047 8D45FC           lea eax,[ebp-$04]

0799204A BA18219907       mov edx,$07992118

0799204F E824F0FFFF       call $07991078

fuStrTest.pas.131: if lMyStr[1] = '' then

07992054 8B45FC           mov eax,[ebp-$04]

07992057 66833800         cmp word ptr [eax],$00

0799205B 750D             jnz $0799206a

fuStrTest.pas.132: lMyStr := 'Forma desaconselhada';

0799205D 8D45FC           lea eax,[ebp-$04]

07992060 BA54219907       mov edx,$07992154

07992065 E80EF0FFFF       call $07991078

Somente observando o número de instruções necessárias para cada uma das três situações já é suficiente para comprovar que o primeiro if é o mais eficiente. Entretanto o segundo if, que utiliza a função Length, merece alguns comentários.
Observe que há duas instruções call (call $07991060 e call $07991080) que são, na verdade, chamadas para as funções EnsureUnicodeString e UStrLen, respectivamente. Essas funções são compostas por diversas instruções e, do ponto de vista de micro otimizações, impõem uma penalidade de performance bastante grande.
Mesmo não tento realizados testes estatísticos mais precisos, posso afirmar que um simples if lMyStr = '' then é incontáveis vezes mais rápido que o uso da função Length.
Novamente ressaltando que isso é do ponto de vista de micro otimizações e para a maioria dos desenvolvedores o ganho de desempenho seria imperceptível.

Remote Debugging no Delphi 2010

2010-01-15T23:31:00.002-02:00

Esse não é um assunto nada novo, mas sempre que preciso utilizar essa técnica de depuração muitos pequenos detalhes surgem e insistem em tomar um tempo precioso que, quase sempre, não foi previsto ou ultrapassa em muito o esperado.

Assim, dedico esse post para a descrição detalhada do passo-a-passo necessário para a depuração remota sobre o Windows Seven (32 bits) utilizando o Delphi 2010.

Apesar de acreditar que os procedimentos aqui descritos são válidos para versões anteriores e/ou posteriores, as configurações e testes foram realizadas utilizando apenas o Delphi 2010.

Configurações Básicas

Na Máquina Remota

Na máquina remota, ou seja, onde encontra-se o software a ser depurado, é preciso ter o "Remote Debugger" instalado.
A instalação vem inclusa no CD de instalação do RAD Studio 2010 que pode ser acessado através do path "\RemoteDebugger\RemoteDebugger.exe" ou então através do Launcher do RAD Studio (imagem abaixo).

Após a instalação, o remote debugger deverá ser inicializado. Esse é um procedimento que sempre deverá ser feito, caso contrário o IDE do Delphi/RAD Studio não conseguirá conectar-se à máquina remota.

No diretório C:\Program Files\RemoteDebugger (use %ProgramFiles%\RemoteDebugger como path, já que o nome do diretório "Program Files" depende do idioma e da plataforma do sistema opearcional -- 32 ou 64 bits) rode o aplicativo rmtdbg140.exe.

O número 140 no nome do aplicativo refere-se à versão do Delphi, no caso Delphi 2010. Se você tiver utilizando uma outra versão, esse número será diferente (ex: rmtdbt105.exe no Delphi 2007; rmtdbg120.exe no Delphi 2009).

O Tray ico, como mostra a imagem ao lado, informa que o remote debugger está rodando.

Na primeira vez que o aplicativo é executado o Windows Vista/Seven irá apresentar um alerta do Firewall.

Confirme a permissão. Caso contrário o IDE não conseguirá conectar-se na máquina remota.

Uma recomendação é que o aplicativo seja executado com permissões de administrador e com o parâmetro "-listen".
No caso da instalação do remote debugger não for possível ou desaconselhada por se tratar de uma máquina de cliente ou por qualquer outro motivo, há a possibilidade de distribuir apenas os arquivos necessário do remote debugger e fazer a inicialização manualmente.

a) Copiar arquivos
Copie os arquivos listados abaixo, encontrados no diretório de instalação do D2010, de para um diretório qualquer na máquina do cliente (máquina remota).
  bccide.dll
  bordbk140.dll
  bordbk140N.dll
  comp32x.dll
  dcc140.dll
  rmtdbg140.exe

OBS: Se a versão do Delphi que você está utilizando não é a 2010 então o nome dos arquivos podem ser ligueiramente diferentes.

b) Registro das DLLs relevantes:
Em um prompt de comandos, faça o registro das DLLs bordbk140.dll e bordbk124N.dll através dos comados:
  regsvr32 /s bordbk140.dll
  regsvr32 /s bordbk140N.dll

c) Inicialização:
Ainda no prompt de comandos inicialize o aplicativo:
rmtdbg140 -listen 8000

Na Máquina Local

O projeto do sistema (que gera o arquivo executável) deve ter algumas opções de compilação/link setadas para que a conexão remota posso ocorrer.

Primeiro altere, caso já não esteja setado, o perfil de build (opção Build Configuration) para Debug. Isso habilitará opções padrões específicas e necessárias para depuração.

Além disso habilite a opção "Include remote debug symbols" nas opções de linker, como mostra a image abaixo.

No caso da sua aplicação possuir outros packages (BPLs) ou DLLs sob a forma de projetos, não esqueça de habilitar essas mesmas opções nesses projetos. A menos, é claro, que a depuração não deva ou não necessite abranger desses pacotes/blibliotecas.

Após modificar essas opções no ou nos projetos, rebuild-o(s).

Por padrão, o Delphi sempre inicita a execução/depuração de um processo local. Para iniciar a depuração remota do aplicativo é necessário solicitar explicitamente a intenção. Para isso, vá ao menu Run e selecione a opção "Load Process...".
No lado esquerdo do dialog click na opção "Remote", que indica que o processo é remoto.

Ao clicar na opção, serão apresentados no lado direito da tela quatro opções de configuração.
1) Remote path: Caminho completo onde o executável a ser depurado encontra-se. Não esqueça que esse caminho é relativo à máquina remota;
2) Remote host: Endereço IP da máquina remota;
3) Parameters: Pode ser utilizado para especificar os parâmetros de execução. Caso não haja parâmetros, deixe o campo em branco;
4) Working directory: O diretório de trabalho é opcional e por padrão é sugerido informar o mesmo diretório de localização do aplicativo;

Após isso basta pressionar o botão "Load" e pronto, a depuração será inicializada.

OBS: Na máquina local somente a depuração será realizada. A interação do o aplicativo (clicks com o mouse e entrada de informações) é independente e só pode ser feita na máquina remota. A sugestão aqui é o uso de um aplicativo remote-deskopt (exemplo VNC Client e VNC Server) para a interação remota com o software a ser depurado.

Uso de hash (MD5) em banco de Dados é seguro?

2009-11-11T19:03:00.002-02:00

Vou começar esse documento perguntado:
Se você necessitasse desenvolver um software que exigisse manter um controle de usuários (login, permissões, ...), como você garantiria a segurança da senha armazenada no banco de dados?

Não tenho a menor dúvida que há uma infinidade de soluções para essa pergunta. Mas o que eu gostaria de tratar nesse post é uma das possíveis soluções bastante difundida e utilizada.
Estou referindo-me ao uso de algoritmos hash, mais especificamente o MD5. Nesse caso, em vez de gravar a senha tal como ela é, grava-se o respectivo hash.

Exemplo

Vamos pensar na estrtura de uma tabela para armazenar a lista de usuários desse sistema.

CREATE TABLE "usuario"

(

    "fullname"  VARCHAR(85) NOT NULL,

    "username"  VARCHAR(20) NOT NULL,

    "passwd"    CHAR(32)

);

OBS: Eu estipulei o tamanho de 32 bytes para o field "passwd" porque o código hash retornado pelo algoritmo MD5 costuma ser uma string com 32 caracteres hexadecimais.

Agora, quando em seu sistema você for cadastrando novos usuários, provavelmente utilizaria um SQL semelhante a este:

INSERT INTO "usuario" (fullname, username, passwd) VALUES ('...', 'mylogin', MD5('minha senha'));

ou talvez calcularia o hash da senha na própria aplicação, persistindo o valor final:

INSERT INTO "usuario" (fullname, username, passwd) VALUES ('Fabius Lovato', 'lovato', 'e10adc3949ba59abbe56e057f20f883e');

Então você faz uma consulta em sua tabela "usuarios" e observa que os registros não exibem uma senha "entendível" e, logo, conclui que mesmo que alguém conseguisse obter esses códigos hash não seria nada fácil convertê-los nas senhas originais.
Aí, acreditando estar seguro, você passa a utilizar esse código como identificador de determinadas transações trafegadas por meios não seguros ou, pior ainda, persiste esse valor em um arquivo texto qualquer.

Talvez não seja novidade para você, mas há grandes bases de dados dedicados que mantém códigos hash para palavras simples e compostas que são usualmente utilizadas. E além disso, essas bases de dados estão disponíveis para o acesso público.
Duvida? Então faça um teste muito simples: Vá até o site de busca do google (http://www.google.com.br/) e cole o código hash do nosso exemplo acima (e10adc3949ba59abbe56e057f20f883e).
Provavelmente você encontrará a resposta estampada nos primeiros links da pesquisa.

Bom, possivelmente você deve estar argumentando que essa é uma senha muito comum e muitos outros artigos a utilizariam com exemplo. Então vamos tentar novamente, mas com o hash a8832562d37247d41a7679612a104997.

Entendeu agora porque o uso de algoritmos de hash não é tão seguros assim?

Links interessantes
Um site muito interessante onde você tem a disposição uma gigantesca base de códigos hash é o md5(); que pode ser acessado pelo link http://md5.rednoize.com/
Na data de publicação desse post, uma nota no rodapé do site informava "Search in 57,035,795 md5/sha1 hashes. 20,612,544 searches answered since feb 2005".
Certamente esses valores são superiores hoje. Inclusive se você esperar alguns segundos e fizer um refresh no site (CTRL + F5), notará que o número de registros dessa base está continuamente crescendo.
Esse site também permite que você gere o código hash de um texto qualquer. Para isso basta digitar um texto que não caracterize um hash md5 válido (32 caracteres hexadecimais).

Se você for web design ou trabalham com aplicações com comunicação/acesso remoto, sugiro a leitura do artigo "Cuidado com sua senha - saiba como funciona a autenticação em sites na web".

Se tiver interesse em saber mais sobre criptografia MD5, um bom artigo está disponível no link http://www.devmedia.com.br/articles/viewcomp.asp?comp=2944.

Se você acha que é só, a lista abaixo ainda não são todos os links que você tem a disposição para localizar um código hash md5. Além disso, alguns desses sites trabalham também com códigos hash de outros algoritmos (sha1, lm e ntlm)
http://tools.benramsey.com/md5/
http://md5.gromweb.com/
http://www.thepanicroom.org/index.php?view=md5
http://shm.hard-core.pl/md5/
http://www.mmkey.com/md5/home.php
http://md5.overclock.ch/
http://www.cmd5.org/
http://www.md5encryption.com/
http://www.md5decrypt.com/
http://www.md5decrypter.com/
http://www.milw0rm.com/md5/
http://plain-text.info/
http://schwett.com/md5/
http://www.tmto.org/
http://www.xmd5.org/
http://passcracking.ru/
http://www.hashchecker.com/
http://gdataonline.com/
Esse último tem uma base de mais de 1 bilhão de hash!

Conclusão
Não importa quão seguro é o algoritmo de hash utilizado, se a senha que você utiliza é intuitiva, fácil e/ou possui poucos caracteres, então temo que ela não seja tão segura quanto você imagina.

ZeosLib for Delphi 2010

2009-10-31T23:51:00.001-02:00

Este sem dúvida é um dos projetos open source e freeware destinado aos desenvolvedores Delphi que mais eu respeito.
ZeosLib é uma biblioteca com um conjunto de ferramentas que oferece conexão nativa com vários de tipos de banco de dados (MySQL, ADO, PostgresSQL, Oracle, SQLite, Firebird, Interbase, MSSQL, Sybase).
Além de ser open source e freeware, uma das grandes vantagens em utilizar o ZeosLib é a flexibilidade e facilidade durante a migração de um banco de dados para outro, justamente pelos mesmos componentes serem utilizados para todos os tipos banco de dados que são suportados.

O objetivo desse artigo não é descrever sobre os recursos e funcionalidades do ZeosLib, mas sim anunciar que hoje essa biblioteca é compatível com o Delphi 2010. Para ser mais específico, já faz alguns meses que essa versão já é suportada pelo Delphi 2010, mas há pouco tempo alcançou um grau de estabilidade aceitável.
A última release estável é a versão 6.6.5 que foi publicada em 25/maio/2009 e oferece suporte até o Delphi 2007.
Apesar de algumas versões não oficiais serem lançadas posteriormente, usuário do Delphi 2009 e, hoje, Delphi 2010 têm ansiosamente aguardado por atualizações dessa biblioteca.
O suporte oficial da biblioteca ao Delphi 2009/2010 só está previsto para a versão 7.0 do ZeosLib que não tem um data definida para ser lançado e, acredito, ainda deve demorar um pouco. Entretanto já está disponível uma versão beta que, apesar de ainda requerer um bom trabalho, é suportado pelo Delphi 2010 e está em fase de teste (svn://zeos.firmos.at/zeos/branches/testing), mas totalmente funcional.

Download

A comunidade ZeosLib mantém o repositório svn (svn://zeos.firmos.at/zeos) onde você pode encontrar todas as versões já lançadas e as versões que estão em desenvolvimento.
Como alguma ferramenta svn client (ex. Tortoise) faça checkout do link svn://zeos.firmos.at/zeos/branches/testing para um pasta qualquer.

No final você deverá ter uma estrutura de diretórios igual ao da imagem ao lado.
Apesar de úteis (não sei se essa é a melhor classificação), apenas os diretórios packages e src são realmente relevantes (considerando que o objetivo é a instalação do pacote no RAD Studio 2010). Sendo assim, manter os demais diretórios é opcional.

Instalando o ZeosLib
A biblioteca ZeosLib é muito organizada e o processo de instalação é simples.

1. No IDE do Delphi, abra o projeto ZeosDbo.groupproj;
2. Compile todos os projetos (menu Project -> Build All Projects);
3. Instale o pacote de componentes selecionando a opção "Install" (no menu de contexto) do pacote "ZComponentDesign140.bpl";

Dependendo de como o RAD Studio está configurado, é possível que o IDE apresente uma mensagem de erro quando o segundo pacote (ZPlain140.bpl) for buildado;

[DCC Fatal Error] ZPlain.dpk(30): E2202 Required package 'ZCore' not found

Essa mensagem informa que o pacote ZCore (ZCore140.bpl) não foi encontrado.
Apesar ser clara, a mensagem não é muito intuitiva principalmente depois de ter sido buildado o primeiro pacote (ZCore140.bpl) e, consequentemente, o arquivo existir.
Na verdade o arquivo foi criado e está localizado em C:\Documents and Settings\All Users\Documents\RAD Studio\7.0\Bpl (o diretório depende da versão do sistema operacional e o idioma do mesmo), apenas não está sendo visível pelo RAD Studio.
Para corrigir, basta incluir $(BDSCOMMONDIR)\Bpl no "Library path", como mostra a imagem abaixo.

Após isso você poderá observar a aba "Zeos Access" na Tool Palette.

Usando o Zeos DBO
Quando ainda usava o Delphi 2009, baixei uma versão super-mega-alfa, baseada na release 6.6.5, que dizia ser suportada pelo Delphi 2009. No entanto, não consegui nem mesmo realizar uma conexão com o PostgresSQL.
Com o objetivo de validar o quão estável está essa versão, resolvi fazer alguns testes com os componentes usando uma base de dados no PostgresSQL 8.4.1.

Após configurar o componente de conexão (TZConnection) com os dados para acessar uma base de dados no PostgresSQL, tentei ativar a conexão.
Nesse momento o componente apresentou a mensagem de erro abaixo.

Um detalhe que pode ser corrigido facilmente apenas acrescentando o diretório bin da instalação do postgres (provavelmente C:\Program Files\PostgreSQL\8.4\bin) no system path. Você pode também copiar os arquivos: Comerr32.dll; krb5_32.dll; libconv-2.dll; libeay32.dll; libintl-2.dll; ssleay32.dll para a pasta system32 do Windows!

Acrescentado o diretório no system path, só foi necessário reiniciar o Delphi e tudo correu muito bem.

E por falar em open source, o que acha de ajudar essa versão do ZeosLib a deixar de ser beta?

Alternativas freeware

2009-10-14T16:16:00.059-03:00

Até não muito tempo atrás o mundo open source não era tão expressivo quanto hoje e, muitas vezes, associado a baixa qualidade. No entanto, hoje podemos vislumbrar projetos open source que competem de igual para igual com soluções pagas.
Dedico esse artigo para citar e descrever sobre alguns pacotes de componentes open source e freeware que são excelentes alternativas para produtos comerciais.

The Fastcode Challanges
The Fastcode Challanges é um projeto, ou melhor, é um desafio público de quem escreve o código mais eficiente para substituir funções e procedimentos da RTL e VCL do Delphi. Atualmente a biblioteca conta com mais de 300 funções publicadas para download e geralmente implementadas em assembly inline.
O projeto é realmente sério, tanto que algumas funções foram adotadas pela Borland substituindo as versões originais.

Synapse TCP/IP Library
Synapse é uma biblioteca de comunicação TCP/IP muito light que preza a simplicidade e é um excelente alternativa para o pessado Indy.
Sua abordagem é um pouco diferente, utiliza comunicação síncrona (blocking). Também oferece comunicação assíncrona, mas de forma limitada.
Uma característica curiosa é a retrocompatibilidade com o Delphi 3. A versão atual (release .39) tem suporte até o Delphi 2009, sendo esse último experimental.
Observando a frequência de atualização dessa biblioteca, pressumo que muito em breve será lançado uma release com suporte ao Delphi 2010.

DCPCrypt
DCPCrypt é um bliblioteca open source que trás vários componentes que implementam algortimos de criptografia e hash.
É compatível com o Delphi 4, 5, 6, 7, 2005, 2006, 2007, 2009. Apesar de não possuir pacotes de instalação exclusivos, também é compatível com a versão 2010 do Delphi.

Algorimos de Criptografia

Blowfish
Cast 128
Cast 256
DES, 3DES
Ice, Thin Ice, Ice2
IDEA
Mars
Misty1
RC2, RC4, RC5, RC6
Rijndael (the new AES)
Serpent
Tea
Twofish

Algoritmos de Hash

Haval
MD4
MD5
RipeMD-128
RipeMD-160
SHA-1
SHA-256, SHA-384, SHA-512
Tiger

Se você usa o Delphi 2010, pode utilizar os pacotes de instalação do 2009 ou, então, baixar uma versão customizada do DCPCrypt 2.0 b3 (http://rapidshare.com/files/293117004/DCPCrypt_2b2_D2010.7z).
Eu particularmente já tive a oportunidade de usa essa fantástica biblioteca e recomendo.

Delphi Fast ZLib
Uma biblioteca para compressão e descompressão de arquivos no formato zib muito mais rápida do que a que é fornecida pelo Delphi e, além disso, não requer DLL externa.
Esse bliblioteca possui várias otimizações, incluindo código para processadores P6 e alinhamento de 64 bits. Tais otimizações são automaticamente utilizadas conforme as características do hardware.

O exemplo abaixo foi extraído do site official (http://www.dellapasqua.com/delphizlib/) e demonstra como utilizar a biblioteca.

procedure TForm1.Button1Click(Sender: TObject);

var

  InputStream, OutputStream: TFileStream;

  DeCompressionStream: TZDecompressionStream;

  CompressionStream: TZCompressionStream;

  InputFileName, OutputFileName: string;

begin

  //compress

  InputFileName := 'c:\image.png';

  OutputFilename := 'c:\image.png.bzip';

  InputStream := TFileStream.Create(InputFileName, fmOpenRead);

  OutputStream := TFileStream.Create(OutputFileName, fmCreate);

  CompressionStream := TZCompressionStream.Create(OutputStream, zcFastest);

  CompressionStream.CopyFrom(InputStream, InputStream.Size);

  CompressionStream.Free;

  OutputStream.Free;

  InputStream.Free;

  // decompress

  InputFileName := 'c:\image.png.bzip';

  OutputFilename := 'c:\image2.png'; //rename to original into final code

  InputStream := TFileStream.Create(InputFileName, fmOpenRead);

  OutputStream := TFileStream.Create(OutputFileName, fmCreate);

  DecompressionStream := TZDecompressionStream.Create(InputStream);

  OutputStream.CopyFrom(DecompressionStream, 0);

  DecompressionStream.Free;

  OutputStream.Free;

  InputStream.Free;

end;

NewAC Delphi Components
NewAC é um pacote de componente destinados a tarefas de processamento de áudio.
Oferece suporte a vários tipos de arquivos de áudio (wav, Ogg Vorbis, FLAC, Monkey Audio, WavPack, MP3, Windows WMA, True Audio (TTA), OptimFROG, TAK, Musepack, DTS 5.1, AC-3).

Uma rápida descrição das caractrísticas desse pacote são:

Audio recording and playback using DirectSound
Audio recording and playback using low latency ASIO drivers
CD-ripping
Supported formats: wav, Ogg Vorbis, FLAC, Monkey Audio, WavPack, MP3, Windows WMA, DTS, AC-3, TTA, OptimFROG, TAK, Musepack
Sound mixing, concatenation, cutting and insertion of audio fragments.
Audio resampling
8, 16, 24, 32 bit sound support
Multi-channel sound
Id3v*, Ape, Vorbis tags support
Ready for Delphi 2009
License: NewAC is free for both open source and commercial use

No link http://symmetrica.net/newac/formats.htm você pode ter uma noção melhor dos formatos de arquivos em comparação com as funcionalidades suportadas.

Professional Screen Camera Component
Como o próprio nome sugere, esse é um excelente componente para que deseja fazer captura do desktop em gravar em avi.
Algumas das suas características são:

Save desktop screen to avi file by arbitrary region.
Select region from 5 way. (SelObject, FreeHand, FixedMoving, FixedStable, FullScreen).
Auto selecting best video codecs in your system. (DivX, XviD, MP4, WMV and Standard AVIs).
Capability recording audio from selected input device.
Full support recording from single monitor and/or multi monitor.
Change arbitrary recording frame rate. (Up to 1000 fps — super fast machines).
Capability recording with set timer.
Change on time video priority at recording mode.
Capability preview before recording or with recording.
On time show recording status.
On time drawing objects, texts, images and… over video canvas. (Overlay option).
On time filter effective (GrayScale Drawing, Reverse Color, Rotation, Brightness, Contrast, Color Adjusting, Saturation, Noise).

Link para acesso: http://delphitutorial.info/professional-screen-camera-component-v4710.html

SafeMM - Debug Memory Manager para Delphi e C++

2009-10-07T22:36:00.003-03:00

Já faz um tempinho que a Embarcadero publicou o SafeMM. De lá para cá eu posterguei inúmeras vezes a realização de testes para entender melhor a proposta desse gerenciador de memória.

Definição
O SafeMM é um gerenciador de memória "prova de conceito" que tem a finalidade de identificar alguns tipos de AV (Access Violation) que normalmente não são caputrados pelo gerenciador de memória padrão do Delphi.

Vamos para um exemplo.

procedure TForm1.Create(Sender: TObject);
const

  DEFAULT_OPTIONS: array[0..2] of string = ('Opção 1', 'Opção 2', 'Opção 3');
var

  i: integer;

  lMyStrList: TStringList;
begin

  lMyStrList := TStringList.Create;
try
for i := low(DEFAULT_OPTIONS) to high(DEFAULT_OPTIONS) do

      lMyStrList.Add(DEFAULT_OPTIONS[i]);

// ... outras instruções

    Self.cbbAction.Items.Assign(lMyStrList);
// ... outras instruções

{$IFDEF DEBUG}

    ShowMessage('String list count: ' + IntToStr(lMyStrList.Count));
{$ENDIF}
finally

    lMyStrList.Free;
end;

Self.cbbAction.ItemIndex := lMyStrList.Count - 1;
  ShowMessage('String list count: ' + IntToStr(lMyStrList.Count));
end;

No exemplo acima uma lista de strings é criada e preenchida com as entradas de um array constante; essa lista é, então, atribuída para o componente "cbbAction"; por último, é posto em seleção o último item da lista.
Um trecho de código bastante comum, mas há uma falha nas duas últimas linhas. A variável "lMyStrList", naquele ponto do código, já está com sua área de memória liberada.

Se você compilar esse exemplo no Delphi (não sei se o comportamento é idêntico para todas as versões - utilizei o Delphi 2010), o segundo ShowMessage retorna o valor 0 (zero) quando tenta acessar o método Count do objeto lMyStrList, mas nenhuma exceção ou falha ocorre. No entanto prever o comportamento da instrução "lMyStrList.Count - 1;" é classe impossível, já que a memória foi liberada e não há qualquer garantia de que os dados anteriormente pertencentes ao objeto ainda estejam intactos na memória.

Apesar do exemplo aqui ser simples, essa falha na lógica de programação pode resultar em um bug complicado e consumir um tempo razoável para rastreá-lo.

Usando o SafeMM
É justamente para situações como essa que o SafeMM se propõem.
Se você utilizar esse gerenciador de memória qualquer instrução de leitura ou escrita à uma área de memória que não deveria estar acessível resultará em um AV (Access Violation).

A sua instalação é muito simples:
Step 1. Acesso o site da Embarcadero (http://cc.embarcadero.com/Item/27241) e faça o download do SafeMM.
Apesar de o código fonte ser livre, é necessário que você seja um usuário registrado. Caso não seja, registre-se e faça o download (a Embarcadero agradece);
Step 2. Descompacte o arquivo em uma pasta qualquer (apenas os arquivos 'SafeMM.pas' e 'SafeMMInstall.pas' são serão utilizados, os demais pode se apagados se assim você desejar);
Step 3. No Delphi, abra o seu projeto e adicione os arquivos 'SafeMM.pas' e 'SafeMMInstall.pas'; build e já está pronto para depurar;

OBS: Eu testei em um projeto relativamente grande, com um executável principal de muitos módulos (.bpl). Só foi necessário acrescentar a referência desses dois arquivos no projeto principal.

Exemplo de um projeto incluindo o SafeMM.

program Project2;

uses

  {$IFDEF DEBUG}

  SafeMM,

  SafeMMInstall,

  {$ENDIF}

  Forms,

  fuPrincipal in 'fuPrincipal.pas' {Form1};

{$R *.res}

begin

  Application.Initialize;

  Application.MainFormOnTaskbar := True;

  Application.CreateForm(TForm1, Form1);

  Application.Run;

end.

Eu utilizei um a diretiva {$IFDEF DEBUG} para garantir que o SafeMM não fosse incluído quando o projeto for buildado para release, ou seja, para a versão final.

Como funciona
O código fonte desse gerenciador de memória é bem pequeno e recomendo dedicar um tempinho para compreender seu funcionamento mais detalhado.
Vou explanar num alto nível como funciona e como é feito para detectar esse tipo de acesso indevido.

O SafeMM substitui as rotinas de gerenciamento de memória (GetMem, FreeMem, ReallocMem e AllocMem) por rotinas próprias (SafeGetMem, SafeFreeMem, SafeAllocMem e SafeReallocMem, respectivamente). Essas rotinas utilizaram listas auxiliares para armazenar registros com informações extras para cada bloco de memória que você for alocado durante a execução do código fonte.
Por exemplo, a linha de código do exemplo acima "lMyStrList := TStrings.Create" necessita alocar memória (que é feito pelo internamente pela rotina SafeGetMem). Nesse momento, uma entrada nessa lista auxiliar é adicionada com diversas informações sobre esse bloco de memória e, entre elas, uma se destaca: "Magic".
A propriedade "Magic", como o próprio nome sugere, é usada para armazenar um código mágico (123123 - decimal). E é utilizada, juntamente com outras variáveis, para manter a integridade desses blocos de informações.
Quando o objeto local lMyStrList é desalocado, o SafeMM realiza várias operações internas e, por último, bloqueia o acesso à região de memória onde o TStringList estava alocado (através da rotina VirtualProtect). Assim, quando você tentar acessar novamente a variável lMyStrList, um AV (Access Violation) é levantado fazendo com que a depuração seja interrompida na linha exata onde ocorreu o acesso indevido.
Simples e funcional!

Considerações
O SafeMM não tem o propósito de substituir o gerenciador de memória padrão do Delphi, ele foi concebido para o processo de depuração.
Um aplicativo normal pode chegar a ter a quantidade memória alocada multiplicada em até 4 vezes. A versão atual é 0.3 e é a mesma desde 29 de março de 2007.

Assertivas - Boas práticas de programação

2009-10-05T23:30:00.002-03:00

Olá a todos.

Há alguns dias atrás eu estava corrigindo um daqueles bugs que só ocorrem muito esporadicamente e que você mal sabe como reproduzi-lo, menos ainda o motivo dele estar ocorrendo.
Provavelmente vocês concordarão que na maioria das vezes esse tipo de bug é ocasionado por um descuido durante a programação. E que a correção desse tipo de falha costuma ser um detalhe em uma única linha de código.
Quem nunca gastou horas de depuração para descobrir que usou a variável errada ou o teste errado dentro de, por exemplo, uma condição "if"?
Por essa razão resolvi revisar muitas daquelas boas práticas de programação que costumamos aprender, mas que deixamos de utilizá-las por achar que somos super-programadores ou por qualquer outro motivo.
O uso de assertivas é um assunto bastante velho e não é um recurso exclusivo do Delphi, muito pelo contrário, quase todas as linguagens que tive a oportunidade de aprender oferecem suporte a esse recurso tão simples e útil.

Definição
As assertivas são validações lógicas de uma condição julgada necessária para o correto funcionamento do algoritmo no momento em que são verificadas. A condição testada pela assertiva representa uma pressuposição assumida e instrui o sistema a notificar sempre que essa condição não for satisfeita, garantindo que não haja um comportamento imprevisto.
Asserções no Delphi são implementadas através da rotina Assert. Apesar do IDE informar que esse procedimento faz parte da unit System, você não encontrará seu código fonte porque é uma função interna do compilador.
A sintaxe de uma assertiva, em Delphi, é a seguinte:

Assert(Condition: Boolean; [Message: string]);

O parâmetro "Condition" é uma expressão booleana que representa a condição a ser satisfeita. O parâmetro "Message" é opcional e pode ser utilizado para especificar uma mensagem customizada exibida quando a condição não for satisfeita.
O funcionamento do Assert é bastante simples. A condição especificada pelo parâmetro Condition é validado e, se o resultado for True, o fluxo de execução continua normalmente. Caso contrário, se a condição resultar em False, uma exceção do tipo EAssertFailed será levantada apresentando a mensagem de texto especificada pelo parâmetro "Message".
Caso você não especifique o parâmetro Message, o Delphi irá utilizar por padrão o texto ‘Assertion failure'.
Um exemplo pode ser observado na imagem abaixo:

Por si só a mensagem padrão exibida já é suficientemente útil. Para a maioria das falhas detectada com as assertivas, sabendo-se o local exato no código fonte onde a assertiva encontra-se e obtendo a stack tracing do depurador, é possível identificar e corrigir o bug.

Relevância
Mesmo sendo seu uso muito simples é importante ficar atendo para a finalidade na qual as assertivas se propõem e, assim, evitar que sejam usadas erroneamente.
Tenha em mente que o Assert é uma prática de programação defensiva que instrumenta o código fonte e o instrui a identificar falhas e comportamentos não originalmente previstos e, assim, detectar bugs em seus estágios iniciais.
Apesar de ser na prática bastante usada para validar as entradas de métodos/rotinas, sua proposta não é essa e sim validar condições consideradas obrigatórias e que, quando não satisfeitas, identifica uma falha no sistema.
Muitas vezes a validação de entradas e/ou saídas das rotinas carrega uma pressuposição e, conseqüentemente, passível de uso de assertivas (e recomendável). No entanto, essa sutil diferença de conceito pode fazer a diferença entre incrementar o grau de corretude do seu código fonte ou acrescentar mais bugs.

Versão Interna x Versão de Produção
Uma característica peculiar das assertivas é a possibilidade de "anular" a geração de código binário.
Essa característica é muito útil quando o sistema é buildado e posto em produção, ou seja, quando a intenção é distribuir o software.
Considerando que a finalidade das assertivas é identificar pressuposições não satisfeitas, quando a versão de sistema é considerada estável e, portanto, passível de ser distribuída, a validação dessas condições não são mais relevantes do ponto de vista dos usuários (clientes) e, portanto, não há necessidade que seja gerado código binário.
O Delphi possui um item de configuração específico que permite habilita/desabilita a compilação das assertivas.
Acesso o menu Projet -> Options -> aba Compiler -> grupo Debugging -> opção "Assertions", conforme mostra a imagem abaixo:

Também existe uma alternativa que pode ser utilizada para forçar a compilação das assertivas ou, então, para desabilitá-las em trechos específicos de código fonte.
Nesse caso há as diretivas de compilação {$ASSERTIONS ON / OFF} e {$C + / -}. Com elas você pode delimitar uma região do código fonte que habilitarão ou não a geração de código para as assertivas.

Use Case 1:
Esse é um exemplo muito simples e não tem uma funcionalidade prática, mas servirá para demonstrar o uso desse recurso fantástico.

function TfrmPrincipal.GetCount: Integer; 

begin 

  Assert(Self.FItems <> nil); 

  Result := Self.FItems.Count; 

end;

Observe que nossa assertiva está pressupondo que a propriedade FItems não pode ser nil.
É fácil prever que se não houvesse essa assertiva e a propriedade FItems não fosse inicializada, quando tal método fosse chamado o sistema certamente falharia. O que caracteriza uma brecha para um bug se instalar e que pode ser facilmente detectado com o acréscimo do Assert.
Entretanto dizer se essa assertiva está ou não empregada corretamente irá depender da finalidade do método e da sua visibilidade (private, protected, public).
Nos próximos exemplos essa questão será abordada.

Use Case 2:
Vamos imaginar um programa simples que disponibiliza ao cliente dois campos de edição para valores numéricos e, ao pressionar um botão, é apresentado um dialog com o valor da divisão entre os valores desses dois campos.
Sabemos que a divisão por zero ocasiona uma exceção (EDivByZero) e necessita ser tratado.

function Dividir(const Dividento, Divisor: Integer): Double; 

begin 

  Assert(Divisor <> 0); 

  Result := Dividento / Divisor;

end; 

procedure TfrmPrincipal.btnResultadoClick(Sender: TObject); 

var 

  lResultado: Double; 

begin 

  lResultado := Dividir(sedtDividento.Value, sedtDivisor.Value); 

  ShowMessage('Resultado da divisão: ' + FloatToStr(lResultado)); 

end;

Quando o botão é pressionado, o evento “btnResultadoClick” é gerado. Este chama a rotina “Dividir” repassando os valores dos dois campos e apresentando um resultado em um dialog.
No método Dividir há uma assertiva que pressupõem que o valor do parâmetro Divisor não seja 0 (zero).
Esse é um exemplo do emprego incorreto do Assert.
No momento em que a compilação de assertivas for desabilitada, a possibilidade de falha seria alta, principalmente porque os valores da divisão são fornecidos diretamente pelo cliente.
A visibilidade da rotina “Dividir” vai além de simplesmente ser usada internamente. Além disso, as assertivas não devem ser utilizadas para validar regras de negócio e, portanto, seu emprego no exemplo acima deve ser revisto.

Use Case 3:
O exemplo abaixo apresenta uma situação bastante problemática e que certamente resultará em dores de cabeça no momento em que o sistema for posto em produção.

procedure TfrmPrincipal.AddItem(Item: TObject); 

begin 

  Assert(Self.FItems.Add(Item) >= 0); 

end;

O método “AddItem” tem a finalidade de acrescentar um objeto, passado por parâmetro, a uma lista interna. E há uma pressuposição de que esse item sempre será acrescentado à lista.
Mas aí eu questiono: O que acontecerá se a compilação dos Assertions for desabilitada?
A resposta é muito simples, o sistema falhará. E pior, a falha pode ocorrer em um ponto do código que aparentemente não apresenta relação com o verdadeiro causador do bug.
Então você houve aquela famosa frase: “Sim, mas eu testei e estava funcionando perfeitamente!”

Use Case 4:
Na maioria das vezes o Assert é utilizado no início de métodos/rotinas que exigem a obrigatoriedade de parâmetros, faixa de valores específicos, recursos alocados, variáveis ou objetos inicializados ou qualquer outra condição necessária para o correto funcionamento desse método/rotina. Mas como dito no início desse artigo, o uso de Assert é uma prática de programação defensiva.
Imaginemos uma situação onde o sistema realize um cálculo relativamente complexo e que, baseando-se nos parâmetros fornecidos, o resultado nunca deverá ultrapassar uma faixa de valores específica.

procedure TfrmPrincipal.btnResultadoClick(Sender: TObject); 

var

  lResultado: Integer;

begin 

  lResultado := Calcular(Param1, Param2, Param3, Param4);

  Assert(lResultado <= 80, 'Resultado fora da faixa permitida.'); 

  // ... 

end;

A assertiva aqui é de grande valia e possibilita identificar uma situação falha, seja ela porque os valores dos parâmetros fornecidos não estavam corretos ou porque a função “Calcular” não está realizando o cálculo de forma correta. Independente do motivo, o Assert garante que a inconsistência não seja levada adiante na execução do sistema.

Use Case 5:
Esse próximo exemplo é um pouco semelhante ao caso acima, mas é uma situação comum.
Imagine que o sistema mantenha uma lista dos componentes relacionados com uma funcionalidade qualquer. A referência desses componentes são armazenadas em um objeto TList e em um dado momento é necessário obter o índice de um desses componente dentro da lista.

procedure TfrmPrincipal.btnResultadoClick(Sender: TObject);

var

  lResultado: Integer;

begin

  lResultado := Self.FItems.IndexOf(Self.FSelected);

  Assert(lResultado >= 0, 'Componente não encontrado.');

  // ...

end;

Aqui há a pressuposição de que o componente selecionado deve obrigatoriamente ter usa referência armazenada em um dos itens da lista. Caso isso não ocorra, há o indício de um bug.
Novamente temos um exemplo de programação defensiva que pode evitar dores de cabeça.

Use Case 6:
A situação abaixo não é muito comum e, particularmente, nunca li qualquer relato, mas é uma prática que costumo utilizar quando estou implementando eventos de um formulário.
Vamos supor que um dado sistema deva possuir uma tela de cadastro de clientes, e uma das informações requeridas pelo cadastro é o estado civil.
Então, durante a fase de construção do formulário, você acrescente dois componentes TRadioButtom. Um para representar o estado civil ‘Solteiro’ e o outro para representar o estado civil ‘Casado’.
O sistema determina que se o cliente não for solteiro, alguns campos devem ser habilitados e preenchidos durante o cadastro.
Então você resolve implementar essa regra de negócio da seguinte forma:

procedure TfrmPrincipal.rdbEstadoCivilClick(Sender: TObject); begin 

  if Sender = rdbCasado then 

  begin 

    tabConjugue.Visible := True; 

    // Outras tarefas 

  end 

  else 

    tabConjugue.Visible := False; 

end;

Ou seja, você compartilha o mesmo evento OnClick com os dois componentes TRadioButtom, tornando visível uma parte do formulário caso o componente rdbCasado esteja marcado.
Depois de um tempo você julga necessário acrescentar outro estado civil (Viúvo) e, então, insere um novo TRadioButtom e associa o mesmo método ao evento OnClick deste novo componente.
Se você esquecer-se de modificar o código prevendo essa nova condição, o sistema não irá falhar e, dependendo do caso, pode ser facilmente detectado em testes funcionais. Entretanto, o uso de assertivas aqui pode economizar um tempo considerável e tornar a vida da equipe de testes mais tranqüila.

procedure TfrmPrincipal.rdbEstadoCivilClick(Sender: TObject); begin 

  Assert((Sender = rdbCasado) or (Sender = rdbSolteiro));

  if Sender = rdbCasado then 

  begin 

    tabConjugue.Visible := True; 

    // Outras tarefas 

  end 

  else 

    tabConjugue.Visible := False; 

end;

Aqui o Assert está pressupondo que esse evento só será gerado pelos componentes “rdbCasado” e “rdbSolteiro”.
Assim, se outro componente fosse associado com esse método, a assertiva irá lembrar-te de que algo está faltando.

Use Case 7:
A criação de componentes ou de classes persistentes (que herdam de TPersistent) exige a implementação do método Assign, cuja finalidade é copiar os dados de um outro objeto de mesmo tipo (ou não) para as respectivas propriedades.
Durante a fase de criação dessas classes é muito comum ocorrer constantes modificações na lista de propriedades, o que exige a atualização do método Assign. No entanto, muitas vezes você não atualiza o método Assign imediatamente após ter acrescentado novas propriedades, deixando para um momento mais apropriado.
Então outras tarefas surgem e os métodos de importação/exportação ficam desatualizados.
Vamos analisar o exemplo abaixo:

TTeste = class(TPersistent)   private 

    FID: integer;

    FNome: string;

  public

    property ID:   integer read FID;

    property Nome: string  read FNome write FNome;

    procedure AssignTo(Dest: TPersistent); override;

end;

implementation

procedure TTeste.AssignTo(Dest: TPersistent);

begin

  Assert(Dest <> nil);

  Assert(Dest.inheritsFrom(TTeste));

  Assert(Dest.InstanceSize = 16, ‘A classe TTeste foi modificada, revise o método Tteste.AssignTo()!’);

  TTeste(Dest).FID   := Self.FID;

  TTeste(Dest).FNome := Self.FNome;

end;

Observe o Assert que está em cor vermelha. Se uma nova propriedade fosse acrescentada à classe, o Assert notificaria que o método Assign está desatualizado (logicamente quando ele fosse chamado).
É claro que fazer uma validação utilizando o InstanceSize da classe não irá identificar todos os tipos de mudanças. Você poderia, por exemplo, modificar o tipo da propriedade “FID” para ShortInt e acrescentar outra propriedade, também ShortInt, que e o tamanho da classe permaneceria os mesmos 16 bytes.
Mesmo assim, a assertiva é de grande ajuda. Principalmente em caso onde há dependência de classes.
Métodos de exportação e importação também são exemplos semelhantes onde esse mesmo caso se aplica.

Customizando o Assert
Até agora vimos diversas situações que podemos empregar o uso do Assert para identificar falhas ou nos ajudar a revisar trechos de código fonte que são dependentes de alguma recurso (classe, record, ...).
Para a maioria das necessidades dos desenvolvedores/testers, o uso padrão do comado Assert já é suficiente, mas este comando ainda guarda um recurso muito interessante, que é a sua customização.
Sempre que um asserção é levantada, o Delphi executa a rotina referenciada pela variável AssertErrorProc.
A variável AssertErrorProc está localizada na unit System e é, na verdade, um ponteiro para uma função com a seguinte assinatura:

procedure (const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);

Isso significa que você pode escrever o seu próprio tratador de Assertivas bastando. escrever uma rotina com a mesma assinatura e atribui-la para a variável global AssertErrorProc.

Exemplo:

procedure MeuTratador(const Message, Filename: string; LineNumber: integer; ErrorAddr: Pointer);

begin

   // Seu código fonte.

end;

AssertErrorProc := MeuTratador;

Talvez você se pergunte: “Mas para que eu necessitaria implementar um tratador de assertiva?”
Há algumas situações que podem ser muito úteis como por exemplo o envio de um email de notificação para o time desenvolvimento; manter um log de falhas em arquivo; automatizar alguma ação relacionada a testes; abrir um ocorrência de falhas em um sistema externo;...

Windows 7 + VisualSVN Server + OpenSSL + TortoiseSVN + Trac (Parte 4)

2009-09-24T12:39:00.001-03:00

1. Overview

Trac é uma simples ferramenta, open source e de interface web para controle de mudanças em projetos de desenvolvimento de software. O objetivo do software é ajudar o desenvolvedor a rastrear essas mudanças, entender o porquê de cada uma e qual o seu impacto no projeto como um todo.

A finalidade desse documento não é falar sobre os recursos e funcionalidades da ferramenta (onde maiores detalhes podem ser encontrados no link http://pt.wikipedia.org/wiki/Trac), mas descrever o passo-a-passo necessário para instalar essa magnífica ferramenta e integrá-la com o repositório do subversion e ao VisualSVN Server.

No site official do VisualSVN (http://www.visualsvn.com/server/trac) é disponibilizado uma versão pré-configurada do Trac juntamente como o passo-a-passo necessário para integrá-lo ao VisualSVN Server. No entanto, apesar desse caminho ser relativamente mais simples, é provável haver situações que você necessite realizar upgrades, acréscimo/remoção de plugins, migração de banco de dados e outras tarefas que exigirá um conhecimento maior sobre o processo, os componentes instalados e suas funcionalidades.

Pensando nisso, esse documento não usará de atalhos ou simplificações e o passo-a-passo da instalação e integração da ferramenta Trac será detalhado de uma forma completa, descrevendo as razões para as respectivas escolhas.

2. Considerações

A ferramenta Trac foi desenvolvida na linguagem de programação Python e conta com uma gama variada de plugins. Os plugins também são desenvolvidos em Python. No entanto, é comum um determinado plugin suportar uma ou outra versão do Python, limitando seu uso.

Além disso, muitos plugins também só podem ser integrados a versões específicas do Trac.

Antes de iniciar a instalação dos softwares requisitos, é importante avaliar quais os plugins deseja instalar ao Trac de forma a escolher adequadamente a versão do Python e de outros softwares requisitos.

Passo 1 – Instalação do Python

A versão atual do Trac (0.11.5) requer a versão 2.3 até 2.6 do Python. A recomendação aqui é utilizar a versão 2.5 devido à maior compatibilidade e suporte por parte dos plugins e drivers.

Apesar de esse documento utilizar tal versão, novamente destaco a importância de avaliar a compatibilidade exigida pelos demais softwares/plugins que serão integrados.

Mais especificamente falando, será usado a versão 2.5 em vez da 2.5.4 (mais recente) porque um dos drivers necessários (mod_python 3.3.1) está, atualmente, disponível para tal release. Essa questão será novamente abordada em outro tópico.

A instalação pode ser baixada através do link: http://www.python.org/ftp/python/2.5/python-2.5.msi.

Por padrão, a instalação assume o diretório C:\Python25 como o local onde serão descompactados os arquivos. No entanto usaremos o path C:\Program Files\Python\.

O processo é simples bastando apenas avançar as abas da instalação (Next, Next, Finish).

Passo 1.1 – System Path

Nas variáveis de ambiente do Windows, acrescente o caminho da instalação do Python no System Path.

Também será necessário adicionar uma variável de ambiente “PYTHONHOME” com o caminho da instalação do Python.

Passo 2 – Instalação do SetupTools

O SetupTools é um coleção de ferramentas para o Python distutils que permite a criação e distribuição de pacotes Python mais facilmente.

Necessitaremos desse pacote para a instalação de plugins e, inclusive, a própria ferramenta Trac.

A instalação pode ser feita através de forma automática, utilizando a instalação binária, ou de forma manual.

Particularmente eu recomendo a instalação manual porque essa opção elimina a possibilidade de você instalar uma versão inadequada ou não suportada pela versão do Python. Nesse caso, será necessário baixar o bootstrap module e copia-lo para a pasta scripts, no diretório de instalação do Python (C:\Program Files\Python\Scripts).

$ cd c:\Program Files\Python

$ md Scripts

$ cd Scripts

$ ez_setup.py

O script ez_setup.py irá fazer o download e instalar a versão adequada do SetupTools.
O resultado da execução desse script deve ser semelhante à apresentada abaixo:

C:\Program Files\Python\scripts>ez_setup.py

Downloading http://pypi.python.org/packages/2.5/s/setuptools/setuptools-0.6c9-py

2.5.egg

Processing setuptools-0.6c9-py2.5.egg

Copying setuptools-0.6c9-py2.5.egg to c:\program files\python\lib\site-packages

Adding setuptools 0.6c9 to easy-install.pth file

Installing easy_install-script.py script to C:\Program Files\Python\Scripts

Installing easy_install.exe script to C:\Program Files\Python\Scripts

Installing easy_install-2.5-script.py script to C:\Program Files\Python\Scripts

Installing easy_install-2.5.exe script to C:\Program Files\Python\Scripts

Installed c:\program files\python\lib\site-packages\setuptools-0.6c9-py2.5.egg

Processing dependencies for setuptools==0.6c9

Finished processing dependencies for setuptools==0.6c9

Como dito acima, pode-se optar pela instalação binária. Nesse caso, será necessário baixar a versão do SetupTools compatível com a versão do Python.

No link http://pypi.python.org/pypi/setuptools é possível encontrar a instalação binária for MS Windows.
Concluído o download, o processo de instalação é igualmente simples (Next, Next, Finish). A versão utilizada na criação desse tutorial é a 0.6c9 e foi baixada desse link.

Após a instalação, confirme a existência do subdiretório Scripts e, dentro dele, o arquivo easy_install.exe.

OBS: É necessário que seja dado permissão de administrador para a instalação (Run as Administrator).

Passo 2.1 – Path

Acrescente o subdiretório Scripts (C:\Program Files\Python\Scripts) no system path, igualmente como feito no passo 1.1.

Passo 3 – Instalação do Genshi

A instalação pode ser feita através do SetupTools ou através da instalação binária.
Em caso de ser feita através do SetupTools, basta abrir um prompt de comandos (aberto com privilégio de Administrador) e digitar:

$ easy_install Genshi

Se desejar a instalação binária, faça o download pelo link e instale-o normalmente (com privilégio de Administrador).

Também há outras formas. Se achar necessário, consulte esse site.

OBS: A imagem acima mostra a instação bem sucedida do Genshi utilizando o SetupTools. No entanto, após concluir toda as etapas de instalação e acessar o Trac via web browser, o módulo de interpretação do python (mod_python) notificou erro informando que o Genshi não estava instalado. O problema só foi solucionado utilizando a instalação binária.

Passo 4 – ClearSilver

O ClearSilver é uma linguagem neutra para system de template HTML. Sua instalação é opcional, mas é requerida para alguns plugins.

Durante a criação desse tutorial, tentou-se realizar a instalação através do comando “easy_install ClearSilver”. O SetupTools fez o download da versão 0.10.1, mas falhou ao instalar o pacote. A solução foi utilizar a url completa para o pacote de versão 0.10.4 para python 2.5.

$ easy_install http://www.clearsilver.net/downloads/win32/clearsilver-0.10.4-py2.5-win32.egg

Passo 5 – Instalando Banco de Dados

Será necessária a instalação de um banco de dados na qual o Trac usará para seu funcionamento. Atualmente é oferecido suporte ao SQLite, PostgresSQL e MySQL. Isso porque o Python possui drives para apenas esses três banco de dados, sendo o driver para MySQL ainda experimental.

Passo 5.1 – Drive para PostgresSQL

Para utilizar o PostgresSQL como gerenciador de banco de dados no Track, é necessário a instalação do driver pyPgSQL e do pacote mxDataTime e são detalhados nos sub-tópicos abaixo.

Apesar dos procedimentos de instalação ser simples, em diversos outros momentos onde optei por utilizar o PostgreSQL, enfrentei diversos problemas e conflitos. Por isso, sugiro o uso do SQLite que é bem mais flexível, principalmente em caso de migração.

Passo 5.1.1 – O gerenciador de banco de dados

Se você já possui o PostgreSQL instalado, pule essa etapa. Caso contrário acesse o link http://www.postgres.org/ e baixe a versão desejada.
Mas antes de fazer o download, leia o próximo tópico.

Passo 5.1.2 – Driver pyPgSQL

A versão do drive pyPgSQL a ser instada depende da versão do gerenciador de banco de dados e da versão do Python.
No link http://www.stickpeople.com/projects/python/win-psycopg/ você encontra uma tabela de downloads que, atualmente, disponibiliza a versão 2.0.12 para o Python 2.5 (usado nesse documento) e para o PostgreSQL 8.4.0 (link direto).

OBS.: A instalação binária deve ser executada com permissões de administrador.

Passo 5.1.3 – Instalando mxDateTime

O mxDateTime implementa novos tipos de objetos: DateTime, DateTimeDelta e RelativeDateTime e varias outras ferramentas destas for tornar fácil a conversar em formatos date/time. Esse pacote é uma exigência do drive pyPgSQL.
Com a instalação do SetupTools, basta executar o seguinte comando no prompt:

easy_install egenix-mx-base

Em caso de falha, é possível fazer o download da instalação binária (para download link aqui)

OBS.: Mais uma vez lembrando de que é requerida permissão de administrador para a instalação binária.

Passo 5.2 – Drive para SQLite

No caso de você optar pelo SQLite, o processo é mais simples.

Passo 5.2.1 – O gerenciador de banco de dados

Esse gerenciador de banco de dados é muito simples (nem mesmo requer um instalador).
a) Acesse o site oficial (http://www.sqlite.org/) e faça o download da versão for Windows mais recente. Atualmente a versão disponível é a 3.6.17 (link direto);
b) Crie uma pasta chamada “SQLite” em “C:\Program Files” e descompacte o arquivo dentro dessa pasta;
c) Por último, acrescente C:\Program Files\SQLite no path do sistema (semelhante ao tópico 1.1)
Uma outra sugestão, em vez de criar um diretório específico para o SQLite, você pode copia-lo para, por exemplo, o diretório de instalação do Python (que já está referenciado no system path).

Passo 5.2.2 – Drive pySQLite

É necessário instalar o drive pySQLite no Python. Essa instalação pode ser feita manualmente (recomendável) ou automática, através de uma instalação binária.
Se optar por fazer manualmente (processo mais simples) abra um prompt de comandos com privilégio de administrador e simplesmente digite o comando abaixo.

$ easy_install pysqlite

Além de mais simples e rápido, e modo remove a possibilidade de você instalar uma versão incompatível com a do Python.

A instalação binária pode ser encontrada nesse link. Deve observar que é necessário a instalar o drive correspondente à versão do Python que foi instalado, que nesse caso é a 2.5 (link direto).

Passo 6 – SVN Python

A instalação dos pacotes de acesso e gerenciamento do repositório svn no python é um dos requisitos obrigatórios e deve considerar a versão do servidor Apache que está instalado e também a versão do Python. E como esse tutorial é destinado a integrar o Trac no VisualSVN Server (mas especificamente a versão 2.0.6 do VisualSVN Server), então você deverá optar por uma instalação com suporte ao Apache 2.2.x.

Isso porque o VisualSVN Server (versão 2.0.6) é composto pelo Apache/2.2.13 (Win32) DAV/2 SVN/1.6.5 mod_ssl/2.2.13 OpenSSL/0.9.8k.

Esse pacote pode ser acrescentado ao Python através de uma instalação binária ou de forma manual (usando o SetupTools), mas deve-se adotar uma instalação compatível com a versão do Subversion (que nesse caso é a 1.6.5) e a versão do Python (2.5).

O instalador é encontrado no mesmo site do Subversion, descrito no tópico acima (http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=8100) ou pelo link direto.

OBS: É requerido “Run as administrator”.

Se preferir, pode fazer a instalação através do SetupTools:

$ easy_install -Z http://subversion.tigris.org/files/documents/15/46527/svn-python-1.6.5.win32-py2.5.exe

Passo 7 - Módulo mod_python

Esse módulo é particularmente necessário para o Apache HTTP Server e deve ser compatível com a versão do python e do próprio Apache instalado (v2.2.13 – VisualSVN Server).

O site oficial (http://www.modpython.org/) redireciona para a página de download de módulos do Apache (http://httpd.apache.org/modules/python-download.cgi). A versão atual 3.3.1 é destinada ao Apache HTTP Server 2.0 e 2.2 (que é o nosso caso). Link direto.

Antes de fazer a instalação é recomendável criar uma pasta chamada “modules” no diretório de instalação do VisualSVN Server. Isso porque o instalador do mod_python irá solicitar, em um dado momento, que informe o diretório de instalação do Apache. No entanto, o VisualSVN Server tem uma estrutura de diretório levemente diferente da do Apache, e isso inclui não possuir a pasta “modules” para onde o instalador irá copiar o módulo mod_python.so.

$ cd c:\Program Files\VisualSVN Server\

$ md modules

OBS: Se após concluída todas as etapas de instalação do Trac ou em um upgrade for exibida a mensagem abaixo no web browser, isso é um forte indicativo de que necessite instalar/reinstalar o mod_python.

Warning: Can't synchronize with the repository (Unsupported version control system "svn": "No module named svn"). Look in the Trac log for more information.

Passo 8 – Trac

Passo 8.1 – Instalando o Track

Para instalar o Track você pode fazer através da instalação binária (), ou então através do SetupTools.
Através do SetupTools basta executar o comando abaixo no prompt de comandos.

$ easy_install Trac

Também pode-se utilizar o link do repositório subversion.

$ easy_install http://svn.edgewall.org/repos/trac/tags/trac-0.11

OBS: O prompt de comandos deve ser aberto com privilégios de administrador.

Vá até o diretório C:\Program Files\Python\Tools\Scripts e execute o comando:

$ cd C:\Program Files\Python\Tools\Scripts

$ python setup.py install

Passo 8.2 – Trac-Admin

O Trac environment é onde serão armazenadas as informações sobre Wiki pages, Tickets, Reports, Settings, etc. Um environment é basicamente um diretório que contém um arquivo de configuração específico juntamente com vários outros arquivos e diretórios.

Para exemplificação, nosso projeto será criado no caminho “D:\Repositories\Trac”. Esse diretório deve ser manualmente criado.

Criado o diretório, vamos criar um novo ambiente usando trac-admin:

$ trac-admin D:\Repositories\Trac\MyProject initenv

O trac-admin irá solicitar informações necessárias para criar o ambiente, tal como nome do projeto, string de conexão com a base de dados, repositório, ...

Para exemplificar usaremos o projeto “MyProject”. Assim, quando solicitado informe:

Passo 8.2.1 – Se estiver usando PostgresSQL

Project Name[My Project]: MyProject
Database connection string [sqlite:db/trac.db]: postgres://tracuser:tracpass@localhost:5432/trac
Repository type [svn]: svn
Path to repository [/path/to/repos]: D:\Repositories\SVN\MyProject

OBS: A string de conexão com o banco de dados especifica: O usuário tracuser, cuja senha é tracpass, tem acesso à base de dados trac cuja conexão é feita através o hostname localhost e porta 5432.

Tanto o usuário quanto a base de dados devem ser previamente criados pela ferramenta DB administrativa de sua preferência.

Passo 8.2.2 – Se estiver usando SQLite

Project Name[My Project]: MyProject
Database connection string [sqlite:db/trac.db]: sqlite:db/myproject.db
Repository type [svn]: svn
Path to repository [/path/to/repos]: D:\Repositories\SVN\MyProject

Passo 8.3 – Execução do Servidor Standalone

Após a criação do ambiente trac, você pode facilmente acessar a interface web através da execução do standalone server tracd.

$ tracd --port 8000 D:\Repositories\Trac\MyProject

No browser digite: http://127.0.0.1:8000/

Passo 8.4 – Firewall / Permissões para o Python

Quando você inicializar o servidor em modelo standalone pela primeira vez, o firewall do Windows 7 irá questiolá-lo sobre o tipo de permissão que o Python deverá receber.

Uma tela semelhante à imagem abaixo será exibida.

Marque das duas opções (como é mostrado na imagem) e clique no botão “Allow access”.

Passo 8.5 – Criando repositório svn

Ao acessar http://127.0.0.1:8000/MyProject/ pelo browser, provavelmente será exibida a seguinte mensagem:

Warning: Can't synchronize with the repository (D:/Repositories/SVN/MyProject does not appear to be a Subversion repository.). Look in the Trac log for more information.

Essa mensagem é porque o repositório svn (MyProject) não foi criado.

$ cd c:\Repositories

$ svnadmin create c:\Repositories\MyProject

Passo 9 – Configurando o VisualSVN Server

Esse capítulo é dedicado a configuração do VisualSVN Server para integrar a ferramenta Trac. E os passos abaixo foram descritos considerando a versão 2.0.7 do VisualSVN Server.
Essa versão utiliza o Apache 2.2.13 e o Subversion 1.6.5.

Passo 9.1 - Arquivo vsvnvars.bat

No arquivo vsvnvars.bat, localizado em C:\Program Files\VisualSVN Server\, acrescente uma linha contendo: set PYTHONHOME=c:\Program Files\Python

@echo off

set PYTHONHOME=c:\Program Files\Python

set PATH=%~dp0bin;%PATH%

IF "%1" == "" GOTO welcome

%*

GOTO end

:welcome

echo Welcome to VisualSVN Server command prompt!

echo Use 'svn help', 'svnadmin help' and 'svnlook help' for more information.

echo Type 'exit' to exit.

GOTO end

:end

Passo 9.2 - Configurando httpd-custom.conf

Em C:\Program Files\VisualSVN Server\conf, abra o arquivo httpd-custom.conf e acrescente no final as seguintes linhas:

LoadModule python_module modules/mod_python.so

LoadModule authz_user_module bin/mod_authz_user.so

<Location /trac>

  SetHandler        mod_python

  PythonInterpreter main_interpreter

  PythonHandler     trac.web.modpython_frontend

  PythonOption      TracEnvParentDir D:\Repositories\Trac

  PythonOption      TracUriRoot /trac

  PythonDebug       on

  AuthName          "Trac"

  AuthType          Basic

  AuthBasicProvider file

  AuthUserFile      "D:/Repositories/SVN/htpasswd"

  Require valid-user

</Location>

Agora basta resetar o VisualSVN Server.

Windows 7 + VisualSVN Server + OpenSSL + TortoiseSVN + Trac (Parte 3)

2009-09-23T09:15:00.000-03:00

1. SVN Client / Tourtoise

O TortoiseSVN é desenvolvido pela Tigris.org, um consórcio que desenvolve soluções open source. Este software é classificado como "Windows Explorer Shell Extension", e uma vez instalado, acrescenta uma opção do menu contextual do Windows Explorer (menu exibido com o clique do botão direito do mouse) apresentando todas as tarefas de controle de versão poderá executar.

Essa ferramenta é muito prática, devido sua integração com o Windows Explorer. Se preferir, pode utilizar um client de linha de comando.

Esse documento não irá detalhar os recursos e funcionalidades do Tortoise, mas sim como configurar o sistema para utilizar o certificado client automaticamente.

Devido ao VisualSVN Server estar configurado para exigir uma conexão SSL e, consequentemente, solicitar um certificado de cliente, em toda operação que exigir leitura ou escrita no repositório svn, o tortoise irá apresentar um dialog solicitando que você informe o caminho onde o certificado client (arquivo .pfx) encontra-se e, posteriormente, a senha de proteção deste certificado.

Para evitar que tortoise sempre solicite o certificado será necessário modificar o arquivo de configuração do subversion (servers). Esse arquivo está localizado em %APPDATA%\Subversion sob o nome “servers” (não possui extenção).

O diretório %APPDATA% é relativo ao sistema operacional, ao idioma do sistema operacional e ao usuário logado. Por exemplo, se você estiver usando Windows XP, uma possível de localização é: C:\Documents and Settings\lovatof\Application Data\Subversion.

Em caso de dúvida, basta digitar %APPDATA% [ENTER] no Windows Explorer e ele expandirá essa variável de ambiente para o correspondente valor.

Abra o arquivo “servers” e localize a linha onde aparece “[groups]”.

O trecho abaixo é um exemplo de configuração que você pode utilizar como base.

[groups] 

flovatosvn               = flovatosvn.myserver.com.br

local                    = localhost 

[flovatosvn] 

ssl-client-cert-file     = C:\Program Files\VisualSVN Server\bin\Cert\Fabius.pfx 

ssl-client-cert-password = [minha senha]

ssl-trust-default-ca     = yes 

http-compression         = yes 

http-timeout             = 300 

[local] 

ssl-client-cert-file     = C:\Program Files\VisualSVN Server\bin\Cert\Fabius.pfx 

ssl-client-cert-password = [Minha Senha]

ssl-trust-default-ca     = yes 

http-compression         = yes 

http-timeout             = 300

Em “[groups]” foi acrescentado a definição de dois grupos (flovatosvn e local). Isso significa que quando o svn client (no caso o tortoise) for acessar um repositório svn utilizando o endereço localhost (por exemplo: https://localhost:8443/svn) deverá ser utilizado as configurações do grupo “local”. O mesmo vale para o grupo “flovatosvn”.

O item “ssl-client-cert-file” define a localização completa do certificado de cliente que deve ser utilizado para a autenticação. Nesse caso, modifique esse parâmetro para refletir a condição definida em seu ambiente de trabalho.

O item “ssl-client-cert-password” é utilizado para armazenar a senha de proteção do certificado. Particularmente eu não recomendo ignorar esse item de configuração por questões de segurança. No entanto, se não for especificado o tortoise irá solicitar tal senha sempre que um acesso ao repositório for realizado.

2. PHP

O suporte ao PHP é um requisito para o funcionamento do WebSVN que será abordado no capítulo abaixo. Além disso, o uso do PHP pode estender à outros frameworks ou mesmo implementações internas.

As etapas abaixos descreve o que deve ser feito a instalação/configuração do PHP5 no Windows 7 com foco ao VisualSVN Server, no entanto esse mesmo passo-a-passo pode ser utilizado (como uma ou outra diferença) para a instalação em outra versão do MS Windows e/ou com foco no Apache.

    2.1 Instalação
No site http://br.php.net/ você encontra informações mais detalhadas sobre o PHP. No nosso tutorial utilizaremos a versão mais recente e estável disponível (verão 5.2.11). Se desejar, faça o download pelo link direto.

Crie uma pasta chamada “PHP” em %ProgramFiles% (C:\Program Files\PHP) e descompacte a instalação para essa pasta.

    2.2 Configurando o PHP
a) No diretório de instalação do PHP (%ProgramFiles%\PHP), copie o arquivo php5ts.dll para a pasta bin do diretório de instalação do VisualSVN Server (%ProgramFiles%\VisualSVN Server\bin). Se você preferir pode copiá-lo para a pasta system32 do Windows (%WINDIR%\system32) como a maioria dos tutoriais recomendam.
A finalidade é tornar acessível tal arquivo acrescentando-o em um local “visível” ao servidor http(s). Não cheguei a testar, mas acredito que simplesmente acrescentando a pasta C:\Program Files\PHP no system path tenha o mesmo efeito.

b) Também no diretório de instalação do PHP você encontra o arquivo “php.ini”. Abra-o e localize a linha onde aparece extension_dir = “./” e modifique para extension_dir = “c:/Program Files/PHP/ext/”, que é o caminho complato do diretório onde ficam as extensões do php (GD, MySQL, Postgres, ...).

c) Caso você tenha instalado MySQL, PostgresSQL, ou outro banco de dados e deseje acessá-los) via PHP, localize, por exemplo, a linha onde aparece ;extension=php_mysql.dll e remova o caracter ponto-e-vírgula (;). Esse caracter tem funcionalidade de comentário (assim como // ou /* */ em C/C++ ou { } em Delphi, ...).
Nesse exemplo, é acrescentado suporte ao MySQL, mas há diversas outras extensões que também estão comentadas, bastando remover o caracter de comentário (;).

d) Seguindo o passo anterior, habilite suporte ao módulo “php_openssl.dll”.

e) O arquivo de configuração do PHP (php.ini) possui muitos parâmetros que permite a customização. Assim, depois de feitas as devidas alterações, salve o arquivo e mova-o para a pasta "conf" do diretório de instalação do VisualSVN (C:\Program Files\VisualSVN\conf).
Aqui a situação é a mesma, o objetivo é tornar o arquivo "visível" ao servidor web. Se preferir, pode mover o php.ini para o diretório de instalação do Windows (%WINDIR%), como é recomendado pela maioria dos guias de instalação.

    2.3. Suporte ao PHP no VisualSVN Server
No arquivo httpd-custom.conf, acrescente as seguintes linhas:

LoadModule php5_module "C:/Program Files/PHP/php5apache2_2.dll"

AddType application/x-httpd-php .php

AddType application/x-httpd-php-source .phps

# configure the path to php.ini

PHPIniDir "C:/Program Files/PHP"

No arquivo httpd.conf, localize a linha onde aparece “<ifmodule dir_module>” e modifique a instrução Directoryindex como aparece abaixo.

<ifmodule dir_module>

    DirectoryIndex index.html index.php default.php main.php

</ifmodule>

Isso fará com que o servidor reconheça os arquivos index.php, default.php e main.php a um diretório aberto. Apesar desses nomes de arquivos serem largamente utilizado, não é obrigatório que utilize-os, você pode incluir inicio.php ou qualquer outro nome de sua escolha.

2.4 Testando o PHP no browser
Acrescentado a configuração acima listada, é necessório um reset o VisualSVN Server para que este inicialize o PHP.

a) Para verificar se o PHP está sendo carregado e funcionando corretamente, crie um arquivo com extensão .php (exemp: info.php) com o seguinte conteúdo:

<? phpinfo(); ?>

b) Salve esse arquivo na pasta "htdocs" do VisualSVN (%ProgramFiles\VisualSVN Server\htdocs).

c) Em seguida, abra um webbrowser e digite: https://localhost:8443/info.php. Se tudo correr bem, deve se exibido uma tela com as informações sobre a configuração do PHP:

3. WebSVN

O WebSVN, como o próprio nome sugere, é um solução open source que permite a navegação no repositório svn através de uma interface web.

É uma solução cuja proposta se assemelha em muito com ao do VisualSVN Server (no quesito web browser), mas possui uma interface melhorada e com vários recursos.

Acesse o site oficial (http://www.websvn.info/) para obter maiores detalhes.

3.1 Instalação
O processo de instalação é muito simples.

Faça o download a versão mais recente (http://www.websvn.info/download/ ) e descompacte o arquivo para uma pasta qualquer dentro de htdocs do VisualSVN (%ProgramFiles\VisualSVN Server\htdocs).

Se preferir pode deixar o diretório com o nome da pasta contida no arquivo de instalação (websvn-2.2.1), mas sugiro renomeá-lo para websvn.

3.2. Configurando o acesso ao WebSVN
Caso deseje posteriormente utilizar o WebSVN acrescente o trecho abaixo no final do arquivo (https.conf) ou, o mais recomendado, acrescente as linhas abaixo no arquivo httpd-custom.conf.

<location /websvn/>

    SVNListParentPath  on

    SVNParentPath      "D:/Repositories/SVN/"

    SVNIndexXSLT       "/svnindex.xsl"

    AuthName           "Subversion Web Browsing"

    AuthType           Basic

    AuthBasicProvider  file

    AuthUserFile       "D:/Repositories/SVN/htpasswd"

    AuthzSVNAccessFile "D:/Repositories/SVN/authz"

    Require valid-user

</location>

OBS: O WebSVN faz uso do php para o sincronismo com o svn, além da construção dinâmica das próprias páginas. Sendo assim, é necessário que o PHP esteja instalado, conforme descrito no capítulo anterior.

Agora, resete o VisualSVN Server (ou Apache) e digite no browser: https://localhost:8443/websvn/.

Provavelmente irá aparecer a seguinte mensagem:

File "includes\config.php" does not exists, please create one. The example is located under "includes\distconfig.php"

Em %ProgramFiles%\VisualSVN Server\htdocs\websvn\include, você encontrará um arquivo chamado “distconfig.php”, faça uma cópia desse arquivo com o nome “config.php”.

Abra o arquivo config.php e acrescente a linha “$config->parentPath('D:\\Repositories\\svn');”. Logicamente, se o repositório svn em sua máquina não está localizado em D:\Repositories\svn, altere para refletir o caminho correto.

Salve o arquivo; volte ao browser e tente novamente. Voai lá.

Windows 7 + VisualSVN Server + OpenSSL + TortoiseSVN + Trac (Parte 2)

2009-09-14T14:53:00.000-03:00

1. Certificado Digital – OpenSSL

Esse tutorial descreverá como configurar o VisualSVN Server para utilizar certificados digitais e assegurar que não haja acessos indevidos.

O objetivo é ter um certificado digital para cada usuário possibilitando o acesso dos mesmos ao repositório svn.

Para a criação desses certificados digitais será utilizado a ferramenta OpenSSL que já vem incluso na instalação do VisualSVN Server.

1.1. Preparando o Ambiente

Antes de iniciar a criação dos certificados será necessário preparar um ambiente configurando-o adequadamente.

Como o openssl será utilizado e é uma ferramenta de linha de comandos, utilizaremos o prompt de comandos para a execução dos scripts necessários.

Para isso, abra um prompt de comandos com permissões de administrador (necessário no Windows Vista/7) e vá até o diretório bin da instalação do VisualSVN (provavelmente em C:\Program Files\VisualSVN Server\bin).

1.1.1. Estrutura de Diretórios/Arquivos

a) Dentro do diretório bin deve-ser criar a seguinte estrutura de diretórios:

Você pode criar essa estrutura de diretórios com o Windows Explorer ou com o próprio prompt de comandos.

b) Crie um arquivo chamado Serial (sem extensão) com o conteúdo “01” (sem as aspas duplas) e grave-o no diretório .\Cert\demoCA\.
c) Crie um arquivo chamado Index.txt (vazio) gravando-o no diretório .\Cert\demoCA\.

O script MS-DOS Batch abaixo cria a estrutura de diretórios.

@ECHO OFF

IF NOT EXIST "%ProgramFiles%\VisualSVN Server\bin" GOTO VSVN_NO_EXIT

SET VSVN=%ProgramFiles%\VisualSVN Server\bin

IF NOT EXIST "%VSVN%\Cert" GOTO BIN_CLEAR

    DEL /S /Q /F "%VSVN%\Cert\*.*" > .\Log.txt

    CHOICE /N /C:Y /T:1 /D:Y > .\Log.txt

    RD /S /Q "%VSVN%\Cert"

:BIN_CLEAR

MD "%VSVN%\Cert"

MD "%VSVN%\Cert\demoCA"

MD "%VSVN%\Cert\demoCA\certs"

MD "%VSVN%\Cert\demoCA\crt"

MD "%VSVN%\Cert\demoCA\newcerts"

MD "%VSVN%\Cert\demoCA\private"

ECHO 01>"%VSVN%\Cert\demoCA\serial"

@ECHO OFF>"%VSVN%\Cert\demoCA\index.txt"

COPY .\openssl.config "%VSVN%\Cert" > .\Log.txt

COPY .\genCA.bat "%VSVN%\Cert" > .\Log.txt

COPY .\genClient.bat "%VSVN%\Cert" > .\Log.txt

COPY .\genServer.bat "%VSVN%\Cert" > .\Log.txt

DEL /Q .\Log.txt

%SystemDrive%

CD "%ProgramFiles%\VisualSVN Server\bin\Cert"

GOTO FIM

:VSVN_NO_EXIT

ECHO Diretório "%ProgramFiles%\VisualSVN Server\bin" não existente.

:FIM

1.1.2. Script de configuração

Crie um arquivo chamado openssl.config no diretório .\Cert\ com o conteúdo abaixo:

File: openssl.config

#EXTENSION SYNTAX.

#ver arquivo openssl-extensions-sintaxe.txt

#

# OpenSSL example configuration file.

# This is mostly being used for generation of certificate requests.

#

# This definition stops the following lines choking if HOME isn't

# defined.

HOME                           = .

RANDFILE                       = $ENV::HOME/.rnd

# Extra OBJECT IDENTIFIER info:

#oid_file                      = $ENV::HOME/.oid

oid_section                    = new_oids

# To use this configuration file with the "-extfile" option of the

# "openssl x509" utility, name here the section containing the

# X.509v3 extensions to use:

# extensions                   =

# (Alternatively, use a configuration file that has only

# X.509v3 extensions in its main [= default] section.)

[ new_oids ]

# We can add new OIDs in here for use by 'ca' and 'req'.

# Add a simple OID like this:

#testoid1=1.2.3.4

# FAKE OIDS CRIADOS A PARTIR DO OBJ_ID_KP DA PKIX (ver objects.h):

OBJ_id_kp                      = 1.3.6.1.5.5.7.3

fake_oid_user_type1            = ${OBJ_id_kp}.999

fake_oid_user_type2            = ${OBJ_id_kp}.998

# Or use config file substitution like this:

# testoid2               = ${testoid1}.5.6

####################################################################

[ ca ]

default_ca = CA_default # The default ca section

####################################################################

[ CA_default ]

dir                            = ./demoCA # Where everything is kept

certs                          = $dir/certs # Where the issued certs are kept

crl_dir                        = $dir/crl # Where the issued crl are kept

database                       = $dir/index.txt # database index file.

new_certs_dir                  = $dir/newcerts # default place for new certs.

certificate                    = $dir/cacert.pem # The CA certificate

serial                         = $dir/serial # The current serial number

crl                            = $dir/crl.pem # The current CRL

private_key                    = $dir/private/cakey.key # The private key

RANDFILE                       = $dir/private/.rand # private random number file

x509_extensions                = serv_cert # The extentions to add to the cert

# Comment out the following two lines for the "traditional"

# (and highly broken) format.

name_opt                       = ca_default # Subject Name options

cert_opt                       = ca_default # Certificate field options

# Extension copying option: use with caution.

# copy_extensions = copy

# Extensions to add to a CRL. Note: Netscape communicator chokes on V2 CRLs

# so this is commented out by default to leave a V1 CRL.

# (descomentei apesar do que esta dito acima):

crl_extensions                 = crl_ext

default_days                   = 365 # how long to certify for

default_crl_days               =  30 # how long before next CRL

default_md                     = md5 # which md to use.

preserve                       =  no # keep passed DN ordering

# A few difference way of specifying how similar the request should look

# For type CA, the listed attributes must be the same, and the optional

# and supplied fields are just that :-)

policy                         = policy_match

# For the CA policy

[ policy_match ]

countryName                    = supplied

stateOrProvinceName            = optional

organizationName               = optional

organizationalUnitName         = optional

commonName                     = supplied

emailAddress                   = optional

# For the 'anything' policy

# At this point in time, you must list all acceptable 'object'

# types.

[ policy_anything ]

countryName                    = optional

stateOrProvinceName            = optional

localityName                   = optional

organizationName               = optional

organizationalUnitName         = optional

commonName                     = supplied

emailAddress                   = optional

####################################################################

[ req ]

default_bits                   = 1024

default_keyfile                = privkey.key

distinguished_name             = req_distinguished_name

attributes                     = req_attributes

x509_extensions                = v3_ca # The extentions to add to the self signed cert

# Passwords for private keys if not present they will be prompted for

# input_password                 = secret

# output_password                = secret

# This sets a mask for permitted string types. There are several options.

# default: PrintableString, T61String, BMPString.

# pkix : PrintableString, BMPString.

# utf8only: only UTF8Strings.

# nombstr : PrintableString, T61String (no BMPStrings or UTF8Strings).

# MASK:XXXX a literal mask value.

# WARNING: current versions of Netscape crash on BMPStrings or UTF8Strings

# so use this option with caution!

string_mask                    = nombstr

# req_extensions = v3_req # The extensions to add to a certificate request

[ req_distinguished_name ]

countryName                    = Country Name (2 letter code)

countryName_default            = BR

countryName_min                = 2

countryName_max                = 2

stateOrProvinceName            = State or Province Name (full name)

stateOrProvinceName_default    = Rio Grande do Sul

localityName                   = Locality Name (eg, city)

localityName_default           = Porto Alegre

0.organizationName             = Organization Name (eg, company)

0.organizationName_default     = My Company LTDA

# we can do this but it is not needed normally :-)

#1.organizationName              = Second Organization Name (eg, company)

#1.organizationName_default      = World Wide Web Pty Ltd

organizationalUnitName         = Organizational Unit Name (eg, section)

organizationalUnitName_default = Security

commonName                     = Common Name (eg, YOUR name)

commonName_default             = My CA

commonName_max                 = 64

emailAddress                   = Email Address

emailAddress_default           = email@server.com

emailAddress_max               = 64

# SET-ex3 = SET extension number 3

[ req_attributes ]

challengePassword              = A challenge password

challengePassword_min          = 4

challengePassword_max          = 20

unstructuredName               = An optional company name

[ serv_cert ]

# These extensions are added when 'ca' signs a request.

# This goes against PKIX guidelines but some CAs do it and some software

# requires this to avoid interpreting an end user certificate as a CA.

basicConstraints               = CA:FALSE

# Here are some examples of the usage of nsCertType. If it is omitted

# the certificate can be used for anything *except* object signing.

# This is OK for an SSL server.

# nsCertType = server

# For an object signing certificate this would be used.

# nsCertType = objsign

# For normal client use this is typical

# nsCertType = client, email

# and for everything including object signing:

# nsCertType = client, email, objsign

# under ASN.1, the 0 bit would be encoded as 80

nsCertType                     = 0x40

# This will be displayed in Netscape's comment listbox.

nsComment                      = "OpenSSL Generated Certificate"

keyUsage                       = keyEncipherment, dataEncipherment, keyAgreement

# PKIX recommendations harmless if included in all certificates.

subjectKeyIdentifier           = hash

authorityKeyIdentifier         = keyid,issuer:always

# This stuff is for subjectAltName and issuerAltname.

# Import the email address.

# subjectAltName=email:copy

# An alternative to produce certificates that aren't

# deprecated according to PKIX.

# subjectAltName=email:move

# Copy subject details

# issuerAltName=issuer:copy

# Netscape extensions:

nsCaRevocationUrl              = http://www.cryptsoft.com/ca-crl.pem

#nsBaseUrl

#nsRevocationUrl

#nsRenewalUrl

#nsCaPolicyUrl

#nsSslServerName

# This is the link where to get the latest CRL (obs - da erro se algum nao estiver online?)

crlDistributionPoints          = URI:https://flovato.sytes.net:8443/crl.crl

#opcional, extended key usage que pode ser usada num WEB-server:

extendedKeyUsage               = serverAuth, codeSigning, emailProtection

#ABAIXO ex. como seria para um ocsp server:

#extendedKeyUsage              = serverAuth, 1.3.6.1.5.5.7.48.1.5

#ABAIXO para um usuario normal

[ cli_cert1 ]

# obs- Esta secao usa fake_oid_user_type1 no extendedKeyUsage

basicConstraints               = CA:FALSE

nsComment                      = "OpenSSL Generated Certificate"

subjectKeyIdentifier           = hash

authorityKeyIdentifier         = keyid,issuer:always

keyUsage                       = nonRepudiation, digitalSignature, keyEncipherment, dataEncipherment, keyAgreement

# This is the link where to get the latest CRL 

crlDistributionPoints          = URI:https://flovato.sytes.net:8443/crl.crl

#extended key usage para um usuario client

extendedKeyUsage               = clientAuth, codeSigning, emailProtection

[ cli_cert2 ]

# obs- Esta secao usa fake_oid_user_type2 no extendedKeyUsage

basicConstraints               = CA:FALSE

nsComment                      = "OpenSSL Generated Certificate"

subjectKeyIdentifier           = hash

authorityKeyIdentifier         = keyid,issuer:always

keyUsage                       = nonRepudiation, digitalSignature, keyEncipherment, dataEncipherment, keyAgreement

# This is the link where to get the latest CRL (obs - da erro se algum nao estiver online?)

crlDistributionPoints          = URI:https://flovato.sytes.net:8443/crl.crl

#extended key usage para um usuario client

extendedKeyUsage               = clientAuth, codeSigning, emailProtection

[ v3_req ]

# Extensions to add to a certificate request

basicConstraints               = CA:FALSE

keyUsage                       = nonRepudiation, digitalSignature, keyEncipherment

[ v3_ca ]

# Extensions for a typical CA

# PKIX recommendation.

subjectKeyIdentifier           = hash

authorityKeyIdentifier         = keyid:always,issuer:always

# This is what PKIX recommends but some broken software chokes on critical

# extensions.

#basicConstraints = critical,CA:true

# So we do this instead.

basicConstraints               = CA:true

# This is the link where to get the latest CRL (obs - da erro se algum nao estiver online?)

crlDistributionPoints          = URI:https://flovato.sytes.net:8443/crl.crl

# This is the link where we can get the issuer certificate

# issuerAltName                = URI:https://flovato.sytes.net:9999/certificado_ca.crt

# Key usage: this is typical for a CA certificate. However since it will

# prevent it being used as an test self-signed certificate it is best

# left out by default.

# keyUsage                     = cRLSign, keyCertSign

# Some might want this also

# nsCertType                   = sslCA, emailCA

# Include email address in subject alt name: another PKIX recommendation

# subjectAltName               = email:copy

# Copy issuer details

# issuerAltName                = issuer:copy

# DER hex encoding of an extension: beware experts only!

# obj=DER:02:03

# Where 'obj' is a standard or added object

# You can even override a supported extension:

# basicConstraints             = critical, DER:30:03:01:01:FF

[ crl_ext ]

# CRL extensions.

# Only issuerAltName and authorityKeyIdentifier make any sense in a CRL.

# issuerAltName                = issuer:copy

authorityKeyIdentifier         = keyid:always,issuer:always

[ usr_cert ]

basicConstraints               = CA:FALSE

subjectKeyIdentifier           = hash

authorityKeyIdentifier         = keyid,issuer:always

nsComment                      = "OpenSSL Generated Certificate"

subjectAltName                 = email:copy

issuerAltName                  = issuer:copy

1.2. Criando o Certificado da Certificadora

Para que os certificados dos usuários e do servidor possam ser assinados, é necessário criar um certificado auto-assinado. Para isso, vá até o diretório .\Cert\ e execute as etapas abaixo:

a) Criação do par de chaves RSA

..\openssl genrsa -out chave_privada_ca.key 1024

b) Copie o arquivo chave_privada_ca.key para .\demoCA\private\

copy chave_privada_ca.key .\demoCA\private\cakey.key 

c) Criação do certificado Root

..\openssl req -new -x509 -config openssl.config -key chave_privada_ca.key -out certificado_ca.pem -days 3650

d) Copie o certificado para .\demoCA\

copy certificado_ca.pem .\demoCA\cacert.pem

Obs.: O par de chaves RSA da certificadora não está protegido.

1.2.1. Script

Abaixo está um exemplo de shell script um pouco mais elaborado e possibilitando a definição de um password de proteção para as chaves RSA.

File: genCA.bat

@ECHO OFF

ECHO [1/4] - CRIANDO PAR DE CHAVES RSA DA CERTIFICADORA

ECHO ***********************************************

IF "%1" == "" GOTO RSA_NOPASS

..\openssl genrsa -des -passout pass:%1 -out chave_privada_ca.key 1024 2> log.txt

GOTO RSA_FIM

:RSA_NOPASS

..\openssl genrsa -out chave_privada_ca.key 1024 2> log.txt

:RSA_FIM

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [2/4] - Copiando Chaves RSA para .\demoCA\private\

ECHO ***********************************************

COPY chave_privada_ca.key .\demoCA\private\cakey.key /y 1>> log.txt

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [3/4] - CRIANDO CERTIFICADO ROOT

ECHO ***********************************************

ECHO Sugestão: Country.: BR

ECHO           State...: Rio Grade do Sul

ECHO           Locality: Porto Alegre

ECHO           Company.: Empresa LTDA

ECHO           Unit....: TI

ECHO           Common N: Minha CA

ECHO           Email...: email@servidor.com

ECHO -----------------------------------------------

IF "%1" == "" GOTO CA_NOPASS

..\openssl req -new -x509 -config openssl.config -key chave_privada_ca.key -passin pass:%1 -out certificado_ca.pem -days 3650

GOTO CA_EXIT

:CA_NOPASS

..\openssl req -new -x509 -config openssl.config -key chave_privada_ca.key -out certificado_ca.pem -days 3650

:CA_EXIT

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [4/4] - Copiando certificado para .\demoCA\

ECHO ***********************************************

COPY certificado_ca.pem .\demoCA\cacert.pem /y 1>> log.txt

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... Sucesso. Certificado criado.

GOTO FIM

:FIM

1.3. Criando o Certificado do Servidor

Durante a instalação do VisualSVN Server um certificado é automaticamente gerado. Este certificado é utilizado para as conexões https.

Um novo certificado deverá ser criado e assinado pela “certificadora” que foi criada.

a) Criação do par de chaves RSA

..\openssl genrsa -out server.key 1024

b) Criação de uma requisição de certificado

..\openssl req -new -config openssl.config -key server.key -out server.req

c) Assinando a requisição com o certificado da “certificadora”

..\openssl ca -config openssl.config -extensions usr_cert -out server.pem -in server.req

d) Exportando o certificado criado para um .cer

..\openssl x509 -in server.pem -out server.cer -outform PEM

1.3.1. Script

Abaixo está um exemplo de shell script (.bat).

File: genServer.bat

@ECHO OFF

IF "%1" == "" GOTO SINTAXE

ECHO [1/5] - CRIANDO PAR DE CHAVES RSA DO SERVIDOR

ECHO ***********************************************

..\openssl genrsa -out %1.key 1024 2> log.txt

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [2/5] - CRIANDO REQUISIÇÃO DE CERTIFICADO PARA SERVIDOR

ECHO **************************************************

ECHO Sugestão: Country.: BR

ECHO           State...: Rio Grade do Sul

ECHO           Locality: Porto Alegre

ECHO           Company.: Empresa LTDA

ECHO           Unit....: TI

ECHO           Common N: SVNServer

ECHO           Email...: email@server.com

ECHO -----------------------------------------------

..\openssl req -new -config openssl.config -key %1.key -out %1.req

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [3/5] - ASSINANDO A REQUISIÇÃO DE CERTIFICADO DO SERVIDOR

ECHO **************************************************

..\openssl ca -config openssl.config -extensions usr_cert -out %1.pem -in %1.req

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [4/5] - EXPORTANDO CERTIFICADO (.CER)

ECHO **************************************************

..\openssl x509 -in %1.pem -out %1.cer -outform PEM

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [5/5] - GERANDO CERTIFICADO + PRIVATE KEY (.P12)

ECHO **************************************************

copy %1.key + %1.cer %1.p12 1>> log.txt

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... Sucesso. Certificado do servidor criado.

GOTO FIM

:SINTAXE

ECHO genServer [Filename]

:FIM

1.3.2. Usando o novo certificado de servidor

Criado o novo certificado, agora se deve configurar o VisualSVN Server para utilizá-lo.

a) Caso o servidor svn esteja rodando, pare a execução do serviço. Isso é feito no console de gerenciamento do VisualSVN Server através da opção Stop, que é disponibilizada no menu de contexto ou através do menu Action;

b) Copie os arquivos server.key e Server.cer, para o subdiretório certs do diretório de instalação do VisualSVN Server (provavelmente C:\Program Files\VisualSVN Server\certs);

c) Localize no arquivo de configuração do VisualSVN Server (httpd.conf) as outra opção que especificam o certificado a chave privada do certificado digital padrão (server.pem) e substitua pelos arquivos anteriormente copiados.

Para isso basta editar httpd.conf modificando as linhas:

SSLCertificateFile certs/server.pem

SSLCertificateKeyFile certs/server.pem

por

SSLCertificateFile certs/server.cer

SSLCertificateKeyFile certs/server.key

1.4. Criando os Certificados dos Usuários

A criação dos certificados de usuários é muito semelhante à criação do certificado de servidor.

a) Criação do par de chaves RSA

..\openssl genrsa -out cliente.key 1024

b) Criação de uma requisição de certificado

..\openssl req -new -config openssl.config -key cliente.key -out cliente.req

c) Assinando a requisição com o certificado da “certificadora”

..\openssl ca -config openssl.config -extensions cli_cert1 -out cliente.pem -in cliente.req

d) Exportando o certificado para o formato PFX

..\openssl pkcs12 -export -clcerts -in cliente.pem -inkey cliente.key -out cliente.pfx

OBS: O certificado no formato pkcs12 (.pfx) deve ser instalado no browser do cliente.

1.4.1. Script

File: genClient.bat

@ECHO OFF

IF "%1" == "" GOTO SINTAXE

ECHO [1/4] - CRIANDO PAR DE CHAVES RSA DO CLIENTE

ECHO ***********************************************

..\openssl genrsa -out %1.key 1024 2> log.txt

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [2/4] - CRIANDO REQUISIÇÃO DE CERTIFICADO PARA O CLIENTE

ECHO **************************************************

ECHO Sugestão: Country.: BR

ECHO           State...: Rio Grade do Sul

ECHO           Locality: Porto Alegre

ECHO           Company.: Empresa LTDA

ECHO           Unit....: Developer

ECHO           Common N: Fabius

ECHO           Email...: flovato@empresa.com.br

ECHO -----------------------------------------------

..\openssl req -new -config openssl.config -key %1.key -out %1.req

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [3/4] - ASSINANDO O CERTIFICADO DO CLIENTE

ECHO **************************************************

..\openssl ca -config openssl.config -extensions cli_cert1 -out %1.pem -in %1.req

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... OK

ECHO [4/4] - EXPORTANDO O CERTIFICADO NO FORMATO PFX

ECHO **************************************************

..\openssl pkcs12 -export -clcerts -in %1.pem -inkey %1.key -out %1.pfx

IF NOT %ERRORLEVEL% == 0 GOTO FIM

ECHO ... Sucesso. Certificado do cliente %1 criado.

GOTO FIM

:SINTAXE

ECHO genServer [Filename]

:FIM

2. Opções de configuração do Apache

Antes de configurarmos o Apache (VisualSVN Server) é importante conhecer para que serve e como utilizar algumas das muitas opções de configuração do Apache.

Esse documento se valerá de uma situação simples para o uso de certificados digitais/SSL. No entanto, é provável que configurações mais elaboradas sejam necessárias com o passar do tempo, e conhecer um pouco mais sobre tais opções certamente ajudará.

SSLEngine             : Habilita/Desabilita o módulo SSL.

SSLProtocol           : Tipos de protocolos SSL aceitos.

SSLCipherSuite        : Tipos de ciphers utilizados na negociação

SSLVerifyClient       : Determina a exigência de um certificado de cliente.

SSLVerifyDepth        : Nível de validação do certificado do cliente.

SSLCACertificateFile  : Certificado a ser utilizado para validar o cliente.

SSLCACertificatePath  : Caminho contendo todos os CA aceitas pelo servidor.

SSLCertificateFile    : Certificado do servidor.

SSLCertificateKeyFile : Chave privada do certificado do servidor.

SSLCARevocationFile   : Lista de certificadoras revogadas.

SSLCARevocationPath   : Caminho contendo todos os CA revogados pelo servidor.

SSLOptions +StdEnvVars: Exporta variáveis de ambiente para o PHP

SSLRequireSSL         : Obriga conexão SSL (HTTPS).

SSLRequire            : Permite especificar requisitos para a conexão.

3. Configurando o VisualSVN Server/Apache

Após a criação dos certificados digitais (CA, Server e Client) o VisualSVN Server deverá ser configurado para que o mesmo passe a utiliza-los e a requisitar autenticação nos acessos feitos.

Como já mencionado no tópico 1.3.2, deve-se substituir o certificado utilizado pelo VisualSVN pelo novo certificado que foi gerado nas etapas anteriores.

Além disso, acesse o arquivo httpd.conf (em C:\Program Files\VisualSVN Server\conf\). Localize as seguintes linhas:

<location ⁄svn⁄>    DAV svn

    SVNListParentPath  on

    SVNParentPath      "D:/Repositories/"

    SVNIndexXSLT       "/svnindex.xsl"

    AuthName           "Subversion Repositories"

    AuthType           Basic

    AuthBasicProvider  file

    AuthUserFile       "D:/Repositories/htpasswd"

    AuthzSVNAccessFile "D:/Repositories/authz"

    require valid-user

    SSLRequireSSL

</location>

A opção “SSLRequireSSL” instrui o servidor Apache a requerer conexão SSL (HTTPS). E a opção “require valid-user”, como o próprio nome sugere, exige a identificação de um usuário válido (cuja lista está definida pela opção “AuthUserFile”).

3.1. Permissão a todos os browsers

Por default, o VisualSVN Server vem configurado para permitir conexões apenas do Internet Explorer. No arquivo https.conf, localizado no subdiretório conf, comente (#) as linhas referentes a opção SetEnvIf. Isso permitirá que outros web browsers também possam acessar o repositório.

<IfModule ssl_module>

    SSLEngine on

    SSLRandomSeed startup  builtin

    SSLRandomSeed connect  builtin

    SSLPassPhraseDialog    builtin

    SSLSessionCache        "shm:C:/Repositories/ssl_scache"

    SSLSessionCacheTimeout 300

    SSLMutex default

    SSLCertificateFile     certs/server.cer

    SSLCertificateKeyFile  certs/server.key

    SSLProtocol            -ALL +SSLv3 +TLSv1

    SSLCipherSuite         ALL:!aNULL:!ADH:!eNULL:!LOW:!EXP:RC4+RSA:+HIGH:+MEDIUM

#   SetEnvIf User-Agent ".*MSIE.*" \

#            nokeepalive ssl-unclean-shutdown \

#            downgrade-1.0 force-response-1.0

</IfModule>

3.2. Solicitação de Certificado de Cliente

O exemplo abaixo acrescenta quatro itens de configuração que instrui o servidor Apache.

<IfModule ssl_module>

    SSLEngine on

    SSLRandomSeed startup  builtin

    SSLRandomSeed connect  builtin

    SSLPassPhraseDialog    builtin

    SSLSessionCache        "shm:C:/Repositories/ssl_scache"

    SSLSessionCacheTimeout 300

    SSLMutex default

    SSLVerifyClient         require

    SSLVerifyDepth          1

    SSLCACertificateFile    certs/cacert.pem

    SSLOptions              +StdEnvVars

    SSLCertificateFile     certs/server.cer

    SSLCertificateKeyFile  certs/server.key

    SSLProtocol            -ALL +SSLv3 +TLSv1

    SSLCipherSuite         ALL:!aNULL:!ADH:!eNULL:!LOW:!EXP:RC4+RSA:+HIGH:+MEDIUM

#   SetEnvIf User-Agent ".*MSIE.*" \

#            nokeepalive ssl-unclean-shutdown \

#            downgrade-1.0 force-response-1.0

</IfModule>

4. Acessando Repositório SVN via WebBrowser
Concluído a configuração do VisualSVN Server, tente acessar o repositório SVN via web browser.

Provavelmente será exibido uma tela semelhante a imagem acima (case esteja utilizando o IExplorer como webbroser). Essa falha é um indicativo que não há um certificado de cliente instalado e, nesse caso, crie um certificado de cliente conforme descrito no tópico 1.4 e instale-o no web browser.

Criado o certificado com o openssl, o processo de instalação é trivial, bastando um duplo clique sobre o arquivo .pfx e um wizard de importação será apresentado. Como é exibido na imagem abaixo.

O wizard também irá solicitar a senha de proteção da chave privada. Essa é a “phase” informada no processo de criação do certificado (imagem abaixo).

É recomendado habilitar a opção “Enable strong private key protection”.

Também recomendo marcar a opção “Mark this key as exportable” a qual será útil caso você perca seu arquivo .pfx, possibilitando exporta-lo do web browser.

Após a instalação do certificado de cliente no web browser, tente acessar o repositorório svn novamente (https://localhost:8443/svn).

Um novo dialog (Windows Security) será apresentado solicitando que escolha o certificado que deve ser utilizado para a autenticação (conexão SSL - HTTPS). Observe a imagem abaixo.

Se tudo correr bem, o browser irá apresentar uma notificação (warning) de segurança questionando a autenticidade do certificado.

Essa mensagem é exibida porque o certificado não foi emitido por uma certificadora “conhecida”. Ignore essa notificação e pressione o botão “Continue”.

Em seguida o servidor irá browser irá solicitar a identificação do usuário.

Você deve informar um usuário e senha que foi previamente cadastrado no console de gerenciamento do VisualSVN Server.

Enfim, após a entrada de um usuário e senha válido, será apresentado a página padrão VisualSVN Server listando todos os repositórios.

Windows 7 + VisualSVN Server + OpenSSL + TortoiseSVN + Trac (Parte 1)

2009-08-29T14:30:00.035-03:00

Esse artigo irá mostrar detalhadamente cada passo para a instalação e configuração do VisualSVN Server utilizando certificado digital e trabalhando integrado com a ferramenta Trac, no Windows 7.

Essa primeira parte do artigo irá detalhar o processo de instalação e configuração do VisualSVN Server.

1. Instalando o VisualSVN Server

O VisualSVN Server é um pacote que contém tudo o que é necessário para instalar, configurar e gerenciar um servidor subversion para a plataforma Windows. Isto inclui o Subversion, Apache e um console de gerenciamento.

O VisualSVN Server possibilita o uso de qualquer client Subversion para conexão ou um rápido acesso aos repositórios através de uma interface web (browser).

Além disso, é 100% free.

Faça o download no site http://www.visualsvn.com/server/download/.

1.1. Iniciando a instalação

1.2. Configurações

Essa etapa trás cinco itens de configuração do servidor SVN.

a) Location: Local onde são instalados os arquivos do VisualSVN Server. O default é a pasta “VisualSVN Server”, no diretório “Arquivos de Programas” (ou “Program Files”, se o idioma de seu Windows for o inglês).
b) Repositories: É o diretório padrão usado para repositório, ou seja, o caminho onde os arquivos dos projetos estão ou estarão localizados (repositório do Subversion).
Se o número da equipe de desenvolvedores for considerável e/ou o número de projetos for expressivo, a quantidade de acesso pode tornar-se um gargalo assim como o espaço necessário. Dessa forma, recomendo avaliar com cuidado o grau de acessos e atualizações que serão efetuados de forma a definir um local com espaço e suficientemente rápido para atender à demanda.
c) Server Port: A instalação sugere utilizar ou porta 443 ou a porta 8443. No entanto, é possível modificá-la para outro valor. Nesse caso cuide para não especificar um valor conflitante com a porta utilizado por algum outro aplicativo (consulte Lista padrão de serviços e portas associadas).
d) HTTPS: Determina se o servidor svn irá ou não utilizar conexões seguras (https). É recomendado que deixe essa opção marcada.
e) Authentication: Esse parâmetro é particularmente interessante e deve ser configurado de acordo com a necessidade de cada empresa.

A autenticação dos usuários nas conexões ao servidor pode ser feita de duas formas: 1 – Utilizando usuários e grupos configurados no próprio servidor; 2 – Utilizando os usuários do Windows (login e senha da rede local ou do ActiveDirectory).

Se for utilizar a autenticação do subversion (opção 1), todos os logins e senhas deverão ser criados.

Nesse tutorial instalaremos o VisualSVN com as configurações padrões. Principalmente porque o objetivo é a utilização de certificados digitais para garantir a segurança dos acessos e, para isso, no mínimo a opção https deve estar marcada.

Caso seja necessário, todos esses itens de configuração podem ser modificados no console de gerenciamento.

1.3. Instalação Concluída

Concluído a instalação o console de gerenciamento será executado exibindo uma interface semelhante a da imagem abaixo.

2. Criando Repositórios

A criação de repositório é muito simples. Você utilizará o console de gerenciamento para isso.

Clique com o botão direito sobre o tópico Repositories. Várias opções serão apresentadas em um popup menu, entre elas New.

Ao clicar em Repository... um dialog será apresentado solicitando que informe o nome do repositório que deseja criar.

Não é obrigatório, mas se você deseja trabalhar com o sistema de private branches, recomendo marcar a opção Create default structure. Essa opção irá criar automaticamente as pastas trunk, branches e tags na estrutura do repositório.

3. Importando Repositórios

Se você já possui um repositório e deseja importá-lo ao gerenciamento do VisualSVN, você pode proceder de forma manual ou através do console de gerenciamento.

Na forma manual basta você copiar o repositório desejado para a pasta D:\Repositórios\SVN (ou para o diretório que você especificou como sendo o repositório padrão do Subversion).

Se desejar fazer através do console de gerenciamento, acesse a opção Import Existing Repository, como detalha a imagem abaixo.

Ao selecionar essa opção, um dialog será exibido solicitando que informe o diretório de localização do Repository na qual deseja importar e um nome para o mesmo.

Um ponto a ser observado é que a importação de repositórios deveser feito projeto a projeto.

O exemplo acima mostra a importação do projeto WorkPlus que está no repositório antigo (I:\Repositories\). E, no caso de uma migração entre repositório, esse procedimento deve ser repetido para os demais projetos.

Tanto a cópia manual das pastas quanto a importação de repositórios não considerada a lista de usuários e as regras/restrições de acessos. Essa informação não está armazenada dentro dos projetos e sim no próprio repositório (D:\Repositories\SVN). Maiores detalhes serão apresentados no tópico abaixo.

4. Usuários e Controle de Acesso

Logo após a instalação do VisualSVN Server o sistema não possui qualquer conta de usuário definida. E é necessário possuir pelo menos um usuário para acesso aos projetos via web browser.
A imagem ao lado pertence à página principal do console de gerenciamento do VisualSVN Server e podemos observar claramente que não há usuários e nem grupos definidos.

A criação dos usuários pode ser feita utilizando os links (“Create new user...” e “Create new group...”) dessa mesma página principal ou clicando com o botão direito sobre a pasta “Users” no lado esquerdo da console de gerenciamento.

Tome cuidado na definição das senhas. Elas são sensitivas a maiúsculo-minúscula. O nome dos usuários também é case sensitive.

4.1. Restringindo o Acesso

No acesso via web browser ou através de um client subversion ao repositório, ou a um projeto específico, será solicitado login. O acesso será liberado somente os usuários que foram cadastrados. No entanto o VisualSVN Server, ao ser instalado, vem com uma configuração padrão que dá acesso completo ao repositório a qualquer usuário (quando é dito “qualquer usuário” está se referindo aos usuários previamente cadastrados).

Essa configuração padrão é “herdada” sempre que um repositório for criado ou importado. E para evitar acessos indesejados devido a descuidos, particularmente, eu recomendo remover o acesso “Everyone”.

Para isso acesse o menu de contexto em “Repositories”, no console de gerenciamento, e click na opção “Properties”, como exemplifica a imagem à esquerda.

Observe que a permissão do usuário especial “Everyone” está definida como leitura e escrita (default da instalação).

O controle de acesso do repositório subversion é bastante flexível e possibilita restringir o acesso não somente a todo o repositório, mas também para diretórios e mesmo arquivos específicos. No entanto, tome cuidado para não especificar regras que venham conflitar com outras, resultando em um comportamento indesejado.

Um exemplo de regra conflitante é definir as permissões do usuário “Everyone” como “No Access” e acrescentar outros usuários/grupos. O resultado é falha sempre que os usuários tentarem fazer um svn commit, mesmo tais usuários tendo permissão “Read / Write”.

4.2. Migrando repositórios

Como comentado no capítulo anterior (3. Importando Repositórios), as informações sobre usuários, grupos e restrições de acesso são armazenados no repositório raiz (C:\Repositories, ou outro caminho que você tenha especificado na instalação) através dos arquivos htpasswd e authz.

No arquivo htpasswd são armazenados os usuários e suas respectivas senhas (criptografadas). O arquivo authz contém as restrições de acesso aos repositórios.

Durante a importação dos projetos, nem a lista de usuários/grupos nem as regras de acesso serão importadas, sendo assumido por default o controle de acesso do repositório raiz. Nesse caso é possível copiar as linhas relativas ao projeto que está sendo importando do arquivo authz do repositório antigo para o novo. Isso é possível porque o arquivo é armazenado em formato texto e sua sintaxe é simples.