@things-factory/integration-base 7.0.0-alpha.0 → 7.0.0-alpha.18

package/server/service/connection/connection-type.ts

@@ -1,20 +1,12 @@
 import { Field, ID, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+
+import { User, Appliance } from '@things-factory/auth-base'
 import { logger } from '@things-factory/env'
-import { Domain } from '@things-factory/shell'
+import { Domain, ObjectRef } from '@things-factory/shell'
 
 import { ConnectionManager } from '../../engine'
+import { ProxyConnector } from '../../engine/connector/proxy-connector'
 
 export enum ConnectionStatus {
   CONNECTED = 'CONNECTED',
@@ -30,74 +22,138 @@ registerEnumType(ConnectionStatus, {
 @Index('ix_connection_0', (connection: Connection) => [connection.domain, connection.name], { unique: true })
 @ObjectType()
 export class Connection {
+  /**
+   * Unique identifier for the connection, generated in UUID format.
+   */
   @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
   readonly id: string
 
+  /**
+   * Many-to-One relationship with the Domain entity.
+   */
   @ManyToOne(type => Domain)
   @Field({ nullable: true })
   domain: Domain
 
+  /**
+   * Stores the ID of the associated Domain.
+   */
   @RelationId((connection: Connection) => connection.domain)
   domainId: string
 
+  /**
+   * The name of the connection.
+   */
   @Column()
   @Field()
   name: string
 
+  /**
+   * Optional description for the connection.
+   */
   @Column({
     nullable: true
   })
   @Field({ nullable: true })
   description: string
 
+  /**
+   * The type of the connection.
+   */
   @Column()
   @Field({ nullable: true })
   type: string
 
+  /**
+   * Many-to-One relationship with the Appliance entity which delegate the connection. Optional field.
+   */
+  @ManyToOne(type => Appliance, { nullable: true })
+  @Field({ nullable: true })
+  edge: Appliance
+
+  /**
+   * Stores the ID of the Appliance who delegate the connection.
+   */
+  @RelationId((connection: Connection) => connection.edge)
+  edgeId: string
+
+  /**
+   * The endpoint for the connection.
+   */
   @Column()
   @Field({ nullable: true })
   endpoint: string
 
-  @Column({
-    nullable: true
-  })
+  /**
+   * Indicates the active status of the connection.
+   */
+  @Column({ nullable: true })
   @Field({ nullable: true })
   active: boolean
 
+  /**
+   * The status of the connection, using the ConnectionStatus type.
+   */
   @Field({ nullable: true })
   state: ConnectionStatus
 
-  @Column({
-    nullable: true
-  })
+  /**
+   * Additional parameters for the connection, stored as a JSON string.
+   */
+  @Column({ nullable: true })
   @Field({ nullable: true })
   params: string
 
+  /**
+   * The date and time when the connection was created.
+   */
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt: Date
 
+  /**
+   * The date and time when the connection was last updated.
+   */
   @UpdateDateColumn()
   @Field({ nullable: true })
   updatedAt: Date
 
+  /**
+   * Many-to-One relationship with the User entity who created the connection. Optional field.
+   */
   @ManyToOne(type => User, { nullable: true })
   @Field({ nullable: true })
   creator: User
 
+  /**
+   * Stores the ID of the User who created the connection.
+   */
   @RelationId((connection: Connection) => connection.creator)
   creatorId: string
 
+  /**
+   * Many-to-One relationship with the User entity who last updated the connection.
+   * Optional field.
+   */
   @ManyToOne(type => User, { nullable: true })
   @Field({ nullable: true })
   updater: User
 
+  /**
+   * Stores the ID of the User who last updated the connection.
+   *
+   */
   @RelationId((connection: Connection) => connection.updater)
   updaterId: string
 
+  /**
+   * Asynchronous method to establish the connection.
+   *
+   */
   async connect() {
-    var connector = ConnectionManager.getConnector(this.type)
+    const { type, edge } = this
+    const connector = edge ? ProxyConnector.instance : ConnectionManager.getConnector(type)
     var params = {}
 
     try {
@@ -112,15 +168,29 @@ export class Connection {
     })
   }
 
+  /**
+   * @brief Asynchronous method to disconnect the connection.
+   *
+   */
   async disconnect() {
     try {
-      var connector = ConnectionManager.getConnector(this.type)
+      const { type, edge } = this
+      const connector = edge ? ProxyConnector.instance : ConnectionManager.getConnector(type)
       await connector.disconnect(this)
     } finally {
     }
   }
 }
 
+/**
+ * Connection의 params의 원 타입과 사용 시에 타입 불일치로 인해 임시적으로 생성한 타입으로
+ * 추후, 타입 일치를 통해서 제거할 예정임.
+ *
+ */
+export interface InputConnection extends Connection {
+  params: any
+}
+
 @ObjectType()
 export class ConnectionState {
   @Field({ nullable: true })
@@ -138,6 +208,9 @@ export class ConnectionState {
   @Field({ nullable: true })
   type?: string
 
+  @Field(type => Appliance, { nullable: true })
+  edge?: Appliance
+
   @Field({ nullable: true })
   state?: ConnectionStatus
 
@@ -156,6 +229,9 @@ export class NewConnection {
   @Field({ nullable: true })
   type?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  edge?: Appliance
+
   @Field({ nullable: true })
   endpoint?: string
 
@@ -177,6 +253,9 @@ export class ConnectionPatch {
   @Field({ nullable: true })
   type?: string
 
+  @Field(type => ObjectRef, { nullable: true })
+  edge?: Appliance
+
   @Field({ nullable: true })
   endpoint?: string
 

package/server/service/scenario-instance/scenario-instance-mutation.ts

@@ -1,35 +1,14 @@
 import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
 
-import { getRepository, Domain, GraphqlLocalClient, ScalarObject } from '@things-factory/shell'
+import { ScalarObject } from '@things-factory/shell'
 
-import { ScenarioEngine } from '../../engine'
-import { Scenario } from '../scenario/scenario'
 import { ScenarioInstance } from './scenario-instance-type'
-import { PrivilegeObject, User, checkPermission } from '@things-factory/auth-base'
-import { Step } from '../step/step-type'
 
-const debug = require('debug')('things-factory:integration-base:scenario-instance-mutation')
-
-async function findScenario(
-  scenarioName: string,
-  domain: Domain
-): Promise<{ name: string; steps: Step[]; domain: Domain; privilege?: PrivilegeObject }> {
-  var repository = getRepository(Scenario)
-
-  var scenario = await repository.findOne({
-    where: { domain: { id: domain.id }, name: scenarioName },
-    relations: ['domain', 'steps', 'creator', 'updater']
-  })
-
-  if (!scenario && domain.parentId) {
-    scenario = await repository.findOne({
-      where: { domain: { id: domain.parentId }, name: scenarioName },
-      relations: ['domain', 'steps', 'creator', 'updater']
-    })
-  }
-
-  return scenario as any
-}
+import {
+  runScenario as controllerRunScenario,
+  startScenario as controllerStartScenario,
+  stopScenario as controllerStopScenario
+} from '../../controllers/scenario-controller'
 
 @Resolver(ScenarioInstance)
 export class ScenarioInstanceMutation {
@@ -42,42 +21,7 @@ export class ScenarioInstanceMutation {
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
     @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
-    const { domain, user, lng, unsafeIP, prohibitedPrivileges } = context.state
-
-    debug('runScenario', scenarioName, instanceName, variables)
-
-    var scenario = await findScenario(scenarioName, domain)
-
-    if (!scenario) {
-      throw new Error(
-        context.t('error.scenario not found', {
-          scenario: scenarioName
-        })
-      )
-    }
-
-    if (!(await checkPermission(scenario.privilege, user, domain, unsafeIP, prohibitedPrivileges))) {
-      const { category, privilege } = scenario.privilege || {}
-      throw new Error(
-        `Unauthorized! ${
-          category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'
-        } required`
-      )
-    }
-
-    /* 시나리오 인스턴스를 생성한다. */
-    instanceName = instanceName || scenarioName + '-' + String(Date.now())
-    var instance = new ScenarioInstance(instanceName, scenario, {
-      domain,
-      user,
-      lng,
-      variables,
-      client: GraphqlLocalClient.client
-    })
-
-    await instance.run()
-
-    return instance
+    return await controllerRunScenario(instanceName, scenarioName, variables, context)
   }
 
   @Mutation(returns => ScenarioInstance, { description: 'To start new scenario instance' })
@@ -87,66 +31,11 @@ export class ScenarioInstanceMutation {
     @Arg('variables', type => ScalarObject, { nullable: true }) variables: any,
     @Ctx() context: ResolverContext
   ): Promise<ScenarioInstance> {
-    const { domain, user, lng, unsafeIP, prohibitedPrivileges } = context.state
-
-    debug('startScenario', instanceName, scenarioName, variables)
-
-    var scenario = await findScenario(scenarioName, domain)
-
-    if (!scenario) {
-      throw new Error(
-        context.t('error.scenario not found', {
-          scenario: scenarioName
-        })
-      )
-    }
-
-    if (!(await checkPermission(scenario.privilege, user, domain, unsafeIP, prohibitedPrivileges))) {
-      const { category, privilege } = scenario.privilege || {}
-      throw new Error(
-        `Unauthorized! ${
-          category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'
-        } required`
-      )
-    }
-
-    instanceName = instanceName || scenarioName
-    return await ScenarioEngine.load(instanceName, scenario, { domain, user, lng, variables })
+    return await controllerStartScenario(instanceName, scenarioName, variables, context)
   }
 
   @Mutation(returns => ScenarioInstance, { nullable: true, description: 'To start new scenario instance' })
-  async stopScenario(
-    @Arg('instanceName', { nullable: true }) instanceName: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ScenarioInstance | undefined> {
-    const { domain, user, unsafeIP, prohibitedPrivileges } = context.state
-
-    debug('stopScenario', instanceName)
-
-    var scenarioInstance = ScenarioEngine.getScenarioInstance(domain, instanceName)
-
-    if (!scenarioInstance) {
-      debug('stopScenario', `ScenarioInstance(${instanceName}) Not Found.`)
-      throw new Error(
-        context.t('error.scenario instance not found', {
-          instance: instanceName
-        })
-      )
-    }
-
-    var scenario = await findScenario(scenarioInstance.scenarioName, domain)
-
-    if (!(await checkPermission(scenario.privilege, user, domain, unsafeIP, prohibitedPrivileges))) {
-      const { category, privilege } = scenario.privilege || {}
-      throw new Error(
-        `Unauthorized! ${
-          category && privilege ? category + ':' + privilege + ' privilege' : 'ownership granted'
-        } required`
-      )
-    }
-
-    await ScenarioEngine.unload(domain, instanceName)
-
-    return scenarioInstance
+  async stopScenario(@Arg('instanceName', { nullable: true }) instanceName: string, @Ctx() context: ResolverContext): Promise<ScenarioInstance | undefined> {
+    return await controllerStopScenario(instanceName, context)
   }
 }

package/server/service/scenario-instance/scenario-instance-subscription.ts

@@ -1,5 +1,5 @@
 import { Resolver, Subscription, Root, Arg } from 'type-graphql'
-import { withFilter } from 'graphql-subscriptions'
+import { filter, pipe } from 'graphql-yoga'
 import { pubsub, Log } from '@things-factory/shell'
 import { ScenarioInstance, ScenarioInstanceState } from './scenario-instance-type'
 import { ScenarioEngine } from '../../engine'
@@ -9,7 +9,7 @@ const debug = require('debug')('things-factory:integration:scenario-instance-sub
 @Resolver(ScenarioInstance)
 export class ScenarioInstanceSubscription {
   @Subscription({
-    subscribe: (_, args, context, info) => {
+    subscribe: ({ args, context, info }) => {
       const { domain, user } = context.state
       const { instanceName, scenarioName, level } = args
       const subdomain = domain?.subdomain
@@ -24,11 +24,11 @@ export class ScenarioInstanceSubscription {
         throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
       }
 
-      return withFilter(
-        () => pubsub.asyncIterator('scenario-instance-log'),
-        (payload, variables, context, info) => {
+      return pipe(
+        pubsub.subscribe('scenario-instance-log'),
+        filter((payload: { scenarioInstanceLog: Log }) => {
           const { source, level: plevel } = payload.scenarioInstanceLog
-          const { domain: pdomain, scenarioName: pscenarioName, instanceName: pinstanceName } = source
+          const { domain: pdomain, scenarioName: pscenarioName, instanceName: pinstanceName } = source as any
 
           if (subdomain !== pdomain?.subdomain) {
             return false
@@ -47,8 +47,8 @@ export class ScenarioInstanceSubscription {
           }
 
           return true
-        }
-      )(_, args, context, info)
+        })
+      )
     }
   })
   scenarioInstanceLog(
@@ -61,7 +61,7 @@ export class ScenarioInstanceSubscription {
   }
 
   @Subscription({
-    subscribe: (_, args, context, info) => {
+    subscribe: ({ args, context, info }) => {
       const { domain, user } = context.state
       const { instanceName, scenarioName } = args
       const subdomain = domain?.subdomain
@@ -79,24 +79,17 @@ export class ScenarioInstanceSubscription {
       process.nextTick(() => {
         ScenarioEngine.getScenarioInstances(domain)
           .filter(instance => {
-            return (
-              (!instanceName || instance.instanceName === instanceName) &&
-              (!scenarioName || instance.scenarioName === scenarioName)
-            )
+            return (!instanceName || instance.instanceName === instanceName) && (!scenarioName || instance.scenarioName === scenarioName)
           })
           .forEach(instance => {
             instance.publishState()
           })
       })
 
-      return withFilter(
-        () => pubsub.asyncIterator('scenario-instance-state'),
-        (payload, variables, context, info) => {
-          const {
-            domain: pdomain,
-            scenarioName: pscenarioName,
-            instanceName: pinstanceName
-          } = payload.scenarioInstanceState
+      return pipe(
+        pubsub.subscribe('scenario-instance-state'),
+        filter((payload: { scenarioInstanceState: ScenarioInstanceState }) => {
+          const { domain: pdomain, scenarioName: pscenarioName, instanceName: pinstanceName } = payload.scenarioInstanceState
 
           if (subdomain !== pdomain?.subdomain) {
             return false
@@ -111,8 +104,8 @@ export class ScenarioInstanceSubscription {
           }
 
           return true
-        }
-      )(_, args, context, info)
+        })
+      )
     }
   })
   scenarioInstanceState(

package/server/service/scenario-instance/scenario-instance-type.ts

@@ -10,9 +10,11 @@ import { Domain, pubsub, PubSubLogTransport, ScalarObject } from '@things-factor
 import { User } from '@things-factory/auth-base'
 import { sleep } from '@things-factory/utils'
 
+import { ConnectionManager } from '../../engine/connection-manager'
 import { TaskRegistry } from '../../engine'
 import { Context } from '../../engine/types'
 import { Step } from '../step/step-type'
+import { handler as edgeHandler } from '../../engine/edge-client'
 
 const debug = require('debug')('things-factory:integration-base:scenario-instance')
 const { combine, timestamp, splat, printf } = format
@@ -125,7 +127,7 @@ export class ScenarioInstance {
   timestamp: Date
 
   @Field({ nullable: true })
-  private message: string
+  public message: string
 
   private steps: Step[]
   private rounds: number = 0
@@ -267,10 +269,7 @@ export class ScenarioInstance {
       this.context.logger.error(ex.message ? ex.message : ex)
 
       debug('failed to run ', `[ Domain: ${domain.name}, Scenario: ${scenarioName} ]\n`, ex)
-      this.setState(
-        ScenarioInstanceStatus.HALTED,
-        typeof message == 'object' ? JSON.stringify(message, null, 2) : message
-      )
+      this.setState(ScenarioInstanceStatus.HALTED, typeof message == 'object' ? JSON.stringify(message, null, 2) : message)
 
       throw ex
     }
@@ -376,9 +375,9 @@ export class ScenarioInstance {
       return
     }
 
-    this.message = `${this.instanceName}:[state changed] ${ScenarioInstanceStatus[this.getState()]} => ${
-      ScenarioInstanceStatus[state]
-    }${message ? ' caused by ' + util.inspect(message, false, 2, true) : ''}`
+    this.message = `${this.instanceName}:[state changed] ${ScenarioInstanceStatus[this.getState()]} => ${ScenarioInstanceStatus[state]}${
+      message ? ' caused by ' + util.inspect(message, false, 2, true) : ''
+    }`
 
     this.context.state = state
 
@@ -421,6 +420,12 @@ export class ScenarioInstance {
     if (this.disposer) {
       await this.disposer.call(this)
     }
+
+    // {{ CHECKPOINT 본 인스턴스를 위해서 생성된 logger를 닫는다.
+    if (this.context?.logger) {
+      this.context.logger.close()
+    }
+    // }}
   }
 
   async process(step, context): Promise<{ next: string; state: ScenarioInstanceStatus; data: object }> {
@@ -437,12 +442,18 @@ export class ScenarioInstance {
     }
     step.params = step.params || {}
 
-    var handler = TaskRegistry.getTaskHandler(step.task)
-    if (!handler) {
-      throw new Error(`no task handler for step '${step.name}'(${step.id})`)
-    }
+    const connection = step.connection && ConnectionManager.getConnectionInstanceEntityByName(this.domain, step.connection)
 
-    var retval: any = await handler(step, context)
+    if (!connection || !connection.edgeId) {
+      var handler = TaskRegistry.getTaskHandler(step.task)
+      if (!handler) {
+        throw new Error(`no task handler for step '${step.name}'(${step.id})`)
+      }
+
+      var retval: any = await handler(step, context)
+    } else {
+      var retval: any = await edgeHandler(step, context)
+    }
 
     if (step.log) {
       var { data } = retval || {}

package/server/service/scenario-queue/scenario-queue-subscription.ts

@@ -1,7 +1,7 @@
 import { Resolver, Subscription, Root, Arg } from 'type-graphql'
 import { ScenarioQueueState } from './scenario-queue-type'
 import { pubsub } from '@things-factory/shell'
-import { withFilter } from 'graphql-subscriptions'
+import { filter, pipe } from 'graphql-yoga'
 import { ScenarioEngine } from '../../engine'
 
 const debug = require('debug')('things-factory:integration:connection-subscription')
@@ -9,7 +9,7 @@ const debug = require('debug')('things-factory:integration:connection-subscripti
 @Resolver()
 export class ScenarioQueueSubscription {
   @Subscription({
-    subscribe: (_, args, context, info) => {
+    subscribe: ({ args, context, info }) => {
       const { domain, user } = context.state
       const subdomain = domain?.subdomain
 
@@ -35,9 +35,9 @@ export class ScenarioQueueSubscription {
         }
       })
 
-      return withFilter(
-        () => pubsub.asyncIterator('scenario-queue-state'),
-        (payload, variables, context, info) => {
+      return pipe(
+        pubsub.subscribe('scenario-queue-state'),
+        filter((payload: { scenarioQueueState: ScenarioQueueState }) => {
           const { domain: pdomain } = payload.scenarioQueueState
 
           if (pdomain?.subdomain !== subdomain) {
@@ -45,8 +45,8 @@ export class ScenarioQueueSubscription {
           }
 
           return true
-        }
-      )(_, args, context, info)
+        })
+      )
     }
   })
   scenarioQueueState(@Root() payload: { scenarioQueueState: ScenarioQueueState }): ScenarioQueueState {