@things-factory/edge-client 8.0.0-beta.9 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/edge-client",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "things-factory": true,
   "license": "MIT",
@@ -22,10 +22,10 @@
     "clean": "npm run clean:server"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/integration-base": "^8.0.0-beta.9",
-    "@things-factory/lock-client": "^8.0.0-beta.9",
-    "@things-factory/shell": "^8.0.0-beta.9"
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/integration-base": "^8.0.0",
+    "@things-factory/lock-client": "^8.0.0",
+    "@things-factory/shell": "^8.0.0"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/controllers/connect-connections.ts

@@ -0,0 +1,6 @@
+import { pubsub } from '@things-factory/shell'
+import { Connection } from '@things-factory/integration-base'
+
+export async function connectConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+  pubsub.publish('connect-connections', connections)
+}

package/server/controllers/disconnect-connections.ts

@@ -0,0 +1,6 @@
+import { pubsub } from '@things-factory/shell'
+import { Connection } from '@things-factory/integration-base'
+
+export async function disconnectConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+  pubsub.publish('disconnect-connections', connections)
+}

package/server/controllers/index.ts

@@ -0,0 +1,2 @@
+export * from './run-task'
+export * from './sync-connections'

package/server/controllers/run-task.ts

@@ -0,0 +1,33 @@
+import { pubsub } from '@things-factory/shell'
+import { Context, Step, TaskHandler } from '@things-factory/integration-base'
+import { requestLock, tryLock } from '@things-factory/lock-client'
+
+export const runTask: TaskHandler = async (step: Step, scenarioContext: Context) => {
+  const { logger }: { logger: any } = scenarioContext
+
+  try {
+    const id = await requestLock()
+
+    pubsub.publish('run-task', {
+      id,
+      step,
+      context: scenarioContext
+    })
+
+    const result = await tryLock({ id })
+    const { out, logs, error } = result || {}
+
+    if (logger.transports?.length > 0) {
+      /* 강제로 시나리오 인스턴스가 종료된 경우에는 logger도 닫힌 상태가 된다. 이 경우에는 transports가 설정되지 않게된다. */
+      logs && logs.map(log => logger.log(log))
+    }
+
+    if (error) {
+      throw new Error(error)
+    }
+
+    return out
+  } catch (err) {
+    throw new Error(err)
+  }
+}

package/server/controllers/sync-connections.ts

@@ -0,0 +1,6 @@
+import { pubsub } from '@things-factory/shell'
+import { Connection } from '@things-factory/integration-base'
+
+export async function syncConnections(connections: Connection[], context: ResolverContext): Promise<any> {
+  pubsub.publish('sync-connections', connections)
+}

package/server/engine/connector/edge-connector.ts

@@ -0,0 +1,45 @@
+import { Connector, ConnectionManager, InputConnection } from '@things-factory/integration-base'
+
+/**
+ * This connector only serves the role of a tag specifying that a particular step of the task will be performed on the Edge Server,
+ * and therefore, contains no special logic.
+ */
+export class EdgeConnector implements Connector {
+  async ready(connectionConfigs: InputConnection[]) {
+    await Promise.all(connectionConfigs.map(this.connect.bind(this)))
+
+    ConnectionManager.logger.info('edge-connector connections are ready')
+  }
+
+  async connect(connection: InputConnection) {
+    const edge = {}
+
+    ConnectionManager.addConnectionInstance(connection, edge)
+
+    ConnectionManager.logger.info(`edge-connector connection(${connection.name}:${connection.endpoint}) is connected`)
+  }
+
+  async disconnect(connection: InputConnection) {
+    ConnectionManager.removeConnectionInstance(connection)
+
+    ConnectionManager.logger.info(`edge-connector connection(${connection.name}) is disconnected`)
+  }
+
+  get parameterSpec() {
+    return []
+  }
+
+  get taskPrefixes() {
+    return [] // intentionally empty
+  }
+
+  get help() {
+    return 'integration/connector/edge-connector'
+  }
+
+  get description() {
+    return 'Operato Edge Connector'
+  }
+}
+
+ConnectionManager.registerConnector('edge-connector', new EdgeConnector())

package/server/engine/index.ts

@@ -0,0 +1 @@
+import './connector/edge-connector'

package/server/index.ts

@@ -0,0 +1,17 @@
+export * from './service'
+
+import { setEdgeClient } from '@things-factory/integration-base'
+import { runTask } from './controllers/run-task'
+import { syncConnections } from './controllers/sync-connections'
+import { connectConnections } from './controllers/connect-connections'
+import { disconnectConnections } from './controllers/disconnect-connections'
+import './engine' // for registering edge-connector
+
+process.on('bootstrap-module-start' as any, async ({ app, config, client }: any) => {
+  setEdgeClient({
+    handler: runTask,
+    syncConnections,
+    connectConnections,
+    disconnectConnections
+  })
+})

package/server/service/appliance/edge-client-mutation.ts

@@ -0,0 +1,18 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+
+import { Appliance } from '@things-factory/auth-base'
+import { releaseLock } from '@things-factory/lock-client'
+
+import { RunTaskCallbackInput } from './edge-client-type'
+
+@Resolver(Appliance)
+export class EdgeClientMutation {
+  @Mutation(returns => Boolean, { description: 'To receive the result of runTask' })
+  async runTaskCallback(@Arg('result', type => RunTaskCallbackInput) result: RunTaskCallbackInput, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { id, out, logs, error } = result
+
+    await releaseLock({ id, payload: { out, logs, error } })
+
+    return true
+  }
+}

package/server/service/appliance/edge-client-subscription.ts

@@ -0,0 +1,241 @@
+import { filter, pipe } from 'graphql-yoga'
+import { Resolver, Subscription, Root, Arg } from 'type-graphql'
+
+import { pubsub, getRepository, Domain } from '@things-factory/shell'
+import { Appliance, User } from '@things-factory/auth-base'
+import { ConnectionManager, Connection, Step } from '@things-factory/integration-base'
+
+import { EdgeContext, RunTaskPayload } from './edge-client-type'
+
+@Resolver(Appliance)
+export class EdgeClientSubscription {
+  @Subscription(type => [Connection], {
+    subscribe: async ({ args, context, info }) => {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+      const subdomain = domain?.subdomain
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      const appliance =
+        user.reference &&
+        (await getRepository(Appliance).findOne({
+          where: {
+            id: user.reference
+          }
+        }))
+
+      if (!appliance) {
+        throw new Error('Appliance not found')
+      }
+
+      process.nextTick(async () => {
+        const connections = Object.values(ConnectionManager.getConnectionInstanceEntities(domain)).filter(
+          ({ edgeId }) => edgeId == appliance.id
+        )
+
+        if (connections.length > 0) {
+          pubsub.publish('sync-connections', connections)
+        }
+      })
+
+      return pipe(
+        pubsub.subscribe('sync-connections'),
+        filter(async (payload: Connection[]) => {
+          const connections = payload
+          const { edgeId } = connections[0]
+
+          if (connections.find(connection => connection.domain?.subdomain !== subdomain)) {
+            return false
+          }
+
+          if (!edgeId || appliance?.id !== edgeId) {
+            return false
+          }
+
+          return true
+        })
+      )
+    }
+  })
+  syncConnections(@Root() payload: Connection[]): Connection[] {
+    return payload.map(connection => {
+      return {
+        ...connection,
+        params: JSON.stringify(connection.params)
+      }
+    }) as any
+  }
+
+  @Subscription(type => [Connection], {
+    subscribe: async ({ args, context, info }) => {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+      const subdomain = domain?.subdomain
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      const appliance =
+        user.reference &&
+        (await getRepository(Appliance).findOne({
+          where: {
+            id: user.reference
+          }
+        }))
+
+      if (!appliance) {
+        throw new Error('Appliance not found')
+      }
+
+      return pipe(
+        pubsub.subscribe('connect-connections'),
+        filter(async (payload: Connection[]) => {
+          const connections = payload
+          const { edgeId } = connections[0]
+
+          if (connections.find(connection => connection.domain?.subdomain !== subdomain)) {
+            return false
+          }
+
+          if (!edgeId || appliance?.id !== edgeId) {
+            return false
+          }
+
+          return true
+        })
+      )
+    }
+  })
+  connectConnections(@Root() payload: Connection[]): Connection[] {
+    return payload.map(connection => {
+      return {
+        ...connection,
+        params: JSON.stringify(connection.params)
+      }
+    }) as any
+  }
+
+  @Subscription(type => [Connection], {
+    subscribe: async ({ args, context, info }) => {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+      const subdomain = domain?.subdomain
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      const appliance =
+        user.reference &&
+        (await getRepository(Appliance).findOne({
+          where: {
+            id: user.reference
+          }
+        }))
+
+      if (!appliance) {
+        throw new Error('Appliance not found')
+      }
+
+      return pipe(
+        pubsub.subscribe('disconnect-connections'),
+        filter(async (payload: Connection[]) => {
+          const connections = payload
+          const { edgeId } = connections[0]
+
+          if (connections.find(connection => connection.domain?.subdomain !== subdomain)) {
+            return false
+          }
+
+          if (!edgeId || appliance?.id !== edgeId) {
+            return false
+          }
+
+          return true
+        })
+      )
+    }
+  })
+  disconnectConnections(@Root() payload: Connection[]): Connection[] {
+    return payload.map(connection => {
+      return {
+        ...connection,
+        params: JSON.stringify(connection.params)
+      }
+    }) as any
+  }
+
+  @Subscription({
+    subscribe: async ({ args, context, info }) => {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+
+      const subdomain = domain?.subdomain
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      const appliance =
+        user.reference &&
+        (await getRepository(Appliance).findOne({
+          where: {
+            id: user.reference
+          }
+        }))
+
+      if (!appliance) {
+        throw new Error('Appliance not found')
+      }
+      return pipe(
+        pubsub.subscribe('run-task'),
+        filter(async (payload: { id: string; step: Step; context: EdgeContext }) => {
+          const { domainId, connection } = payload.step
+
+          if (domainId !== domain.id) {
+            return false
+          }
+
+          const { edgeId } = connection && ConnectionManager.getConnectionInstanceEntityByName(domain, connection)
+
+          if (!edgeId || appliance?.id !== edgeId) {
+            return false
+          }
+
+          return true
+        })
+      )
+    }
+  })
+  runTask(@Root() payload: RunTaskPayload): RunTaskPayload {
+    const { id, step, context } = payload
+    const { name, task, description, connection, params } = step
+
+    return {
+      id, // requestId
+      step: {
+        name,
+        task,
+        description,
+        connection,
+        params: JSON.stringify(params)
+      },
+      context
+    }
+  }
+}

package/server/service/appliance/edge-client-type.ts

@@ -0,0 +1,46 @@
+import { InputType, ObjectType, Field } from 'type-graphql'
+
+import { Domain, ScalarObject } from '@things-factory/shell'
+import { Step } from '@things-factory/integration-base'
+
+@ObjectType()
+export class EdgeContext {
+  @Field(type => Domain, { nullable: true })
+  domain: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  data: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  variables: any
+
+  @Field({ nullable: true })
+  lng: string
+}
+
+@ObjectType()
+export class RunTaskPayload {
+  @Field()
+  id: string
+
+  @Field()
+  step: Step
+
+  @Field()
+  context: EdgeContext
+}
+
+@InputType()
+export class RunTaskCallbackInput {
+  @Field({ nullable: true })
+  id: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  out: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  logs: any
+
+  @Field(type => ScalarObject, { nullable: true })
+  error: any
+}

package/server/service/appliance/index.ts

@@ -0,0 +1,6 @@
+import { EdgeClientMutation } from './edge-client-mutation'
+import { EdgeClientSubscription } from './edge-client-subscription'
+
+export const entities = []
+export const resolvers = [EdgeClientMutation, EdgeClientSubscription]
+export const subscribers = []

package/server/service/index.ts

@@ -0,0 +1,21 @@
+/* EXPORT ENTITY TYPES */
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as EdgeClientEntities, resolvers as EdgeClientResolvers, subscribers as EdgeClientSubscribers } from './appliance'
+
+export const entities = [
+  /* ENTITIES */
+  ...EdgeClientEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...EdgeClientSubscribers
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...EdgeClientResolvers
+  ]
+}

package/server/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"]
+}