263 lines
8.2 KiB
TypeScript
263 lines
8.2 KiB
TypeScript
import Logger from '@dzeio/logger'
|
|
import { objectMap, objectOmit } from '@dzeio/object-util'
|
|
import URLManager from '@dzeio/url-manager'
|
|
import type { APIRoute } from 'astro'
|
|
import { evaluate } from 'mathjs'
|
|
import { spawn } from 'node:child_process'
|
|
import fs from 'node:fs/promises'
|
|
import os from 'node:os'
|
|
import path from 'node:path'
|
|
import StatusCode from '../../../../libs/HTTP/StatusCode'
|
|
import { buildRFC7807 } from '../../../../libs/RFCs/RFC7807'
|
|
import { getParams } from '../../../../libs/gcodeUtils'
|
|
import DaoFactory from '../../../../models/DaoFactory'
|
|
|
|
interface SliceError {
|
|
code: number
|
|
output: Array<string>
|
|
}
|
|
|
|
let tmpDir: string
|
|
|
|
/**
|
|
* body is the stl
|
|
* query
|
|
* price: algorithm from settings
|
|
* adionnal settings from https://manual.slic3r.org/advanced/command-line
|
|
*/
|
|
export const post: APIRoute = async ({ params, request, locals }) => {
|
|
if (!tmpDir) {
|
|
tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'saas-'))
|
|
}
|
|
|
|
const configId = params.configId ?? 'undefined'
|
|
const config = await DaoFactory.get('config').get(configId)
|
|
|
|
if (!config) {
|
|
return buildRFC7807({
|
|
type: '/docs/errors/missing-config',
|
|
status: StatusCode.NOT_FOUND,
|
|
title: 'The configuration does not exists',
|
|
details: `The configuration ${configId} does not exists`
|
|
})
|
|
}
|
|
|
|
const input = new Uint8Array(Buffer.from(await request.arrayBuffer()))
|
|
|
|
if (input.length <= 0) {
|
|
return buildRFC7807({
|
|
type: '/docs/errors/missing-input-file',
|
|
status: StatusCode.BAD_REQUEST,
|
|
title: 'You are missing the STL file',
|
|
details: `To process a file you need to input the file binary datas as the only body in your request`
|
|
})
|
|
}
|
|
|
|
const query = new URLManager(request.url).query()
|
|
|
|
const processId = (Math.random() * 1000000).toFixed(0)
|
|
const logger = new Logger(`process-${processId}`)
|
|
const processFolder = `${tmpDir}/${processId}`
|
|
const pouet = await fs.mkdir(processFolder, { recursive: true })
|
|
|
|
logger.log('poeut', pouet)
|
|
|
|
logger.log('started processing request')
|
|
|
|
logger.log('writing configs to dir')
|
|
for (const file of config.files) {
|
|
await fs.writeFile(`${processFolder}/${file.name}`, file.data)
|
|
}
|
|
|
|
|
|
const overrides = objectOmit(query, 'algo')
|
|
|
|
const stlPath = `${processFolder}/input.stl`
|
|
const gcodePath = `${processFolder}/output.gcode`
|
|
|
|
logger.log('writing STL to filesystem')
|
|
// write input
|
|
await fs.writeFile(stlPath, input, {
|
|
encoding: null
|
|
})
|
|
|
|
// additionnal parameters
|
|
let additionnalParams = objectMap(overrides, (value, key) => `--${(key as string).replace(/_/g, '-')} ${value}`).join(' ')
|
|
|
|
|
|
let slicerPath: string
|
|
let slicerCommand: string
|
|
|
|
if (config.type === 'prusa' || true) {
|
|
slicerPath = import.meta.env.PRUSASLICER_PATH ?? 'prusa-slicer'
|
|
additionnalParams += ' --export-gcode --loglevel 4'
|
|
slicerCommand = `${path.normalize(stlPath)} --load ${path.normalize(`${processFolder}/config.ini`)} --output ${path.normalize(gcodePath)} ${additionnalParams}`
|
|
}
|
|
|
|
|
|
// TODO: check if it does work on a linux environment
|
|
// TODO: Externalise IO for the different slicers
|
|
try {
|
|
logger.log('Running', slicerPath, slicerCommand)
|
|
await new Promise<void>((res, rej) => {
|
|
const logs: Array<string> = []
|
|
const slicer = spawn(`"${slicerPath}"`, slicerCommand.split(' '), {
|
|
shell: true
|
|
})
|
|
const log = (data: Buffer) => {
|
|
const line = `${data.toString('utf-8')}`
|
|
logger.log(line)
|
|
logs.push(line)
|
|
}
|
|
slicer.stdout.on('data', log)
|
|
slicer.stderr.on('data', log)
|
|
|
|
slicer.on('spawn', () => {
|
|
logs.push('Process spawned')
|
|
logger.log('Process spawned')
|
|
})
|
|
|
|
slicer.on('error', (err) => {
|
|
logs.push('Process error')
|
|
logger.log('Process error')
|
|
logger.log('error', err)
|
|
logs.push(err.toString())
|
|
rej(err)
|
|
})
|
|
|
|
slicer.on('close', (code, signal) => {
|
|
logs.push('Process closed')
|
|
logger.log('Process closed')
|
|
logs.push(`with code ${code}`)
|
|
logger.log(`with code ${code}`)
|
|
logs.push(`and signal ${signal}`)
|
|
logger.log(`and signal ${signal}`)
|
|
if (typeof code === 'number' && code !== 0) {
|
|
rej({
|
|
code: code,
|
|
output: logs
|
|
} as SliceError)
|
|
return
|
|
}
|
|
res()
|
|
})
|
|
})
|
|
} catch (e: any) {
|
|
const err = e as SliceError
|
|
logger.log('request finished in error :(', processId)
|
|
const line = err.toString()
|
|
logger.error('error', err, typeof err)
|
|
if (err.code === 3221226505 || line.includes('Objects could not fit on the bed')) {
|
|
await fs.rm(stlPath)
|
|
return buildRFC7807({
|
|
type: '/docs/errors/object-too-large',
|
|
status: StatusCode.PAYLOAD_TOO_LARGE,
|
|
title: 'Object is too large',
|
|
details: 'The STL you are trying to compile is too large for the configuration you chose'
|
|
}, locals.responseBuilder)
|
|
} else if (line.includes('No such file')) {
|
|
await fs.rm(stlPath)
|
|
return buildRFC7807({
|
|
type: '/docs/errors/missing-config-file',
|
|
status: StatusCode.NOT_FOUND,
|
|
title: 'Configuration file is missing',
|
|
details: `the configuration file "${configId}" is not available on the remote server`
|
|
}, locals.responseBuilder)
|
|
} else if (line.includes('Unknown option')) {
|
|
await fs.rm(stlPath)
|
|
return buildRFC7807({
|
|
type: '/docs/errors/slicer-option-unknown',
|
|
status: 400,
|
|
title: ' config override doew not exists',
|
|
details: 'an override does not exists, please contact an administrator or refer to the documentation'
|
|
}, locals.responseBuilder)
|
|
} else if (
|
|
line.includes('is not recognized as an internal or external command') ||
|
|
line.includes('.dll was not loaded')
|
|
) {
|
|
await fs.rm(stlPath)
|
|
return buildRFC7807({
|
|
type: '/docs/errors/slicer-not-found',
|
|
status: StatusCode.SERVICE_UNAVAILABLE,
|
|
title: 'the slicer used to process this file has not been found',
|
|
details: 'the server has a misconfiguration meaning that we can\'t process the request, please contact an administrator',
|
|
additionnalInfo: line.includes('dll') ? 'Missing DLL' : 'Slicer not found '
|
|
}, locals.responseBuilder)
|
|
} else if (line.includes('ETIMEDOUT')) {
|
|
await fs.rm(stlPath)
|
|
return buildRFC7807({
|
|
type: '/docs/errors/timed-out-slicing',
|
|
status: StatusCode.PAYLOAD_TOO_LARGE,
|
|
title: 'Timed out slicing file',
|
|
detail: `The file you are trying to process takes too long to be processed`,
|
|
processingTimeoutMillis: 60000
|
|
}, locals.responseBuilder)
|
|
}
|
|
return buildRFC7807({
|
|
type: '/docs/errors/general-input-output-error',
|
|
status: StatusCode.INTERNAL_SERVER_ERROR,
|
|
title: 'General I/O error',
|
|
details: 'A server error make it impossible to slice the file, please contact an administrator with the json error',
|
|
fileId: processId,
|
|
config: configId,
|
|
// fileSize: req.body.length,
|
|
overrides: overrides,
|
|
serverMessage:
|
|
err.output.map((line) => line.replace(new RegExp(stlPath), `***FILE***`).replace(new RegExp(processFolder), ''))
|
|
}, locals.responseBuilder)
|
|
}
|
|
const gcode = await fs.readFile(gcodePath, 'utf-8')
|
|
await fs.rm(processFolder, { recursive: true, force: true })
|
|
logger.log('Getting parameters')
|
|
const gcodeParams = getParams(gcode)
|
|
let price: string | undefined
|
|
if (query?.algo) {
|
|
let algo = decodeURI(query.algo as string)
|
|
// objectLoop(params, (value, key) => {
|
|
// if (typeof value !== 'number') {
|
|
// return
|
|
// }
|
|
// while (algo.includes(key)) {
|
|
// algo = algo.replace(key, value.toString())
|
|
// }
|
|
// })
|
|
try {
|
|
logger.log('Evaluating Alogrithm')
|
|
const tmp = evaluate(algo, gcodeParams)
|
|
if (typeof tmp === 'number') {
|
|
price = tmp.toFixed(2)
|
|
} else {
|
|
return buildRFC7807({
|
|
type: '/docs/errors/algorithm-error',
|
|
status: 500,
|
|
title: 'Algorithm compilation error',
|
|
details: 'It seems the algorithm resolution failed',
|
|
algorithm: algo,
|
|
algorithmError: 'Algorithm return a Unit',
|
|
parameters: gcodeParams
|
|
}, locals.responseBuilder)
|
|
}
|
|
} catch (e) {
|
|
logger.dir(e)
|
|
return buildRFC7807({
|
|
type: '/docs/errors/algorithm-error',
|
|
status: 500,
|
|
title: 'Algorithm compilation error',
|
|
details: 'It seems the algorithm resolution failed',
|
|
algorithm: algo,
|
|
algorithmError: e,
|
|
parameters: gcodeParams
|
|
}, locals.responseBuilder)
|
|
}
|
|
}
|
|
logger.log('request successfull :)')
|
|
return locals.responseBuilder
|
|
.body({
|
|
price: price ? parseFloat(price) : undefined,
|
|
...getParams(gcode),
|
|
gcode
|
|
})
|
|
.status(200)
|
|
.build()
|
|
}
|