CURLを使用した HTML の解析

Andrei Novichkov | 22 1月, 2020

イントロダクション

通常のリクエストではウェブサイトからのデータが得られない場合について議論しましょう。 この場合、何ができるでしょうか。 最初に考えられる考え方は、GET リクエストまたは POST リクエストを使用してアクセスできるリソースを見つけることです。 ただし、このようなリソースが存在しない場合があります。 たとえば、ユニークなインジケータの動作や、めったに更新されない統計へのアクセスに関係する場合があります。

"要点は何でしょうか。" 簡単な解決策は、MQLスクリプトから直接サイトページにアクセスし、既知のページポジションにある既知の位置を読み取ることです。 その後、受信した文字列をさらに処理できます。 可能性のある方法の 1 つです。 しかし、この場合、MQL スクリプトコードはページのHTMLコードに密接にバインドされます。 HTML コードが変更された場合はどうなるでしょうか。 そのため、HTML ドキュメントを使用してツリーのような操作を可能にするパーサーが必要です (詳細については別のセクションで説明します)。 MQLでパーサーを実装する場合、パフォーマンスの面で便利で効率的でしょうか? このようなコードを適切に保守できるでしょうか。 そのため、解析関数は別のライブラリで実装します。 ただし、パーサーはすべての問題を解決するわけではありません。 必要な機能を実行します。 しかし、サイトのデザインが根本的に変更され、他のクラス名と属性を使用する場合はどうでしょうか。 この場合、検索オブジェクトまたはイベント複数のオブジェクトを変更する必要があります。 したがって、目標の1つは、できるだけ早く、最小限の労力で必要なコードを作成することです。 既製のパーツを使えば良くなります。 これより、デベロッパはコードを保持し、上記の状況に応じてすばやく編集できます。

ページが大きすぎないウェブサイトを選定し、該当サイトから興味深いデータを取得しましょう。 この場合、データの種類は重要ではありませんが、便利なツールを作成してみましょう。 もちろん、このデータはターミナルの MQL スクリプトで使用できる必要があります。 プログラム コードは標準DLLとして作成されます。

この記事では、非同期呼び出しとマルチスレッドを使用せずにツールを実装します。

既存のソリューション

インターネットからデータを取得し、処理する可能性は、デベロッパにとって常に興味深いものでした。 mql5.comのウェブサイトには、興味深く多様なアプローチを説明する記事があります。

• MQL5-RPC. MQL5 からのリモート プロシージャ コール。 この記事では、XML-RPC テクノロジを使用してアクセスできるリソースからデータを受信する方法の詳細な分析をします。 リクエストは MQL スクリプトから直接送信されます。
  
• CSS セレクタを使用した HTML ページからの構造化データの抽出: この例では、MQL を使用してデータを取得し、HTML コードパーサーを作成する方法を示します。
• DIY マルチスレッド非同期 MQL5 ウェブリクエスト. この記事では、MQLを使用して分析することなく、非同期リクエストを作成するバージョンを提供します。

タスクの定義

まず次のサイトを試します。https://www.mataf.net/en/forex/tools/volatility. 名前から明らかなように、サイトは通貨ペアのボラティリティに関するデータを備えています。 このボラティリティは、pips、米ドル、パーセントの3つの異なる単位で表示されます。 Web サイトページはあまりにもかさばらないので、効率的に受け入れることができ、必要な値を取得できます。 ソーステキストの予備的な研究は、別々のテーブルセルに格納された値を取得する必要があることを示します。 したがって、メイン タスクを 2 つのサブタスクに分割してみましょう。

1. ページの取得と保存。
2. 取得したページを解析してドキュメント構造を受け取り、この構造体で必要な情報を詳しく見ることができます。 データ処理とクライアントへの受け渡し。

#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;
}

CURL操作の重要な側面に注意を払いましょう。 まず、2 つの初期化が実行され、その結果、ユーザーはCURL "core" とその "handle" へのポインタを受け取り、以降の呼び出しで使用します。 さらに接続が構成され、多くの設定が必要になる場合があります。 この場合、接続アドレスの決定、証明書の確認、エラーの書き込み先のバッファの指定、タイムアウト期間の決定、"user-agent" ヘッダ、リダイレクトの処理の必要性、呼び出される関数の指定を使用して、受信したデータ (上記のデフォルトの方法) とデータを格納するオブジェクトを処理します。 CURLOPT_VERBOSE オプション を設定すると、実行されている操作に関する詳細情報を表示できます。 すべてのオプションを指定すると、curl_easy_performの curl 関数が呼び出されます。 主な操作を行う。 その後、データがクリアされます。

もう 1 つの一般的なメソッドを追加してみましょう。

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;
}

このメソッドを使用すると、デベロッパはカスタム コールバック関数を使用して受信したデータ (pFunc パラメータ) と、このデータを格納するカスタム オブジェクト (pTarget パラメータ) を処理できます。 したがって、HTML ページは csv ファイルなどとして保存できます。

詳細に説明せずに、情報がファイルに保存される方法を見てみましょう。 適切なコールバック関数は、ヘルパー オブジェクト FSTRUCT とファイル名を選択するためのコードと共に前述しました。 しかし、ほとんどの場合、このタスクはそこで終わりません。 ファイル名を取得するには、事前に設定するか (この場合は、書き込む前にこの名前のファイルが存在するかどうかを確認する必要があります)、ライブラリが読み取り可能でわかりやすいファイル名を取得できるようにすることができます。 このような名前は、リダイレクトの処理後にデータが読み取られた実際のアドレスから取得する必要があります。 次のメソッドは、実際のアドレスを取得する方法を示します。 

bool CCurlExec::GetFiletoFile(const char * pUri)

完全なメソッド コードはアーカイブにあります。 「curl」で提供されるツールは、アドレス解析に使用します。

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;
}

CURLが URI から "PATH" を正しく抽出し、PATH が '/' 文字で終わるかどうかを確認することがわかります。 存在する場合、ファイル名は "index.html" である必要があります。 そうでない場合、"PATH" は別々の要素に分割され、ファイル名は結果のリストの直近の要素になります。

上記の方法はどちらもプロジェクトに実装されていますが、通常、ファイルにデータを保存するタスクはこの記事の範囲外です。

CCurlExec クラスには、説明されているメソッドに加えて、ネットワークから受信したデータが保存されたメモリ バッファへのアクセスを受信するための 2 つの基本メソッドが用意されています。 データは次のように表示できます。

std::vector<char>

std::string

以降の html パーサーの選択に応じて異なります。 CCurlExec クラスはプロジェクト内で適用できないため、他のメソッドやプロパティを調べる必要はありません。

この章を締めくくるために、いくつか注意を述べておきます。 CURL ライブラリはスレッドで保護されています。 この場合、curl_easy_init型のメソッドが使用する同期的に使用します。 名前に "easy" が含まれるすべてのCURL関数は、同期的にのみ使用します。 ライブラリの非同期使用は、名前に "multi" を含む関数を介して提供されます。 たとえば、curl_easy_initには非同期の類似関数curl_multi_initがあります。 curl での非同期関数の操作はほど複雑ではありませんが、長い呼び出しコードが必要です。 したがって、ここでは非同期操作は考慮しませんが、後で戻る可能性があります。

HTML 解析クラス

このタスクを実行する準備ができているコンポーネントを見つけてみましょう。 使用可能なさまざまなコンポーネントがあります。 コンポーネントを選択する場合は、前の章と同じ基準を使用します。 この場合、推奨されるオプションは Google の Gumbo プロジェクトです。 それはgithub で入手できます。 添付されたプロジェクトアーカイブで適切なリンクを使用できます。 プロジェクトは自分でコンパイルできますが、curl を使用するよりも簡単な場合があります。 とにかく、添付されたプロジェクトには、すべての必要なファイルがあります。

• gumbo.lib は lib プロジェクトフォルダにあります。
• gumbo.dll はデバッグとリリースに含まれています

#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 ReqTypeTPe=byPips; 
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+

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

結論

ページ HTML を最もシンプルな形式で解析する方法について説明しました。 ライブラリは準備完了コンポーネントで構成されています。 このコードは、初心者がアイデアを理解するのに役立つ大幅に簡略化されています。 このソリューションの主な欠点は、同期実行です。 ライブラリが HTML ページを受け取って処理するまで、スクリプトは制御を取得しません。 時間がかかる場合があり、インジケータやEAには受け入れられない場合があります。 このようなアプリケーションで使用するには、別のアプローチが必要です。 さらなる記事でより良い解決策を見つけることを試みます。

この記事で使用されているプログラム