chore: restructure repo into sub folders

2026-01-09 07:20:05 +00:00 · 2021-10-20 11:43:10 +00:00
parent 99d55775aa
commit d530e0801e
28 changed files with 18 additions and 2 deletions
--- a/api/src/controllers/Execution.ts
+++ b/api/src/controllers/Execution.ts
@@ -0,0 +1,108 @@
+import { getSessionController } from './'
+import { readFile, fileExists, createFile } from '@sasjs/utils'
+import path from 'path'
+import { configuration } from '../../package.json'
+import { promisify } from 'util'
+import { execFile } from 'child_process'
+import { Session } from '../types'
+import { generateFileUploadSasCode } from '../utils'
+const execFilePromise = promisify(execFile)
+
+export class ExecutionController {
+  async execute(
+    program = '',
+    autoExec?: string,
+    session?: Session,
+    vars?: any,
+    otherArgs?: any
+  ) {
+    if (program) {
+      if (!(await fileExists(program))) {
+        throw 'ExecutionController: SAS file does not exist.'
+      }
+
+      program = await readFile(program)
+
+      if (vars) {
+        Object.keys(vars).forEach(
+          (key: string) => (program = `%let ${key}=${vars[key]};\n${program}`)
+        )
+      }
+    }
+
+    const sessionController = getSessionController()
+
+    if (!session) {
+      session = await sessionController.getSession()
+      session.inUse = true
+    }
+
+    let log = path.join(session.path, 'log.log')
+
+    let webout = path.join(session.path, 'webout.txt')
+    await createFile(webout, '')
+
+    program = `
+%let sasjsprocessmode=Stored Program;
+filename _webout "${webout}";
+${program}`
+
+    // if no files are uploaded filesNamesMap will be undefined
+    if (otherArgs && otherArgs.filesNamesMap) {
+      const uploadSasCode = await generateFileUploadSasCode(
+        otherArgs.filesNamesMap,
+        session.path
+      )
+
+      //If sas code for the file is generated it will be appended to the top of sasCode
+      if (uploadSasCode.length > 0) {
+        program = `${uploadSasCode}` + program
+      }
+    }
+
+    const code = path.join(session.path, 'code.sas')
+    if (!(await fileExists(code))) {
+      await createFile(code, program)
+    }
+
+    let additionalArgs: string[] = []
+    if (autoExec) additionalArgs = ['-AUTOEXEC', autoExec]
+
+    const { stdout, stderr } = await execFilePromise(configuration.sasPath, [
+      '-SYSIN',
+      code,
+      '-LOG',
+      log,
+      '-WORK',
+      session.path,
+      ...additionalArgs,
+      process.platform === 'win32' ? '-nosplash' : ''
+    ]).catch((err) => ({ stderr: err, stdout: '' }))
+
+    if (await fileExists(log)) log = await readFile(log)
+    else log = ''
+
+    if (await fileExists(webout)) webout = await readFile(webout)
+    else webout = ''
+
+    const debug = Object.keys(vars).find(
+      (key: string) => key.toLowerCase() === '_debug'
+    )
+
+    if ((debug && vars[debug] >= 131) || stderr) {
+      webout = `<html><body>
+${webout}
+<div style="text-align:left">
+<hr /><h2>SAS Log</h2>
+<pre>${log}</pre>
+</div>
+</body></html>`
+    }
+
+    session.inUse = false
+
+    sessionController.deleteSession(session)
+
+    return Promise.resolve(webout)
+  }
+}
--- a/api/src/controllers/FileUploadController.ts
+++ b/api/src/controllers/FileUploadController.ts
@@ -0,0 +1,36 @@
+import { uuidv4 } from '@sasjs/utils'
+import { getSessionController } from '.'
+const multer = require('multer')
+
+export class FileUploadController {
+  private storage = multer.diskStorage({
+    destination: function (req: any, file: any, cb: any) {
+      //Sending the intercepted files to the sessions subfolder
+      cb(null, req.sasSession.path)
+    },
+    filename: function (req: any, file: any, cb: any) {
+      //req_file prefix + unique hash added to sas request files
+      cb(null, `req_file_${uuidv4().replace(/-/gm, '')}`)
+    }
+  })
+
+  private upload = multer({ storage: this.storage })
+
+  //It will intercept request and generate unique uuid to be used as a subfolder name
+  //that will store the files uploaded
+  public preuploadMiddleware = async (req: any, res: any, next: any) => {
+    let session
+
+    const sessionController = getSessionController()
+    session = await sessionController.getSession()
+    session.inUse = true
+
+    req.sasSession = session
+
+    next()
+  }
+
+  public getMulterUploadObject() {
+    return this.upload
+  }
+}
--- a/api/src/controllers/Session.ts
+++ b/api/src/controllers/Session.ts
@@ -0,0 +1,127 @@
+import { Session } from '../types'
+import { getTmpSessionsFolderPath, generateUniqueFileName } from '../utils'
+import {
+  deleteFolder,
+  createFile,
+  fileExists,
+  deleteFile,
+  generateTimestamp
+} from '@sasjs/utils'
+import path from 'path'
+import { ExecutionController } from './Execution'
+
+export class SessionController {
+  private sessions: Session[] = []
+  private executionController: ExecutionController
+
+  constructor() {
+    this.executionController = new ExecutionController()
+  }
+
+  public async getSession() {
+    const readySessions = this.sessions.filter((sess: Session) => sess.ready)
+
+    const session = readySessions.length
+      ? readySessions[0]
+      : await this.createSession()
+
+    if (readySessions.length < 2) this.createSession()
+
+    return session
+  }
+
+  private async createSession() {
+    const sessionId = generateUniqueFileName(generateTimestamp())
+    const sessionFolder = path.join(await getTmpSessionsFolderPath(), sessionId)
+
+    const autoExecContent = `data _null_;
+    /* remove the dummy SYSIN */
+    length fname $8;
+    rc=filename(fname,getoption('SYSIN') );
+    if rc = 0 and fexist(fname) then rc=fdelete(fname);
+    rc=filename(fname);
+    /* now wait for the real SYSIN */
+    slept=0;
+    do until ( fileexist(getoption('SYSIN')) or slept>(60*15) );
+      slept=slept+sleep(0.01,1);
+    end;
+  run;
+  EOL`
+
+    const autoExec = path.join(sessionFolder, 'autoexec.sas')
+    await createFile(autoExec, autoExecContent)
+
+    await createFile(path.join(sessionFolder, 'code.sas'), '')
+
+    const creationTimeStamp = sessionId.split('-').pop() as string
+
+    const session: Session = {
+      id: sessionId,
+      ready: false,
+      creationTimeStamp: creationTimeStamp,
+      deathTimeStamp: (
+        parseInt(creationTimeStamp) +
+        15 * 60 * 1000 -
+        1000
+      ).toString(),
+      path: sessionFolder,
+      inUse: false
+    }
+
+    this.scheduleSessionDestroy(session)
+
+    this.executionController.execute('', autoExec, session).catch(() => {})
+
+    this.sessions.push(session)
+
+    await this.waitForSession(session)
+
+    return session
+  }
+
+  public async waitForSession(session: Session) {
+    if (await fileExists(path.join(session.path, 'code.sas'))) {
+      while (await fileExists(path.join(session.path, 'code.sas'))) {}
+
+      await deleteFile(path.join(session.path, 'log.log'))
+
+      session.ready = true
+
+      return Promise.resolve(session)
+    } else {
+      session.ready = true
+
+      return Promise.resolve(session)
+    }
+  }
+
+  public async deleteSession(session: Session) {
+    await deleteFolder(session.path)
+
+    if (session.ready) {
+      this.sessions = this.sessions.filter(
+        (sess: Session) => sess.id !== session.id
+      )
+    }
+  }
+
+  private scheduleSessionDestroy(session: Session) {
+    setTimeout(async () => {
+      if (session.inUse) {
+        session.deathTimeStamp = session.deathTimeStamp + 1000 * 10
+
+        this.scheduleSessionDestroy(session)
+      } else {
+        await this.deleteSession(session)
+      }
+    }, parseInt(session.deathTimeStamp) - new Date().getTime() - 100)
+  }
+}
+
+export const getSessionController = () => {
+  if (process.sessionController) return process.sessionController
+
+  process.sessionController = new SessionController()
+
+  return process.sessionController
+}
--- a/api/src/controllers/deploy.ts
+++ b/api/src/controllers/deploy.ts
@@ -0,0 +1,57 @@
+import { MemberType, FolderMember, ServiceMember } from '../types'
+import { getTmpFilesFolderPath } from '../utils/file'
+import { createFolder, createFile, asyncForEach } from '@sasjs/utils'
+import path from 'path'
+
+// REFACTOR: export FileTreeCpntroller
+export const createFileTree = async (
+  members: [FolderMember, ServiceMember],
+  parentFolders: string[] = []
+) => {
+  const destinationPath = path.join(
+    getTmpFilesFolderPath(),
+    path.join(...parentFolders)
+  )
+
+  await asyncForEach(members, async (member: FolderMember | ServiceMember) => {
+    const name = member.name
+
+    if (member.type === MemberType.folder) {
+      await createFolder(path.join(destinationPath, name)).catch((err) =>
+        Promise.reject({ error: err, failedToCreate: name })
+      )
+
+      await createFileTree(member.members, [...parentFolders, name]).catch(
+        (err) => Promise.reject({ error: err, failedToCreate: name })
+      )
+    } else {
+      await createFile(path.join(destinationPath, name), member.code).catch(
+        (err) => Promise.reject({ error: err, failedToCreate: name })
+      )
+    }
+  })
+
+  return Promise.resolve()
+}
+
+export const getTreeExample = () => ({
+  members: [
+    {
+      name: 'jobs',
+      type: 'folder',
+      members: [
+        {
+          name: 'extract',
+          type: 'folder',
+          members: [
+            {
+              name: 'makedata1',
+              type: 'service',
+              code: '%put Hello World!;'
+            }
+          ]
+        }
+      ]
+    }
+  ]
+})
--- a/api/src/controllers/index.ts
+++ b/api/src/controllers/index.ts
@@ -0,0 +1,6 @@
+export * from './deploy'
+export * from './sasjsExecutor'
+export * from './sasjsDrive'
+export * from './Session'
+export * from './Execution'
+export * from './FileUploadController'
--- a/api/src/controllers/sasjsDrive.ts
+++ b/api/src/controllers/sasjsDrive.ts
@@ -0,0 +1,15 @@
+import { fileExists, readFile, createFile } from '@sasjs/utils'
+
+export class SASjsDriveController {
+  async readFile(filePath: string) {
+    if (await fileExists(filePath)) {
+      return await readFile(filePath)
+    }
+  }
+
+  async updateFile(filePath: string, fileContent: string) {
+    if (await fileExists(filePath)) {
+      return await createFile(filePath, fileContent)
+    }
+  }
+}
--- a/api/src/controllers/sasjsExecutor.ts
+++ b/api/src/controllers/sasjsExecutor.ts
@@ -0,0 +1,40 @@
+import fs from 'fs'
+import { TreeNode } from '../types'
+import { getTmpFilesFolderPath } from '../utils'
+
+export const sasjsExecutor = () => {
+  const root: TreeNode = {
+    name: 'files',
+    relativePath: '',
+    absolutePath: getTmpFilesFolderPath(),
+    children: []
+  }
+
+  const stack = [root]
+
+  while (stack.length) {
+    const currentNode = stack.pop()
+
+    if (currentNode) {
+      const children = fs.readdirSync(currentNode.absolutePath)
+
+      for (let child of children) {
+        const absoluteChildPath = `${currentNode.absolutePath}/${child}`
+        const relativeChildPath = `${currentNode.relativePath}/${child}`
+        const childNode: TreeNode = {
+          name: child,
+          relativePath: relativeChildPath,
+          absolutePath: absoluteChildPath,
+          children: []
+        }
+        currentNode.children.push(childNode)
+
+        if (fs.statSync(childNode.absolutePath).isDirectory()) {
+          stack.push(childNode)
+        }
+      }
+    }
+  }
+
+  return root
+}