chore(nodes): preparation for IPFS infoService health check

src/components/nodes/ipfs/IpfsNodesTable.vue

@@ -0,0 +1,48 @@
+<template>
+  <NodesTableContainer>
+    <NodesTableHead hide-label />
+
+    <tbody>
+      <IpfsNodesTableItem v-for="node in ipfsNodes" :key="node.url" blockchain="adm" :node="node" />
+    </tbody>
+  </NodesTableContainer>
+</template>
+
+<script lang="ts">
+import { computed, defineComponent } from 'vue'
+import { useStore } from 'vuex'
+import NodesTableContainer from '@/components/nodes/components/NodesTableContainer.vue'
+import NodesTableHead from '@/components/nodes/components/NodesTableHead.vue'
+import IpfsNodesTableItem from './IpfsNodesTableItem.vue'
+import { sortNodesFn } from '@/components/nodes/utils/sortNodesFn'
+
+const className = 'adm-nodes-table'
+const classes = {
+  root: className
+}
+
+export default defineComponent({
+  components: {
+    NodesTableContainer,
+    NodesTableHead,
+    IpfsNodesTableItem
+  },
+  setup() {
+    const store = useStore()
+    const ipfsNodes = computed(() => {
+      const arr = store.getters['nodes/ipfs']
+
+      return [...arr].sort(sortNodesFn)
+    })
+
+    return {
+      ipfsNodes,
+      classes
+    }
+  }
+})
+</script>
+
+<style lang="scss">
+@import 'vuetify/settings';
+</style>

src/components/nodes/ipfs/IpfsNodesTableItem.vue

@@ -0,0 +1,122 @@
+<template>
+  <tr :class="classes.root">
+    <NodeColumn checkbox>
+      <NodeStatusCheckbox :value="active" @change="toggleActiveStatus" />
+    </NodeColumn>
+
+    <NodeColumn>
+      <NodeUrl :node="node" />
+      <NodeVersion v-if="node.version && active" :node="node" />
+    </NodeColumn>
+
+    <NodeColumn :colspan="!showSocketColumn ? 2 : 1">
+      <NodeStatus :node="node" />
+    </NodeColumn>
+
+    <NodeColumn v-if="showSocketColumn">
+      <SocketSupport :node="node" />
+    </NodeColumn>
+  </tr>
+</template>
+
+<script lang="ts">
+import { computed, PropType } from 'vue'
+import { useStore } from 'vuex'
+import type { NodeStatusResult } from '@/lib/nodes/abstract.node'
+import NodeUrl from '@/components/nodes/components/NodeUrl.vue'
+import NodeColumn from '@/components/nodes/components/NodeColumn.vue'
+import NodeStatus from '@/components/nodes/components/NodeStatus.vue'
+import NodeVersion from '@/components/nodes/components/NodeVersion.vue'
+import SocketSupport from '@/components/nodes/components/SocketSupport.vue'
+import NodeStatusCheckbox from '@/components/nodes/components/NodeStatusCheckbox.vue'
+
+const className = 'adm-nodes-table-item'
+const classes = {
+  root: className,
+  column: `${className}__column`,
+  columnCheckbox: `${className}__column--checkbox`,
+  checkbox: `${className}__checkbox`
+}
+
+export default {
+  components: {
+    NodeStatusCheckbox,
+    NodeColumn,
+    NodeStatus,
+    NodeVersion,
+    SocketSupport,
+    NodeUrl
+  },
+  props: {
+    node: {
+      type: Object as PropType<NodeStatusResult>,
+      required: true
+    }
+  },
+  setup(props) {
+    const store = useStore()
+
+    const url = computed(() => props.node.url)
+    const active = computed(() => props.node.active)
+    const socketSupport = computed(() => props.node.socketSupport)
+    const isUnsupported = computed(() => props.node.status === 'unsupported_version')
+    const type = computed(() => props.node.type)
+    const showSocketColumn = computed(() => active.value && !isUnsupported.value)
+
+    const toggleActiveStatus = () => {
+      store.dispatch('nodes/toggle', {
+        type: type.value,
+        url: url.value,
+        active: !active.value
+      })
+      store.dispatch('nodes/updateStatus')
+    }
+
+    const computedResult = computed(() => {
+      const baseUrl = new URL(url.value)
+      const protocol = baseUrl.protocol
+      const hostname = baseUrl.hostname
+      const port = baseUrl.port
+      const result = /^[\d.]+$/.test(hostname)
+
+      let nodeName = null
+      let domain = null
+
+      if (!result) {
+        const regex = /([^.]*)\.(.*)/
+        const parts = hostname.match(regex)
+        if (parts !== null) {
+          nodeName = parts[1]
+          domain = parts[2]
+        }
+      }
+
+      return {
+        protocol,
+        hostname,
+        nodeName,
+        domain,
+        result,
+        port
+      }
+    })
+
+    return {
+      classes,
+      url,
+      active,
+      socketSupport,
+      isUnsupported,
+      showSocketColumn,
+      toggleActiveStatus,
+      computedResult
+    }
+  }
+}
+</script>
+
+<style lang="scss">
+.ipfs-nodes-table-item {
+  line-height: 14px;
+}
+</style>

src/components/nodes/ipfs/index.ts

@@ -0,0 +1 @@
+export { default as IpfsNodesTable } from './IpfsNodesTable.vue'

src/lib/nodes/constants.ts

@@ -7,6 +7,7 @@ export type TNodeLabel =
   | 'doge-node'
   | 'doge-indexer'
   | 'dash-node'
+  | 'ipfs-node'
   | 'lsk-node'
   | 'lsk-indexer'
   | 'rates-info'
@@ -36,6 +37,7 @@ export const NODE_LABELS: NodeLabels = {
   DogeNode: 'doge-node',
   DogeIndexer: 'doge-indexer',
   DashNode: 'dash-node',
+  IpfsNode: 'ipfs-node',
   LskNode: 'lsk-node',
   LskIndexer: 'lsk-indexer',
   RatesInfo: 'rates-info'

src/lib/nodes/ipfs/IpfsClient.ts

@@ -0,0 +1,62 @@
+import { isNodeOfflineError } from '@/lib/nodes/utils/errors'
+import { IpfsNode, Payload, RequestConfig } from './IpfsNode.ts'
+import { Client } from '../abstract.client'
+
+/**
+ * Provides methods for calling the ADAMANT API.
+ *
+ * The `ApiClient` instance automatically selects an ADAMANT node to
+ * send the API-requests to and switches to another node if the current one
+ * is not available at the moment.
+ */
+export class IpfsClient extends Client<IpfsNode> {
+  constructor(endpoints: string[] = [], minNodeVersion = '0.0.0') {
+    super('ipfs')
+    this.nodes = endpoints.map((endpoint) => new IpfsNode(endpoint, minNodeVersion))
+    this.minNodeVersion = minNodeVersion
+
+    void this.watchNodeStatusChange()
+  }
+
+  /**
+   * Performs a GET API request.
+   * @param {String} url relative API url
+   * @param {any} params request params (an object) or a function that accepts `ApiNode` and returns the request params
+   */
+  get<P extends Payload = Payload>(url: string, params: P) {
+    return this.request({ method: 'get', url, payload: params })
+  }
+
+  /**
+   * Performs a POST API request.
+   * @param {String} url relative API url
+   * @param {any} payload request payload (an object) or a function that accepts `ApiNode` and returns the request payload
+   */
+  post<P extends Payload = Payload>(url: string, payload: P) {
+    return this.request({ method: 'post', url, payload })
+  }
+
+  /**
+   * Performs an API request.
+   * @param {RequestConfig} config request config
+   */
+  async request<P extends Payload = Payload, R = any>(config: RequestConfig<P>): Promise<R> {
+    const node = this.useFastest ? this.getFastestNode() : this.getRandomNode()
+    if (!node) {
+      // All nodes seem to be offline: let's refresh the statuses
+      this.checkHealth()
+      // But there's nothing we can do right now
+      return Promise.reject(new Error('No online nodes at the moment'))
+    }
+
+    return node.request(config).catch((error) => {
+      if (isNodeOfflineError(error)) {
+        // Initiate nodes status check
+        this.checkHealth()
+        // If the selected node is not available, repeat the request with another one.
+        return this.request(config)
+      }
+      throw error
+    })
+  }
+}

src/lib/nodes/ipfs/IpfsNode.ts

@@ -0,0 +1,124 @@
+import utils from '@/lib/adamant'
+import { NodeOfflineError } from '@/lib/nodes/utils/errors'
+import { GetNodeStatusResponseDto } from '@/lib/schema/client'
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios'
+import { Node } from '@/lib/nodes/abstract.node'
+import { NODE_LABELS } from '@/lib/nodes/constants'
+
+type FetchNodeInfoResult = {
+  socketSupport: boolean
+  version: string
+  height: number
+  wsPort?: string
+}
+
+export type Payload =
+  | Record<string, any>
+  | {
+      (ctx: IpfsNode): Record<string, any>
+    }
+export type RequestConfig<P extends Payload> = {
+  url: string
+  method?: string
+  payload?: P
+}
+
+/**
+ * Encapsulates a node. Provides methods to send API-requests
+ * to the node and verify is status (online/offline, version, ping, etc.)
+ */
+export class IpfsNode extends Node<AxiosInstance> {
+  constructor(url: string, minNodeVersion = '0.0.0') {
+    super(url, 'ipfs', 'node', NODE_LABELS.IpfsNode, '', minNodeVersion)
+
+    this.wsPort = '36668' // default wsPort
+    this.wsProtocol = this.protocol === 'https:' ? 'wss:' : 'ws:'
+    this.wsPortNeeded = this.wsProtocol === 'ws:' && !this.hostname.includes('.onion')
+  }
+
+  protected buildClient(): AxiosInstance {
+    return axios.create({
+      baseURL: this.url
+    })
+  }
+
+  /**
+   * Performs an API request.
+   *
+   * The `payload` of the `cfg` can be either an object or a function that
+   * accepts `ApiNode` as a first argument and returns an object.
+   */
+  request<P extends Payload = Payload, R = any>(cfg: RequestConfig<P>): Promise<R> {
+    const { url, method = 'get', payload } = cfg
+
+    const config: AxiosRequestConfig = {
+      url,
+      method: method.toLowerCase(),
+      [method === 'get' ? 'params' : 'data']:
+        typeof payload === 'function' ? payload(this) : payload
+    }
+
+    return this.client.request(config).then(
+      (response) => {
+        const body = response.data
+        // Refresh time delta on each request
+        if (body && isFinite(body.nodeTimestamp)) {
+          this.timeDelta = utils.epochTime() - body.nodeTimestamp
+        }
+
+        return body
+      },
+      (error) => {
+        // According to https://github.com/axios/axios#handling-errors this means, that request was sent,
+        // but server could not respond.
+        if (!error.response && error.request) {
+          this.online = false
+          throw new NodeOfflineError()
+        }
+        throw error
+      }
+    )
+  }
+
+  /**
+   * Fetch node version, block height and ping.
+   * @returns {Promise<{version: string, height: number, ping: number}>}
+   */
+  private async fetchNodeInfo(): Promise<FetchNodeInfoResult> {
+    const { success, version, network, wsClient } = await this.request<
+      Payload,
+      GetNodeStatusResponseDto
+    >({ url: '/api/node/status' })
+
+    if (success) {
+      const readableVersion = version.version
+      const height = Number(network.height)
+      const socketSupport = wsClient ? wsClient.enabled : false
+      const wsPort = wsClient ? String(wsClient.port) : ''
+
+      this.version = readableVersion
+      this.height = height
+      this.socketSupport = socketSupport
+      this.wsPort = wsPort
+
+      return {
+        version: readableVersion,
+        height,
+        socketSupport,
+        wsPort
+      }
+    }
+
+    throw new Error('Request to /api/node/status was unsuccessful')
+  }
+
+  protected async checkHealth() {
+    const time = Date.now()
+    const { height } = await this.fetchNodeInfo()
+
+    return {
+      height,
+      ping: Date.now() - time
+    }
+  }
+}

src/lib/nodes/ipfs/index.ts

@@ -0,0 +1,8 @@
+import config from '@/config'
+import { NodeInfo } from '@/types/wallets'
+import { IpfsClient } from './IpfsClient.ts'
+
+const endpoints = (config.ipfs.nodes.list as NodeInfo[]).map((endpoint) => endpoint.url)
+export const ipfs = new IpfsClient(endpoints, config.ipfs.nodes.minVersion)
+
+export default ipfs