| var util = require('util') |
| var os = require('os') |
| |
| var program = require('commander') |
| var Promise = require('bluebird') |
| var ip = require('my-local-ip') |
| |
| var pkg = require('../package') |
| var cliutil = require('./util/cliutil') |
| var logger = require('./util/logger') |
| var path = require('path') |
| |
| global.appRoot = path.resolve(__dirname); |
| |
| Promise.longStackTraces() |
| |
| program |
| .version(pkg.version) |
| |
| program |
| .command('provider [serial...]') |
| .description('start provider') |
| .option('-s, --connect-sub <endpoint>' |
| , 'sub endpoint' |
| , cliutil.list) |
| .option('-p, --connect-push <endpoint>' |
| , 'push endpoint' |
| , cliutil.list) |
| .option('-n, --name <name>' |
| , 'name (or os.hostname())' |
| , String |
| , os.hostname()) |
| .option('--min-port <port>' |
| , 'minimum port number for worker use' |
| , Number |
| , 7400) |
| .option('--max-port <port>' |
| , 'maximum port number for worker use' |
| , Number |
| , 7700) |
| .option('--public-ip <ip>' |
| , 'public ip for global access' |
| , String |
| , ip()) |
| .option('-t, --group-timeout <seconds>' |
| , 'group timeout' |
| , Number |
| , 900) |
| .option('-r, --storage-url <url>' |
| , 'URL to storage client' |
| , String) |
| .option('--heartbeat-interval <ms>' |
| , 'heartbeat interval' |
| , Number |
| , 10000) |
| .option('--adb-host <host>' |
| , 'ADB host (defaults to 127.0.0.1)' |
| , String |
| , '127.0.0.1') |
| .option('--adb-port <port>' |
| , 'ADB port (defaults to 5037)' |
| , Number |
| , 5037) |
| .option('-R, --allow-remote' |
| , 'Whether to allow remote devices to be set up') |
| .option('--screen-ws-url-pattern <pattern>' |
| , 'screen WebSocket URL pattern' |
| , String |
| , 'ws://${publicIp}:${publicPort}') |
| .option('--connect-url-pattern <pattern>' |
| , 'adb connect URL pattern' |
| , String |
| , '${publicIp}:${publicPort}') |
| .option('--vnc-initial-size <size>' |
| , 'initial VNC size' |
| , cliutil.size |
| , [600, 800]) |
| .option('--mute-master' |
| , 'whether to mute master volume when devices are being used') |
| .option('--lock-rotation' |
| , 'whether to lock rotation when devices are being used') |
| .action(function(serials, options) { |
| if (!options.connectSub) { |
| this.missingArgument('--connect-sub') |
| } |
| if (!options.connectPush) { |
| this.missingArgument('--connect-push') |
| } |
| if (!options.storageUrl) { |
| this.missingArgument('--storage-url') |
| } |
| |
| require('./units/provider')({ |
| name: options.name |
| , killTimeout: 10000 |
| , ports: cliutil.range(options.minPort, options.maxPort) |
| , filter: function(device) { |
| return serials.length === 0 || serials.indexOf(device.id) !== -1 |
| } |
| , allowRemote: options.allowRemote |
| , fork: function(device, ports) { |
| var fork = require('child_process').fork |
| return fork(__filename, [ |
| 'device', device.id |
| , '--provider', options.name |
| , '--connect-sub', options.connectSub.join(',') |
| , '--connect-push', options.connectPush.join(',') |
| , '--screen-port', ports.shift() |
| , '--connect-port', ports.shift() |
| , '--vnc-port', ports.shift() |
| , '--public-ip', options.publicIp |
| , '--group-timeout', options.groupTimeout |
| , '--storage-url', options.storageUrl |
| , '--adb-host', options.adbHost |
| , '--adb-port', options.adbPort |
| , '--screen-ws-url-pattern', options.screenWsUrlPattern |
| , '--connect-url-pattern', options.connectUrlPattern |
| , '--heartbeat-interval', options.heartbeatInterval |
| , '--vnc-initial-size', options.vncInitialSize.join('x') |
| ] |
| .concat(options.muteMaster ? ['--mute-master'] : []) |
| .concat(options.lockRotation ? ['--lock-rotation'] : [])) |
| } |
| , endpoints: { |
| sub: options.connectSub |
| , push: options.connectPush |
| } |
| , adbHost: options.adbHost |
| , adbPort: options.adbPort |
| }) |
| }) |
| |
| program |
| .command('device <serial>') |
| .description('start device worker') |
| .option('-n, --provider <name>' |
| , 'provider name' |
| , String) |
| .option('-s, --connect-sub <endpoint>' |
| , 'sub endpoint' |
| , cliutil.list) |
| .option('-p, --connect-push <endpoint>' |
| , 'push endpoint' |
| , cliutil.list) |
| .option('--screen-port <port>' |
| , 'port allocated to the screen websocket' |
| , Number) |
| .option('--connect-port <port>' |
| , 'port allocated to adb connect' |
| , Number) |
| .option('--vnc-port <port>' |
| , 'port allocated to vnc' |
| , Number) |
| .option('--vnc-initial-size <size>' |
| , 'initial VNC size' |
| , cliutil.size |
| , [600, 800]) |
| .option('--connect-url-pattern <pattern>' |
| , 'adb connect URL pattern' |
| , String |
| , '${publicIp}:${publicPort}') |
| .option('--public-ip <ip>' |
| , 'public ip for global access' |
| , String |
| , ip()) |
| .option('-t, --group-timeout <seconds>' |
| , 'group timeout' |
| , Number |
| , 900) |
| .option('-r, --storage-url <url>' |
| , 'URL to storage client' |
| , String) |
| .option('--adb-host <host>' |
| , 'ADB host (defaults to 127.0.0.1)' |
| , String |
| , '127.0.0.1') |
| .option('--adb-port <port>' |
| , 'ADB port (defaults to 5037)' |
| , Number |
| , 5037) |
| .option('--screen-ws-url-pattern <pattern>' |
| , 'screen WebSocket URL pattern' |
| , String |
| , 'ws://${publicIp}:${publicPort}') |
| .option('--heartbeat-interval <ms>' |
| , 'heartbeat interval' |
| , Number |
| , 10000) |
| .option('--mute-master' |
| , 'whether to mute master volume when devices are being used') |
| .option('--lock-rotation' |
| , 'whether to lock rotation when devices are being used') |
| .action(function(serial, options) { |
| if (!options.connectSub) { |
| this.missingArgument('--connect-sub') |
| } |
| if (!options.connectPush) { |
| this.missingArgument('--connect-push') |
| } |
| if (!options.provider) { |
| this.missingArgument('--provider') |
| } |
| if (!options.screenPort) { |
| this.missingArgument('--screen-port') |
| } |
| if (!options.connectPort) { |
| this.missingArgument('--connect-port') |
| } |
| if (!options.vncPort) { |
| this.missingArgument('--vnc-port') |
| } |
| if (!options.storageUrl) { |
| this.missingArgument('--storage-url') |
| } |
| |
| require('./units/device')({ |
| serial: serial |
| , provider: options.provider |
| , publicIp: options.publicIp |
| , endpoints: { |
| sub: options.connectSub |
| , push: options.connectPush |
| } |
| , groupTimeout: options.groupTimeout * 1000 // change to ms |
| , storageUrl: options.storageUrl |
| , adbHost: options.adbHost |
| , adbPort: options.adbPort |
| , screenWsUrlPattern: options.screenWsUrlPattern |
| , screenPort: options.screenPort |
| , connectUrlPattern: options.connectUrlPattern |
| , connectPort: options.connectPort |
| , vncPort: options.vncPort |
| , vncInitialSize: options.vncInitialSize |
| , heartbeatInterval: options.heartbeatInterval |
| , muteMaster: options.muteMaster |
| , lockRotation: options.lockRotation |
| }) |
| }) |
| |
| program |
| .command('processor <name>') |
| .description('start processor') |
| .option('-a, --connect-app-dealer <endpoint>' |
| , 'app dealer endpoint' |
| , cliutil.list) |
| .option('-d, --connect-dev-dealer <endpoint>' |
| , 'device dealer endpoint' |
| , cliutil.list) |
| .action(function(name, options) { |
| if (!options.connectAppDealer) { |
| this.missingArgument('--connect-app-dealer') |
| } |
| if (!options.connectDevDealer) { |
| this.missingArgument('--connect-dev-dealer') |
| } |
| |
| require('./units/processor')({ |
| name: name |
| , endpoints: { |
| appDealer: options.connectAppDealer |
| , devDealer: options.connectDevDealer |
| } |
| }) |
| }) |
| |
| program |
| .command('reaper <name>') |
| .description('start reaper') |
| .option('-p, --connect-push <endpoint>' |
| , 'push endpoint' |
| , cliutil.list) |
| .option('-s, --connect-sub <endpoint>' |
| , 'sub endpoint' |
| , cliutil.list) |
| .option('-t, --heartbeat-timeout <ms>' |
| , 'consider devices with heartbeat older than this value dead' |
| , Number |
| , 30000) |
| .action(function(name, options) { |
| require('./units/reaper')({ |
| name: name |
| , heartbeatTimeout: options.heartbeatTimeout |
| , endpoints: { |
| push: options.connectPush |
| , sub: options.connectSub |
| } |
| }) |
| }) |
| |
| program |
| .command('triproxy <name>') |
| .description('start triproxy') |
| .option('-u, --bind-pub <endpoint>' |
| , 'pub endpoint' |
| , String |
| , 'tcp://*:7111') |
| .option('-d, --bind-dealer <endpoint>' |
| , 'dealer endpoint' |
| , String |
| , 'tcp://*:7112') |
| .option('-p, --bind-pull <endpoint>' |
| , 'pull endpoint' |
| , String |
| , 'tcp://*:7113') |
| .action(function(name, options) { |
| require('./units/triproxy')({ |
| name: name |
| , endpoints: { |
| pub: options.bindPub |
| , dealer: options.bindDealer |
| , pull: options.bindPull |
| } |
| }) |
| }) |
| |
| program |
| .command('auth-ldap') |
| .description('start LDAP auth client') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7120) |
| .option('-s, --secret <secret>' |
| , 'secret (or $SECRET)' |
| , String |
| , process.env.SECRET) |
| .option('-i, --ssid <ssid>' |
| , 'session SSID (or $SSID)' |
| , String |
| , process.env.SSID || 'ssid') |
| .option('-a, --app-url <url>' |
| , 'URL to app' |
| , String) |
| .option('-u, --ldap-url <url>' |
| , 'LDAP server URL (or $LDAP_URL)' |
| , String |
| , process.env.LDAP_URL) |
| .option('-t, --ldap-timeout <timeout>' |
| , 'LDAP timeout (or $LDAP_TIMEOUT)' |
| , Number |
| , process.env.LDAP_TIMEOUT || 1000) |
| .option('--ldap-bind-dn <dn>' |
| , 'LDAP bind DN (or $LDAP_BIND_DN)' |
| , String |
| , process.env.LDAP_BIND_DN) |
| .option('--ldap-bind-credentials <credentials>' |
| , 'LDAP bind credentials (or $LDAP_BIND_CREDENTIALS)' |
| , String |
| , process.env.LDAP_BIND_CREDENTIALS) |
| .option('--ldap-search-dn <dn>' |
| , 'LDAP search DN (or $LDAP_SEARCH_DN)' |
| , String |
| , process.env.LDAP_SEARCH_DN) |
| .option('--ldap-search-scope <scope>' |
| , 'LDAP search scope (or $LDAP_SEARCH_SCOPE)' |
| , String |
| , process.env.LDAP_SEARCH_SCOPE || 'sub') |
| .option('--ldap-search-class <class>' |
| , 'LDAP search objectClass (or $LDAP_SEARCH_CLASS)' |
| , String |
| , process.env.LDAP_SEARCH_CLASS || 'top') |
| .option('--ldap-search-field <name>' |
| , 'LDAP search field (or $LDAP_SEARCH_FIELD)' |
| , String |
| , process.env.LDAP_SEARCH_FIELD) |
| .action(function(options) { |
| if (!options.secret) { |
| this.missingArgument('--secret') |
| } |
| if (!options.appUrl) { |
| this.missingArgument('--app-url') |
| } |
| |
| require('./units/auth/ldap')({ |
| port: options.port |
| , secret: options.secret |
| , ssid: options.ssid |
| , appUrl: options.appUrl |
| , ldap: { |
| url: options.ldapUrl |
| , timeout: options.ldapTimeout |
| , bind: { |
| dn: options.ldapBindDn |
| , credentials: options.ldapBindCredentials |
| } |
| , search: { |
| dn: options.ldapSearchDn |
| , scope: options.ldapSearchScope |
| , objectClass: options.ldapSearchClass |
| , field: options.ldapSearchField |
| } |
| } |
| }) |
| }) |
| |
| program |
| .command('auth-oauth2') |
| .description('start OAuth 2.0 auth client') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7120) |
| .option('-s, --secret <secret>' |
| , 'secret (or $SECRET)' |
| , String |
| , process.env.SECRET) |
| .option('-i, --ssid <ssid>' |
| , 'session SSID (or $SSID)' |
| , String |
| , process.env.SSID || 'ssid') |
| .option('-a, --app-url <url>' |
| , 'URL to app' |
| , String) |
| .option('--oauth-authorization-url <url>' |
| , 'OAuth 2.0 authorization URL (or $OAUTH_AUTHORIZATION_URL)' |
| , String |
| , process.env.OAUTH_AUTHORIZATION_URL) |
| .option('--oauth-token-url <url>' |
| , 'OAuth 2.0 token URL (or $OAUTH_TOKEN_URL)' |
| , String |
| , process.env.OAUTH_TOKEN_URL) |
| .option('--oauth-userinfo-url <url>' |
| , 'OAuth 2.0 token URL (or $OAUTH_USERINFO_URL)' |
| , String |
| , process.env.OAUTH_USERINFO_URL) |
| .option('--oauth-client-id <id>' |
| , 'OAuth 2.0 client ID (or $OAUTH_CLIENT_ID)' |
| , String |
| , process.env.OAUTH_CLIENT_ID) |
| .option('--oauth-client-secret <value>' |
| , 'OAuth 2.0 client secret (or $OAUTH_CLIENT_SECRET)' |
| , String |
| , process.env.OAUTH_CLIENT_SECRET) |
| .option('--oauth-callback-url <url>' |
| , 'OAuth 2.0 callback URL (or $OAUTH_CALLBACK_URL)' |
| , String |
| , process.env.OAUTH_CALLBACK_URL) |
| .option('--oauth-scope <scope>' |
| , 'Space-separated OAuth 2.0 scope (or $OAUTH_SCOPE)' |
| , String |
| , process.env.OAUTH_SCOPE) |
| .action(function(options) { |
| if (!options.secret) { |
| this.missingArgument('--secret') |
| } |
| if (!options.appUrl) { |
| this.missingArgument('--app-url') |
| } |
| if (!options.oauthAuthorizationUrl) { |
| this.missingArgument('--oauth-authorization-url') |
| } |
| if (!options.oauthTokenUrl) { |
| this.missingArgument('--oauth-token-url') |
| } |
| if (!options.oauthUserinfoUrl) { |
| this.missingArgument('--oauth-userinfo-url') |
| } |
| if (!options.oauthClientId) { |
| this.missingArgument('--oauth-client-id') |
| } |
| if (!options.oauthClientSecret) { |
| this.missingArgument('--oauth-client-secret') |
| } |
| if (!options.oauthCallbackUrl) { |
| this.missingArgument('--oauth-callback-url') |
| } |
| if (!options.oauthScope) { |
| this.missingArgument('--oauth-scope') |
| } |
| |
| require('./units/auth/oauth2')({ |
| port: options.port |
| , secret: options.secret |
| , ssid: options.ssid |
| , appUrl: options.appUrl |
| , oauth: { |
| authorizationURL: options.oauthAuthorizationUrl |
| , tokenURL: options.oauthTokenUrl |
| , userinfoURL: options.oauthUserinfoUrl |
| , clientID: options.oauthClientId |
| , clientSecret: options.oauthClientSecret |
| , callbackURL: options.oauthCallbackUrl |
| , scope: options.oauthScope.split(/\s+/) |
| } |
| }) |
| }) |
| |
| program |
| .command('auth-saml2') |
| .description('start SAML 2.0 auth client') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7120) |
| .option('-s, --secret <secret>' |
| , 'secret (or $SECRET)' |
| , String |
| , process.env.SECRET) |
| .option('-i, --ssid <ssid>' |
| , 'session SSID (or $SSID)' |
| , String |
| , process.env.SSID || 'ssid') |
| .option('-a, --app-url <url>' |
| , 'URL to app' |
| , String) |
| .option('--saml-id-provider-entry-point-url <url>' |
| , 'SAML 2.0 identity provider URL (or $SAML_ID_PROVIDER_ENTRY_POINT_URL)' |
| , String |
| , process.env.SAML_ID_PROVIDER_ENTRY_POINT_URL) |
| .option('--saml-id-provider-issuer <issuer>' |
| , 'SAML 2.0 identity provider issuer (or $SAML_ID_PROVIDER_ISSUER)' |
| , String |
| , process.env.SAML_ID_PROVIDER_ISSUER) |
| .option('--saml-id-provider-cert-path <path>' |
| , 'SAML 2.0 identity provider certificate file path (or $SAML_ID_PROVIDER_CERT_PATH)' |
| , String |
| , process.env.SAML_ID_PROVIDER_CERT_PATH) |
| .action(function(options) { |
| if (!options.secret) { |
| this.missingArgument('--secret') |
| } |
| if (!options.appUrl) { |
| this.missingArgument('--app-url') |
| } |
| if (!options.samlIdProviderEntryPointUrl) { |
| this.missingArgument('--saml-id-provider-entry-point-url') |
| } |
| if (!options.samlIdProviderIssuer) { |
| this.missingArgument('--saml-id-provider-issuer') |
| } |
| |
| require('./units/auth/saml2')({ |
| port: options.port |
| , secret: options.secret |
| , ssid: options.ssid |
| , appUrl: options.appUrl |
| , saml: { |
| entryPoint: options.samlIdProviderEntryPointUrl |
| , issuer: options.samlIdProviderIssuer |
| , certPath: options.samlIdProviderCertPath |
| } |
| }) |
| }) |
| |
| program |
| .command('auth-mock') |
| .description('start mock auth client') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7120) |
| .option('-s, --secret <secret>' |
| , 'secret (or $SECRET)' |
| , String |
| , process.env.SECRET) |
| .option('-i, --ssid <ssid>' |
| , 'session SSID (or $SSID)' |
| , String |
| , process.env.SSID || 'ssid') |
| .option('-a, --app-url <url>' |
| , 'URL to app' |
| , String) |
| .option('--use-basic-auth' |
| , 'Whether to use basic authentication for login or not') |
| .option('--basic-auth-username <username>' |
| , 'Basic Auth Username (or $BASIC_AUTH_USERNAME)' |
| , String |
| , process.env.BASIC_AUTH_USERNAME || 'username') |
| .option('--basic-auth-password <password>' |
| , 'Basic Auth Password (or $BASIC_AUTH_PASSWORD)' |
| , String |
| , process.env.BASIC_AUTH_PASSWORD || 'password') |
| .action(function(options) { |
| if (!options.secret) { |
| this.missingArgument('--secret') |
| } |
| if (!options.appUrl) { |
| this.missingArgument('--app-url') |
| } |
| |
| require('./units/auth/mock')({ |
| port: options.port |
| , secret: options.secret |
| , ssid: options.ssid |
| , appUrl: options.appUrl |
| , mock: { |
| useBasicAuth: options.useBasicAuth |
| , basicAuth: { |
| username: options.basicAuthUsername |
| , password: options.basicAuthPassword |
| } |
| } |
| }) |
| }) |
| |
| // Start the service for token-based authentication. |
| // Hard coded values follow OpenSTF pattern above. |
| program |
| .command('auth-token') |
| .description('start token auth client') |
| .option('-p, --port <port>', |
| 'port (or $PORT)', |
| Number, |
| process.env.PORT || 7120) |
| .option('-s, --secret <secret>', 'secret (or $SECRET)', |
| String, process.env.SECRET) |
| .option('-i, --ssid <ssid>', 'session SSID (or $SSID)', String, |
| process.env.SSID || 'ssid') |
| .option('-a, --app-url <url>', 'URL to app', String) |
| .option('--use-basic-auth', |
| 'Whether to use basic authentication for login or not') |
| .option('--basic-auth-username <username>', |
| 'Basic Auth Username (or $BASIC_AUTH_USERNAME)', String, |
| process.env.BASIC_AUTH_USERNAME || 'username') |
| .option('--basic-auth-password <password>', |
| 'Basic Auth Password (or $BASIC_AUTH_PASSWORD)', String, |
| process.env.BASIC_AUTH_PASSWORD || 'password') |
| .action(function(options) { |
| if (!options.secret) { |
| this.missingArgument('--secret'); |
| } |
| if (!options.appUrl) { |
| this.missingArgument('--app-url'); |
| } |
| |
| require('./units/auth/token')({ |
| port: options.port, |
| secret: options.secret, |
| ssid: options.ssid, |
| appUrl: options.appUrl, |
| mock: { |
| useBasicAuth: options.useBasicAuth, |
| basicAuth: { |
| username: options.basicAuthUsername, |
| password: options.basicAuthPassword |
| } |
| } |
| }); |
| }); |
| |
| program |
| .command('auth-openid') |
| .description('start openid auth client') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7120) |
| .option('-s, --secret <secret>' |
| , 'secret (or $SECRET)' |
| , String |
| , process.env.SECRET) |
| .option('-a, --app-url <url>' |
| , 'URL to app' |
| , String) |
| .option('--openid-identifier-url <openidIdentifierUrl>' |
| , 'openidIdentifierUrl' |
| , String |
| , process.env.OPENID_IDENTIFIER_URL) |
| .action(function(options) { |
| if (!options.openidIdentifierUrl) { |
| this.missingArgument('--openid-identifier-url') |
| } |
| if (!options.secret) { |
| this.missingArgument('--secret') |
| } |
| if (!options.appUrl) { |
| this.missingArgument('--app-url') |
| } |
| |
| require('./units/auth/openid')({ |
| port: options.port |
| , secret: options.secret |
| , appUrl: options.appUrl |
| , openid: { |
| identifierUrl: options.openidIdentifierUrl |
| } |
| }) |
| }) |
| |
| program |
| .command('notify-hipchat') |
| .description('start HipChat notifier') |
| .option('-t, --token <token>' |
| , 'HipChat v2 API token (or $HIPCHAT_TOKEN)' |
| , String |
| , process.env.HIPCHAT_TOKEN) |
| .option('-r, --room <room>' |
| , 'HipChat room (or $HIPCHAT_ROOM)' |
| , String |
| , process.env.HIPCHAT_ROOM) |
| .option('-p, --priority <level>' |
| , 'minimum log level' |
| , Number |
| , logger.Level.IMPORTANT) |
| .option('-n, --notify-priority <level>' |
| , 'minimum log level to cause a notification' |
| , Number |
| , logger.Level.WARNING) |
| .option('-s, --connect-sub <endpoint>' |
| , 'sub endpoint' |
| , cliutil.list) |
| .action(function(options) { |
| if (!options.token) { |
| this.missingArgument('--token') |
| } |
| if (!options.room) { |
| this.missingArgument('--room') |
| } |
| if (!options.connectSub) { |
| this.missingArgument('--connect-sub') |
| } |
| |
| require('./units/notify/hipchat')({ |
| token: options.token |
| , room: options.room |
| , priority: options.priority |
| , notifyPriority: options.notifyPriority |
| , endpoints: { |
| sub: options.connectSub |
| } |
| }) |
| }) |
| |
| program |
| .command('notify-slack') |
| .description('start Slack notifier') |
| .option('-t, --token <token>' |
| , 'Slack API token (or $SLACK_TOKEN)' |
| , String |
| , process.env.SLACK_TOKEN) |
| .option('-c, --channel #<channel>' |
| , 'Slack channel (or $SLACK_CHANNEL)' |
| , String |
| , process.env.SLACK_CHANNEL) |
| .option('-p, --priority <level>' |
| , 'minimum log level' |
| , Number |
| , logger.Level.IMPORTANT) |
| .option('-s, --connect-sub <endpoint>' |
| , 'sub endpoint' |
| , cliutil.list) |
| .action(function(options) { |
| if (!options.token) { |
| this.missingArgument('--token') |
| } |
| if (!options.channel) { |
| this.missingArgument('--channel') |
| } |
| if (!options.connectSub) { |
| this.missingArgument('--connect-sub') |
| } |
| |
| require('./units/notify/slack')({ |
| token: options.token |
| , channel: options.channel |
| , priority: options.priority |
| , endpoints: { |
| sub: options.connectSub |
| } |
| }) |
| }) |
| |
| program |
| .command('log-rethinkdb') |
| .description('start a rethinkdb log recorder') |
| .option('-p, --priority <level>' |
| , 'minimum log level' |
| , Number |
| , logger.Level.DEBUG) |
| .option('-s, --connect-sub <endpoint>' |
| , 'sub endpoint' |
| , cliutil.list) |
| .action(function(options) { |
| if (!options.connectSub) { |
| this.missingArgument('--connect-sub') |
| } |
| |
| require('./units/log/rethinkdb')({ |
| priority: options.priority |
| , endpoints: { |
| sub: options.connectSub |
| } |
| }) |
| }) |
| |
| program |
| .command('poorxy') |
| .description('start a poor reverse proxy for local development') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7100) |
| .option('-u, --app-url <url>' |
| , 'URL to app' |
| , String) |
| .option('-a, --auth-url <url>' |
| , 'URL to auth client' |
| , String) |
| .option('-w, --websocket-url <url>' |
| , 'URL to websocket client' |
| , String) |
| .option('-r, --storage-url <url>' |
| , 'URL to storage client' |
| , String) |
| .option('--storage-plugin-image-url <url>' |
| , 'URL to image storage plugin' |
| , String) |
| .option('--storage-plugin-apk-url <url>' |
| , 'URL to apk storage plugin' |
| , String) |
| .action(function(options) { |
| if (!options.appUrl) { |
| this.missingArgument('--app-url') |
| } |
| if (!options.authUrl) { |
| this.missingArgument('--auth-url') |
| } |
| if (!options.websocketUrl) { |
| this.missingArgument('--websocket-url') |
| } |
| if (!options.storageUrl) { |
| this.missingArgument('--storage-url') |
| } |
| if (!options.storagePluginImageUrl) { |
| this.missingArgument('--storage-plugin-image-url') |
| } |
| if (!options.storagePluginApkUrl) { |
| this.missingArgument('--storage-plugin-apk-url') |
| } |
| |
| require('./units/poorxy')({ |
| port: options.port |
| , appUrl: options.appUrl |
| , authUrl: options.authUrl |
| , websocketUrl: options.websocketUrl |
| , storageUrl: options.storageUrl |
| , storagePluginImageUrl: options.storagePluginImageUrl |
| , storagePluginApkUrl: options.storagePluginApkUrl |
| }) |
| }) |
| |
| program |
| .command('app') |
| .description('start app') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7105) |
| .option('-s, --secret <secret>' |
| , 'secret (or $SECRET)' |
| , String |
| , process.env.SECRET) |
| .option('-i, --ssid <ssid>' |
| , 'session SSID (or $SSID)' |
| , String |
| , process.env.SSID || 'ssid') |
| .option('-a, --auth-url <url>' |
| , 'URL to auth client' |
| , String) |
| .option('-w, --websocket-url <url>' |
| , 'URL to websocket client' |
| , String) |
| .option('--user-profile-url <url>' |
| , 'URL to external user profile page' |
| , String) |
| .action(function(options) { |
| if (!options.secret) { |
| this.missingArgument('--secret') |
| } |
| if (!options.authUrl) { |
| this.missingArgument('--auth-url') |
| } |
| if (!options.websocketUrl) { |
| this.missingArgument('--websocket-url') |
| } |
| |
| require('./units/app')({ |
| port: options.port |
| , secret: options.secret |
| , ssid: options.ssid |
| , authUrl: options.authUrl |
| , websocketUrl: options.websocketUrl |
| , userProfileUrl: options.userProfileUrl |
| }) |
| }) |
| |
| program |
| .command('websocket') |
| .description('start websocket') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7110) |
| .option('-s, --secret <secret>' |
| , 'secret (or $SECRET)' |
| , String |
| , process.env.SECRET) |
| .option('-i, --ssid <ssid>' |
| , 'session SSID (or $SSID)' |
| , String |
| , process.env.SSID || 'ssid') |
| .option('-r, --storage-url <url>' |
| , 'URL to storage client' |
| , String) |
| .option('-u, --connect-sub <endpoint>' |
| , 'sub endpoint' |
| , cliutil.list) |
| .option('-c, --connect-push <endpoint>' |
| , 'push endpoint' |
| , cliutil.list) |
| .action(function(options) { |
| if (!options.secret) { |
| this.missingArgument('--secret') |
| } |
| if (!options.storageUrl) { |
| this.missingArgument('--storage-url') |
| } |
| if (!options.connectSub) { |
| this.missingArgument('--connect-sub') |
| } |
| if (!options.connectPush) { |
| this.missingArgument('--connect-push') |
| } |
| |
| require('./units/websocket')({ |
| port: options.port |
| , secret: options.secret |
| , ssid: options.ssid |
| , storageUrl: options.storageUrl |
| , endpoints: { |
| sub: options.connectSub |
| , push: options.connectPush |
| } |
| }) |
| }) |
| |
| program |
| .command('storage-temp') |
| .description('start temp storage') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7100) |
| .option('--save-dir <dir>' |
| , 'where to save files' |
| , String |
| , os.tmpdir()) |
| .action(function(options) { |
| require('./units/storage/temp')({ |
| port: options.port |
| , saveDir: options.saveDir |
| }) |
| }) |
| |
| program |
| .command('storage-s3') |
| .description('start s3 storage') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7100) |
| .option('--bucket <bucketname>' |
| , 'your s3 bucket name' |
| , String) |
| .option('--profile <name>' |
| , 'your aws credentials profile name' |
| , String) |
| .option('--endpoint <endpoint>' |
| , 'your buckets endpoint' |
| , String) |
| .action(function(options) { |
| if (!options.profile) { |
| this.missingArgument('--profile') |
| } |
| |
| if (!options.endpoint) { |
| this.missingArgument('--endpoint') |
| } |
| |
| require('./units/storage/s3')({ |
| port: options.port |
| , profile: options.profile |
| , bucket: options.bucket |
| , endpoint: options.endpoint |
| }) |
| }) |
| |
| program |
| .command('storage-plugin-image') |
| .description('start storage image plugin') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7100) |
| .option('-r, --storage-url <url>' |
| , 'URL to storage client' |
| , String) |
| .option('-c, --concurrency <num>' |
| , 'maximum number of simultaneous transformations' |
| , Number) |
| .option('--cache-dir <dir>' |
| , 'where to cache images' |
| , String |
| , os.tmpdir()) |
| .action(function(options) { |
| if (!options.storageUrl) { |
| this.missingArgument('--storage-url') |
| } |
| |
| require('./units/storage/plugins/image')({ |
| port: options.port |
| , storageUrl: options.storageUrl |
| , cacheDir: options.cacheDir |
| , concurrency: options.concurrency || os.cpus().length |
| }) |
| }) |
| |
| program |
| .command('storage-plugin-apk') |
| .description('start storage apk plugin') |
| .option('-p, --port <port>' |
| , 'port (or $PORT)' |
| , Number |
| , process.env.PORT || 7100) |
| .option('-r, --storage-url <url>' |
| , 'URL to storage client' |
| , String) |
| .option('--cache-dir <dir>' |
| , 'where to cache images' |
| , String |
| , os.tmpdir()) |
| .action(function(options) { |
| if (!options.storageUrl) { |
| this.missingArgument('--storage-url') |
| } |
| |
| require('./units/storage/plugins/apk')({ |
| port: options.port |
| , storageUrl: options.storageUrl |
| , cacheDir: options.cacheDir |
| }) |
| }) |
| |
| program |
| .command('migrate') |
| .description('migrates the database to the latest version') |
| .action(function() { |
| var log = logger.createLogger('cli:migrate') |
| var db = require('./db') |
| |
| db.setup() |
| .then(function() { |
| process.exit(0) |
| }) |
| .catch(function(err) { |
| log.fatal('Migration had an error:', err.stack) |
| process.exit(1) |
| }) |
| }) |
| |
| program |
| .command('generate-fake-device [model]') |
| .description('generates a fake device for testing') |
| .option('-n, --number <n>' |
| , 'how many devices to create (defaults to 1)' |
| , Number |
| , 1) |
| .action(function(model, options) { |
| var log = logger.createLogger('cli:generate-fake-device') |
| var fake = require('./util/fakedevice') |
| var n = options.number |
| |
| function nextDevice() { |
| return fake.generate(model) |
| .then(function(serial) { |
| log.info('Created fake device "%s"', serial) |
| |
| if (--n) { |
| return nextDevice() |
| } |
| }) |
| } |
| |
| nextDevice() |
| .then(function() { |
| process.exit(0) |
| }) |
| .catch(function(err) { |
| log.fatal('Fake device creation had an error:', err.stack) |
| process.exit(1) |
| }) |
| }) |
| |
| program |
| .command('local [serial...]') |
| .description('start everything locally') |
| .option('--bind-app-pub <endpoint>' |
| , 'app pub endpoint' |
| , String |
| , 'tcp://127.0.0.1:7111') |
| .option('--bind-app-dealer <endpoint>' |
| , 'app dealer endpoint' |
| , String |
| , 'tcp://127.0.0.1:7112') |
| .option('--bind-app-pull <endpoint>' |
| , 'app pull endpoint' |
| , String |
| , 'tcp://127.0.0.1:7113') |
| .option('--bind-dev-pub <endpoint>' |
| , 'device pub endpoint' |
| , String |
| , 'tcp://127.0.0.1:7114') |
| .option('--bind-dev-dealer <endpoint>' |
| , 'device dealer endpoint' |
| , String |
| , 'tcp://127.0.0.1:7115') |
| .option('--bind-dev-pull <endpoint>' |
| , 'device pull endpoint' |
| , String |
| , 'tcp://127.0.0.1:7116') |
| .option('--auth-type <mock|ldap|oauth2|saml2|openid|token>' |
| , 'auth type' |
| , String |
| , 'token') |
| .option('-a, --auth-url <url>' |
| , 'URL to auth client' |
| , String) |
| .option('--auth-port <port>' |
| , 'auth port' |
| , Number |
| , 7120) |
| .option('--auth-secret <secret>' |
| , 'auth secret' |
| , String |
| , 'kute kittykat') |
| .option('--auth-options <json>' |
| , 'array of options to pass to the auth implementation' |
| , String |
| , '[]') |
| .option('--poorxy-port <port>' |
| , 'poorxy port' |
| , Number |
| , 7100) |
| .option('--app-port <port>' |
| , 'app port' |
| , Number |
| , 7105) |
| .option('--websocket-port <port>' |
| , 'websocket port' |
| , Number |
| , 7110) |
| .option('--storage-type <temp|s3>' |
| , 'storage type' |
| , String |
| , 'temp') |
| .option('--storage-port <port>' |
| , 'storage port' |
| , Number |
| , 7102) |
| .option('--storage-options <json>' |
| , 'array of options to pass to the storage implementation' |
| , String |
| , '[]') |
| .option('--storage-plugin-image-port <port>' |
| , 'storage image plugin port' |
| , Number |
| , 7103) |
| .option('--storage-plugin-apk-port <port>' |
| , 'storage apk plugin port' |
| , Number |
| , 7104) |
| .option('--provider <name>' |
| , 'provider name (or os.hostname())' |
| , String |
| , os.hostname()) |
| .option('--provider-min-port <port>' |
| , 'minimum port number for worker use' |
| , Number |
| , 7400) |
| .option('--provider-max-port <port>' |
| , 'maximum port number for worker use' |
| , Number |
| , 7700) |
| .option('-t, --group-timeout <seconds>' |
| , 'group timeout' |
| , Number |
| , 900) |
| .option('--public-ip <ip>' |
| , 'public ip for global access' |
| , String |
| , 'localhost') |
| .option('--adb-host <host>' |
| , 'ADB host (defaults to 127.0.0.1)' |
| , String |
| , '127.0.0.1') |
| .option('--adb-port <port>' |
| , 'ADB port (defaults to 5037)' |
| , Number |
| , 5037) |
| .option('-R, --allow-remote' |
| , 'Whether to allow remote devices to be set up') |
| .option('--user-profile-url <url>' |
| , 'URL to external user profile page' |
| , String) |
| .option('--vnc-initial-size <size>' |
| , 'initial VNC size' |
| , cliutil.size |
| , [600, 800]) |
| .option('--mute-master' |
| , 'whether to mute master volume when devices are being used') |
| .option('--lock-rotation' |
| , 'whether to lock rotation when devices are being used') |
| .action(function(serials, options) { |
| var log = logger.createLogger('cli:local') |
| var procutil = require('./util/procutil') |
| |
| // Each forked process waits for signals to stop, and so we run over the |
| // default limit of 10. So, it's not a leak, but a refactor wouldn't hurt. |
| process.setMaxListeners(20) |
| |
| function run() { |
| var procs = [ |
| // app triproxy |
| procutil.fork(__filename, [ |
| 'triproxy', 'app001' |
| , '--bind-pub', options.bindAppPub |
| , '--bind-dealer', options.bindAppDealer |
| , '--bind-pull', options.bindAppPull |
| ]) |
| |
| // device triproxy |
| , procutil.fork(__filename, [ |
| 'triproxy', 'dev001' |
| , '--bind-pub', options.bindDevPub |
| , '--bind-dealer', options.bindDevDealer |
| , '--bind-pull', options.bindDevPull |
| ]) |
| |
| // processor one |
| , procutil.fork(__filename, [ |
| 'processor', 'proc001' |
| , '--connect-app-dealer', options.bindAppDealer |
| , '--connect-dev-dealer', options.bindDevDealer |
| ]) |
| |
| // processor two |
| , procutil.fork(__filename, [ |
| 'processor', 'proc002' |
| , '--connect-app-dealer', options.bindAppDealer |
| , '--connect-dev-dealer', options.bindDevDealer |
| ]) |
| |
| // reaper one |
| , procutil.fork(__filename, [ |
| 'reaper', 'reaper001' |
| , '--connect-push', options.bindDevPull |
| , '--connect-sub', options.bindAppPub |
| ]) |
| |
| // provider |
| , procutil.fork(__filename, [ |
| 'provider' |
| , '--name', options.provider |
| , '--min-port', options.providerMinPort |
| , '--max-port', options.providerMaxPort |
| , '--connect-sub', options.bindDevPub |
| , '--connect-push', options.bindDevPull |
| , '--group-timeout', options.groupTimeout |
| , '--public-ip', options.publicIp |
| , '--storage-url' |
| , util.format('http://localhost:%d/', options.poorxyPort) |
| , '--adb-host', options.adbHost |
| , '--adb-port', options.adbPort |
| , '--vnc-initial-size', options.vncInitialSize.join('x') |
| ] |
| .concat(options.allowRemote ? ['--allow-remote'] : []) |
| .concat(options.muteMaster ? ['--mute-master'] : []) |
| .concat(options.lockRotation ? ['--lock-rotation'] : []) |
| .concat(serials)) |
| |
| // auth |
| , procutil.fork(__filename, [ |
| util.format('auth-%s', options.authType) |
| , '--port', options.authPort |
| , '--secret', options.authSecret |
| , '--app-url', util.format( |
| 'http://%s:%d/' |
| , options.publicIp |
| , options.poorxyPort |
| ) |
| ].concat(JSON.parse(options.authOptions))) |
| |
| // app |
| , procutil.fork(__filename, [ |
| 'app' |
| , '--port', options.appPort |
| , '--secret', options.authSecret |
| , '--auth-url', options.authUrl || util.format( |
| 'http://%s:%d/auth/%s/' |
| , options.publicIp |
| , options.poorxyPort |
| , { |
| oauth2: 'oauth' |
| , saml2: 'saml' |
| }[options.authType] || options.authType |
| ) |
| , '--websocket-url', util.format( |
| 'http://%s:%d/' |
| , options.publicIp |
| , options.websocketPort |
| ) |
| ].concat((function() { |
| var extra = [] |
| if (options.userProfileUrl) { |
| extra.push('--user-profile-url', options.userProfileUrl) |
| } |
| return extra |
| })())) |
| |
| // websocket |
| , procutil.fork(__filename, [ |
| 'websocket' |
| , '--port', options.websocketPort |
| , '--secret', options.authSecret |
| , '--storage-url' |
| , util.format('http://localhost:%d/', options.poorxyPort) |
| , '--connect-sub', options.bindAppPub |
| , '--connect-push', options.bindAppPull |
| ]) |
| |
| // storage |
| , procutil.fork(__filename, [ |
| util.format('storage-%s', options.storageType) |
| , '--port', options.storagePort |
| ].concat(JSON.parse(options.storageOptions))) |
| |
| // image processor |
| , procutil.fork(__filename, [ |
| 'storage-plugin-image' |
| , '--port', options.storagePluginImagePort |
| , '--storage-url' |
| , util.format('http://localhost:%d/', options.poorxyPort) |
| ]) |
| |
| // apk processor |
| , procutil.fork(__filename, [ |
| 'storage-plugin-apk' |
| , '--port', options.storagePluginApkPort |
| , '--storage-url' |
| , util.format('http://localhost:%d/', options.poorxyPort) |
| ]) |
| |
| // poorxy |
| , procutil.fork(__filename, [ |
| 'poorxy' |
| , '--port', options.poorxyPort |
| , '--app-url' |
| , util.format('http://localhost:%d/', options.appPort) |
| , '--auth-url' |
| , util.format('http://localhost:%d/', options.authPort) |
| , '--websocket-url' |
| , util.format('http://localhost:%d/', options.websocketPort) |
| , '--storage-url' |
| , util.format('http://localhost:%d/', options.storagePort) |
| , '--storage-plugin-image-url' |
| , util.format('http://localhost:%d/', options.storagePluginImagePort) |
| , '--storage-plugin-apk-url' |
| , util.format('http://localhost:%d/', options.storagePluginApkPort) |
| ]) |
| ] |
| |
| function shutdown() { |
| log.info('Shutting down all child processes') |
| procs.forEach(function(proc) { |
| proc.cancel() |
| }) |
| return Promise.settle(procs) |
| } |
| |
| process.on('SIGINT', function() { |
| log.info('Received SIGINT, waiting for processes to terminate') |
| }) |
| |
| process.on('SIGTERM', function() { |
| log.info('Received SIGTERM, waiting for processes to terminate') |
| }) |
| |
| return Promise.all(procs) |
| .then(function() { |
| process.exit(0) |
| }) |
| .catch(function(err) { |
| log.fatal('Child process had an error', err.stack) |
| return shutdown() |
| .then(function() { |
| process.exit(1) |
| }) |
| }) |
| } |
| |
| procutil.fork(__filename, ['migrate']) |
| .done(run) |
| }) |
| |
| program |
| .command('doctor') |
| .description('diagnose issues before starting') |
| .option('--devices' |
| , 'diagnose devices connected to stf') |
| .action(function(options) { |
| require('./util/doctor').run(options) |
| }) |
| |
| program.parse(process.argv) |
