Tolerância a falhas

O termo "tolerância a falhas" refere-se à capacidade de um sistema automatizado continuar a funcionar quando se depara com uma falha. Para os algos do cTrader, a tolerância a falhas significa que os processos que alojam cBots, plugins e indicadores podem continuar a funcionar mesmo quando se deparam com erros.

Este artigo explica como funciona a tolerância a falhas e descreve os principais benefícios que esta funcionalidade oferece aos traders algorítmicos.

Regras de tolerância a falhas

Em resumo, a tolerância a falhas garante que todos os algos seguem as regras detalhadas abaixo:

• Ao encontrar uma exceção, um algo deve continuar a funcionar.
• Todas as exceções que ocorrem durante o funcionamento de um algo devem ser registadas.
• Os utilizadores devem ter a oportunidade de introduzir regras personalizadas que determinam como os algos lidam com várias exceções.

A tolerância a falhas permite que os algos essencialmente ignorem todos os erros que não ameaçam bloquear os seus processos. Embora as exceções ainda possam impedir a execução do código, a tolerância a falhas reduz significativamente o número de vezes que um algo pode bloquear inesperadamente.

O método OnException()

De acordo com as regras de tolerância a falhas, os algos têm de ignorar as exceções. No entanto, também pode personalizar a forma como os seus algos reagem a determinadas exceções, ou substituir completamente os comportamentos predefinidos de tolerância a falhas.

Para o fazer, utilize o método OnException(). Este atua como o manipulador dedicado para quaisquer exceções não tratadas. A sua assinatura predefinida é a seguinte:

1
2
3
4

protected virtual void OnException(Exception exception)
{
    /// Introduce your custom exception handling logic here.
}

Considere o seguinte exemplo em que o método OnException() é utilizado para alterar a forma como um cBot reage à exceção NullReferenceException.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class SampleExceptionBot : Robot
    {
        private const string label = "Sample Exception Bot";
        protected override void OnStart()
        {
                var shortPosition = Positions.Find(label, SymbolName, TradeType.Sell);
                ClosePosition(shortPosition);
        }

        protected override void OnException(Exception exception)
        {
            if (exception is NullReferenceException)
            {
                MessageBox.Show("The position does not exist", "Error!");
            }
        }
    }
}

Para lançar a exceção NullReferenceException, fazemos com que o nosso cBot feche uma posição curta que pode não existir. Ao encontrar a exceção especificada, o nosso cBot deve mostrar uma MessageBox com texto explicativo, para que possamos reagir rapidamente a esta exceção e ajustar os comportamentos do nosso cBot.

Note que o manipulador OnException() não se destina a tratar exceções que ocorram durante a invocação deste método. No entanto, essas exceções são ainda registadas no registo de eventos.

Benefícios da tolerância a falhas

A tolerância a falhas é um aspeto crucial do funcionamento da negociação algorítmica no cTrader, proporcionando os seguintes benefícios.

• A tolerância a falhas aumenta significativamente a fiabilidade dos algos e proporciona novas oportunidades para aperfeiçoar a sua abordagem à negociação automatizada.
• Como os algos podem apresentar as exceções que encontram no registo de eventos, pode facilmente determinar as condições em que um algo encontrou um determinado erro.
• Ao permitir o tratamento de eventos de exceção, o método OnException() pode ser utilizado para aperfeiçoar os comportamentos dos seus algos e melhorar a sua fiabilidade.

Lidar com bloqueios

Como mencionado anteriormente, vários erros podem bloquear processos inteiros. São os seguintes:

• A exceção OutOfMemoryException.
• A exceção StackOverflowException.
• Qualquer exceção não tratada que ocorra numa thread separada.
• Quaisquer outros erros que possam ameaçar bloquear o processo em que um algo está a ser executado.

Ao enfrentar qualquer um dos erros acima, uma instância de indicador será interrompida; não será reiniciada automaticamente. No entanto, a exceção será ainda registada no registo.

Em contraste, quando um processo que aloja uma instância de cBot bloqueia, será reiniciado automaticamente (com a exceção a ser registada no registo).

Resumo

A tolerância a falhas proporciona várias oportunidades valiosas para tornar os algos ainda mais estáveis e eficazes. O manipulador OnException() fornece uma camada adicional de controlo sobre como os seus algos reagem às exceções.