Analisador Sintático HTML com o curl

Andrei Novichkov | 4 janeiro, 2020

Introdução

Vamos discutir o caso, quando os dados de um site não podem ser obtidos usando os métodos de requisição normais. O que pode ser feito neste caso? A primeira ideia possível é encontrar um recurso que possa ser acessado usando os métodos HTTP GET ou POST. Às vezes, esses recursos não existem. Por exemplo, isso pode dizer respeito à operação de algum indicador exclusivo ou ao acesso a dados estatísticos que são raramente atualizados.

Podemos questionar: "Qual é o objetivo?" Uma solução simples é acessar a página do site diretamente de um script em MQL e ler um número já conhecido de posições de uma página já vista. Assim, a porção de código recebida pode ser processada posteriormente. Este é um dos métodos possíveis. Mas, neste caso, o código do script em MQL será fortemente vinculado ao código HTML da página. E se o código HTML mudar? É por isso que nós precisamos de um analisador sintático (parser) que permita uma operação semelhante a uma árvore com um documento HTML (os detalhes serão discutidos em uma seção separada). Se nós implementarmos o analisador em MQL, isso será conveniente e eficiente em termos de desempenho? Esse código pode ser mantido de forma adequada? É por isso que a tarefa de um analisador será implementado em uma biblioteca separada. No entanto, o analisador não resolverá todos os problemas. Ele executará a funcionalidade desejada. Mas e se o leiaute do site mudar radicalmente e usar outros nomes e atributos de classe? Nesse caso, nós precisaremos alterar o objeto de busca ou vários objetos deste evento. Portanto, um dos nossos objetivos é criar o código da maneira mais rápida possível e com o mínimo de esforço. Será melhor se nós usarmos ferramentas que já estão prontas. Isso permitirá que o desenvolvedor mantenha o código com facilidade e edite-o rapidamente em caso de acontecer a situação descrita acima.

Nós selecionaremos um site com páginas não muito extensas e tentaremos obter alguns dados interessantes dele. O tipo de dados não é importante neste caso, no entanto, vamos tentar criar uma ferramenta útil. Obviamente, esses dados devem estar disponíveis nos scripts em MQL da plataforma. O código do programa será criado como uma DLL padrão.

Neste artigo, nós implementaremos a ferramenta sem chamadas assíncronas e multithread.

Soluções existentes

A possibilidade de obter os dados da Internet e processá-los sempre foi interessante para os desenvolvedores. O site mql5.com apresenta vários artigos, que descrevem abordagens interessantes e diversas:

• MQL5-RPC. Chamadas de Procedimento Remoto de MQL5. O artigo fornece uma análise detalhada de como receber dados dos recursos que podem ser acessados usando a tecnologia XML-RPC. A requisição é enviada diretamente do script em MQL.
  
• Extraindo dados estruturados de páginas HTML através de seletores CSS. O exemplo mostra como obter os dados e criar um analisador de código HTML usando a MQL.
• WebRequest Multi-Threaded assíncrono em MQL5. O artigo fornece uma versão interessante da criação de requisições assíncronas usando apenas os recursos da MQL.

Definindo as Tarefas

Nós vamos experimentar o seguinte site: https://www.mataf.net/en/forex/tools/volatility. Como fica claro no nome, o site apresenta dados sobre a volatilidade dos pares de moedas. A volatilidade é mostrada em três unidades diferentes: pips, dólar americano e percentual. A página do site não é muito extensa; portanto, pode ser aceita e analisada com eficiência para obter os valores necessários. O estudo preliminar do código fonte mostra que nós teremos que obter os valores armazenados em células de tabela separadas. Assim, vamos dividir a tarefa principal em duas subtarefas:

1. Obtenção e armazenamento da página.
2. Análise da página obtida para receber a estrutura do documento e busca das informações necessárias nessa estrutura. Processamento de dados e envio para o cliente.

#include <curl\curl.h>

typedef size_t (*callback)(void*, size_t, size_t, void*);

typedef struct MemoryStruct {
        vector<char> membuff;
        size_t size = 0;
} MSTRUCT, *PMSTRUCT;

typedef struct FileStruct {
        std::string CalcName() {
                char cd[MAX_PATH];
                char fl[MAX_PATH];
                srand(unsigned(std::time(0)));
                ::GetCurrentDirectoryA(MAX_PATH, cd);
                ::GetTempFileNameA(cd, "_cUrl", std::rand(), fl);
                return std::string(fl);
        }
        std::string filename;
        FILE* stream = nullptr;
} FSTRUCT, *PFSTRUCT;

size_t CCurlExec::WriteMemoryCallback(void * contents, size_t size, size_t nmemb, void * userp)
{
        size_t realsize = size * nmemb;
        PMSTRUCT mem = (PMSTRUCT)userp;
        vector<char>tmp;
        char* data = (char*)contents;
        tmp.insert(tmp.end(), data, data + realsize);
        if (tmp.size() <= 0) return 0;
        mem->membuff.insert(mem->membuff.end(), tmp.begin(), tmp.end() );
        mem->size += realsize;
        return realsize;
}

bool CCurlExec::GetFiletoMem(const char* pUri)
{
        CURL *curl;
        CURLcode res;
        res  = curl_global_init(CURL_GLOBAL_ALL);
        if (res == CURLE_OK) {
                curl = curl_easy_init();
                if (curl) {
                        curl_easy_setopt(curl, CURLOPT_URL, pUri);
                        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
                        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
                        curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, m_errbuf);
                        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 20L);
                        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 60L);
                        curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
                        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); //redirects
#ifdef __DEBUG__ 
                        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
#endif
                        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
                        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &m_mchunk);
                        res = curl_easy_perform(curl);
                        if (res != CURLE_OK) PrintCurlErr(m_errbuf, res);
                        curl_easy_cleanup(curl);
                }// if (curl)
                curl_global_cleanup();
        } else PrintCurlErr(m_errbuf, res);
        return (res == CURLE_OK)? true: false;
}

Vamos prestar atenção aos aspectos importantes do funcionamento de curl. Primeiramente, são executadas duas inicializações, como resultado o usuário recebe um ponteiro para o "núcleo" de curl e para o seu "identificador", que é usado para as chamadas seguintes. Uma conexão adicional está configurada, o que pode envolver muitas configurações. Nesse caso, nós determinamos o endereço de conexão, devemos verificar os certificados, especificamos o buffer no qual os erros serão gravados, determinamos a duração do tempo limite, o cabeçalho "user-agent", a necessidade de lidar com redirecionamentos, a função que será chamada para processar os dados recebidos (o método padrão descrito acima) e o objeto para armazenar os dados. Configurando a opção CURLOPT_VERBOSE, nos permite exibir informações detalhadas sobre as operações que estão sendo executadas, o que pode ser útil para fins de depuração. Depois que todas as opções são especificadas, a função curl curl_easy_perform é chamada. Ela executa a operação principal. Depois que os dados são limpos.

Vamos adicionar mais um método geral:

bool CCurlExec::GetFile(const char * pUri, callback pFunc, void * pTarget)
{
        CURL *curl;
        CURLcode res;
        res = curl_global_init(CURL_GLOBAL_ALL);
        if (res == CURLE_OK) {
                curl = curl_easy_init();
                if (curl) {
                        curl_easy_setopt(curl, CURLOPT_URL, pUri);
                        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
                        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
                        curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, m_errbuf);
                        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 20L);
                        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 60L);
                        curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
                        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); 
#ifdef __DEBUG__ 
                        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
#endif
                        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, pFunc);
                        curl_easy_setopt(curl, CURLOPT_WRITEDATA, pTarget);
                        res = curl_easy_perform(curl);
                        if (res != CURLE_OK) PrintCurlErr(m_errbuf, res);
                        curl_easy_cleanup(curl);
                }// if (curl)
                curl_global_cleanup();
        }       else PrintCurlErr(m_errbuf, res);

        return (res == CURLE_OK) ? true : false;
}

Esse método permite que o desenvolvedor use uma função de retorno de chamada personalizada para processar os dados recebidos (o parâmetro pFunc) e um objeto personalizado para armazenar esses dados (o parâmetro pTarget). Assim, uma página HTML pode ser facilmente salva, por exemplo, como um arquivo csv.

Vamos ver como as informações são salvas em um arquivo sem entrar em detalhes. A função de retorno de chamada apropriada foi mencionada anteriormente, juntamente com o objeto auxiliar FSTRUCT com um código para selecionar o nome do arquivo. No entanto, na maioria dos casos, o trabalho não termina aí. Para obter o nome do arquivo, ele pode ser definido com antecedência (nesse caso, você deve verificar se o arquivo com esse nome existe antes de escrever) ou se pode permitir que a biblioteca obtenha um nome de arquivo legível e significativo. Esse nome deve ser obtido do endereço real, no qual os dados foram lidos após o processamento dos redirecionamentos. O método a seguir mostra como um endereço real é obtido 

bool CCurlExec::GetFiletoFile(const char * pUri)

O código completo do método está disponível no arquivo em anexo. As ferramentas fornecidas no curl são usadas para realizar a análise sintática do endereço:

std::string CCurlExec::ParseUri(const char* pUri) {
#if !CURL_AT_LEAST_VERSION(7, 62, 0)
#error "this example requires curl 7.62.0 or later"
        return  std::string();
#endif
        CURLU *h  = curl_url();
        if (!h) {
                cerr << "curl_url(): out of memory" << endl;
                return std::string();
        }
        std::string szres{};
        if (pUri == nullptr) return  szres;
        char* path;
        CURLUcode res;
        res = curl_url_set(h, CURLUPART_URL, pUri, 0);
        if ( res == CURLE_OK) {
                res = curl_url_get(h, CURLUPART_PATH, &path, 0);
                if ( res == CURLE_OK) {
                        std::vector <string> elem;
                        std::string pth = path;
                        if (pth[pth.length() - 1] == '/') {
                                szres = "index.html";
                        }
                        else {
                                Split(pth, elem);
                                cout << elem[elem.size() - 1] << endl;
                                szres =  elem[elem.size() - 1];
                        }
                        curl_free(path);
                }// if (curl_url_get(h, CURLUPART_PATH, &path, 0) == CURLE_OK)
        }// if (curl_url_set(h, CURLUPART_URL, pUri, 0) == CURLE_OK)
        return szres;
}

Você vê que o curl extrai corretamente o "PATH" do uri e verifica se o PATH termina com o caractere '/'. Se isso acontecer, o nome do arquivo deve ser "index.html". Caso contrário, o "PATH" é dividido em elementos separados, enquanto o nome do arquivo será o último elemento da lista resultante.

Ambos os métodos acima são implementados no projeto, embora geralmente a tarefa de salvar os dados em um arquivo esteja além do escopo deste artigo.

Além dos métodos descritos, a classe CCurlExec fornece dois métodos elementares para receber acesso ao buffer de memória, no qual os dados recebidos da rede foram salvos. Os dados podem ser apresentados como

std::vector<char>

std::string

dependendo da seleção do parser html. Não há necessidade de estudar outros métodos e propriedades da classe CCurlExec, pois eles não se aplicam em nosso projeto.

Para concluir este capítulo, eu gostaria de acrescentar algumas observações. A biblioteca curl é thread-safe. Nesse caso, ela é usada de forma síncrona, para a qual os métodos do tipo curl_easy_init são utilizados. Todas as funções curl contendo "easy" em seu nome são usadas apenas de forma síncrona. O uso assíncrono da biblioteca é fornecido através das funções que incluem "multi" em seus nomes. Por exemplo, curl_easy_init possui uma função análoga assíncrona curl_multi_init. O trabalho com funções assíncronas em curl não é muito complicado, mas envolve um longo código de chamada. Portanto, nós não consideraremos a operação assíncrona agora, mas nós podemos voltar a ela mais tarde.

Classe para o Analisador Sintático HTML

Vamos tentar encontrar um componente pronto para executar esta tarefa. Existem muitos componentes diferentes disponíveis. Ao selecionar um componente, nós usamos os mesmos critérios do capítulo anterior. Nesse caso, a opção preferida é o projeto Gumbo do Google. Ele está disponível no github. O link apropriado está disponível no arquivo do projeto anexado. Você pode compilar o projeto de forma independente, podendo ser mais fácil do que usar o curl. De qualquer forma, o projeto anexado inclui todos os arquivos necessários:

• gumbo.lib está disponível na pasta lib do projeto
• gumbo.dll está incluído em debug e release

#include <gumbo\gumbo.h>

        GumboOutput* output = gumbo_parse(input); 
//      ... do something with output ...
        gumbo_destroy_output(&options, output);

typedef enum {
        byPips = 2,
        byCurr = 3,
        byPerc = 4
} VOLTYPE;

double CVolatility::FindData(const std::string& szHtml, const std::string& pair, VOLTYPE vtype)
{
        if (pair.empty()) return -1;
        m_pair = pair;
        TOUPPER(m_pair);
        m_column = vtype;
        GumboOutput* output = gumbo_parse(szHtml.c_str() );
        double res = FindTable(output->root);
        const GumboOptions mGumboDefaultOptions = { &malloc_wrapper, &free_wrapper, NULL, 8, false, -1, GUMBO_TAG_LAST, GUMBO_NAMESPACE_HTML };
        gumbo_destroy_output(&mGumboDefaultOptions, output);
        return res;
}// void CVolatility::FindData(char * pHtml)

double CVolatility::FindTable(GumboNode * node) {
        double res = -1;
        if (node->type != GUMBO_NODE_ELEMENT) {
                return res; 
        }
        GumboAttribute* ptable;
        if ( (node->v.element.tag == GUMBO_TAG_TABLE)                          && \
                (ptable = gumbo_get_attribute(&node->v.element.attributes, "id") ) && \
                (m_idtable.compare(ptable->value) == 0) )                          {
                GumboVector* children = &node->v.element.children;
                GumboNode*   pchild = nullptr;
                for (unsigned i = 0; i < children->length; ++i) {
                        pchild = static_cast<GumboNode*>(children->data[i]);
                        if (pchild && pchild->v.element.tag == GUMBO_TAG_TBODY) {
                                return FindTableRow(pchild);
                        }
                }//for (int i = 0; i < children->length; ++i)
        }
        else {
                for (unsigned int i = 0; i < node->v.element.children.length; ++i) {
                        res = FindTable(static_cast<GumboNode*>(node->v.element.children.data[i]));
                        if ( res != -1) return res;
                }// for (unsigned int i = 0; i < node->v.element.children.length; ++i) 
        }
        return res;
}//void CVolatility::FindData(GumboNode * node, const std::string & szHtml)

double CVolatility::FindTableRow(GumboNode* node) {
        std::string szRow = "row_" + m_pair;
        GumboAttribute* prow       = nullptr;
        GumboNode*      child_node = nullptr;
        GumboVector* children = &node->v.element.children;
        for (unsigned int i = 0; i < children->length; ++i) {
                child_node = static_cast<GumboNode*>(node->v.element.children.data[i]);
                if ( (child_node->v.element.tag == GUMBO_TAG_TR) && \
                         (prow = gumbo_get_attribute(&child_node->v.element.attributes, "id")) && \
                        (szRow.compare(prow->value) == 0)) {
                        return GetVolatility(child_node);
                }
        }// for (unsigned int i = 0; i < node->v.element.children.length; ++i)
        return -1;
}// double CVolatility::FindVolatility(GumboNode * node)

double CVolatility::GetVolatility(GumboNode* node)
{
        double res = -1;
        GumboNode*      child_node = nullptr;
        GumboVector* children = &node->v.element.children;
        int j = 0;
        for (unsigned int i = 0; i < children->length; ++i) {
                child_node = static_cast<GumboNode*>(node->v.element.children.data[i]);
                if (child_node->v.element.tag == GUMBO_TAG_TD && j++ == (int)m_column) {
                        GumboNode* ch = static_cast<GumboNode*>(child_node->v.element.children.data[0]);
                        std::string t{ ch->v.text.text };
                        std::replace(t.begin(), t.end(), ',', '.');
                        res = std::stod(t);
                        break;
                }// if (child_node->v.element.tag == GUMBO_TAG_TD && j++ == (int)m_column)
        }// for (unsigned int i = 0; i < children->length; ++i) {
        return res;
}

#ifdef GETANDPARSE_EXPORTS
#define GETANDPARSE_API extern "C" __declspec(dllexport)
#else
#define GETANDPARSE_API __declspec(dllimport)
#endif

GETANDPARSE_API double GetVolatility(const wchar_t* wszPair, UINT vtype);

const static char vol_url[] = "https://www.mataf.net/ru/forex/tools/volatility";

GETANDPARSE_API double GetVolatility(const wchar_t*  wszPair, UINT vtype) {
        if (!wszPair) return -1;
        if (vtype < 2 || vtype > 4) return -1;

        std::wstring w{ wszPair };
        std::string s(w.begin(), w.end());

        CCurlExec cc;
        cc.GetFiletoMem(vol_url);
        CVolatility cv;
        return cv.FindData(cc.GetBufferAsString(), s, (VOLTYPE)vtype);
}

#property copyright "Copyright 2019, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property script_show_inputs

#import "GETANDPARSE.dll"
double GetVolatility(string wszPair,uint vtype);
#import
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum ReqType 
  {
   byPips    = 2, //Volatility by Pips
   byCurr    = 3, //Volatility by Currency
   byPercent = 4  //Volatility by Percent
  };

input string  PairName="EURUSD";
input ReqType tpe=byPips; 
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+

void OnStart()
  {
   double res=GetVolatility(PairName,tpe);
   PrintFormat("Volatility for %s is %.3f",PairName,res);
  }

Conclusão

Nós discutimos um método para analisar a página HTML de forma simplificada. A biblioteca é feita de componentes prontos. O código foi bastante simplificado para ajudar os iniciantes a entender a ideia. A principal desvantagem desta solução é a execução síncrona. O script não assumirá o controle até que a biblioteca receba a página HTML e a processe. Isso pode levar tempo, o que é inaceitável para indicadores e Expert Advisors. Outra abordagem é necessária para uso em tais aplicações. Nós vamos tentar encontrar melhores soluções em outros artigos.

Programas utilizados no artigo