289 lines
8.0 KiB
TypeScript
Executable File
289 lines
8.0 KiB
TypeScript
Executable File
#!/usr/bin/env -S /root/.deno/bin/deno run --allow-env --allow-read --allow-sys --allow-run --allow-write
|
|
|
|
import { printf } from "https://deno.land/std@0.170.0/fmt/printf.ts";
|
|
import {brightGreen, brightMagenta} from "https://deno.land/std@0.170.0/fmt/colors.ts";
|
|
import { Command } from "https://deno.land/x/cliffy@v0.25.2/command/mod.ts";
|
|
import { getLogger } from "https://deno.land/std@0.170.0/log/mod.ts";
|
|
|
|
|
|
class CommandError extends Error{}
|
|
class ArgError extends CommandError {}
|
|
class NginxError extends CommandError {}
|
|
|
|
interface DeployedService{
|
|
name: string,
|
|
port?: number,
|
|
unixSocketPath?: string,
|
|
}
|
|
|
|
async function saveService(services: DeployedService[]){
|
|
const content = JSON.stringify(services);
|
|
await Deno.writeTextFile("services.json", content);
|
|
}
|
|
async function loadService(): Promise<DeployedService[]> {
|
|
try {
|
|
const content = await Deno.readTextFile("services.json");
|
|
return JSON.parse(content);
|
|
} catch (error) {
|
|
if(error instanceof Deno.errors.NotFound){
|
|
return [];
|
|
}
|
|
else{
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
interface NginxConfigOption {
|
|
name: string,
|
|
|
|
/**
|
|
* port number
|
|
*/
|
|
port?: number,
|
|
|
|
/**
|
|
* unix socket path
|
|
*/
|
|
unixSocket?: string,
|
|
|
|
/**
|
|
* megabyte unit
|
|
*/
|
|
clientMaxBodySize?: number,
|
|
/**
|
|
* proxy pass
|
|
* @default "127.0.0.1"
|
|
*/
|
|
proxyPass?: string,
|
|
/**
|
|
* socket IO support
|
|
* @default true
|
|
*/
|
|
socketIO?: boolean,
|
|
}
|
|
|
|
function createNginxConfigContent({ port, unixSocket, name, clientMaxBodySize, proxyPass, socketIO }: NginxConfigOption) {
|
|
clientMaxBodySize ??= 20;
|
|
proxyPass ??= "127.0.0.1";
|
|
socketIO ??= true;
|
|
if (!port && !unixSocket) {
|
|
throw new ArgError("Both port and unixSocket cannot be false.");
|
|
}
|
|
if ((!!port) && (!!unixSocket)){
|
|
throw new ArgError("Both port and unixSocket cannot be true.");
|
|
}
|
|
if (!!port && (isNaN(port) || !isFinite(port) )){
|
|
throw new ArgError("Port must be number.");
|
|
}
|
|
if (!!port && (port > 65535 || port < 0)){
|
|
throw new ArgError("Port cannnot be less than 0 or greater than 65535")
|
|
}
|
|
if (!!unixSocket && !unixSocket.startsWith("/")){
|
|
throw new ArgError("unix socket path must be absolute path.")
|
|
}
|
|
const content = `# it created by deploy script.
|
|
server {
|
|
server_name ${name}.prelude.duckdns.org;
|
|
|
|
location /{
|
|
proxy_set_header Host $host;
|
|
proxy_set_header X-Real-IP $remote_addr;
|
|
proxy_set_header X-Scheme $scheme;
|
|
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
|
proxy_set_header X-Forwarded-Proto $scheme;
|
|
proxy_set_header X-NginX-Proxy true;
|
|
proxy_pass ${
|
|
port ? `http://${proxyPass}:${port}` : `http://unix:${unixSocket}/`
|
|
};
|
|
proxy_redirect off;
|
|
|
|
# client body size
|
|
client_max_body_size ${clientMaxBodySize}M;
|
|
|
|
${ socketIO ?
|
|
`# Socket.IO Support
|
|
proxy_http_version 1.1;
|
|
proxy_set_header Upgrade $http_upgrade;
|
|
proxy_set_header Connection "upgrade";` : ""
|
|
}
|
|
}
|
|
|
|
listen 80;
|
|
}`;
|
|
return content;
|
|
}
|
|
|
|
function isRunAsRoot() {
|
|
return Deno.uid() == 0;
|
|
}
|
|
|
|
async function NginxCheck() {
|
|
const c = new Deno.Command("nginx",{
|
|
args: ["-t"],
|
|
});
|
|
const status = await c.output();
|
|
return status.success && status.code == 0;
|
|
}
|
|
|
|
async function NginxReload() {
|
|
const c = new Deno.Command("nginx",{
|
|
args: ["-s", "reload"],
|
|
});
|
|
const status = await c.output();
|
|
return status.success && status.code == 0;
|
|
}
|
|
|
|
interface DeployCommandOption{
|
|
port?: number;
|
|
proxy?: string;
|
|
disableSocket?: boolean;
|
|
clientMaxBodySize?: number;
|
|
unixSocket?: string;
|
|
}
|
|
|
|
function checkDomainName(name: string){
|
|
return /^[a-z0-9][a-z0-9_-]{0,61}[a-z0-9]?$/i.test(name);
|
|
}
|
|
|
|
async function deployCommand(deployName: string,
|
|
options?: DeployCommandOption): Promise<void>{
|
|
options ??= {}
|
|
|
|
if(!checkDomainName(deployName)){
|
|
throw new ArgError("name invalid")
|
|
}
|
|
|
|
if(!isRunAsRoot()){
|
|
getLogger().warning("It's not executed as root")
|
|
}
|
|
|
|
const services = await loadService();
|
|
const dir = [...Deno.readDirSync("/etc/nginx/sites-available")]
|
|
|
|
if (dir.map(x => x.name).includes(deployName)) {
|
|
throw new ArgError("duplicated name: please use other name.")
|
|
}
|
|
|
|
const proxyPass = options.proxy;
|
|
const socketIO = !options.disableSocket;
|
|
const content = createNginxConfigContent({
|
|
port: options.port,
|
|
name: deployName,
|
|
unixSocket: options.unixSocket,
|
|
proxyPass: proxyPass,
|
|
socketIO: socketIO,
|
|
clientMaxBodySize: options.clientMaxBodySize
|
|
});
|
|
await Deno.writeTextFile("/etc/nginx/sites-available/"+deployName,content);
|
|
await Deno.symlink("/etc/nginx/sites-available/"+deployName,"/etc/nginx/sites-enabled/"+deployName);
|
|
|
|
if(services.map(x=>x.name).includes(deployName)){
|
|
const target = services.find(x=>x.name == deployName);
|
|
if(target){
|
|
target.port = options.port;
|
|
target.unixSocketPath = options.unixSocket;
|
|
}
|
|
}
|
|
else {
|
|
services.push({
|
|
name: deployName,
|
|
port: options.port,
|
|
unixSocketPath: options.unixSocket,
|
|
});
|
|
}
|
|
await saveService(services);
|
|
|
|
if(!await NginxCheck()){
|
|
throw new NginxError("nginx config grammar failed");
|
|
}
|
|
|
|
if(!await NginxReload()){
|
|
throw new NginxError("nginx reload failed");
|
|
}
|
|
}
|
|
|
|
|
|
if (import.meta.main) {
|
|
const cmd = new Command()
|
|
.name("deployNginx")
|
|
.version("1.0.2")
|
|
.description("CLI")
|
|
.action(()=>{
|
|
console.log("sub command required");
|
|
})
|
|
.command("deploy", "deploy app")
|
|
.option("-p, --port <port:number>","port for app")
|
|
.option("--unixSocket <unixSocket:string>","unix socket path")
|
|
.option("--disableSocket","disable socket io")
|
|
.option("--clientMaxBodySize <clientMaxBodySize:number>","client max body size: MB Unit",{
|
|
default: 20
|
|
})
|
|
.option("--proxy <proxy:string>","proxy pass for app. you can bind unix socket like \"unix:<your unix socket path>\"")
|
|
.arguments("<value:string>")
|
|
.action(async (options, name)=>{
|
|
try {
|
|
await deployCommand(name,{
|
|
port: options.port,
|
|
unixSocket: options.unixSocket,
|
|
clientMaxBodySize: options.clientMaxBodySize,
|
|
disableSocket: options.disableSocket,
|
|
proxy: options.proxy
|
|
});
|
|
}
|
|
catch(e){
|
|
if (e instanceof Error){
|
|
console.log(e.message);
|
|
}
|
|
}
|
|
})
|
|
.command("undeploy","undeploy app")
|
|
.arguments("<value:string>")
|
|
.action(async (_,name)=>{
|
|
const services = await loadService();
|
|
const i = services.findIndex(x=>x.name == name);
|
|
if(i < 0){
|
|
console.log("not deployed");
|
|
Deno.exit(1);
|
|
}
|
|
services.splice(i,1);
|
|
|
|
await Deno.remove("/etc/nginx/sites-enabled/"+name);
|
|
await Deno.remove("/etc/nginx/sites-available/"+name);
|
|
|
|
await saveService(services);
|
|
if(!await NginxReload()){
|
|
console.log("error! nginx reload failed");
|
|
Deno.exit(1);
|
|
}
|
|
console.log(`success to unload ${name}`);
|
|
})
|
|
.command("list","list deployed service")
|
|
.action(async ()=>{
|
|
const services = await loadService();
|
|
if(!Deno.stdout.isTerminal()){
|
|
for (const service of services) {
|
|
printf("%s %s\n",service.name, (service.port ?? service.unixSocketPath ?? "ERROR").toString());
|
|
}
|
|
}
|
|
else {
|
|
const maxServiceNameLength = services.map(x=>x.name.length).reduce((x,y)=>Math.max(x,y), 0);
|
|
const maxPadLength = Math.max(6,maxServiceNameLength);
|
|
const maxServiceOrNumberLength = services.map(x=> Math.max((x.port ?? 0).toString().length, x.unixSocketPath?.length ?? 0)).reduce((x,y)=>Math.max(x,y), 0);
|
|
const maxPad2Length = Math.max("PORT OR SOCKET PATH".length, maxServiceOrNumberLength);
|
|
const prettyPrint = (name: string, port: string) => {
|
|
printf("%s %s\n",brightGreen(name.padEnd(maxPadLength, " ")),
|
|
brightMagenta(port.padEnd(maxPad2Length)
|
|
));
|
|
}
|
|
|
|
prettyPrint("NAME","PORT OR SOCKET PATH");
|
|
for (const service of services) {
|
|
prettyPrint(service.name,(service.port ?? service.unixSocketPath ?? "ERROR").toString());
|
|
}
|
|
}
|
|
});
|
|
|
|
await cmd.parse(Deno.args);
|
|
}
|