Feature Toggle – Parte 4

Faaala Time, bom ou não?

No último post criamos a estrutura básica do projeto que utilizaremos para provar alguns conceitos relacionados ao feature toggle. Neste post daremos continuidade e implementaremos alguns mecanismos importantes. Bora la?

Se você não leu o último post, confira aqui.

Implementações

Na criação da estrutuda do projeto adiconamos também as bibliotecas de dependência. Uma das bibliotecas é o Config Cat. Iniciaremos nossa implementação através do arquivo FatureToggleFilterAttrbute.cs.

A estratégia é criar um atributo para “anotar” Actions nas classes de controller. Sendo assim, este atributo irá validar se o Feature Toggle definido no atributo está habilitado ou não. Se estiver habilitado, então a action é executada, caso contrário será retornado o status code 404 (not found):

public class FeatureToggleFilterAttribute : ActionFilterAttribute
    {
         protected readonly string _toggle;

        public FeatureToggleFilterAttribute(string toggle)
        {
            _toggle = toggle;
        }

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            IConfigCatClient _configCatClient = context.HttpContext.RequestServices.GetService(typeof(IConfigCatClient)) as IConfigCatClient;

            if (_configCatClient != null) 
            {
                _configCatClient.ForceRefresh();

                if (!_configCatClient.GetValue(_toggle, false))
                    context.Result = new NotFoundResult();
            }
        }
    }

• Na linha 1 adicionamos uma herança para a classe ActionFilterAttribute que é um tipo especial que acrescenta funcionalidades no fluxo de execução das actions, no caso, validar o feature toggle. Para maiores detalhes sobre filters no .net core, consultar aqui.
• Nas linhas 3 a 18 definimos uma propriedade que irá conter o nome do feature toggle e obtemos o seu valor no construtor do atributo.
• Nas linhas 12-19 são feitas as validações necessárias obtendo o client do configcat, obtido pelo contâiner de injeção de dependência do .net core, forçando a recuperação dos valores de toggles(linha 16) e finalmente validando se o toggle está ativo ou não.

Manteremos a implementação o mais simples possível neste momento.

No arquivo ConfiCatOptions.cs apenas adicionamos uma propriedade que precisaremos neste momento, Key, que irá conter a chave de conexão com o SDK do Config cat:

 public class ConfigCatOptions
    {
        public string Key { get; set; }
    }

Antes de alterar o arquivo IDogAPIService.cs, crie uma nova classe chamada DogServiceModel.cs na pasta Models:

public class DogServiceModel
    {
        public string Message { get; set; }   

        public string Status { get; set; }

        public int Code { get; set; }
    }

Esta classe apenas contém um objeto que será retornado ao consumir a API que utilizaremos neste exemplo. Esta API retornará um link aleatório contendo uma foto de algum cachorro com base em sua raça.

Agora altere a classe IDogAPIService.cs:

public interface IDogAPIService
    {
        [Get("/breed/{dogName}/images/random")]
        Task<DogServiceModel> GetDogImage(string dogName);
    }

Pontos importantes nesta classe:

• É uma interface
• Linha 3: Anotamos o método da interface com um atributo Get. Este atributo é definido pela library do Refit e diz que o método GetDogImage efetuará uma requisição GET a um recurso REST tendo como sufixo o path /breed/{dogName}/images/random. Observem que o atributo {dogName} tem o mesmo nome do parâmetro definido no método.
• Linha 4: definição do método que recebe como parâmetro o nome de uma raça de cachorro e retorna um objeto DogServiceModel.

É uma abordagem diferente anotar o método de uma interface com um atributo que diz respeito a uma requisição HTTP. E este é um dos grandes benefícios do REFIT. Definida a interface, não será necessário implementar uma classe que faz a requisição HTTP para o serviço. O Refit cuidará desta abstração. Para saber mais sobre o refit, clique aqui.

Considerações finais

O artigo está ficando um pouco extenso e não desejo criar muitas dúvidas no momento. A ideia é simplificar para enteder, de fato, o objetivo da estratégia de utilização de feature toggles. Menos é mais. Então vamos parar por aqui, neste momento.
De uma forma resumida apenas criamos um filtro para abstrair a consulta de toggles habilitados ou não em nossas actions, implementamos a interface que será responsável por comunicar com um serviço externo, além de criar um model para representar o retorno da API, e implementamos uma classe para abstrair dados de configurações.

Você pode acessar o código desenvolvido até o momento: https://github.com/codefc/serie-feature-toggle

Creio que por hoje é só. Deixe seus comentários com dúvidas, críticas e sugestões e até o próximo post o vídeo.