Merge pull request #33 from TheSnowfield/test

bug fix

Author: TheSnowfield

source/@declares/global.d.ts

@@ -13,12 +13,20 @@ declare var BOTARCAPI_USERBEST_HISTORY_DEFAULT: number;
 declare var BOTARCAPI_AGGREGATE_LIMITATION: number;
 declare var BOTARCAPI_AGGREGATE_ENABLED: boolean;
 declare var BOTARCAPI_AGGREGATE_CONCURRENT: boolean;
+declare var BOTARCAPI_FRONTPROXY_NODES: Array<FontProxyNode>;
+
+interface FontProxyNode {
+  url: string,
+  weight: number
+  enabled: boolean,
+}
 
 declare var ARCAPI_RETRY: number;
 declare var ARCAPI_VERSION: number;
 declare var ARCAPI_APPVERSION: string;
 declare var ARCAPI_USERAGENT: string;
 declare var ARCAPI_URL: string;
+declare var ARCAPI_URL_CODENAME: string;
 
 declare var DATABASE_PATH: string;
 declare var SERVER_PORT: number;

source/corefunc/config.ts

@@ -36,7 +36,7 @@ const _default_config: any = {
   'BOTARCAPI_FORWARD_TIMESEC_DEFAULT': 10,
 
   // the number of times the callers can extend the valid time of the token
-  // BotArcAPI will deny the feeds while exceeding the limitation
+  // BotArcAPI will decline the feeds while exceeding the limitation
   'BOTARCAPI_FORWARD_FEED_MAX': 2,
 
   'BOTARCAPI_USERBEST_HISTORY_MAX': 20,
@@ -50,16 +50,27 @@ const _default_config: any = {
   // this feature is for 3.6.0 arcapi
   'BOTARCAPI_AGGREGATE_ENABLED': false,
 
-  // send a huge of requests concurrently
+  // sending requests concurrently
   // only valid on 'BOTARCAPI_AGGREGATE_ENABLED' set to false
   'BOTARCAPI_AGGREGATE_CONCURRENT': false,
 
+  // frontend http proxy
+  // used to load balance for per ip
+  // change this will ignore the 'ARCAPI_URL' config
+  // if set to '[]' will disable the frontend proxy
+  'BOTARCAPI_FRONTPROXY_NODES': [
+    // { url: "https://arcapi.lowiro.com", weight: 1.0 },
+    // { url: "https://example.com", weight: 0.8 },
+    // { url: "https://your.proxy.node.com", weight: 0.3 },
+  ],
+
   // arcaea api config
   'ARCAPI_RETRY': 3,
   'ARCAPI_VERSION': 14,
   'ARCAPI_APPVERSION': '3.6.0c',
   'ARCAPI_USERAGENT': 'Grievous Lady (Linux; U; Android 2.3.3; BotArcAPI)',
-  'ARCAPI_URL': 'https://arcapi.lowiro.com/blockchain',
+  'ARCAPI_URL': 'https://arcapi.lowiro.com',
+  'ARCAPI_URL_CODENAME': 'blockchain',
 
   // path to database folder
   'DATABASE_PATH': './savedata/',

source/modules/arcfetch/arcapi.aggregate.ts

@@ -5,43 +5,74 @@ import arcfetch, { ArcFetchRequest, ArcFetchMethod } from './arcfetch';
 import IArcAccount from './interfaces/IArcAccount';
 import arcapi_any from './arcapi.any';
 
-export default (account: IArcAccount, endpoints: Array<string>) => {
+export default async (account: IArcAccount,
+  endpoints: Array<string>): Promise<any> => {
+
+  // account will be BANNED from server if exceed
+  if (endpoints.length > BOTARCAPI_AGGREGATE_LIMITATION)
+    throw new Error('Endpoints limit exceeded');
+
+  if (BOTARCAPI_AGGREGATE_ENABLED) {
+
+    // construct endpoint object
+    const _endpoints: Array<any> = [];
+    endpoints.forEach((element, index) => {
+      _endpoints.push({ endpoint: element, id: index });
+    });
+
+    // construct remote request
+    const _remote_request =
+      new ArcFetchRequest(ArcFetchMethod.GET, 'compose/aggregate', {
+        deviceId: account.device,
+        userToken: account.token,
+        submitData: new URLSearchParams({ 'calls': JSON.stringify(_endpoints) })
+      });
 
-  return new Promise(async (resolve, reject) => {
+    // send request
+    return arcfetch(_remote_request)
+      .then((root: any) => {
 
-    // account will be BANNED from server if exceed
-    if (endpoints.length > BOTARCAPI_AGGREGATE_LIMITATION)
-      return reject(new Error('Endpoints limit exceeded'));
+        // teardown the object and pack data into array
+        const _data: Array<any> = [];
+        root.value.forEach((element: any) => {
+          _data[element.id] = element.value[0];
+        })
 
-    if (BOTARCAPI_AGGREGATE_ENABLED) {
+        return _data;
+      })
+      .catch((e: string) => {
 
-      // construct endpoint object
-      const _endpoints: Array<any> = [];
-      endpoints.forEach((element, index) => {
-        _endpoints.push({ endpoint: element, id: index });
+        // if token is invalid
+        // just erase the token and wait for
+        // auto login in next time allocating
+        if (e == 'UnauthorizedError') {
+          account.token = '';
+          syslog.w(TAG, `Invalid token => ${account.name} ${account.token}`);
+        }
+
+        throw e;
       });
 
-      // construct remote request
-      const _remote_request =
-        new ArcFetchRequest(ArcFetchMethod.GET, 'compose/aggregate', {
-          deviceId: account.device,
-          userToken: account.token,
-          submitData: new URLSearchParams({ 'calls': JSON.stringify(_endpoints) })
-        });
+  } else {
+    if (BOTARCAPI_AGGREGATE_CONCURRENT) {
 
-      // send request
-      arcfetch(_remote_request)
-        .then((root: any) => {
+      // construct tasks
+      const _tasks: Array<Promise<any>> = [];
+      endpoints.forEach((element, index) => {
+        _tasks.push(arcapi_any(account, ArcFetchMethod.GET, element, ""));
+      });
 
-          // teardown the object and pack data into array
-          const _data: Array<any> = [];
-          root.value.forEach((element: any) => {
-            _data[element.id] = element.value[0];
-          })
+      // wait for data coming in
+      return Promise.all(_tasks)
+        .then(data => {
+          let _results: any[] = [];
+          
+          data.forEach((element, index) =>
+            _results.push(element.value[0]));
 
-          resolve(_data);
-        })
-        .catch((e: string) => {
+          return _results;
+
+        }).catch((e: string) => {
 
           // if token is invalid
           // just erase the token and wait for
@@ -50,49 +81,36 @@ export default (account: IArcAccount, endpoints: Array<string>) => {
             account.token = '';
             syslog.w(TAG, `Invalid token => ${account.name} ${account.token}`);
           }
-
-          reject(e);
-
+          throw e;
         });
 
     } else {
-      if (BOTARCAPI_AGGREGATE_CONCURRENT) {
-
-        // construct tasks
-        const _tasks: Array<Promise<any>> = [];
-        endpoints.forEach((element, index) => {
-          _tasks.push(new Promise(async (resolve, reject) => {
-            resolve(await arcapi_any(account, ArcFetchMethod.GET, element, ""));
-          }));
-        });
-
-        // wait for data coming in
-        Promise.all(_tasks)
-          .then(data => {
-            let _results: any[] = [];
-
-            data.forEach((element, index) =>
-              _results.push(element.value[0]));
 
-            resolve(_results);
+      let _results: any[] = [];
 
-          }).catch((e: string) => reject(e));
-
-      } else {
-
-        let _results: any[] = [];
+      try {
 
         // request one by one
         for (let i = 0; i < endpoints.length; ++i) {
           const _data: any = await arcapi_any(account, ArcFetchMethod.GET, endpoints[i], "");
           _results.push(_data.value[0]);
         }
+        return _results;
 
-        resolve(_results);
+      } catch (e) {
+
+        // if token is invalid
+        // just erase the token and wait for
+        // auto login in next time allocating
+        if (e == 'UnauthorizedError') {
+          account.token = '';
+          syslog.w(TAG, `Invalid token => ${account.name} ${account.token}`);
+        }
+        throw e;
       }
 
     }
 
-  });
+  }
 
 }

source/modules/arcfetch/arcfetch.ts

@@ -34,15 +34,14 @@ export class ArcFetchRequest extends Request {
 
     // request url
     let _request_url: ArcFetchRestUrl =
-      `${ARCAPI_URL}/${ARCAPI_VERSION}/${resturl}`;
+      `${do_selectnode()}/${ARCAPI_URL_CODENAME}/${ARCAPI_VERSION}/${resturl}`;
 
     // http headers
     const _request_headers: ArcFetchHeaders = {
       'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
       'AppVersion': ARCAPI_APPVERSION,
       'User-Agent': ARCAPI_USERAGENT,
       'Platform': 'android',
-      'Host': 'arcapi.lowiro.com',
       'Connection': 'Keep-Alive'
     }
 
@@ -91,6 +90,38 @@ export class ArcFetchRequest extends Request {
 
 }
 
+const do_selectnode = (): string => {
+
+  if (!BOTARCAPI_FRONTPROXY_NODES.length
+    || BOTARCAPI_FRONTPROXY_NODES.length == 0) {
+    return ARCAPI_URL;
+  }
+
+  let _enabled = [];
+  let _weight_sum = 0;
+
+  // filter the nodes
+  for (let i = 0; i < BOTARCAPI_FRONTPROXY_NODES.length; ++i) {
+    if (BOTARCAPI_FRONTPROXY_NODES[i].enabled
+      || BOTARCAPI_FRONTPROXY_NODES[i].enabled == undefined) {
+      _enabled.push(BOTARCAPI_FRONTPROXY_NODES[i]);
+      _weight_sum += BOTARCAPI_FRONTPROXY_NODES[i].weight;
+    }
+  }
+
+  // roll a number select node by weight
+  let roll = Math.random() * _weight_sum;
+  _weight_sum = 0;
+
+  // select a node
+  for (let i = 0; i < _enabled.length; ++i) {
+    _weight_sum += _enabled[i].weight;
+    if (_weight_sum >= roll) return _enabled[i].url;
+  }
+
+  return _enabled[_enabled.length - 1].url;
+}
+
 const do_fetch = (request: ArcFetchRequest): Promise<any> => {
 
   // request origin arcapi