You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
384 lines
9.6 KiB
384 lines
9.6 KiB
#!/usr/bin/env node
|
|
|
|
// Packages
|
|
const chalk = require('chalk')
|
|
const isURL = require('is-url')
|
|
const minimist = require('minimist')
|
|
const ms = require('ms')
|
|
const printf = require('printf')
|
|
require('epipebomb')()
|
|
const supportsColor = require('supports-color')
|
|
|
|
// Ours
|
|
const cfg = require('../lib/cfg')
|
|
const { handleError, error } = require('../lib/error')
|
|
const NowScale = require('../lib/scale')
|
|
const login = require('../lib/login')
|
|
const exit = require('../lib/utils/exit')
|
|
const logo = require('../lib/utils/output/logo')
|
|
const info = require('../lib/scale-info')
|
|
const sort = require('../lib/sort-deployments')
|
|
const success = require('../lib/utils/output/success')
|
|
|
|
const argv = minimist(process.argv.slice(2), {
|
|
string: ['config', 'token'],
|
|
boolean: ['help', 'debug'],
|
|
alias: { help: 'h', config: 'c', debug: 'd', token: 't' }
|
|
})
|
|
|
|
let id = argv._[0]
|
|
const scaleArg = argv._[1]
|
|
const optionalScaleArg = argv._[2]
|
|
|
|
// Options
|
|
const help = () => {
|
|
console.log(`
|
|
${chalk.bold(`${logo} now scale`)} ls
|
|
${chalk.bold(`${logo} now scale`)} <url>
|
|
${chalk.bold(`${logo} now scale`)} <url> <min> [max]
|
|
|
|
${chalk.dim('Options:')}
|
|
|
|
-h, --help Output usage information
|
|
-c ${chalk.bold.underline('FILE')}, --config=${chalk.bold.underline(
|
|
'FILE'
|
|
)} Config file
|
|
-d, --debug Debug mode [off]
|
|
|
|
${chalk.dim('Examples:')}
|
|
|
|
${chalk.gray('–')} Create a deployment with 3 instances, never sleeps:
|
|
|
|
${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh 3')}
|
|
|
|
${chalk.gray('–')} Create an automatically scaling deployment:
|
|
|
|
${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh 1 5')}
|
|
|
|
${chalk.gray(
|
|
'–'
|
|
)} Create an automatically scaling deployment without specifying max:
|
|
|
|
${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh 1 auto')}
|
|
|
|
${chalk.gray(
|
|
'–'
|
|
)} Create an automatically scaling deployment without specifying min or max:
|
|
|
|
${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh auto')}
|
|
|
|
${chalk.gray(
|
|
'–'
|
|
)} Create a deployment that is always active and never "sleeps":
|
|
|
|
${chalk.cyan('$ now scale my-deployment-ntahoeato.now.sh 1')}
|
|
`)
|
|
}
|
|
|
|
// Options
|
|
const debug = argv.debug
|
|
const apiUrl = argv.url || 'https://api.zeit.co'
|
|
|
|
if (argv.config) {
|
|
cfg.setConfigFile(argv.config)
|
|
}
|
|
|
|
if (argv.help) {
|
|
help()
|
|
exit(0)
|
|
} else {
|
|
Promise.resolve()
|
|
.then(async () => {
|
|
const config = await cfg.read({ token: argv.token })
|
|
|
|
let token
|
|
try {
|
|
token = config.token || (await login(apiUrl))
|
|
} catch (err) {
|
|
error(`Authentication error – ${err.message}`)
|
|
exit(1)
|
|
}
|
|
|
|
try {
|
|
await run({ token, config })
|
|
} catch (err) {
|
|
if (err.userError) {
|
|
error(err.message)
|
|
} else {
|
|
error(`Unknown error: ${err}\n${err.stack}`)
|
|
}
|
|
exit(1)
|
|
}
|
|
})
|
|
.catch(err => {
|
|
handleError(err)
|
|
process.exit(1)
|
|
})
|
|
}
|
|
|
|
function guessParams() {
|
|
if (Number.isInteger(scaleArg) && !optionalScaleArg) {
|
|
return { min: scaleArg, max: scaleArg }
|
|
} else if (Number.isInteger(scaleArg) && Number.isInteger(optionalScaleArg)) {
|
|
return { min: scaleArg, max: optionalScaleArg }
|
|
} else if (Number.isInteger(scaleArg) && optionalScaleArg === 'auto') {
|
|
return { min: scaleArg, max: 'auto' }
|
|
} else if (
|
|
(!scaleArg && !optionalScaleArg) ||
|
|
(scaleArg === 'auto' && !optionalScaleArg)
|
|
) {
|
|
return { min: 1, max: 'auto' }
|
|
}
|
|
help()
|
|
process.exit(1)
|
|
}
|
|
|
|
function isHostNameOrId(str) {
|
|
return (
|
|
/(https?:\/\/)?((?:(?=[a-z0-9-]{1,63}\.)(?:xn--)?[a-z0-9]+(?:-[a-z0-9]+)*\.)+[a-z]{2,63})/.test(
|
|
str
|
|
) || str.length === 28
|
|
)
|
|
}
|
|
|
|
async function run({ token, config: { currentTeam } }) {
|
|
const scale = new NowScale({ apiUrl, token, debug, currentTeam })
|
|
const start = Date.now()
|
|
|
|
if (id === 'ls') {
|
|
await list(scale)
|
|
process.exit(0)
|
|
} else if (id === 'info') {
|
|
await info(scale)
|
|
process.exit(0)
|
|
} else if (id && isHostNameOrId(id)) {
|
|
// Normalize URL by removing slash from the end
|
|
if (isURL(id)) {
|
|
id = id.replace(/^https:\/\//i, '')
|
|
if (id.slice(-1) === '/') {
|
|
id = id.slice(0, -1)
|
|
}
|
|
}
|
|
} else {
|
|
error('Please specify a deployment: now scale <id|url>')
|
|
help()
|
|
exit(1)
|
|
}
|
|
|
|
const deployments = await scale.list()
|
|
|
|
let match = deployments.find(d => {
|
|
// `url` should match the hostname of the deployment
|
|
let u = id.replace(/^https:\/\//i, '')
|
|
|
|
if (u.indexOf('.') === -1) {
|
|
// `.now.sh` domain is implied if just the subdomain is given
|
|
u += '.now.sh'
|
|
}
|
|
return d.uid === id || d.name === id || d.url === u
|
|
})
|
|
|
|
if (!match) {
|
|
// Maybe it's an alias
|
|
const aliasDeployment = (await scale.listAliases()).find(
|
|
e => e.alias === id
|
|
)
|
|
if (!aliasDeployment) {
|
|
error(`Could not find any deployments matching ${id}`)
|
|
return process.exit(1)
|
|
}
|
|
match = deployments.find(d => {
|
|
return d.uid === aliasDeployment.deploymentId
|
|
})
|
|
}
|
|
|
|
const { min, max } = guessParams()
|
|
|
|
if (
|
|
!(Number.isInteger(min) || min === 'auto') &&
|
|
!(Number.isInteger(max) || max === 'auto')
|
|
) {
|
|
help()
|
|
return exit(1)
|
|
}
|
|
|
|
if (match.type === 'STATIC') {
|
|
if (min === 0 && max === 0) {
|
|
error("Static deployments can't be FROZEN. Use `now rm` to remove")
|
|
return process.exit(1)
|
|
}
|
|
console.log('> Static deployments are automatically scaled!')
|
|
return process.exit(0)
|
|
}
|
|
|
|
const {
|
|
max: currentMax,
|
|
min: currentMin,
|
|
current: currentCurrent
|
|
} = match.scale
|
|
if (
|
|
max === currentMax &&
|
|
min === currentMin &&
|
|
Number.isInteger(min) &&
|
|
currentCurrent >= min &&
|
|
Number.isInteger(max) &&
|
|
currentCurrent <= max
|
|
) {
|
|
// Nothing to do, let's print the rules
|
|
printScaleingRules(match.url, currentCurrent, min, max)
|
|
return
|
|
}
|
|
|
|
if ((match.state === 'FROZEN' || match.scale.current === 0) && min > 0) {
|
|
console.log(
|
|
`> Deployment is currently in 0 replicas, preparing deployment for scaling...`
|
|
)
|
|
if (match.scale.max < 1) {
|
|
await scale.setScale(match.uid, { min: 0, max: 1 })
|
|
}
|
|
await scale.unfreeze(match)
|
|
}
|
|
|
|
const { min: newMin, max: newMax } = await scale.setScale(match.uid, {
|
|
min,
|
|
max
|
|
})
|
|
|
|
const elapsed = ms(new Date() - start)
|
|
|
|
const currentReplicas = match.scale.current
|
|
printScaleingRules(match.url, currentReplicas, newMin, newMax, elapsed)
|
|
await info(scale, match.url)
|
|
|
|
scale.close()
|
|
}
|
|
function printScaleingRules(url, currentReplicas, min, max, elapsed) {
|
|
const log = console.log
|
|
success(
|
|
`Configured scaling rules ${chalk.gray(elapsed ? '[' + elapsed + ']' : '')}`
|
|
)
|
|
log()
|
|
log(
|
|
`${chalk.bold(url)} (${chalk.gray(currentReplicas)} ${chalk.gray(
|
|
'current'
|
|
)})`
|
|
)
|
|
log(printf('%6s %s', 'min', chalk.bold(min)))
|
|
log(printf('%6s %s', 'max', chalk.bold(max)))
|
|
log(printf('%6s %s', 'auto', chalk.bold(min === max ? '✖' : '✔')))
|
|
log()
|
|
}
|
|
|
|
async function list(scale) {
|
|
let deployments
|
|
try {
|
|
const app = argv._[1]
|
|
deployments = await scale.list(app)
|
|
} catch (err) {
|
|
handleError(err)
|
|
process.exit(1)
|
|
}
|
|
|
|
scale.close()
|
|
|
|
const apps = new Map()
|
|
|
|
for (const dep of deployments) {
|
|
const deps = apps.get(dep.name) || []
|
|
apps.set(dep.name, deps.concat(dep))
|
|
}
|
|
|
|
const sorted = await sort([...apps])
|
|
|
|
const timeNow = new Date()
|
|
const urlLength =
|
|
deployments.reduce((acc, i) => {
|
|
return Math.max(acc, (i.url && i.url.length) || 0)
|
|
}, 0) + 5
|
|
|
|
for (const app of sorted) {
|
|
const depls = argv.all ? app[1] : app[1].slice(0, 5)
|
|
console.log(
|
|
`${chalk.bold(app[0])} ${chalk.gray(
|
|
'(' + depls.length + ' of ' + app[1].length + ' total)'
|
|
)}`
|
|
)
|
|
console.log()
|
|
const urlSpec = `%-${urlLength}s`
|
|
console.log(
|
|
printf(
|
|
` ${chalk.grey(urlSpec + ' %8s %8s %8s %8s %8s')}`,
|
|
'url',
|
|
'cur',
|
|
'min',
|
|
'max',
|
|
'auto',
|
|
'age'
|
|
)
|
|
)
|
|
for (const instance of depls) {
|
|
if (!instance.scale) {
|
|
let spec
|
|
if (supportsColor) {
|
|
spec = ` %-${urlLength + 10}s %8s %8s %8s %8s %8s`
|
|
} else {
|
|
spec = ` %-${urlLength + 1}s %8s %8s %8s %8s %8s`
|
|
}
|
|
const infinite = '∞'
|
|
console.log(
|
|
printf(
|
|
spec,
|
|
chalk.underline(instance.url),
|
|
infinite,
|
|
1,
|
|
infinite,
|
|
'✔',
|
|
ms(timeNow - instance.created)
|
|
)
|
|
)
|
|
} else if (instance.scale.current > 0) {
|
|
let spec
|
|
if (supportsColor) {
|
|
spec = ` %-${urlLength + 10}s %8s %8s %8s %8s %8s`
|
|
} else {
|
|
spec = ` %-${urlLength + 1}s %8s %8s %8s %8s %8s`
|
|
}
|
|
console.log(
|
|
printf(
|
|
spec,
|
|
chalk.underline(instance.url),
|
|
instance.scale.current,
|
|
instance.scale.min,
|
|
instance.scale.max,
|
|
instance.scale.max === instance.scale.min ? '✖' : '✔',
|
|
ms(timeNow - instance.created)
|
|
)
|
|
)
|
|
} else {
|
|
let spec
|
|
if (supportsColor) {
|
|
spec = ` %-${urlLength + 10}s ${chalk.gray('%8s %8s %8s %8s %8s')}`
|
|
} else {
|
|
spec = ` %-${urlLength + 1}s ${chalk.gray('%8s %8s %8s %8s %8s')}`
|
|
}
|
|
console.log(
|
|
printf(
|
|
spec,
|
|
chalk.underline(instance.url),
|
|
instance.scale.current,
|
|
instance.scale.min,
|
|
instance.scale.max,
|
|
instance.scale.max === instance.scale.min ? '✖' : '✔',
|
|
ms(timeNow - instance.created)
|
|
)
|
|
)
|
|
}
|
|
}
|
|
console.log()
|
|
}
|
|
}
|
|
|
|
process.on('uncaughtException', err => {
|
|
handleError(err)
|
|
exit(1)
|
|
})
|
|
|