balena-cli/build/commands/device/detect.js

The official balena Command Line Interface

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require("@oclif/core");
const lazy_1 = require("../../utils/lazy");
class DeviceDetectCmd extends core_1.Command {
    async run() {
        const _ = await Promise.resolve().then(() => require('lodash'));
        const { discoverLocalBalenaOsDevices } = await Promise.resolve().then(() => require('../../utils/discover'));
        const prettyjson = await Promise.resolve().then(() => require('prettyjson'));
        const dockerUtils = await Promise.resolve().then(() => require('../../utils/docker'));
        const dockerPort = 2375;
        const dockerTimeout = 2000;
        const { flags: options } = await this.parse(DeviceDetectCmd);
        const discoverTimeout = options.timeout != null ? options.timeout * 1000 : undefined;
        const ux = (0, lazy_1.getCliUx)();
        ux.action.start('Scanning for local balenaOS devices');
        const localDevices = await discoverLocalBalenaOsDevices(discoverTimeout);
        const engineReachableDevices = await Promise.all(localDevices.map(async ({ address }) => {
            const docker = await dockerUtils.createClient({
                host: address,
                port: dockerPort,
                timeout: dockerTimeout,
            });
            try {
                await docker.ping();
                return true;
            }
            catch (err) {
                return false;
            }
        }));
        const developmentDevices = localDevices.filter((_localDevice, index) => engineReachableDevices[index]);
        const productionDevices = _.differenceWith(localDevices, developmentDevices, _.isEqual);
        const productionDevicesInfo = productionDevices.map((device) => {
            return {
                host: device.host,
                address: device.address,
                osVariant: 'production',
                dockerInfo: undefined,
                dockerVersion: undefined,
            };
        });
        const devicesInfo = await Promise.all(developmentDevices.map(async ({ host, address }) => {
            const docker = await dockerUtils.createClient({
                host: address,
                port: dockerPort,
                timeout: dockerTimeout,
            });
            const [dockerInfo, dockerVersion] = await Promise.all([
                docker.info(),
                docker.version(),
            ]);
            return {
                host,
                address,
                osVariant: 'development',
                dockerInfo,
                dockerVersion,
            };
        }));
        ux.action.stop('Reporting scan results');
        if (!options.verbose) {
            devicesInfo.forEach((d) => {
                d.dockerInfo = _.isObject(d.dockerInfo)
                    ? _.pick(d.dockerInfo, DeviceDetectCmd.dockerInfoProperties)
                    : d.dockerInfo;
                d.dockerVersion = _.isObject(d.dockerVersion)
                    ? _.pick(d.dockerVersion, DeviceDetectCmd.dockerVersionProperties)
                    : d.dockerVersion;
            });
        }
        const cmdOutput = [...productionDevicesInfo, ...devicesInfo];
        if (!options.json && cmdOutput.length === 0) {
            console.error(process.platform === 'win32'
                ? DeviceDetectCmd.noDevicesFoundMessage +
                    DeviceDetectCmd.windowsTipMessage
                : DeviceDetectCmd.noDevicesFoundMessage);
            return;
        }
        console.log(options.json
            ? JSON.stringify(cmdOutput, null, 4)
            : prettyjson.render(cmdOutput, { noColor: true }));
    }
}
DeviceDetectCmd.aliases = ['scan'];
DeviceDetectCmd.deprecateAliases = true;
DeviceDetectCmd.description = (0, lazy_1.stripIndent) `
		Scan for balenaOS devices on your local network.

		Scan for balenaOS devices on your local network.

		The output includes device information collected through balenaEngine for
		devices running a development image of balenaOS. Devices running a production
		image do not expose balenaEngine (on TCP port 2375), which is why less
		information is printed about them.
`;
DeviceDetectCmd.examples = [
    '$ balena device detect',
    '$ balena device detect --timeout 120',
    '$ balena device detect --verbose',
];
DeviceDetectCmd.flags = {
    verbose: core_1.Flags.boolean({
        default: false,
        char: 'v',
        description: 'display full info',
    }),
    timeout: core_1.Flags.integer({
        char: 't',
        description: 'scan timeout in seconds',
    }),
    json: core_1.Flags.boolean({
        default: false,
        char: 'j',
        description: 'produce JSON output instead of tabular output',
    }),
};
DeviceDetectCmd.primary = true;
DeviceDetectCmd.root = true;
DeviceDetectCmd.offlineCompatible = true;
DeviceDetectCmd.dockerInfoProperties = [
    'Containers',
    'ContainersRunning',
    'ContainersPaused',
    'ContainersStopped',
    'Images',
    'Driver',
    'SystemTime',
    'KernelVersion',
    'OperatingSystem',
    'Architecture',
];
DeviceDetectCmd.dockerVersionProperties = ['Version', 'ApiVersion'];
DeviceDetectCmd.noDevicesFoundMessage = 'Could not find any balenaOS devices on the local network.';
DeviceDetectCmd.windowsTipMessage = `

Note for Windows users:
  The 'device detect' command relies on the Bonjour service. Check whether Bonjour is
  installed (Control Panel > Programs and Features). If not, you can download
  Bonjour for Windows (included with Bonjour Print Services) from here:
  https://support.apple.com/kb/DL999

  After installing Bonjour, restart your PC and run the 'balena device detect' command
  again.`;
exports.default = DeviceDetectCmd;
//# sourceMappingURL=detect.js.map