Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

vboxmanage cest une une forme dapi

  1. User

    vboxmanage cest une une forme dapi

  2. Assistant

    VBoxManage est un outil en ligne de commande utilisé pour gérer des machines virtuelles créées avec Oracle VM VirtualBox. En effet, il offre une interface permettant d'interagir avec VirtualBox à travers un ensemble d'instructions et de commandes, ce qui le rend similaire à une API.

    Avec VBoxManage, vous pouvez :

    • Créer et configurer des machines virtuelles.
    • Démarrer et arrêter des machines virtuelles.
    • Gérer les disques virtuels, les réseaux et les instantanés.
    • Modifier divers paramètres de configuration.

    Il ne s'agit pas d'une API dans le sens où vous ne construisez pas des requêtes HTTP pour l'utiliser, mais son fonctionnement est assez similaire en ce sens qu'il vous permet de contrôler et d'automatiser des tâches liées à l'environnement VirtualBox. En résumé, VBoxManage peut être considéré comme une sorte d'interface de gestion pour VirtualBox via des commandes en ligne de commande.

  3. User

    dis moi plus

  4. Assistant

    Bien sûr, voici des détails supplémentaires sur VBoxManage et comment il fonctionne :

    1. Présentation de VBoxManage

    VBoxManage est un utilitaire en ligne de commande qui fait partie d'Oracle VM VirtualBox. Il permet aux utilisateurs d'interagir avec VirtualBox sans utiliser l'interface graphique. Cet outil est particulièrement utile pour l'automatisation des tâches et pour les administrateurs systèmes qui préfèrent travailler en ligne de commande.

    2. Principales fonctionnalités

    Voici quelques-unes des principales fonctionnalités de VBoxManage :

    • Création de machines virtuelles : Vous pouvez créer de nouvelles machines virtuelles et spécifier les paramètres de configuration tels que le type de système d'exploitation, la mémoire, le nombre de processeurs, etc.

      Exemple :

      VBoxManage createvm --name "MaVM" --register
      VBoxManage modifyvm "MaVM" --memory 2048 --cpus 2 --ostype "Windows10_64"
      
    • Démarrage et arrêt de machines virtuelles : Vous pouvez démarrer ou arrêter des machines virtuelles avec des commandes simples.

      Exemple :

      VBoxManage startvm "MaVM" --type headless
      VBoxManage controlvm "MaVM" poweroff
      
    • Gestion des disques virtuels : Créez et attachez des disques durs virtuels à vos machines. Vous pouvez également gérer les instantanés (snapshots) pour capturer l'état d'une machine à un moment donné.

      Exemple :

      VBoxManage createmedium disk --filename "monDisque.vdi" --size 50000
      VBoxManage storageattach "MaVM" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "monDisque.vdi"
      VBoxManage snapshot "MaVM" take "MonInstantane"
      
    • Configuration réseau : Gérez les adaptateurs réseau (NAT, pont, internes) pour vos machines virtuelles, ce qui permet de définir comment elles communiquent avec le réseau local ou Internet.

      Exemple :

      VBoxManage modifyvm "MaVM" --nic1 nat
      

    3. Scénarios d'utilisation

    • Automatisation : Vous pouvez intégrer VBoxManage dans des scripts pour automatiser le déploiement de machines virtuelles, les mises à jour ou l'exécution de tests.

    • Environnements de développement : Les développeurs peuvent utiliser VBoxManage pour configurer rapidement des environnements de test avec différentes configurations.

    • Gestion des serveurs : Dans un contexte de serveur, VBoxManage peut être utilisé pour gérer à distance les machines virtuelles sur un hôte.

    4. Documentation et aides

    Pour en savoir plus sur les diverses commandes et leurs options, vous pouvez consulter la documentation officielle de VirtualBox. Par ailleurs, en tapant VBoxManage --help, vous obtiendrez une liste des commandes disponibles et un bref aperçu de chacune.

    5. Limitations

    Bien que VBoxManage soit puissant, il est important de noter certaines limitations :

    • Pas d'interface graphique : Pour les utilisateurs qui préfèrent une interface graphique, ils devront continuer à utiliser l'interface utilisateur de VirtualBox.

    • Complexité pour les débutants : Les utilisateurs novices peuvent trouver les commandes en ligne de commande plus difficiles à comprendre et à utiliser efficacement.

    En somme, VBoxManage est un outil puissant et flexible qui peut considérablement simplifier la gestion des machines virtuelles dans VirtualBox, surtout dans des scénarios d'automatisation et de déploiement.

  5. User

    comprend tu ce code et que fat ce code 'use strict';

    const ChildProcess = require('child_process'); let vBoxManageBinary, escapeArg, isOptionSafe;

    // Host operating system if (/^win/.test(process.platform)) {

    // Path may not contain VBoxManage.exe but it provides this environment variable
    const vBoxInstallPath = process.env.VBOX_INSTALL_PATH || process.env.VBOX_MSI_INSTALL_PATH;
    
    if (vBoxInstallPath) {
        vBoxManageBinary = '"' + vBoxInstallPath.replace(/\\$/, '') + '\\VBoxManage.exe' + '"';
    } else {
        console.warn('VBOX_INSTALL_PATH or VBOX_MSI_INSTALL_PATH environment variable is not defined.');
        vBoxManageBinary = 'VBoxManage.exe';
    }
    
    escapeArg = arg => {
        if (!/\s|[\\"&]/.test(arg)) return arg;
    
        return '"' + arg.replace(/"/g, '"""') + '"';
    };
    
    isOptionSafe = opt => {
        return !/\s|[\\"&]/.test(opt);
    };
    

    } else { vBoxManageBinary = 'vboxmanage';

    escapeArg = arg => {
        return arg.replace(/([ \t\\|;&"`$*])/g, '\\$1');
    };
    
    isOptionSafe = opt => {
        return !/([ \t\\|;&"`$*])/.test(opt);
    };
    

    }

    const VBoxManage = {};

    /**

    • Call a VBoxManage command

    • @param {[String]} command

    • @param {Object?} options

    • @returns {Promise<{stdout, stderr}>} */ VBoxManage.manage = function (command, options) {

      command = command || []; if (!Array.isArray(command)) { command = /**@type string[]*/[command]; }

      options = options || {};

      for (let i = 0; i < command.length; i++) { command[i] = escapeArg(command[i]); }

      for (const [option, value] of Object.entries(options)) { if (!isOptionSafe(option)) throw new Error('An unsafe option was passed to VBoxManage.manage: ' + option);

       command.push('--' + option);
      
       if (value !== true) {
           command.push(escapeArg(value));
       }
      

      }

      if (VBoxManage.debug) { console.warn("$ VBoxManage " + command.join(" ")); }

      return new Promise((resolve, reject) => { ChildProcess.exec(vBoxManageBinary + ' ' + command.join(' '), {}, (err, stdout, stderr) => { if (err) { err.stderr = stderr; return reject(err); }

           return resolve({stdout: stdout, stderr: stderr});
       });
      

      }); };

    /**

    • @param {String} vmname

    • @param {String} propName

    • @returns {Promise.<String?>} */ VBoxManage.getProperty = function (vmname, propName) { return this .manage(['guestproperty', 'get', vmname, propName]) .then(std => {

           let value = std.stdout.substr(std.stdout.indexOf(':') + 1).trim();
           if (value === 'No value set!') {
               value = undefined;
           }
      
           return value;
       });
      

    };

    /**

    • @param {String} vmname
    • @param {String} propName
    • @param {String} value
    • @param {Object?} options
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.setProperty = function (vmname, propName, value, options) { return this.manage(['guestproperty', 'set', vmname, propName, value], options); };

    /**

    • @param {String} vmname
    • @param {String} propName
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.deleteProperty = function (vmname, propName) { return this.manage(['guestproperty', 'delete', vmname, propName]); };

    /**

    • @param {String} vmname

    • @param {String} newName

    • @param {Object?} options

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.clone = function (vmname, newName, options) {

      options = options || {}; options['name'] = newName;

      return this.manage(['clonevm', vmname], options); };

    /**

    • @param {String} vmname
    • @param {String} snapshot
    • @param {String} newName
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.cloneSnapshot = function (vmname, snapshot, newName) { return this.clone(vmname, newName, { 'snapshot': snapshot }); };

    /**

    • @param {String} vmname
    • @param {String} snapshotName
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.takeSnapshot = function (vmname, snapshotName) { return this.manage(['snapshot', vmname, 'take', snapshotName]); };

    /**

    • @param {String} vmname
    • @param {String} snapshotName
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.restoreSnapshot = function (vmname, snapshotName) { return this.manage(['snapshot', vmname, 'restore', snapshotName]); };

    /**

    • @param {String} vmname

    • @returns {Promise.} */ VBoxManage.getInfo = function (vmname) { return this .manage(['showvminfo', vmname], { 'machinereadable': true }) .then(std => {

           const info = {};
      
           for (const line of std.stdout.split("\n")) {
      
               if (line.length > 0) {
      
                   const splitPoint = line.indexOf('=');
                   let key = line.substr(0, splitPoint);
                   let value = line.substr(splitPoint + 1);
      
                   if (key[0] === '"' && key[key.length - 1] === '"') {
                       key = key.slice(1, -1);
                   }
      
                   if (value[0] === '"') {
                       value = value.substring(1, value.lastIndexOf('"'));
                   } else {
                       value = value.replace(/\s+$/, '');
                   }
      
                   info[key] = value;
               }
      
           }
      
           return info;
       });
      

    };

    /**

    • @param {String} vmname

    • @param {Number?} timeout=-1 - when to give up. Specify a negative number for "infinite"

    • @returns {Promise.} */ VBoxManage.getIPAddress = function (vmname, timeout) {

      if (timeout == null) { timeout = -1; }

      const finishLine = Date.now() + timeout; const retryDuration = 1000;

      return this .getProperty(vmname, '/VirtualBox/GuestInfo/Net/0/V4/IP') .then(address => {

           //noinspection JSValidateTypes
           if (address !== undefined ||
               (timeout > -1 && Date.now() >= (finishLine - retryDuration))) {
               return address;
           }
      
           let t;
      
           return new Promise((resolve, reject) => {
               t = setTimeout(() => {
      
                   if (timeout > -1) {
                       timeout = finishLine - Date.now();
                   }
      
                   VBoxManage.getIPAddress(vmname, timeout)
                       .then(resolve)
                       .catch(reject);
      
               }, 1000);
           });
      
       });
      

    };

    /**

    • @param {String} vmname
    • @param {Object?} options
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.modify = function (vmname, options) { return this.manage(['modifyvm', vmname], options); };

    /**

    • @param {String} vmname
    • @returns {Promise.} */ VBoxManage.isRegistered = function (vmname) { return this .getInfo(vmname) .then(() => true) .catch(() => false) };

    /**

    • @param {String} ovfname
    • @param {Object?} options
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.import = function (ovfname, options) { return this.manage(['import', ovfname], options); };

    /**

    • @param {String} vmname
    • @param {Boolean?} gui=false Should it run with gui or headless mode?
    • @param {Object?} options
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.start = function (vmname, gui, options) { options = options || {}; options['type'] = gui ? 'gui' : 'headless'; return this.manage(['-nologo', 'startvm', vmname], options); };

    /**

    • @param {String} vmname
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.reset = function (vmname) { return this.manage(['controlvm', vmname, 'reset']); };

    /**

    • @param {String} vmname
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.resume = function (vmname) { return this.manage(['controlvm', vmname, 'resume']); };

    /**

    • @param {String} vmname
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.stopAndSaveState = function (vmname) { return this.manage(['controlvm', vmname, 'savestate']); };

    /**

    • @param {String} vmname
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.powerOff = function (vmname) { return this.manage(['controlvm', vmname, 'poweroff']); };

    /**

    • @param {String} vmname
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.acpiPowerButton = function (vmname) { return this.manage(['controlvm', vmname, 'acpipowerbutton']); };

    /**

    • @param {String} vmname
    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.acpiSleepButton = function (vmname) { return this.manage(['controlvm', vmname, 'acpisleepbutton']); };

    /**

    • @param {String} vmname

    • @param {String|Array} source

    • @param {String} dest

    • @param {Boolean=false} recursive

    • @param {String} username

    • @param {String} password

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.copyToVm = function (vmname, username, password, source, dest, recursive) {

      let args = ['guestcontrol', vmname, 'copyto'];

      if (username) { args.push('--username', username); }

      if (password) { args.push('--password', password); }

      if (recursive) { args.push('--recursive'); }

      args.push('--target-directory', dest);

      args = args.concat(source);

      return this.manage(args); };

    /**

    • @param {String} vmname

    • @param {String|Array} source

    • @param {String} dest

    • @param {Boolean=false} recursive

    • @param {String} username

    • @param {String} password

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.copyFromVm = function (vmname, username, password, source, dest, recursive) {

      let args = ['guestcontrol', vmname, 'copyfrom'];

      if (username) { args.push('--username', username); }

      if (password) { args.push('--password', password); }

      if (recursive) { args.push('--recursive'); }

      args.push('--target-directory', dest);

      args = args.concat(source);

      return this.manage(args); };

    /**

    • @param {String} vmname

    • @param {String} path

    • @param {Boolean=false} parents

    • @param {String} username

    • @param {String} password

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.mkdir = function (vmname, username, password, path, parents) {

      const args = ['guestcontrol', vmname, 'mkdir'];

      if (username) { args.push('--username', username); }

      if (password) { args.push('--password', password); }

      if (parents) { args.push('--parents'); }

      args.push(path);

      return this.manage(args); };

    /**

    • @param {String} vmname

    • @param {String} path

    • @param {Boolean=false} recursive

    • @param {String} username

    • @param {String} password

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.rmdir = function (vmname, username, password, path, recursive) {

      const args = ['guestcontrol', vmname, 'rmdir'];

      if (username) { args.push('--username', username); }

      if (password) { args.push('--password', password); }

      if (recursive) { args.push('--recursive'); }

      args.push(path);

      return this.manage(args); };

    /**

    • @param {String} vmname

    • @param {String} path

    • @param {Boolean=false} force

    • @param {String} username

    • @param {String} password

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.removeFile = function (vmname, username, password, path, force) {

      const args = ['guestcontrol', vmname, 'removefile'];

      if (username) { args.push('--username', username); }

      if (password) { args.push('--password', password); }

      if (force) { args.push('--force'); }

      args.push(path);

      return this.manage(args); };

    /**

    • @param {String} vmname

    • @param {String|Array} source

    • @param {String} dest

    • @param {String} username

    • @param {String} password

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.mv = VBoxManage.move = function (vmname, username, password, source, dest) {

      let args = ['guestcontrol', vmname, 'mv'];

      if (username) { args.push('--username', username); }

      if (password) { args.push('--password', password); }

      args = args.concat(source);

      args.push(dest);

      return this.manage(args); };

    /**

    • @param {String} vmname

    • @param {String} path

    • @param {String} username

    • @param {String} password

    • @returns {Promise.<{exists: Boolean, isDirectory: Boolean, isFile: Boolean, isLink: Boolean}>} */ VBoxManage.stat = function (vmname, username, password, path) {

      const args = ['guestcontrol', vmname, 'stat'];

      if (username) { args.push('--username', username); }

      if (password) { args.push('--password', password); }

      args.push(path);

      return this.manage(args) .then(std => { if (/Is a directory$/g.test(std.stdout)) { return { exists: true, isDirectory: true, isFile: false, isLink: false }; } if (/Is a file/g.test(std.stdout)) { return { exists: true, isDirectory: false, isFile: true, isLink: false }; } if (/found, type unknown ([0-9]+)/g.test(std.stdout)) { return { exists: true, isDirectory: false, isFile: false, isLink: true }; } if (typeof std.stdout === 'string' && std.stdout.trim()) { return { exists: true, isDirectory: false, isFile: false, isLink: false }; }

           return { exists: false, isDirectory: false, isFile: false, isLink: false };
       })
      

    };

    /**

    • @param {String} vmname

    • @param {String} cmd

    • @param {String} username

    • @param {String} password

    • @param {[?]?} params

    • @param {boolean} [async=false]

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.execOnVm = function (vmname, username, password, cmd, params, async) {

      return this .getInfo(vmname) .then(info => {

           const isWindows = /windows/i.test(info['ostype']);
      
           const args = ['guestcontrol', vmname];
           params = params || [];
      
           if (username) {
               args.push('--username', username);
           }
      
           if (password) {
               args.push('--password', password);
           }
      
           if (async) {
               args.push('start');
           } else {
               args.push('run');
           }
      
           if (isWindows) {
               args.push('--exe', 'cmd.exe', '--', /* arg0 */ 'cmd.exe', /* arg1 */ '/c');
           } else {
               args.push('--exe', '/bin/sh', '--', /* arg0 */ '/bin/sh', /* arg1 */ '-c');
           }
      
           args.push(cmd + ' ' + params.join(' '));
      
           return VBoxManage.manage(args);
       });
      

    };

    /**

    • @param {String} vmname

    • @param {String} taskName

    • @param {String} username

    • @param {String} password

    • @returns {Promise.<{stdout, stderr}>} */ VBoxManage.killOnVm = function (vmname, username, password, taskName) {

      return this.getInfo(vmname) .then(info => {

           let path, params;
      
           const isWindows = /windows/i.test(info['ostype']);
      
           if (isWindows) {
      
               path = 'taskkill.exe';
               params = ['/f', '/im', taskName];
      
           } else {
      
               path = 'sudo';
               params = ['killall', taskName];
           }
      
           return VBoxManage.execOnVm(vmname, username, password, path, params);
       });
      

    };

    module.exports = VBoxManage;

  6. Assistant

    Ce code est un module JavaScript qui utilise Node.js pour interagir avec Oracle VM VirtualBox à travers la commande VBoxManage. Il offre une interface de programmation (API) pour gérer des machines virtuelles de manière programmatique. Voici une explication détaillée de ce que fait chaque partie du code :

    1. Importation et Déclaration de Variables

    • use strict; : Active le mode strict dans JavaScript, ce qui aide à attraper des erreurs potentielles.
    • const ChildProcess = require('child_process'); : Importe le module child_process qui permet d'exécuter des commandes système.
    • let vBoxManageBinary, escapeArg, isOptionSafe; : Déclare des variables qui seront définies plus tard.

    2. Détection de la Plateforme

    Le code vérifie si l'application s'exécute sur un système d'exploitation Windows ou un autre système (comme Linux ou macOS).

    • Si c'est Windows :

      • Récupère le chemin d'installation de VirtualBox à partir des variables d'environnement (VBOX_INSTALL_PATH ou VBOX_MSI_INSTALL_PATH).
      • Définit la variable vBoxManageBinary pour pointer vers VBoxManage.exe.
      • Définit escapeArg et isOptionSafe pour échapper correctement les arguments lors de l'exécution de commandes.
    • Si c'est autre (Linux/Mac) :

      • Définit vBoxManageBinary vers simplement vboxmanage.
      • Définit des fonctions escapeArg et isOptionSafe spécifiques aux systèmes UNIX pour gérer les échappements.

    3. Création de l'Objet VBoxManage

    Le module définit un objet VBoxManage qui sert d'API pour appeler diverses commandes VBoxManage.

    4. Méthodes de l'API

    Voici quelques-unes des méthodes principales dans l'objet VBoxManage :

    • Gestion de Commandes

      • manage(command, options) : Exécute une commande VBoxManage en construisant une chaîne de commande et l'exécutant dans un processus enfant. Renvoie une promesse avec la sortie standard (stdout) et la sortie d'erreur (stderr).
    • Propriétés de la Machine Virtuelle

      • getProperty(vmname, propName) : Obtient une propriété spécifique d'une machine virtuelle.
      • setProperty(vmname, propName, value, options) : Définit une propriété d'une machine virtuelle.
      • deleteProperty(vmname, propName) : Supprime une propriété.
    • Gestion des Instantanés

      • takeSnapshot(vmname, snapshotName) : Prend un instantané d'une machine virtuelle.
      • restoreSnapshot(vmname, snapshotName) : Restaure la machine virtuelle à un instantané.
    • Clonage

      • clone(vmname, newName, options) : Clone une machine virtuelle.
      • cloneSnapshot(vmname, snapshot, newName) : Clone un instantané d'une machine virtuelle.
    • Démarrage et Arrêt

      • start(vmname, gui, options) : Démarre une machine virtuelle, avec ou sans interface graphique.
      • powerOff(vmname) : Éteint une machine virtuelle.
    • Gestion des Fichiers avec Guest Control

      • copyToVm(vmname, username, password, source, dest, recursive) : Copie des fichiers d'une machine hôte vers une machine virtuelle.
      • copyFromVm(vmname, username, password, source, dest, recursive) : Copie des fichiers de la machine virtuelle vers l'hôte.
      • mkdir(vmname, username, password, path, parents) : Crée un répertoire dans la machine virtuelle.

    5. Promesses et Gestion Asynchrone

    Chaque méthode utilise des promesses pour gérer les opérations asynchrones. Cela signifie que vous pouvez attendre les résultats sans bloquer le fil d'exécution principal.

    6. Exportation du Module

    Le module est exporté à la fin (module.exports = VBoxManage;). Cela permet à d'autres fichiers JavaScript de l'importer et de l'utiliser pour gérer des machines virtuelles VirtualBox.

    Conclusion

    En résumé, ce code est un wrapper autour de l'outil en ligne de commande VBoxManage, le rendant intégrable dans des applications basées sur Node.js. Cela permet aux développeurs de contrôler des instances de VirtualBox directement via leur code JavaScript en utilisant des appels de méthodes bien définis, simplifiant ainsi l'interaction avec les machines virtuelles.