Feat: (Health check) Check alt_ip if web domain is not accessible

release-notes.md

@@ -10,6 +10,7 @@ All notable changes in this release are listed below.
 - Release notes file added [#853](https://github.com/Adamant-im/adamant-im/pull/853) — [@S-FrontendDev](https://github.com/S-FrontendDev)
 
 ### Improvements
+- Use secondary URL with alternate IP if a node is unavailable by primary URL [#768](https://github.com/Adamant-im/adamant-im/pull/768) — [@graycraft](https://github.com/graycraft)
 - APK name changed in GitHub workflow [#839](https://github.com/Adamant-im/adamant-im/pull/839) — [@S-FrontendDev](https://github.com/S-FrontendDev)
 - Wallets UI updated for better usability [#846](https://github.com/Adamant-im/adamant-im/pull/846) — [@Linhead](https://github.com/Linhead), [@adamant-al](https://github.com/adamant-al)
 - ESLint updated to improve code quality [#849](https://github.com/Adamant-im/adamant-im/pull/849) — [@graycraft](https://github.com/graycraft)

src/config/utils/nodes.ts

@@ -1,4 +1,4 @@
-import { NodeInfo } from '@/types/wallets'
+import type { NodeInfo } from '@/types/wallets'
 import { BlockchainSymbol } from './types'
 import config from '../index'
 

src/lib/nodes/__tests__/eth/EthNode.test.js

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest'
+
+import { EthNode } from '../../eth/EthNode.ts'
+
+const nodeByDomain = new EthNode({
+    alt_ip: 'http://95.216.114.252:44099',
+    url: 'https://ethnode2.adamant.im'
+  }),
+  nodeByIP = new EthNode({
+    alt_ip: 'http://95.216.114.252:44099',
+    url: 'https://aaa.adamant.im'
+  }),
+  nodeOffline = new EthNode({
+    alt_ip: 'http://111.111.111.111:44099',
+    url: 'https://aaa.adamant.im'
+  })
+
+describe('client', () => {
+  describe('by domain', () => {
+    it('get block number', async () => {
+      expect(await nodeByDomain.client().getBlockNumber()).toBeTypeOf('bigint')
+    })
+  })
+  describe('by IP', () => {
+    it('get block number', async () => {
+      try {
+        await nodeByIP.client().getBlockNumber()
+      } catch (error) {
+        expect(error).toEqual({
+          message:
+            'request to https://aaa.adamant.im/ failed, reason: getaddrinfo ENOTFOUND aaa.adamant.im',
+          type: 'system',
+          errno: 'ENOTFOUND',
+          code: 'ENOTFOUND'
+        })
+      }
+    })
+  })
+  describe('offline', () => {
+    it('get block number', async () => {
+      try {
+        await nodeOffline.client().getBlockNumber()
+      } catch (error) {
+        expect(error).toEqual({
+          message:
+            'request to https://aaa.adamant.im/ failed, reason: getaddrinfo ENOTFOUND aaa.adamant.im',
+          type: 'system',
+          errno: 'ENOTFOUND',
+          code: 'ENOTFOUND'
+        })
+      }
+    })
+  })
+})
+describe('node', () => {
+  describe('by domain', () => {
+    it('start healthcheck', async () => {
+      const node = await nodeByDomain.startHealthcheck()
+
+      expect(node.altIp).toBe('http://95.216.114.252:44099')
+      expect(node.altIpAvailable).toBe(false)
+      expect(node.availableByDomain).toBe(true)
+      expect(node.hostname).toBe('ethnode2.adamant.im')
+      expect(node.online).toBe(true)
+      expect(node.preferDomain).toBe(true)
+      expect(node.url).toBe('https://ethnode2.adamant.im')
+    })
+  })
+  describe('by IP', () => {
+    it('start healthcheck', async () => {
+      const node = await nodeByIP.startHealthcheck()
+
+      expect(node.altIp).toBe('http://95.216.114.252:44099')
+      expect(node.altIpAvailable).toBe(false)
+      expect(node.availableByDomain).toBe(false)
+      expect(node.hostname).toBe('aaa.adamant.im')
+      expect(node.online).toBe(true)
+      expect(node.preferDomain).toBe(false)
+      expect(node.url).toBe('https://aaa.adamant.im')
+    })
+  })
+  describe('offline', () => {
+    it('start healthcheck', async () => {
+      const node = await nodeOffline.startHealthcheck()
+
+      expect(node.altIp).toBe('http://111.111.111.111:44099')
+      expect(node.altIpAvailable).toBe(false)
+      expect(node.availableByDomain).toBe(false)
+      expect(node.hostname).toBe('aaa.adamant.im')
+      expect(node.online).toBe(true)
+      expect(node.preferDomain).toBe(false)
+      expect(node.url).toBe('https://aaa.adamant.im')
+    })
+  })
+})

src/lib/nodes/abstract.client.ts

@@ -91,13 +91,6 @@ export abstract class Client<N extends Node> {
     }
   }
 
-  // Use with caution:
-  // This method can throw an error if there are no online nodes.
-  // Better use "useClient()" method.
-  getClient(): N['client'] {
-    return this.getNode().client
-  }
-
   /**
    * Invokes a client method.
    *

src/lib/nodes/abstract.node.ts

@@ -1,3 +1,5 @@
+import type { NodeOfflineError } from '@/lib/nodes/utils/errors.ts'
+import type { NodeInfo } from '@/types/wallets/index.ts'
 import { getHealthCheckInterval } from './utils/getHealthcheckConfig'
 import { TNodeLabel } from './constants'
 import { HealthcheckInterval, HealthcheckResult, NodeKind, NodeStatus, NodeType } from './types'
@@ -29,6 +31,10 @@ export abstract class Node<C = unknown> {
    */
   wsPort = '36668'
 
+  /**
+   * Node alternative IP
+   */
+  altIp?: string
   /**
    * Node base URL
    */
@@ -41,6 +47,10 @@ export abstract class Node<C = unknown> {
    * Node port like 36666 for http nodes (default)
    */
   port: string
+  /**
+   * Indicates that a node URL protocol is the same as page URL.
+   */
+  hasSupportedProtocol = true
   /**
    * Node hostname like bid.adamant.im or 23.226.231.225
    */
@@ -53,13 +63,16 @@ export abstract class Node<C = unknown> {
    * If Socket port like :36668 needed for connection
    */
   wsPortNeeded = false
-  hasSupportedProtocol = true
 
-  // Healthcheck related params
+  /** Healthcheck related params. */
   /**
    * Indicates whether node is available.
    */
   online = true
+  /**
+   * Indicates whether prefer a node with alternative IP or not
+   */
+  preferDomain = true
   /**
    * Node ping estimation
    */
@@ -97,13 +110,16 @@ export abstract class Node<C = unknown> {
   healthcheckInProgress = false
 
   constructor(
-    url: string,
+    endpoint: NodeInfo,
     type: NodeType,
     kind: NodeKind,
     label: TNodeLabel,
     version = '',
     minNodeVersion = ''
   ) {
+    const { alt_ip, url } = endpoint
+
+    this.altIp = alt_ip
     this.url = url
     this.type = type
     this.label = label
@@ -113,7 +129,7 @@ export abstract class Node<C = unknown> {
     this.hostname = new URL(url).hostname
     this.minNodeVersion = minNodeVersion
     this.version = version
-    this.hasSupportedProtocol = !(this.protocol === 'http:' && appProtocol === 'https:')
+    this.hasSupportedProtocol = this.isHttpAllowed(this.protocol)
     this.active = nodesStorage.isActive(url)
 
     this.client = this.buildClient()
@@ -127,16 +143,55 @@ export abstract class Node<C = unknown> {
     clearInterval(this.timer)
 
     if (this.active && !this.healthcheckInProgress) {
+      const protocol = new URL(this.url).protocol
+
       try {
         this.healthcheckInProgress = true
-        const health = await this.checkHealth()
 
-        this.height = health.height
-        this.ping = health.ping
+        const { height, ping } = await this.checkHealth()
+
+        console.info(
+          `[HealthCheck] Connection via ${this.getBaseURL(this)} succeeded (URL: ${this.url}${this.altIp ? ', IP: ' + this.altIp : ''}).`
+        )
+
+        /**
+         * HTTP request might be fulfilled in HTTPS environment if a user allowed insecure content for the site in own Site settings (desktop browsers).
+         */
+        if (protocol === 'http:') this.hasSupportedProtocol = true
+
+        this.height = height
         this.online = true
-      } catch {
-        this.online = false
+        this.ping = ping
+
+        console.info(
+          `[HealthCheck] Node status updated for ${this.getBaseURL(this)}. Height: ${height}. Ping: ${ping}. Node is online.`
+        )
+      } catch (error) {
+        const code = (error as NodeOfflineError).code ?? 'unknown'
+
+        console.info(
+          `[HealthCheck] Connection via ${this.getBaseURL(this)} failed (URL: ${this.url}${this.altIp ? ', IP: ' + this.altIp : ''}). ${code ? `Error code: ${code}` : ''}.`
+        )
+
+        if (this.preferDomain) {
+          if (!this.altIp) {
+            if (protocol === 'https:' || this.isHttpAllowed(protocol)) this.online = false
+
+            console.info(
+              `[HealthCheck] Alternative IP is not defined for ${this.getBaseURL(this)}. Node is offline.`
+            )
+          }
+
+          this.preferDomain = false
+        } else {
+          if (protocol === 'https:' || this.isHttpAllowed(protocol)) this.online = false
+
+          console.info(
+            `[HealthCheck] Node is not reachable by URL ${this.url}${this.altIp ? ' and by alternative IP ' + this.altIp : ''}. Node is offline.`
+          )
+        }
       } finally {
+        this.updateURL()
         this.healthcheckInProgress = false
       }
 
@@ -147,6 +202,8 @@ export abstract class Node<C = unknown> {
       () => this.startHealthcheck(),
       getHealthCheckInterval(this.label, this.online ? this.healthCheckInterval : 'crucial')
     )
+
+    return this
   }
 
   updateHealthCheckInterval(interval: HealthcheckInterval) {
@@ -162,8 +219,20 @@ export abstract class Node<C = unknown> {
     this.onStatusChangeCallback = callback
   }
 
+  /**
+   * Get base URL for requests depending on availability of a node's domain.
+   * @param { Node } node A node instance.
+   * @returns { string } Base URL.
+   */
+  getBaseURL(node: Node): string {
+    const baseURL = node.preferDomain ? node.url : (node.altIp ?? node.url)
+
+    return baseURL
+  }
+
   getStatus() {
     return {
+      alt_ip: this.altIp,
       url: this.url,
       port: this.port,
       hostname: this.hostname,
@@ -217,6 +286,18 @@ export abstract class Node<C = unknown> {
     return this.version >= this.minNodeVersion
   }
 
+  /**
+   * Can not be sure, whether HTTP nodes are allowed or blocked in HTTPS environment, until an actual request is fulfilled.
+   * Therefore, only assume HTTP is not allowed in HTTPS environment in advance here.
+   * @param { "http:" | "https:" } protocol Data transfer protocol.
+   * @returns { boolean } Whether a HTTP node is allowed or not.
+   */
+  isHttpAllowed(protocol: string): boolean {
+    const blocked = !(protocol === 'http:' && appProtocol === 'https:')
+
+    return blocked
+  }
+
   protected abstract checkHealth(): Promise<HealthcheckResult>
   protected abstract buildClient(): C
 
@@ -226,11 +307,33 @@ export abstract class Node<C = unknown> {
   toggleNode(active: boolean) {
     this.active = active
 
+    /** Reset properties for HealthCheck to default if a node enabled again. */
+    if (active) {
+      this.online = true
+      this.preferDomain = true
+    }
+
     nodesStorage.saveActive(this.url, active)
 
     return this.getStatus()
   }
 
+  /**
+   * Update URL components depending on availability of a node by URL with domain.
+   * `altIp` and `url` always contain 'http:' or 'https:' in address.
+   */
+  updateURL() {
+    const baseURL = this.getBaseURL(this)
+
+    /** New URL constructor requires `baseURL` to be a valid URL, otherwise throws TypeError. */
+    if (baseURL) {
+      this.hostname = new URL(baseURL).hostname
+      this.port = new URL(baseURL).port
+      this.protocol = new URL(baseURL).protocol as HttpProtocol
+    }
+    this.wsProtocol = this.protocol === 'https:' ? 'wss:' : 'ws:'
+  }
+
   displayVersion() {
     return this.version ? `v${this.version}` : ''
   }

src/lib/nodes/adm/AdmClient.ts

@@ -5,6 +5,7 @@ import {
   RegisterChatMessageTransaction
 } from '@/lib/schema/client'
 import { NODE_LABELS } from '@/lib/nodes/constants'
+import type { NodeInfo } from '@/types/wallets'
 import { AdmNode, Payload, RequestConfig } from './AdmNode'
 import { Client } from '../abstract.client'
 
@@ -16,7 +17,7 @@ import { Client } from '../abstract.client'
  * is not available at the moment.
  */
 export class AdmClient extends Client<AdmNode> {
-  constructor(endpoints: string[] = [], minNodeVersion = '0.0.0') {
+  constructor(endpoints: NodeInfo[] = [], minNodeVersion = '0.0.0') {
     super('adm', 'node', NODE_LABELS.AdmNode)
     this.nodes = endpoints.map((endpoint) => new AdmNode(endpoint, minNodeVersion))
     this.minNodeVersion = minNodeVersion