126 lines
3.4 KiB
TypeScript
126 lines
3.4 KiB
TypeScript
import { lookpath } from "lookpath"
|
|
import fs from "fs"
|
|
import * as makeFiles from "./makeFiles"
|
|
import { logErrorToFile, downloadFile, error } from "../utils"
|
|
import yaml from "yaml"
|
|
import { DockerCompose } from "./types"
|
|
|
|
const ERROR_FILE = "docker-error.log"
|
|
const COMPOSE_URL =
|
|
"https://raw.githubusercontent.com/Budibase/budibase/master/hosting/docker-compose.yaml"
|
|
|
|
function composeFilename() {
|
|
return COMPOSE_URL.split("/").slice(-1)[0]
|
|
}
|
|
|
|
export function getServiceImage(service: string) {
|
|
const filename = composeFilename()
|
|
try {
|
|
const { services } = getServices(filename)
|
|
const serviceKey = Object.keys(services).find(name =>
|
|
name.includes(service)
|
|
)
|
|
if (serviceKey) {
|
|
return services[serviceKey].image
|
|
} else {
|
|
return null
|
|
}
|
|
} catch (err) {
|
|
return null
|
|
}
|
|
}
|
|
|
|
export function setServiceImage(service: string, image: string) {
|
|
const filename = composeFilename()
|
|
if (!fs.existsSync(filename)) {
|
|
throw new Error(
|
|
`File ${filename} not found, cannot update ${service} image.`
|
|
)
|
|
}
|
|
const current = getServiceImage(service)!
|
|
let contents = fs.readFileSync(filename, "utf8")
|
|
contents = contents.replace(`image: ${current}`, `image: ${image}`)
|
|
fs.writeFileSync(filename, contents)
|
|
}
|
|
|
|
export async function downloadDockerCompose() {
|
|
const filename = composeFilename()
|
|
try {
|
|
await downloadFile(COMPOSE_URL, `./${filename}`)
|
|
} catch (err) {
|
|
console.error(error(`Failed to retrieve compose file - ${err}`))
|
|
}
|
|
}
|
|
|
|
export async function checkDockerConfigured() {
|
|
const error =
|
|
"docker has not been installed, please follow instructions at: https://docs.budibase.com/docs/docker-compose"
|
|
const docker = await lookpath("docker")
|
|
if (!docker) {
|
|
throw error
|
|
}
|
|
}
|
|
|
|
export function checkInitComplete() {
|
|
if (
|
|
!fs.existsSync(makeFiles.ENV_PATH) &&
|
|
!fs.existsSync(makeFiles.COMPOSE_PATH)
|
|
) {
|
|
throw "Please run the hosting --init command before any other hosting command."
|
|
}
|
|
}
|
|
|
|
export async function handleError(func: Function) {
|
|
try {
|
|
await func()
|
|
} catch (err: any) {
|
|
if (err && err.err) {
|
|
logErrorToFile(ERROR_FILE, err.err)
|
|
}
|
|
throw `Failed to start - logs written to file: ${ERROR_FILE}`
|
|
}
|
|
}
|
|
|
|
export function getServices(path: string) {
|
|
if (!fs.existsSync(path)) {
|
|
throw new Error(`No yaml found at path: ${path}`)
|
|
}
|
|
const dockerYaml = fs.readFileSync(path, "utf8")
|
|
const parsedYaml = yaml.parse(dockerYaml)
|
|
return { yaml: parsedYaml, services: parsedYaml.services }
|
|
}
|
|
|
|
export function getAppService(path: string) {
|
|
const { yaml, services } = getServices(path),
|
|
serviceList = Object.keys(services)
|
|
let service
|
|
if (services["app-service"]) {
|
|
service = services["app-service"]
|
|
} else if (serviceList.length === 1) {
|
|
service = services[serviceList[0]]
|
|
}
|
|
return { yaml, service }
|
|
}
|
|
|
|
export function updateDockerComposeService(
|
|
updateFn: (service: DockerCompose) => void
|
|
) {
|
|
const opts = ["docker-compose.yaml", "docker-compose.yml"]
|
|
const dockerFilePath = opts.find(name => fs.existsSync(name))
|
|
if (!dockerFilePath) {
|
|
console.log(error("Unable to locate docker-compose YAML."))
|
|
return
|
|
}
|
|
const { yaml: parsedYaml, service } = getAppService(dockerFilePath)
|
|
if (!service) {
|
|
console.log(
|
|
error(
|
|
"Unable to locate service within compose file, is it a valid Budibase configuration?"
|
|
)
|
|
)
|
|
return
|
|
}
|
|
updateFn(service)
|
|
fs.writeFileSync(dockerFilePath, yaml.stringify(parsedYaml))
|
|
}
|