heroku 10.13.2 → 11.0.0-alpha.10

package/lib/oldCommands/ps/restart.js

@@ -0,0 +1,78 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import color from '@heroku-cli/color'
+import {Args, ux} from '@oclif/core'
+import {ProcessTypeCompletion} from '@heroku-cli/command/lib/completions'
+import heredoc from 'tsheredoc'
+export default class Restart extends Command {
+  static description = heredoc(`
+    restart an app dyno or process type
+    if neither --dyno nor --type are specified, restarts all dynos on app
+  `)
+
+  static topic = 'ps'
+  static aliases = ['dyno:restart']
+  static hiddenAliases = ['restart']
+
+  static examples = [
+    '$ heroku ps:restart --app myapp --dyno-name web.1',
+    '$ heroku ps:restart --app myapp --process-type web',
+    '$ heroku ps:restart --app myapp',
+  ]
+
+  static args = {
+    dyno: Args.string({description: 'name of the dyno to restart', required: false, deprecated: true}),
+  }
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    'dyno-name': flags.string({
+      char: 'd',
+      description: 'name of the dyno to restart',
+    }),
+    'process-type': flags.string({
+      char: 'p',
+      description: 'name of the process type to restart',
+      completion: ProcessTypeCompletion,
+      exclusive: ['dyno-name'],
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Restart)
+    const app = flags.app
+    const dyno = flags['dyno-name'] || args.dyno
+    const type = flags['process-type']
+    let msg = 'Restarting'
+    let restartUrl
+
+    if (type) {
+      msg += ` all ${color.cyan(type)} dynos`
+      restartUrl = `/apps/${app}/formations/${encodeURIComponent(type)}`
+    } else if (dyno) {
+      if (args.dyno) {
+        ux.warn(`DYNO is a deprecated argument. Use ${color.cmd('--dyno-name')} or ${color.cmd('--process-type')} instead.`)
+      }
+
+      msg += ` dyno ${color.cyan(dyno)}`
+      restartUrl = `/apps/${app}/dynos/${encodeURIComponent(dyno)}`
+    } else {
+      msg += ' all dynos'
+      restartUrl = `/apps/${app}/dynos`
+    }
+
+    msg += ` on ${color.app(app)}`
+
+    ux.action.start(msg)
+    await this.heroku.delete<Heroku.Dyno>(restartUrl, {
+      headers: {
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+      },
+    })
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/ps/scale.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/ps/scale.js

@@ -0,0 +1,95 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import * as Heroku from '@heroku-cli/schema'
+import {compact} from 'lodash'
+import heredoc from 'tsheredoc'
+
+const emptyFormationErr = (app: string) => {
+  return new Error(`No process types on ${color.magenta(app)}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`)
+}
+
+export default class Scale extends Command {
+  static strict = false
+  static description = heredoc`
+    scale dyno quantity up or down
+    Appending a size (eg. web=2:Standard-2X) allows simultaneous scaling and resizing.
+
+    Omitting any arguments will display the app's current dyno formation, in a
+    format suitable for passing back into ps:scale.
+  `
+  static examples = [heredoc`
+    $ heroku ps:scale web=3:Standard-2X worker+1 --app APP
+    Scaling dynos... done, now running web at 3:Standard-2X, worker at 1:Standard-1X.
+  `, heredoc`
+    $ heroku ps:scale --app APP
+    web=3:Standard-2X worker=1:Standard-1X
+  `]
+
+  static aliases = ['dyno:scale']
+  static hiddenAliases = ['scale']
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, ...restParse} = await this.parse(Scale)
+    const argv = restParse.argv as string[]
+    const {app} = flags
+
+    function parse(args: string[]) {
+      return compact(args.map(arg => {
+        const change = arg.match(/^([\w-]+)([=+-]\d+)(?::([\w-]+))?$/)
+        if (!change)
+          return
+        const quantity = change[2][0] === '=' ? change[2].slice(1) : change[2]
+        if (change[3])
+          change[3] = change[3].replace('Shield-', 'Private-')
+        return {type: change[1], quantity, size: change[3]}
+      }))
+    }
+
+    const changes = parse(argv)
+
+    if (changes.length === 0) {
+      const {body: formation} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
+      const {body: appProps} = await this.heroku.get<Heroku.App>(`/apps/${app}`)
+      const shielded = appProps.space && appProps.space.shield
+      if (shielded) {
+        formation.forEach(d => {
+          if (d.size !== undefined) {
+            d.size = d.size.replace('Private-', 'Shield-')
+          }
+        })
+      }
+
+      if (formation.length === 0) {
+        throw emptyFormationErr(app)
+      }
+
+      ux.log(formation.map(d => `${d.type}=${d.quantity}:${d.size}`)
+        .sort()
+        .join(' '))
+    } else {
+      ux.action.start('Scaling dynos')
+      const {body: appProps} = await this.heroku.get<Heroku.App>(`/apps/${app}`)
+      const {body: formation} = await this.heroku.patch<Heroku.Formation[]>(`/apps/${app}/formation`, {body: {updates: changes}})
+      const shielded = appProps.space && appProps.space.shield
+      if (shielded) {
+        formation.forEach(d => {
+          if (d.size !== undefined) {
+            d.size = d.size.replace('Private-', 'Shield-')
+          }
+        })
+      }
+
+      const output = formation.filter(f => changes.find(c => c.type === f.type))
+        .map(d => `${color.green(d.type || '')} at ${d.quantity}:${d.size}`)
+      ux.action.stop(`done, now running ${output.join(', ')}`)
+    }
+  }
+}
+*/

package/lib/oldCommands/ps/stop.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/ps/stop.js

@@ -0,0 +1,73 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import * as Heroku from '@heroku-cli/schema'
+import color from '@heroku-cli/color'
+import {Args, ux} from '@oclif/core'
+import {ProcessTypeCompletion} from '@heroku-cli/command/lib/completions'
+import heredoc from 'tsheredoc'
+
+export default class Stop extends Command {
+  static description = 'stop an app dyno or process type'
+  static topic = 'ps'
+  static aliases = ['dyno:stop', 'ps:kill', 'dyno:kill']
+  static hiddenAliases = ['stop', 'kill']
+
+  static examples = [
+    '$ heroku ps:stop --app myapp --dyno-name run.1828',
+    '$ heroku ps:stop --app myapp --process-type run',
+  ]
+
+  static args = {
+    dyno: Args.string({description: 'name of the dyno to stop', required: false, deprecated: true}),
+  }
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    'dyno-name': flags.string({
+      char: 'd',
+      description: 'name of the dyno to stop',
+    }),
+    'process-type': flags.string({
+      char: 'p',
+      description: 'name of the process type to stop',
+      completion: ProcessTypeCompletion,
+      exclusive: ['dyno-name'],
+    }),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Stop)
+
+    const app = flags.app
+    const dyno = flags['dyno-name'] || args.dyno
+    const type = flags['process-type']
+    let msg = 'Stopping'
+    let stopUrl = ''
+
+    if (type) {
+      msg += ` all ${color.cyan(type)} dynos`
+      stopUrl = `/apps/${app}/formations/${encodeURIComponent(type)}/actions/stop`
+    } else if (dyno) {
+      if (args.dyno) {
+        ux.warn(`DYNO is a deprecated argument. Use ${color.cmd('--dyno-name')} or ${color.cmd('--process-type')} instead.`)
+      }
+
+      msg += ` dyno ${color.cyan(dyno)}`
+      stopUrl = `/apps/${app}/dynos/${encodeURIComponent(dyno)}/actions/stop`
+    } else {
+      ux.error(heredoc(`
+        Please specify a process type or dyno name to stop.
+        See more help with --help
+      `))
+    }
+
+    msg += ` on ${color.app(app)}`
+
+    ux.action.start(msg)
+    await this.heroku.post<Heroku.Dyno>(stopUrl, {headers: {Accept: 'application/vnd.heroku+json; version=3.sdk'}})
+    ux.action.stop()
+  }
+}
+*/

package/lib/oldCommands/ps/type.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/ps/type.js

@@ -0,0 +1,190 @@
+export {};
+/*
+import color from '@heroku-cli/color'
+import {APIClient, Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import * as Heroku from '@heroku-cli/schema'
+import {sortBy, compact} from 'lodash'
+import heredoc from 'tsheredoc'
+
+const COST_MONTHLY: Record<string, number> = {
+  Free: 0,
+  Eco: 0,
+  Hobby: 7,
+  Basic: 7,
+  'Standard-1X': 25,
+  'Standard-2X': 50,
+  'Performance-M': 250,
+  Performance: 500,
+  'Performance-L': 500,
+  '1X': 36,
+  '2X': 72,
+  PX: 576,
+  'Performance-L-RAM': 500,
+  'Performance-XL': 750,
+  'Performance-2XL': 1500,
+  'Private-S': 225,
+  'Private-M': 450,
+  'Private-L': 900,
+  'Shield-M': 540,
+  'Shield-L': 1080,
+  'Shield-S': 270,
+  'Private-Memory-L': 500,
+  'Private-Memory-XL': 750,
+  'Private-Memory-2XL': 1500,
+  'Shield-Memory-L': 600,
+  'Shield-Memory-XL': 900,
+  'Shield-Memory-2XL': 1800,
+  'dyno-1c-0.5gb': 25,
+  'dyno-2c-1gb': 50,
+  'dyno-1c-4gb': 80,
+  'dyno-2c-8gb': 160,
+  'dyno-4c-16gb': 320,
+  'dyno-8c-32gb': 640,
+  'dyno-16c-64gb': 1000,
+  'dyno-2c-4gb': 150,
+  'dyno-4c-8gb': 300,
+  'dyno-8c-16gb': 600,
+  'dyno-16c-32gb': 1200,
+  'dyno-32c-64gb': 2400,
+  'dyno-1c-8gb': 100,
+  'dyno-2c-16gb': 250,
+  'dyno-4c-32gb': 500,
+  'dyno-8c-64gb': 750,
+  'dyno-16c-128gb': 1500,
+}
+
+const calculateHourly =  (size: string) => COST_MONTHLY[size] / 720
+
+const emptyFormationErr = (app: string) => {
+  return new Error(`No process types on ${app}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`)
+}
+
+const displayFormation = async (heroku: APIClient, app: string) => {
+  const {body: formation} = await heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
+  const {body: appProps} = await heroku.get<Heroku.App>(`/apps/${app}`)
+  const shielded = appProps.space && appProps.space.shield
+  const dynoTotals: Record<string, number> = {}
+  let isShowingEcoCostMessage = false
+
+  const formationTableData = sortBy(formation, 'type')
+    // this filter shouldn't be necessary, but it makes TS happy
+    .filter((f): f is Heroku.Formation & {size: string, quantity: number} => typeof f.size === 'string' && typeof f.quantity === 'number')
+    .map((d => {
+      if (d.size === 'Eco') {
+        isShowingEcoCostMessage = true
+      }
+
+      if (shielded) {
+        d.size = d.size.replace('Private-', 'Shield-')
+      }
+
+      if (d.size in dynoTotals) {
+        dynoTotals[d.size] += d.quantity
+      } else {
+        dynoTotals[d.size] = d.quantity
+      }
+
+      return {
+        // this rule does not realize `size` isn't used on an array
+        type: color.green(d.type || ''),
+        size: color.cyan(d.size),
+        qty: color.yellow(`${d.quantity}`),
+        'cost/hour': calculateHourly(d.size) ?
+          '~$' + (calculateHourly(d.size) * (d.quantity || 1)).toFixed(3)
+            .toString() :
+          '',
+        'max cost/month': COST_MONTHLY[d.size] ?
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          '$' + (COST_MONTHLY[d.size] * d.quantity).toString() :
+          '',
+      }
+    }))
+
+  const dynoTotalsTableData = Object.keys(dynoTotals)
+    .map(k => ({
+      type: color.green(k), total: color.yellow((dynoTotals[k]).toString()),
+    }))
+
+  if (formation.length === 0) {
+    throw emptyFormationErr(app)
+  }
+
+  hux.styledHeader('Process Types')
+  hux.table(formationTableData, {
+    type: {},
+    size: {},
+    qty: {},
+    'cost/hour': {},
+    'max cost/month': {},
+  })
+  ux.log()
+  hux.styledHeader('Dyno Totals')
+  hux.table(dynoTotalsTableData, {
+    type: {},
+    total: {},
+  })
+
+  if (isShowingEcoCostMessage) {
+    ux.log('\n$5 (flat monthly fee, shared across all Eco dynos)')
+  }
+}
+
+export default class Type extends Command {
+  static strict = false
+  static description = heredoc`
+    manage dyno sizes
+    Called with no arguments shows the current dyno size.
+
+    Called with one argument sets the size.
+    Where SIZE is one of eco|basic|standard-1x|standard-2x|performance
+
+    Called with 1..n TYPE=SIZE arguments sets the quantity per type.
+  `
+  static aliases = ['ps:resize', 'dyno:resize']
+  static hiddenAliases = ['resize', 'dyno:type']
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+  }
+
+  public async run(): Promise<void> {
+    const {flags, ...restParse} = await this.parse(Type)
+    const argv = restParse.argv as string[]
+    const {app} = flags
+
+    const parse = async () => {
+      if (!argv || argv.length === 0)
+        return []
+      const {body: formation} = await this.heroku.get<Heroku.Formation[]>(`/apps/${app}/formation`)
+      if (argv.some(a => a.match(/=/))) {
+        return compact(argv.map(arg => {
+          const match = arg.match(/^([a-zA-Z0-9_]+)=([\w-]+)$/)
+          const type = match && match[1]
+          const size = match && match[2]
+          if (!type || !size || !formation.some(p => p.type === type)) {
+            throw new Error(`Type ${color.red(type || '')} not found in process formation.\nTypes: ${color.yellow(formation.map(f => f.type)
+              .join(', '))}`)
+          }
+
+          return {type, size}
+        }))
+      }
+
+      return formation.map(p => ({type: p.type, size: argv[0]}))
+    }
+
+    const changes = await parse()
+
+    if (changes.length > 0) {
+      ux.action.start(`Scaling dynos on ${color.magenta(app)}`)
+      await this.heroku.patch(`/apps/${app}/formation`, {body: {updates: changes}})
+      ux.action.stop()
+    }
+
+    await displayFormation(this.heroku, app)
+  }
+}
+*/

package/lib/oldCommands/ps/wait.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/ps/wait.js

@@ -0,0 +1,93 @@
+export {};
+/*
+import {Command, flags} from '@heroku-cli/command'
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import {Dyno, Release} from '@heroku-cli/schema'
+
+export default class Wait extends Command {
+  static description = 'wait for all dynos to be running latest version after a release'
+
+  static flags = {
+    app: flags.app({required: true}),
+    remote: flags.remote(),
+    type: flags.string({
+      char: 't',
+      description: 'wait for one specific dyno type',
+    }),
+    'wait-interval': flags.integer({
+      char: 'w',
+      description: 'how frequently to poll in seconds (to avoid hitting Heroku API rate limits)',
+      parse: async input => {
+        const w = Number.parseInt(input, 10)
+        if (w < 10) {
+          ux.error('wait-interval must be at least 10', {exit: 1})
+        }
+
+        return w
+      },
+      default: 10,
+    }),
+    'with-run': flags.boolean({
+      char: 'R',
+      description: 'whether to wait for one-off run dynos',
+      exclusive: ['type'],
+    }),
+  }
+
+  async run() {
+    const {flags} = await this.parse(Wait)
+
+    const {body: releases} = await this.heroku.request<Release[]>(`/apps/${flags.app}/releases`, {
+      partial: true,
+      headers: {
+        Range: 'version ..; max=1, order=desc',
+      },
+    })
+
+    if (releases.length === 0) {
+      this.warn(`App ${flags.app} has no releases`)
+      return
+    }
+
+    const latestRelease = releases[0]
+
+    let released = true
+    const interval = flags['wait-interval'] as number
+
+    while (1 as any) {
+      const {body: dynos} = await this.heroku.get<Dyno[]>(`/apps/${flags.app}/dynos`)
+      const relevantDynos = dynos
+        .filter(dyno => dyno.type !== 'release')
+        .filter(dyno => flags['with-run'] || dyno.type !== 'run')
+        .filter(dyno => !flags.type || dyno.type === flags.type)
+
+      const onLatest = relevantDynos.filter((dyno: Dyno) => {
+        return dyno.state === 'up' &&
+          latestRelease.version !== undefined &&
+          dyno.release !== undefined &&
+          dyno.release.version !== undefined &&
+          dyno.release.version >= latestRelease.version
+      })
+      const releasedFraction = `${onLatest.length} / ${relevantDynos.length}`
+      if (onLatest.length === relevantDynos.length) {
+        if (!released) {
+          ux.action.stop(`${releasedFraction}, done`)
+        }
+
+        break
+      }
+
+      if (released) {
+        released = false
+        ux.action.start(`Waiting for every dyno to be running v${latestRelease.version}`)
+      }
+
+      ux.action.status = releasedFraction
+
+      await hux.wait(interval * 1000)
+    }
+  }
+}
+*/

package/lib/oldCommands/redis/cli.d.ts

@@ -0,0 +1 @@
+export {};