schema validation logic complete

Maple · Maple · commit e96b848f66b3 · 2018-07-11T10:39:10.000+02:00
diff --git a/doc/definitions.json b/doc/definitions.json
@@ -7,6 +7,14 @@
       "type": "string"
     }
   },
+  "symbols": {
+    "description": "JSON schema used in https://api.bitfinex.com/v1/symbols/ endpoint",
+    "type": "array",
+    "items": {
+      "type": "string"
+    },
+    "uniqueItems": false
+  },
   "pubticker": {
     "description": "JSON schema used in https://api.bitfinex.com/v1/pubticker/ endpoint",
     "type": "object",
diff --git a/include/bfx-api-cpp/BitfinexAPI.hpp b/include/bfx-api-cpp/BitfinexAPI.hpp
@@ -137,6 +137,9 @@ namespace BfxAPI
                 "XRP",
                 "ZEC"
             };
+            
+            schemaValidator_ = jsonutils::BfxSchemaValidator(symbols_, currencies_);
+            
             // As found on
             // https://bitfinex.readme.io/v1/reference#rest-auth-deposit
             methods_ =
@@ -152,10 +155,12 @@ namespace BfxAPI
                 "tetheruso",
                 "zcash",
             };
+            
             walletNames_ =
             {
                 "trading", "exchange", "deposit"
             };
+            
             // New order endpoint "type" parameter
             types_ =
             {
@@ -913,6 +918,8 @@ namespace BfxAPI
         CURL *curlGET_;
         CURL *curlPOST_;
         CURLcode curlStatusCode_;
+        // internal jsonutils instances
+        jsonutils::BfxSchemaValidator schemaValidator_;
         // BitfinexAPI settings
         string WDconfFilePath_;
         string APIurl_;
@@ -996,13 +1003,13 @@ namespace BfxAPI
             return noError;
         };
         
-        void doGETrequest(const string &UrlEndPoint, const string &params)
+        void doGETrequest(const string &apiEndPoint, const string &params)
         {
             bfxApiStatusCode_ = noError;
             
             if(curlGET_)
             {
-                string url = APIurl_ + UrlEndPoint + params;
+                string url = APIurl_ + apiEndPoint + params;
                 
                 result_.clear();
                 curl_easy_setopt(curlGET_, CURLOPT_TIMEOUT, CURL_TIMEOUT);
@@ -1018,10 +1025,20 @@ namespace BfxAPI
                 {
                     cerr << "libcurl error in doGETrequest():\n";
                     cerr << "CURLcode: " << curlStatusCode_ << "\n";
+                    bfxApiStatusCode_ = curlERR;
+                }
+                // Check schema
+                else
+                {
+                    bfxApiStatusCode_ =
+                    schemaValidator_.validateSchema(apiEndPoint, result_);
                 }
             }
             else
+            {
                 cerr << "curl not properly initialized curlGET_ = nullptr";
+                bfxApiStatusCode_ = curlERR;
+            }
         };
         
         void doPOSTrequest(const string &UrlEndPoint, const string &params)
diff --git a/include/bfx-api-cpp/error.hpp b/include/bfx-api-cpp/error.hpp
@@ -20,5 +20,7 @@ enum bfxERR
     addressParamsMissing,   // 8
     badOrderType,           // 9
     jsonStrToUSetError,     // 10
-    badWDconfFilePath       // 11
+    badWDconfFilePath,      // 11
+    responseParseError,     // 12
+    responseSchemaError     // 13
 };
diff --git a/include/bfx-api-cpp/jsonutils.hpp b/include/bfx-api-cpp/jsonutils.hpp
@@ -21,23 +21,26 @@
 #include <iostream>
 #include <string>
 #include <unordered_set>
+#include <unordered_map>
 
 // namespaces
 using std::cerr;
 using std::cout;
 using std::endl;
 using std::string;
 using std::unordered_set;
+using std::unordered_map;
 namespace rj = rapidjson;
 
 
-///////////////////////////////////////////////////////////////////////////////
-// Routines
-///////////////////////////////////////////////////////////////////////////////
-
 namespace jsonutils
 {
-    // Helper class resolving remote schema for schema $ref operator
+    
+    ////////////////////////////////////////////////////////////////////////////
+    // Classes
+    ////////////////////////////////////////////////////////////////////////////
+    
+    /// Helper class resolving remote schema for schema $ref operator
     class MyRemoteSchemaDocumentProvider: public rj::IRemoteSchemaDocumentProvider
     {
     public:
@@ -50,27 +53,129 @@ namespace jsonutils
             rj::Document d;
             d.ParseStream(fReadStream);
             fclose(pFileIn);
-            remoteSchemaDoc = new rj::SchemaDocument(d);
+            remoteSchemaDoc_ = new rj::SchemaDocument(d);
         };
         
-        ~MyRemoteSchemaDocumentProvider()
-        {
-            delete remoteSchemaDoc;
-        };
+//        ~MyRemoteSchemaDocumentProvider()
+//        {
+//            delete remoteSchemaDoc_;
+//        };
         
     private:
         
-        rj::SchemaDocument *remoteSchemaDoc;
+        rj::SchemaDocument *remoteSchemaDoc_;
         
         virtual const rj::SchemaDocument*
         GetRemoteDocument(const char* uri, rj::SizeType length)
         {
             // Resolve the URI and return a pointer to that schema
-            return remoteSchemaDoc;
+            return remoteSchemaDoc_;
         }
     };
     
-    // SAX events helper struct for jsonStrToUset() routine
+    class BfxSchemaValidator
+    {
+    public:
+        
+        BfxSchemaValidator() {}
+        BfxSchemaValidator(unordered_set<string> &symbols,
+                           unordered_set<string> &currencies)
+        {
+            // Mapping is needed because rapidjson implementation of $ref
+            // keyword in json schema doesn't support json keys which contain
+            // special characters.
+            // See https://github.com/Tencent/rapidjson/issues/1311
+            
+            // Create map for endpoints which use symbols in URL
+            for (const auto &symbol : symbols)
+            {
+                // Map /pubticker/[symbol] endpoints to "pubticker" schema
+                apiEndPointToSchemaMap_.emplace("/pubticker/" + symbol,
+                                                "pubticker");
+                // Map /stats/[symbol] endpoints to "stats" schema
+                apiEndPointToSchemaMap_.emplace("/stats/" + symbol,
+                                                "stats");
+                // Map /book/[symbol] endpoints to "book" schema
+                apiEndPointToSchemaMap_.emplace("/book/" + symbol,
+                                                "book");
+                // Map /trades/[symbol] endpoints to "trades" schema
+                apiEndPointToSchemaMap_.emplace("/trades/" + symbol,
+                                                "trades");
+            }
+            
+            // Create map for endpoints which use currencies in URL
+            for (const auto &currency : currencies)
+            {
+                // Map /lendbook/[currency] endpoints to "lendbook" schema
+                apiEndPointToSchemaMap_.emplace("/lendbook/" + currency,
+                                                "lendbook");
+                // Map /lends/[currency] endpoints to "lends" schema
+                apiEndPointToSchemaMap_.emplace("/lends/" + currency,
+                                                "lends");
+            }
+            
+            // Create map for static endpoints
+            apiEndPointToSchemaMap_.emplace("/symbols/", "symbols");
+            apiEndPointToSchemaMap_.emplace("/symbols_details/",
+                                            "symbols_details");
+            
+        }
+        
+        auto validateSchema(const string &apiEndPoint, const string &inputJson)
+        {
+            const auto schemaName = getApiEndPointSchemaName(apiEndPoint);
+            
+            // Create rapidjson schema document
+            rj::Document sd;
+            string schema =
+            "{ \"$ref\": \"definitions.json#/" + schemaName + "\" }";
+            sd.Parse(schema.c_str());
+            rj::SchemaDocument schemaDocument(sd, 0, 0, &provider_);
+            
+            // Create rapidjson document and check for parse errors
+            rj::Document d;
+            if (d.Parse(inputJson.c_str()).HasParseError())
+            {
+                cerr << "Invalid json - response:" << endl;
+                cerr << inputJson << endl;
+                cerr << "API endpoint: " << apiEndPoint << endl;
+                return bfxERR::responseParseError;
+            }
+            
+            // Create rapidjson validator and check for schema errors
+            rj::SchemaValidator validator(schemaDocument);
+            if (!d.Accept(validator))
+            {
+                // Input JSON is invalid according to the schema
+                // Output diagnostic information
+                rj::StringBuffer sb;
+                validator.GetInvalidSchemaPointer().StringifyUriFragment(sb);
+                cerr << "Invalid schema: " << sb.GetString() << endl;
+                cerr << "Invalid keyword: " << validator.GetInvalidSchemaKeyword() << endl;
+                sb.Clear();
+                validator.GetInvalidDocumentPointer().StringifyUriFragment(sb);
+                cerr << "Invalid document: " << sb.GetString() << endl;
+                cerr << "Invalid response: " << inputJson << endl;
+                cerr << "Invalid API endpoint: " << apiEndPoint << endl;
+                return bfxERR::responseSchemaError;
+            }
+            
+            return bfxERR::noError;
+        }
+       
+    private:
+        
+        MyRemoteSchemaDocumentProvider provider_;
+        unordered_map<string, string> apiEndPointToSchemaMap_;
+        
+        const string& getApiEndPointSchemaName(const string& apiEndpoint) noexcept
+        {
+            return apiEndPointToSchemaMap_[apiEndpoint];
+        }
+        
+    };
+    
+    /// SAX events helper struct for jsonStrToUset() routine
     struct jsonStrToUsetHandler:
     public rj::BaseReaderHandler<rj::UTF8<>, jsonStrToUsetHandler>
     {
@@ -118,7 +223,11 @@ namespace jsonutils
         } state_;
     };
     
-    bfxERR jsonStrToUset(unordered_set<string> &uSet, const string &jsonStr)
+    ////////////////////////////////////////////////////////////////////////////
+    // Routines
+    ////////////////////////////////////////////////////////////////////////////
+    
+    bfxERR jsonStrToUset(unordered_set<string> &uSet, const string &inputJson)
     {
         // Create schema $ref resolver
         rj::Document sd;
@@ -132,7 +241,8 @@ namespace jsonutils
         jsonStrToUsetHandler handler;
         
         // Create schema validator
-        rj::GenericSchemaValidator<rj::SchemaDocument, jsonStrToUsetHandler> validator(schemaDoc, handler);
+        rj::GenericSchemaValidator<rj::SchemaDocument, jsonStrToUsetHandler>
+        validator(schemaDoc, handler);
         
         // Create reader
         rj::Reader reader;
@@ -142,7 +252,7 @@ namespace jsonutils
         /// DEBUG
         
         // Create input JSON StringStream
-        rj::StringStream ss(jsonStr.c_str());
+        rj::StringStream ss(inputJson.c_str());
 //        rj::StringStream ss(mockJson.c_str()); // DEBUG
         
         // Parse and validate
@@ -162,6 +272,7 @@ namespace jsonutils
                 sb.Clear();
                 validator.GetInvalidDocumentPointer().StringifyUriFragment(sb);
                 cerr << "Invalid document: " << sb.GetString() << endl;
+                cerr << "Invalid response: " << inputJson << endl;
             }
             return bfxERR::jsonStrToUSetError;
         }
