Add hasState field to program entity (#1342)

.github/workflows/CI-CD-gear-js-api.yml

@@ -17,7 +17,7 @@ jobs:
   test:
     if: github.event_name == 'pull_request'
 
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     env: 
       RUSTUP_HOME: /tmp/rustup_home
     steps:
@@ -93,7 +93,7 @@ jobs:
   publish-to-npm:
     if: github.event_name == 'push'
 
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v3
 

idea/api-gateway/src/rabbitmq/index.ts

@@ -1,13 +1,6 @@
 import { CronJob } from 'cron';
 import { connect, Connection, Channel } from 'amqplib';
-import {
-  RMQMessage,
-  RMQReply,
-  RMQServiceActions,
-  RMQServices,
-  RabbitMQExchanges,
-  RabbitMQueues,
-} from '@gear-js/common';
+import { RMQExchanges, RMQMessage, RMQQueues, RMQReply, RMQServiceActions, RMQServices } from '@gear-js/common';
 
 import config from '../config';
 import { logger } from '../common/logger';
@@ -36,36 +29,36 @@ export class RMQService {
     }
 
     this.mainChannel = await this.connection.createChannel();
-    await this.mainChannel.assertExchange(RabbitMQExchanges.TOPIC_EX, 'topic', { durable: true });
-    await this.mainChannel.assertExchange(RabbitMQExchanges.DIRECT_EX, 'direct', { durable: true });
-    await this.mainChannel.assertQueue(RabbitMQueues.REPLIES, {
+    await this.mainChannel.assertExchange(RMQExchanges.TOPIC_EX, 'topic', { durable: true });
+    await this.mainChannel.assertExchange(RMQExchanges.DIRECT_EX, 'direct', { durable: true });
+    await this.mainChannel.assertQueue(RMQQueues.REPLIES, {
       durable: true,
       exclusive: false,
       autoDelete: false,
       messageTtl: 30_000,
     });
 
-    await this.mainChannel.bindQueue(RabbitMQueues.REPLIES, RabbitMQExchanges.DIRECT_EX, RabbitMQueues.REPLIES);
+    await this.mainChannel.bindQueue(RMQQueues.REPLIES, RMQExchanges.DIRECT_EX, RMQQueues.REPLIES);
 
-    await this.mainChannel.assertQueue(RabbitMQueues.GENESISES, {
+    await this.mainChannel.assertQueue(RMQQueues.GENESISES, {
       durable: true,
       exclusive: false,
       autoDelete: false,
       messageTtl: 30_000,
     });
 
-    await this.mainChannel.bindQueue(RabbitMQueues.GENESISES, RabbitMQExchanges.DIRECT_EX, RabbitMQueues.GENESISES);
+    await this.mainChannel.bindQueue(RMQQueues.GENESISES, RMQExchanges.DIRECT_EX, RMQQueues.GENESISES);
 
     this.metaChannel = await this.connection.createChannel();
-    this.metaChannel.assertExchange(RabbitMQExchanges.DIRECT_EX, 'direct', { durable: true });
+    this.metaChannel.assertExchange(RMQExchanges.DIRECT_EX, 'direct', { durable: true });
 
     await this.subscribeToGenesises();
     await this.subscribeToReplies();
   }
 
   private async subscribeToReplies(): Promise<void> {
     await this.mainChannel.consume(
-      RabbitMQueues.REPLIES,
+      RMQQueues.REPLIES,
       (message) => {
         if (!message) {
           return;
@@ -85,7 +78,7 @@ export class RMQService {
 
   private async subscribeToGenesises() {
     await this.mainChannel.consume(
-      RabbitMQueues.GENESISES,
+      RMQQueues.GENESISES,
       async (message) => {
         if (!message) {
           return;
@@ -148,41 +141,31 @@ export class RMQService {
 
   private async createChannel() {
     const channel = await this.connection.createChannel();
-    channel.assertExchange(RabbitMQExchanges.DIRECT_EX, 'direct', { durable: true });
+    channel.assertExchange(RMQExchanges.DIRECT_EX, 'direct', { durable: true });
     return channel;
   }
 
   public sendMsgToIndexer({ genesis, params, correlationId, method }: RMQMessage) {
     const channel = this.indexerChannels.get(genesis);
 
-    channel.publish(
-      RabbitMQExchanges.DIRECT_EX,
-      `${RMQServices.INDEXER}.${genesis}`,
-      Buffer.from(JSON.stringify(params)),
-      {
-        correlationId,
-        headers: { method },
-      },
-    );
+    channel.publish(RMQExchanges.DIRECT_EX, `${RMQServices.INDEXER}.${genesis}`, Buffer.from(JSON.stringify(params)), {
+      correlationId,
+      headers: { method },
+    });
   }
 
   public sendMsgToMetaStorage({ params, correlationId, method }: RMQMessage) {
-    this.metaChannel.publish(
-      RabbitMQExchanges.DIRECT_EX,
-      RMQServices.META_STORAGE,
-      Buffer.from(JSON.stringify(params)),
-      {
-        correlationId,
-        headers: { method },
-      },
-    );
+    this.metaChannel.publish(RMQExchanges.DIRECT_EX, RMQServices.META_STORAGE, Buffer.from(JSON.stringify(params)), {
+      correlationId,
+      headers: { method },
+    });
   }
 
   public sendMsgToTestBalance({ genesis, params, correlationId, method }: RMQMessage) {
     const channel = this.tbChannels.get(genesis);
 
     channel.publish(
-      RabbitMQExchanges.DIRECT_EX,
+      RMQExchanges.DIRECT_EX,
       `${RMQServices.TEST_BALANCE}.${genesis}`,
       Buffer.from(JSON.stringify(params)),
       {
@@ -193,11 +176,11 @@ export class RMQService {
   }
 
   public sendMsgIndexerGenesises() {
-    this.mainChannel.publish(RabbitMQExchanges.TOPIC_EX, `${RMQServices.INDEXER}.genesises`, Buffer.from(''));
+    this.mainChannel.publish(RMQExchanges.TOPIC_EX, `${RMQServices.INDEXER}.genesises`, Buffer.from(''));
   }
 
   public sendMsgTBGenesises() {
-    this.mainChannel.publish(RabbitMQExchanges.TOPIC_EX, `${RMQServices.TEST_BALANCE}.genesises`, Buffer.from(''));
+    this.mainChannel.publish(RMQExchanges.TOPIC_EX, `${RMQServices.TEST_BALANCE}.genesises`, Buffer.from(''));
   }
 
   public isExistTBChannel(genesis: string) {

idea/common/src/enums/api-methods.enum.ts

@@ -19,6 +19,10 @@ export enum INDEXER_METHODS {
   STATE_GET = 'state.get',
 }
 
+export enum INDEXER_INTERNAL_METHODS {
+  META_HAS_STATE = 'meta.hasState',
+}
+
 export enum META_STORAGE_METHODS {
   META_GET = 'meta.get',
   META_ADD = 'meta.add',

idea/common/src/enums/index.ts

@@ -4,4 +4,4 @@ export * from './api-methods.enum';
 export * from './message-read-reason.enum';
 export * from './code-status.enum';
 export * from './program-status.enum';
-export * from './rabbit-mqueues.enum';
+export * from './rmq';

idea/common/src/enums/rabbit-mqueues.enum.ts → idea/common/src/enums/rmq.ts

@@ -1,22 +1,20 @@
-enum RabbitMQueues {
+export enum RMQQueues {
   GENESISES = 'genesises',
   REPLIES = 'replies',
 }
 
-enum RabbitMQExchanges {
+export enum RMQExchanges {
   DIRECT_EX = 'direct.ex',
   TOPIC_EX = 'topic.ex',
 }
 
-enum RMQServices {
+export enum RMQServices {
   INDEXER = 'indxr',
   TEST_BALANCE = 'tb',
   META_STORAGE = 'meta',
 }
 
-enum RMQServiceActions {
+export enum RMQServiceActions {
   ADD = 'add',
   DELETE = 'delete',
 }
-
-export { RabbitMQueues, RabbitMQExchanges, RMQServiceActions, RMQServices };

idea/indexer/src/database/entities/code.entity.ts

@@ -40,4 +40,7 @@ export class Code extends BaseEntity implements ICode {
 
   @OneToMany(() => StateToCode, (stateToCode) => stateToCode.code)
   public stateToCodes!: StateToCode[];
+
+  @Column({ default: false })
+  public hasState: boolean;
 }

idea/indexer/src/database/entities/program.entity.ts

@@ -43,4 +43,7 @@ export class Program extends BaseEntity implements IProgram {
 
   @OneToMany(() => Message, (message) => message.program)
   public messages: Message[];
+
+  @Column({ default: false })
+  public hasState: boolean;
 }

idea/indexer/src/database/migrations/1690793654952-add-has-state-field.ts

@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class addHasStateField1690793654952 implements MigrationInterface {
+    name = 'addHasStateField1690793654952'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`
+            ALTER TABLE "code"
+            ADD "hasState" boolean NOT NULL DEFAULT false
+        `);
+        await queryRunner.query(`
+            ALTER TABLE "program"
+            ADD "hasState" boolean NOT NULL DEFAULT false
+        `);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`
+            ALTER TABLE "program" DROP COLUMN "hasState"
+        `);
+        await queryRunner.query(`
+            ALTER TABLE "code" DROP COLUMN "hasState"
+        `);
+    }
+
+}

idea/indexer/src/gear/connect.ts

@@ -2,7 +2,7 @@ import { GearApi } from '@gear-js/api';
 import { RMQServiceActions } from '@gear-js/common';
 
 import config from '../config';
-import { changeStatus } from '../healthcheck';
+import { changeStatus } from '../healthcheck.server';
 import { logger } from '../common';
 import { GearIndexer } from './indexer';
 

idea/indexer/src/gear/indexer.ts

@@ -35,7 +35,7 @@ import { Block, Code, Message, Program } from '../database/entities';
 import { BlockService, CodeService, MessageService, ProgramService, StatusService } from '../services';
 import { TempState } from './temp-state';
 import config from '../config';
-import { RMQService } from '../rabbitmq';
+import { RMQService } from '../rmq';
 
 export class GearIndexer {
   public api: GearApi;
@@ -316,6 +316,7 @@ export class GearIndexer {
           genesis: this.genesis,
           metahash: await this.getMeta(programId, code),
           status: ProgramStatus.PROGRAM_SET,
+          hasState: code.hasState,
         }),
       );
     }

idea/indexer/src/gear/temp-state.ts

@@ -3,7 +3,7 @@ import { CodeStatus, MessageReadReason } from '@gear-js/common';
 import { MessageStatus, ProgramStatus, generateUUID } from '../common';
 import { Block, Code, Message, Program } from '../database';
 import { BlockService, CodeService, MessageService, ProgramService } from '../services';
-import { RMQService } from '../rabbitmq';
+import { RMQService } from '../rmq';
 
 export class TempState {
   private programs: Map<string, Program>;

idea/indexer/src/healthcheck/index.ts → idea/indexer/src/healthcheck.server.ts

@@ -1,7 +1,7 @@
 import http from 'http';
 
-import config from '../config';
-import { logger } from '../common';
+import config from './config';
+import { logger } from './common';
 
 export const statuses = {
   rmq: false,

idea/indexer/src/main.ts

@@ -1,9 +1,9 @@
 import { waitReady } from '@polkadot/wasm-crypto';
 import { RMQServiceActions } from '@gear-js/common';
 
-import { changeStatus, runHealthcheckServer } from './healthcheck';
+import { changeStatus, runHealthcheckServer } from './healthcheck.server';
 import { AppDataSource } from './database';
-import { RMQService } from './rabbitmq';
+import { RMQService } from './rmq';
 import { BlockService } from './services';
 import { CodeService } from './services';
 import { MessageService } from './services';

idea/indexer/src/one-time-sync.ts

@@ -1,7 +1,7 @@
 import { waitReady } from '@polkadot/wasm-crypto';
 import { GearApi } from '@gear-js/api';
 
-import { changeStatus, runHealthcheckServer } from './healthcheck';
+import { changeStatus, runHealthcheckServer } from './healthcheck.server';
 import { AppDataSource } from './database';
 import { BlockService, StatusService } from './services';
 import { CodeService } from './services';
@@ -10,7 +10,7 @@ import { ProgramService } from './services';
 import { GearIndexer } from './gear';
 import config from './config';
 import { logger } from './common';
-import { RMQService } from './rabbitmq';
+import { RMQService } from './rmq';
 
 async function bootstrap() {
   runHealthcheckServer();