This leaves the server with the sole responsibility of serving GraphQL requests, with in-memory caching an atomic part of this.
POSTGRES_USER_FILE=/run/secrets/postgres_user
WORKDIR /src
FROM ubuntu-nodejs as db-manager
FROM ubuntu-nodejs as background
ARG NETWORK=mainnet
ARG METADATA_SERVER_URI="https://tokens.cardano.org"
RUN curl --proto '=https' --tlsv1.2 -sSf -L https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add - &&\
HASURA_CLI_PATH=/usr/local/bin/hasura \
HASURA_URI="http://hasura:8080" \
LD_LIBRARY_PATH="/usr/local/lib:$LD_LIBRARY_PATH" \
METADATA_SERVER_URI=${METADATA_SERVER_URI} \
OGMIOS_HOST="cardano-node-ogmios" \
POSTGRES_DB_FILE=/run/secrets/postgres_db \
POSTGRES_HOST=postgres \
POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password \
COPY --from=cardano-graphql-production-deps /app/node_modules /app/node_modules
COPY --from=cardano-graphql-production-deps /app/packages/api-cardano-db-hasura/node_modules /app/packages/api-cardano-db-hasura/node_modules
WORKDIR /app/packages/api-cardano-db-hasura/dist
CMD ["node", "db-manager/run.js"]
CMD ["node", "background.js"]
FROM ubuntu-nodejs as server
ARG NETWORK=mainnet
ARG METADATA_SERVER_URI="https://tokens.cardano.org"
COPY --from=downloader /usr/local/bin/hasura /usr/local/bin/hasura
ENV \
CARDANO_NODE_CONFIG_PATH=/config/cardano-node/config.json \
HASURA_GRAPHQL_ENABLE_TELEMETRY=false \
HASURA_URI="http://hasura:8080" \
LD_LIBRARY_PATH="/usr/local/lib:$LD_LIBRARY_PATH" \
METADATA_SERVER_URI=${METADATA_SERVER_URI} \
NETWORK=${NETWORK} \
OGMIOS_HOST="cardano-node-ogmios"
COPY --from=cardano-graphql-builder /app/packages/api-cardano-db-hasura/dist /app/packages/api-cardano-db-hasura/dist
max-size: "200k"
max-file: "10"
db-manager:
background:
build:
cache_from: [ inputoutput/cardano-graphql-db-manager:latest ]
cache_from: [ inputoutput/cardano-graphql-background:latest ]
context: .
target: db-manager
image: inputoutput/cardano-graphql-db-manager:${CARDANO_GRAPHQL_VERSION:-7.0.2}-${NETWORK:-mainnet}
target: background
image: inputoutput/cardano-graphql-background:${CARDANO_GRAPHQL_VERSION:-7.0.2}-${NETWORK:-mainnet}
depends_on:
- "hasura"
- "postgres"
environment:
- LOGGER_MIN_SEVERITY=${LOGGER_MIN_SEVERITY:-info}
- METADATA_SERVER_URI=${METADATA_SERVER_URI:-https://tokens.cardano.org}
restart: on-failure
secrets:
- postgres_db
max-size: "200k"
max-file: "10"
http-server:
server:
build:
args:
- NETWORK=${NETWORK:-mainnet}
- METADATA_SERVER_URI=${METADATA_SERVER_URI:-https://tokens.cardano.org}
cache_from: [ inputoutput/cardano-graphql:latest ]
cache_from: [ inputoutput/cardano-graphql-server:latest ]
context: .
target: server
image: inputoutput/cardano-graphql:${CARDANO_GRAPHQL_VERSION:-7.0.2}-${NETWORK:-mainnet}
image: inputoutput/cardano-graphql-server:${CARDANO_GRAPHQL_VERSION:-7.0.2}-${NETWORK:-mainnet}
environment:
- ALLOW_INTROSPECTION=true
- CACHE_ENABLED=true
"mainnet:up": "yarn mainnet:stack && docker compose -p mainnet logs -f",
"mainnet:down": "docker compose -p mainnet down --remove-orphans",
"mainnet:server": "CONTEXT=$PWD NETWORK=mainnet . ./scripts/export_env.sh && yarn workspace @cardano-graphql/server start",
"mainnet:db-manager": "CONTEXT=$PWD NETWORK=mainnet . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura db-manager",
"mainnet:background": "CONTEXT=$PWD NETWORK=mainnet . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura background",
"preprod:stack": "CONTEXT=$PWD NETWORK=preprod . ./scripts/export_env.sh && docker compose -p preprod up --build -d",
"preprod:dev": "CONTEXT=$PWD NETWORK=preprod . ./scripts/export_env.sh && yarn service-dependencies -p preprod up --build",
"preprod:up": "yarn preprod:stack && docker compose -p preprod logs -f",
"preprod:down": "docker compose -p preprod down --remove-orphans",
"preprod:server": "CONTEXT=$PWD NETWORK=preprod . ./scripts/export_env.sh && yarn workspace @cardano-graphql/server start",
"preprod:db-manager": "CONTEXT=$PWD NETWORK=preprod . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura db-manager",
"preprod:background": "CONTEXT=$PWD NETWORK=preprod . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura background",
"preview:stack": "CONTEXT=$PWD NETWORK=preview . ./scripts/export_env.sh && docker compose -p preview up --build -d",
"preview:dev": "CONTEXT=$PWD NETWORK=preview . ./scripts/export_env.sh && yarn service-dependencies -p preview up --build",
"preview:up": "yarn preview:stack && docker compose -p preview logs -f",
"preview:down": "docker compose -p preview down --remove-orphans",
"preview:server": "CONTEXT=$PWD NETWORK=preview . ./scripts/export_env.sh && yarn workspace @cardano-graphql/server start",
"preview:db-manager": "CONTEXT=$PWD NETWORK=preview . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura db-manager",
"preview:background": "CONTEXT=$PWD NETWORK=preview . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura background",
"testnet:stack": "CONTEXT=$PWD NETWORK=testnet . ./scripts/export_env.sh && docker compose -p testnet up --build -d",
"testnet:dev": "CONTEXT=$PWD NETWORK=testnet . ./scripts/export_env.sh && yarn service-dependencies -p testnet up --build",
"testnet:up": "yarn testnet:stack && docker compose -p testnet logs -f",
"testnet:down": "docker compose -p testnet down --remove-orphans",
"testnet:server": "CONTEXT=$PWD NETWORK=testnet . ./scripts/export_env.sh && yarn workspace @cardano-graphql/server start",
"testnet:db-manager": "CONTEXT=$PWD NETWORK=testnet . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura db-manager",
"testnet:background": "CONTEXT=$PWD NETWORK=testnet . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura background",
"vasil-dev:stack": "CONTEXT=$PWD NETWORK=vasil-dev . ./scripts/export_env.sh && docker compose -p vasil-dev up --build -d",
"vasil-dev:dev": "CONTEXT=$PWD NETWORK=vasil-dev . ./scripts/export_env.sh && yarn service-dependencies -p vasil-dev up --build",
"vasil-dev:up": "yarn vasil-dev:stack && docker compose -p vasil-dev logs -f",
"vasil-dev:down": "docker compose -p vasil-dev down --remove-orphans",
"vasil-dev:server": "CONTEXT=$PWD NETWORK=vasil-dev . ./scripts/export_env.sh && yarn workspace @cardano-graphql/server start",
"vasil-dev:db-manager": "CONTEXT=$PWD NETWORK=vasil-dev . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura db-manager",
"vasil-dev:background": "CONTEXT=$PWD NETWORK=vasil-dev . ./scripts/export_env.sh && yarn workspace @cardano-graphql/api-cardano-db-hasura background",
"lint": "yarn workspaces run lint",
"loadtest:byron-staging": "artillery run test/loadtest/byron-staging-config.yml",
"publish-packages": "yarn workspaces run publish",
"service-dependencies": "docker-compose config --services | grep -vE \"server|db-manager\" | xargs docker-compose",
"service-dependencies": "docker-compose config --services | grep -vE \"server|background\" | xargs docker-compose",
"test": "yarn workspaces run test"
},
"contributors": [
"lint": "eslint --ignore-path ../../.eslintignore \"**/*.ts\"",
"prepack": "yarn build",
"predb-manager": "yarn build",
"db-manager": "node dist/db-manager/run.js",
"background": "node dist/background.js",
"test": "yarn build && NODE_ENV=test jest -c ./test/jest.config.js"
},
"repository": {
import pRetry from 'p-retry'
import { Config } from './Config'
import util, { assetFingerprint, errors, RunnableModuleState } from '@cardano-graphql/util'
import { HasuraClient } from './HasuraClient'
import PgBoss from 'pg-boss'
import { dummyLogger, Logger } from 'ts-log'
import { createInteractionContextWithLogger } from './util'
import { PointOrOrigin } from '@cardano-ogmios/schema'
import { HasuraBackgroundClient } from './HasuraBackgroundClient'
import { DbConfig } from './typeAliases'
const MODULE_NAME = 'ChainFollower'
private state: RunnableModuleState
constructor (
readonly hasuraClient: HasuraClient,
readonly hasuraClient: HasuraBackgroundClient,
private logger: Logger = dummyLogger,
private queueConfig: Config['db']
private queueConfig: DbConfig
) {
this.state = null
}
export interface Config {
cardanoNodeConfigPath: string,
db?: {
database?: string,
host?: string,
password?: string,
port?: number
user?: string,
},
hasuraUri: string,
metadataServerUri: string,
metadataUpdateInterval?: {
assets: number
},
ogmios?: {
host?: string
port?: number
import { exec } from 'child_process'
import util, { ModuleState } from '@cardano-graphql/util'
import { GraphQLSchema } from 'graphql'
import { GraphQLClient, gql } from 'graphql-request'
import pRetry from 'p-retry'
import path from 'path'
import { dummyLogger, Logger } from 'ts-log'
import { Asset, Block } from './graphql_types'
import { AssetMetadataAndHash, AssetMetadataHashAndId, AssetWithoutTokens } from './typeAliases'
import { Schema } from '@cardano-ogmios/client'
const epochInformationNotYetAvailable = 'Epoch information not yet available. This is expected during the initial chain-sync.'
const withHexPrefix = (value: string) => `\\x${value !== undefined ? value : ''}`
export class HasuraBackgroundClient {
private client: GraphQLClient
private applyingSchemaAndMetadata: boolean
private state: ModuleState
public schema: GraphQLSchema
constructor (
readonly hasuraCliPath: string,
readonly hasuraUri: string,
private logger: Logger = dummyLogger
) {
this.state = null
this.applyingSchemaAndMetadata = false
this.client = new GraphQLClient(
`${this.hasuraUri}/v1/graphql`,
{
headers: {
'X-Hasura-Role': 'cardano-graphql'
}
}
)
}
private async hasuraCli (command: string) {
return new Promise((resolve, reject) => {
exec(
`${this.hasuraCliPath} --skip-update-check --project ${path.resolve(__dirname, '..', 'hasura', 'project')} --endpoint ${this.hasuraUri} ${command}`,
(error, stdout) => {
if (error) {
reject(error)
}
if (stdout !== '') this.logger.debug({ module: 'HasuraBackgroundClient' }, stdout)
resolve()
}
)
})
}
public async initialize () {
if (this.state !== null) return
this.state = 'initializing'
this.logger.info({ module: 'HasuraBackgroundClient' }, 'Initializing')
await this.applySchemaAndMetadata()
this.logger.debug({ module: 'HasuraBackgroundClient' }, 'graphql-engine setup')
await pRetry(async () => {
const result = await this.client.request(
gql`query {
epochs (limit: 1, order_by: { number: desc }) {
number
}
}`
)
if (result.epochs.length === 0) {
this.logger.debug({ module: 'HasuraBackgroundClient' }, epochInformationNotYetAvailable)
throw new Error(epochInformationNotYetAvailable)
}
}, {
factor: 1.05,
retries: 100,
onFailedAttempt: util.onFailedAttemptFor(
'Detecting DB sync state has reached minimum progress',
this.logger
)
})
this.logger.debug({ module: 'HasuraBackgroundClient' }, 'DB sync state has reached minimum progress')
this.state = 'initialized'
this.logger.info({ module: 'HasuraBackgroundClient' }, 'Initialized')
}
public async shutdown () {
this.state = null
}
public async applySchemaAndMetadata (): Promise<void> {
if (this.applyingSchemaAndMetadata) return
this.applyingSchemaAndMetadata = true
await pRetry(async () => {
await this.hasuraCli('migrate --database-name default apply --down all')
await this.hasuraCli('migrate --database-name default apply --up all')
}, {
factor: 1.75,
retries: 9,
onFailedAttempt: util.onFailedAttemptFor(
'Applying PostgreSQL schema migrations',
this.logger
)
})
await pRetry(async () => {
await this.hasuraCli('metadata clear')
await this.hasuraCli('metadata apply')
}, {
factor: 1.75,
retries: 9,
onFailedAttempt: util.onFailedAttemptFor('Applying Hasura metadata', this.logger)
})
this.applyingSchemaAndMetadata = false
}
public async deleteAssetsAfterSlot (slotNo: Block['slotNo']): Promise<number> {
this.logger.debug(
{ module: 'HasuraClient', slotNo },
'deleting assets found in tokens after slot'
)
const result = await this.client.request(
gql`mutation DeleteAssetsAfterSlot($slotNo: Int!) {
delete_assets(
where: {
firstAppearedInSlot: {
_gt: $slotNo
}
}
) {
affected_rows
}
}`,
{
slotNo
}
)
return result.delete_assets.affected_rows
}
public async hasAsset (assetId: Asset['assetId']): Promise<boolean> {
const result = await this.client.request(
gql`query HasAsset (
$assetId: bytea!
) {
assets (
where: { assetId: { _eq: $assetId }}
) {
assetId
}
}`, {
assetId: withHexPrefix(assetId)
}
)
const response = result.assets.length > 0
this.logger.debug(
{ module: 'HasuraClient', assetId, hasAsset: response },
'Has asset?'
)
return response
}
public async getMostRecentPointWithNewAsset (): Promise<Schema.Point | null> {
let point: Schema.Point | null
// Handles possible race condition between the internal chain-follower, which manages the Asset table,
// and cardano-db-sync's which managed the block table.
await pRetry(async () => {
// An offset of 1 is applied to ensure a partial block extraction is not skipped
const result = await this.client.request(
gql`query {
assets (
limit: 1
offset: 1
order_by: { firstAppearedInSlot: desc }
) {
firstAppearedInBlock {
hash
slotNo
}
}
}`
)
if (result.errors !== undefined) {
throw new Error(result.errors)
}
if (result.assets.length !== 0) {
if (result.assets[0].firstAppearedInBlock === null) {
throw new Error('cardano-db-sync is lagging behind the asset sync operation.')
}
const { hash, slotNo } = result.assets[0].firstAppearedInBlock
point = {
hash: hash.substring(2),
slot: slotNo
}
} else {
point = null
}
}, {
factor: 1.5,
retries: 1000,
onFailedAttempt: util.onFailedAttemptFor(
import { Schema } from '@cardano-ogmios/client'
import util, { DataFetcher, ModuleState } from '@cardano-graphql/util'
import fetch from 'cross-fetch'
import { DocumentNode, GraphQLSchema, print } from 'graphql'
Asset,
AssetBalance,
AssetSupply,
Block,
PaymentAddressSummary,
ProtocolParams,
Token,
TransactionOutput
} from './graphql_types'
import { dummyLogger, Logger } from 'ts-log'
import BigNumber from 'bignumber.js'
import {
AssetMetadataAndHash,
AssetMetadataHashAndId,
AssetWithoutTokens
} from './typeAliases'
export type AdaPotsToCalculateSupply = { circulating: AssetSupply['circulating'], reserves: AdaPots['reserves']}
const epochInformationNotYetAvailable = 'Epoch information not yet available. This is expected during the initial chain-sync.'
const withHexPrefix = (value: string) => `\\x${value !== undefined ? value : ''}`
export class HasuraClient {
private client: GraphQLClient
public adaPotsToCalculateSupplyFetcher: DataFetcher<AdaPotsToCalculateSupply>
return schema
}
public async deleteAssetsAfterSlot (slotNo: Block['slotNo']): Promise<number> {
this.logger.debug(
{ module: 'HasuraClient', slotNo },
'deleting assets found in tokens after slot'
)
const result = await this.client.request(
gql`mutation DeleteAssetsAfterSlot($slotNo: Int!) {
delete_assets(
where: {
firstAppearedInSlot: {
_gt: $slotNo
}
}
) {
affected_rows
}
}`,
{
slotNo
}
)
return result.delete_assets.affected_rows
}
public async getCurrentProtocolVersion (): Promise<ProtocolParams['protocolVersion']> {
const result = await this.client.request(
gql`query {
return result.epochs[0]?.protocolParams.protocolVersion
}
public async getMostRecentPointWithNewAsset (): Promise<Schema.Point | null> {
let point: Schema.Point | null
// Handles possible race condition between the internal chain-follower, which manages the Asset table,
// and cardano-db-sync's which managed the block table.
await pRetry(async () => {
// An offset of 1 is applied to ensure a partial block extraction is not skipped
const result = await this.client.request(
gql`query {
assets (
limit: 1
offset: 1
order_by: { firstAppearedInSlot: desc }
) {
firstAppearedInBlock {
hash
slotNo
}
}
}`
)
if (result.errors !== undefined) {
throw new Error(result.errors)
}
if (result.assets.length !== 0) {
if (result.assets[0].firstAppearedInBlock === null) {
throw new Error('cardano-db-sync is lagging behind the asset sync operation.')
}
const { hash, slotNo } = result.assets[0].firstAppearedInBlock
point = {
hash: hash.substring(2),
slot: slotNo
}
} else {
point = null
}
}, {
factor: 1.5,
retries: 1000,
onFailedAttempt: util.onFailedAttemptFor(
'Getting the most recent point with a new asset',
this.logger
)
})
return point
}
public async getPaymentAddressSummary (address: string, atBlock?: number): Promise<PaymentAddressSummary> {
const result = await this.client.request(
gql`query PaymentAddressSummary (
syncPercentage: syncPercentage > 100 ? 100 : syncPercentage
}
}
public async hasAsset (assetId: Asset['assetId']): Promise<boolean> {
const result = await this.client.request(
gql`query HasAsset (
$assetId: bytea!
) {
assets (
where: { assetId: { _eq: $assetId }}
) {
assetId
}
}`, {
assetId: withHexPrefix(assetId)
}
)
const response = result.assets.length > 0
this.logger.debug(
{ module: 'HasuraClient', assetId, hasAsset: response },
'Has asset?'
)
return response
}
public async getAssetMetadataHashesById (assetIds: Asset['assetId'][]): Promise<AssetMetadataHashAndId[]> {
const result = await this.client.request(
gql`query AssetMetadataHashes (
$assetIds: [bytea!]!
){
assets (
where: {
assetId: { _in: $assetIds }
}) {
assetId
metadataHash
}
}`,
{
assetIds: assetIds.map(id => withHexPrefix(id))
}
)
return result.assets
}
public async addAssetMetadata (asset: AssetMetadataAndHash) {
this.logger.info(
{ module: 'HasuraClient', assetId: asset.assetId },
'Adding metadata to asset'
)
const result = await this.client.request(
gql`mutation AddAssetMetadata(
$assetId: bytea!
$decimals: Int
$description: String
$logo: String
$metadataHash: bpchar!
$name: String
$ticker: String
$url: String
) {
update_assets(
where: {
assetId: { _eq: $assetId }
},
_set: {
decimals: $decimals
description: $description
logo: $logo
metadataHash: $metadataHash
name: $name
ticker: $ticker
url: $url
}
) {
affected_rows
returning {
assetId
}
}
}`,
import { errors, RunnableModuleState } from '@cardano-graphql/util'
import hash from 'object-hash'
import { dummyLogger, Logger } from 'ts-log'
import { Config } from './Config'
import { HasuraClient } from './HasuraClient'
import PgBoss, { JobWithDoneCallback } from 'pg-boss'
import { MetadataClient } from './MetadataClient'
import { DbConfig } from './typeAliases'
import { HasuraBackgroundClient } from './HasuraBackgroundClient'
const ASSET_METADATA_FETCH_INITIAL = 'asset-metadata-fetch-initial'
const ASSET_METADATA_FETCH_UPDATE = 'asset-metadata-fetch-update'
private state: RunnableModuleState
constructor (
readonly hasuraClient: HasuraClient,
readonly hasuraClient: HasuraBackgroundClient,
private logger: Logger = dummyLogger,
private metadataFetchClient: MetadataClient,
private queueConfig: Config['db'],
private queueConfig: DbConfig,
private options?: {
metadataUpdateInterval?: {
assets?: Config['metadataUpdateInterval']['assets']
assets?: number
}
}
) {
import { createLogger, LogLevelString } from 'bunyan'
import { Db, HasuraManagementClient } from '../index'
import { ChainFollower, Db, HasuraBackgroundClient, MetadataClient, Worker } from './index'
import onDeath from 'death'
import { Logger } from 'ts-log'
import { CustomError } from 'ts-custom-error'
import fs from 'fs-extra'
import { DbConfig } from '../typeAliases'
import { DbConfig } from './typeAliases'
import { PointOrOrigin } from '@cardano-ogmios/schema'
// Todo: Hoist to util package next major version
export class MissingConfig extends CustomError {
public constructor (message: string) {
}
}
export interface DbManagerConfig {
export interface BackgroundConfig {
db: DbConfig,
hasuraCliPath: string,
hasuraUri: string,
loggerMinSeverity: LogLevelString
loggerMinSeverity: LogLevelString,
metadataServerUri: string,
metadataUpdateInterval?: {
assets: number
},
ogmios?: {
host?: string
port?: number
}
}
async function getConfig (): Promise<DbManagerConfig> {
async function getConfig (): Promise<BackgroundConfig> {
const env = filterAndTypecastEnvs(process.env)
if (!env.hasuraCliPath) {
throw new MissingConfig('HASURA_CLI_PATH env not set')
}
if (!env.hasuraUri) {
throw new MissingConfig('HASURA_URI env not set')
}
if (!env.metadataServerUri) {
throw new MissingConfig('METADATA_SERVER_URI env not set')
}
if (!env.postgres.dbFile && !env.postgres.db) {
throw new MissingConfig('POSTGRES_DB_FILE or POSTGRES_DB env not set')
}
if (!env.postgres.userFile && !env.postgres.user) {
throw new MissingConfig('POSTGRES_USER_FILE or POSTGRES_USER env not set')
}
let db: DbManagerConfig['db']
let db: BackgroundConfig['db']
try {
db = {
database: env.postgres.db || (await fs.readFile(env.postgres.dbFile, 'utf8')).toString().trim(),
function filterAndTypecastEnvs (env: any) {
const {
ASSET_METADATA_UPDATE_INTERVAL,
HASURA_CLI_PATH,
HASURA_URI,
LOGGER_MIN_SEVERITY,
METADATA_SERVER_URI,
OGMIOS_HOST,
OGMIOS_PORT,
POSTGRES_DB,
POSTGRES_DB_FILE,
POSTGRES_HOST,
hasuraCliPath: HASURA_CLI_PATH,
hasuraUri: HASURA_URI,
loggerMinSeverity: LOGGER_MIN_SEVERITY as LogLevelString,
metadataServerUri: METADATA_SERVER_URI,
metadataUpdateInterval: {
assets: ASSET_METADATA_UPDATE_INTERVAL ? Number(ASSET_METADATA_UPDATE_INTERVAL) : undefined
},
ogmios: {
host: OGMIOS_HOST,
port: OGMIOS_PORT ? Number(OGMIOS_PORT) : undefined
},
postgres: {
db: POSTGRES_DB,
dbFile: POSTGRES_DB_FILE,
(async function () {
const config = await getConfig()
const logger: Logger = createLogger({
name: 'db-manager',
name: 'background',
level: config.loggerMinSeverity
})
try {
const hasuraManagementClient = new HasuraManagementClient(
const hasuraBackgroundClient = new HasuraBackgroundClient(
config.hasuraCliPath,
config.hasuraUri,
logger
)
const chainFollower = new ChainFollower(
hasuraBackgroundClient,
logger,
config.db
)
const metadataClient = new MetadataClient(
config.metadataServerUri,
logger
)
const worker = new Worker(
hasuraBackgroundClient,
logger,
metadataClient,
config.db,
{
metadataUpdateInterval: {
assets: config.metadataUpdateInterval?.assets
}
}
)
const db = new Db(config.db, logger)
const getChainSyncPoints = async (): Promise<PointOrOrigin[]> => {
const mostRecentPoint = await hasuraBackgroundClient.getMostRecentPointWithNewAsset()
return mostRecentPoint !== null ? [mostRecentPoint, 'origin'] : ['origin']
}
await db.init({
onDbInit: () => hasuraManagementClient.shutdown(),
onDbInit: () => hasuraBackgroundClient.shutdown(),
onDbSetup: async () => {
try {
await hasuraManagementClient.initialize()
await hasuraBackgroundClient.initialize()
await metadataClient.initialize()
await chainFollower.initialize(config.ogmios, getChainSyncPoints)
await worker.start()
await chainFollower.start(await getChainSyncPoints())
} catch (error) {
process.exit(1)
}
}
})
await hasuraManagementClient.initialize()
onDeath(async () => {
await hasuraManagementClient.shutdown()
await db.shutdown()
await Promise.all([
hasuraBackgroundClient.shutdown,
worker.shutdown,
chainFollower.shutdown,
db.shutdown
])
process.exit(1)
})
} catch (error) {
import { exec } from 'child_process'
import util, { ModuleState } from '@cardano-graphql/util'
import { GraphQLSchema } from 'graphql'
import { GraphQLClient, gql } from 'graphql-request'
import pRetry from 'p-retry'
import path from 'path'
import { dummyLogger, Logger } from 'ts-log'
const epochInformationNotYetAvailable = 'Epoch information not yet available. This is expected during the initial chain-sync.'
export class HasuraManagementClient {
private client: GraphQLClient
private applyingSchemaAndMetadata: boolean
private state: ModuleState
public schema: GraphQLSchema
constructor (
readonly hasuraCliPath: string,
readonly hasuraUri: string,
private logger: Logger = dummyLogger
) {
this.state = null
this.applyingSchemaAndMetadata = false
this.client = new GraphQLClient(
`${this.hasuraUri}/v1/graphql`,
{
headers: {
'X-Hasura-Role': 'cardano-graphql'
}
}
)
}
private async hasuraCli (command: string) {
return new Promise((resolve, reject) => {
exec(
`${this.hasuraCliPath} --skip-update-check --project ${path.resolve(__dirname, '..', '..', 'hasura', 'project')} --endpoint ${this.hasuraUri} ${command}`,
(error, stdout) => {
if (error) {
reject(error)
}
if (stdout !== '') this.logger.debug({ module: 'HasuraManagementClient' }, stdout)
resolve()
}
)
})
}
public async initialize () {
if (this.state !== null) return
this.state = 'initializing'
this.logger.info({ module: 'HasuraManagementClient' }, 'Initializing')
await this.applySchemaAndMetadata()
this.logger.debug({ module: 'HasuraManagementClient' }, 'graphql-engine setup')
await pRetry(async () => {
const result = await this.client.request(
gql`query {
epochs (limit: 1, order_by: { number: desc }) {
number
}
}`
)
if (result.epochs.length === 0) {
this.logger.debug({ module: 'HasuraManagementClient' }, epochInformationNotYetAvailable)
throw new Error(epochInformationNotYetAvailable)
}
}, {
factor: 1.05,
retries: 100,
onFailedAttempt: util.onFailedAttemptFor(
'Detecting DB sync state has reached minimum progress',
this.logger
)
})
this.logger.debug({ module: 'HasuraManagementClient' }, 'DB sync state has reached minimum progress')
this.state = 'initialized'
this.logger.info({ module: 'HasuraManagementClient' }, 'Initialized')
}
public async shutdown () {
this.state = null
}
public async applySchemaAndMetadata (): Promise<void> {
if (this.applyingSchemaAndMetadata) return
this.applyingSchemaAndMetadata = true
await pRetry(async () => {
await this.hasuraCli('migrate --database-name default apply --down all')
await this.hasuraCli('migrate --database-name default apply --up all')
}, {
factor: 1.75,
retries: 9,
onFailedAttempt: util.onFailedAttemptFor(
'Applying PostgreSQL schema migrations',
this.logger
)
})
await pRetry(async () => {
await this.hasuraCli('metadata clear')
await this.hasuraCli('metadata apply')
}, {
factor: 1.75,
retries: 9,
onFailedAttempt: util.onFailedAttemptFor('Applying Hasura metadata', this.logger)
})
this.applyingSchemaAndMetadata = false
}
}
export * from './Db'
export * from './HasuraManagementClient'
export * from './CardanoNodeClient'
export * from './ChainFollower'
export * from './Config'
export * from './Db'
export * from './executableSchema'
export * from './graphql_types'
export * from './HasuraClient'
export * from './db-manager'
export * from './HasuraBackgroundClient'
export * from './MetadataClient'
export * from './typeAliases'
export * from './Worker'
import { Config as ApiCardanoDbHasuraConfig } from '@cardano-graphql/api-cardano-db-hasura'
import { MissingConfig } from './errors'
import fs from 'fs-extra'
import { Config as ServerConfig } from './Server'
import { LogLevelString } from 'bunyan'
if (!env.hasuraUri) {
throw new MissingConfig('HASURA_URI env not set')
}
if (!env.metadataServerUri) {
throw new MissingConfig('METADATA_SERVER_URI env not set')
}
if (!env.postgres.dbFile && !env.postgres.db) {
throw new MissingConfig('POSTGRES_DB_FILE or POSTGRES_DB env not set')
}
if (!env.postgres.host) {
throw new MissingConfig('POSTGRES_HOST env not set')
}
if (!env.postgres.passwordFile && !env.postgres.password) {
throw new MissingConfig('POSTGRES_PASSWORD_FILE or POSTGRES_PASSWORD env not set')
}
if (!env.postgres.port) {
throw new MissingConfig('POSTGRES_PORT env not set')
}
if (!env.postgres.userFile && !env.postgres.user) {
throw new MissingConfig('POSTGRES_USER_FILE or POSTGRES_USER env not set')
}
let db: Config['db']
try {
db = {
database: env.postgres.db || (await fs.readFile(env.postgres.dbFile, 'utf8')).toString().trim(),
host: env.postgres.host,
password: env.postgres.password || (await fs.readFile(env.postgres.passwordFile, 'utf8')).toString().trim(),
port: env.postgres.port,
user: env.postgres.user || (await fs.readFile(env.postgres.userFile, 'utf8')).toString().trim()
}
} catch (error) {
throw new MissingConfig('Database configuration cannot be read')
}
const { postgres, ...selectedEnv } = env
return {
...selectedEnv,
...env,
allowIntrospection:
(process.env.NODE_ENV === 'production' && env.allowIntrospection) ||
(process.env.NODE_ENV !== 'production' && env.allowIntrospection !== false),
allowedOrigins: env.allowedOrigins || true,
apiPort: env.apiPort || 3100,
cacheEnabled: env.cacheEnabled || false,
db,
loggerMinSeverity: env.loggerMinSeverity || 'info' as LogLevelString,
listenAddress: env.listenAddress || '0.0.0.0',
maxQueryComplexity: env.maxQueryComplexity,
ALLOWED_ORIGINS,
ALLOW_LIST_PATH,
API_PORT,
ASSET_METADATA_UPDATE_INTERVAL,
CACHE_ENABLED,
CARDANO_NODE_CONFIG_PATH,
HASURA_URI,
LISTEN_ADDRESS,
LOGGER_MIN_SEVERITY,
MAX_QUERY_COMPLEXITY,
METADATA_SERVER_URI,
OGMIOS_HOST,
OGMIOS_PORT,
POLLING_INTERVAL_ADA_SUPPLY,
POSTGRES_DB,
POSTGRES_DB_FILE,
POSTGRES_HOST,
POSTGRES_PASSWORD,
POSTGRES_PASSWORD_FILE,
POSTGRES_PORT,
POSTGRES_USER,
POSTGRES_USER_FILE,
PROMETHEUS_METRICS,
QUERY_DEPTH_LIMIT,
TRACING
listenAddress: LISTEN_ADDRESS,
loggerMinSeverity: LOGGER_MIN_SEVERITY as LogLevelString,
maxQueryComplexity: Number(MAX_QUERY_COMPLEXITY),
metadataUpdateInterval: {
assets: ASSET_METADATA_UPDATE_INTERVAL ? Number(ASSET_METADATA_UPDATE_INTERVAL) : undefined
},
metadataServerUri: METADATA_SERVER_URI,
ogmios: {
host: OGMIOS_HOST,
port: OGMIOS_PORT ? Number(OGMIOS_PORT) : undefined
},
pollingInterval: {
adaSupply: Number(POLLING_INTERVAL_ADA_SUPPLY)
},
postgres: {
db: POSTGRES_DB,
dbFile: POSTGRES_DB_FILE,
host: POSTGRES_HOST,
password: POSTGRES_PASSWORD,
passwordFile: POSTGRES_PASSWORD_FILE,
port: POSTGRES_PORT ? Number(POSTGRES_PORT) : undefined,
user: POSTGRES_USER,
userFile: POSTGRES_USER_FILE
},
prometheusMetrics: PROMETHEUS_METRICS === 'true',
queryDepthLimit: Number(QUERY_DEPTH_LIMIT),
tracing: TRACING === 'true'
import { createLogger } from 'bunyan'
import { PointOrOrigin } from '@cardano-ogmios/schema'
import { getConfig } from './config'
import {
AlonzoGenesis,
buildSchema as buildCardanoDbHasuraSchema,
ByronGenesis,
CardanoNodeClient,
ChainFollower,
Genesis,
HasuraClient,
MetadataClient,
ShelleyGenesis,
Worker
ShelleyGenesis
} from '@cardano-graphql/api-cardano-db-hasura'
import { errors } from '@cardano-graphql/util'
import onDeath from 'death'
config.pollingInterval.adaSupply,
logger
)
const chainFollower = new ChainFollower(
hasuraClient,
logger,
config.db
)
const metadataClient = new MetadataClient(
config.metadataServerUri,
logger
)
const worker = new Worker(
hasuraClient,
logger,
metadataClient,
config.db,
{
metadataUpdateInterval: {
assets: config.metadataUpdateInterval?.assets
}
}
)
const server = new Server(schemas, config, logger)
schemas.push(await buildCardanoDbHasuraSchema(hasuraClient, genesis, cardanoNodeClient))
const getChainSyncPoints = async (): Promise<PointOrOrigin[]> => {
const mostRecentPoint = await hasuraClient.getMostRecentPointWithNewAsset()
return mostRecentPoint !== null ? [mostRecentPoint, 'origin'] : ['origin']
}
await cardanoNodeClient.initialize(config.ogmios)
try {
await server.init()
await hasuraClient.initialize()
await metadataClient.initialize()
await chainFollower.initialize(config.ogmios, getChainSyncPoints)
await worker.start()
await chainFollower.start(await getChainSyncPoints())
await server.start()
} catch (error) {
logger.error(error.message)
onDeath(async () => {
await Promise.all([
hasuraClient.shutdown,
cardanoNodeClient.shutdown,
worker.shutdown,
chainFollower.shutdown
cardanoNodeClient.shutdown
])
await server.shutdown()
process.exit(1)
- Update readme to address issues and questions presented by CPS-0001 - Update CDDL to support a more flexible scoping structure for future expansion
![iohk-bors[bot]](https://avatars.githubusercontent.com/in/17473?v=4&s=80)
4470: db-analyser: make tracer atomic r=amesgen a=amesgen # Description When enabling verbose logging, tracers from ChainDB background threads can cause undesirable interleavings. Co-authored-by: Alexander Esgen <[email protected]>
When enabling verbose logging, tracers from ChainDB background threads can cause undesirable interleavings.
Co-authored-by: Robert Phair <[email protected]>