Simulazione del terminale Linux nel browser

Question

Ho letto della simulazione di Linux di Fabrice Bellard nel browser.

How does Linux emulator in Javascript by Fabrice Bellard work?

Oggi mi sono imbattuto su questo sito, dove sono simulando terminale Linux completo in del browser, sono in grado di eseguire Python, Perl ecc so che sono in esecuzione il loro sito su node.js, ma io non riuscivo a capire come simulavano esattamente il terminale.

http://runnable.com/UWRl3KlLuONCAACG/read-files-from-filesystem-in-python

Answer 1

Il Linux completo è http://docker.io, il resto è https://github.com/Runnable/dockworker

Non stiamo simulando il terminale, ma come dice Kyle, replicando il terminale sopra WebSockets (con un fallback Ajax).

Nel browser si utilizza https://github.com/chjj/term.js derivato dall'emulatore di Fabrice Bellard. Gestisce l'output e anche l'acquisizione dei tasti.

Answer 2

Permettetemi prefisso questo dicendo che non è una buona idea per fare questo.

Tuttavia, è possibile generare una shell e utilizzare socket Web o XMLHttpRequests per premere i tasti per il processo del server generato. Ecco un esempio funzionante di uno che gira su Windows. Sfortunatamente, non sono riuscito a collegarmi/capire Ctrl + c. Ma dovresti averne il succo.

require("underscore"); 

    var Server = {}, 
     express = require("express"), 
     path = require("path"), 
     sys = require("sys"), 
     application_root = __dirname; 

    global.Server = Server; 
    Server.root = application_root; 
    global.app = express(); 

    Server.setup = require("./lib/setup.js").setup({ 
    //redis: require("./lib/redis-client").createClient(), 
    app: app, 
    //mongoose : require("mongoose"), 
    io : require("socket.io"), 
    express : express, 
    port: 1773, 
    paths : { 
     views : path.join(application_root,"app","views"), 
     root : path.join(application_root,"public"), 
     controllers : path.join(application_root,"app","controllers"), 
     models : path.join(application_root,"app","models") 
    } 
    }); 

    var proc = require('child_process'), 
     cmd; 

    app.socket.on('connection', function(socket) { 
    if (!cmd) { 
     //console.log('spawning cmd'); 
     cmd = proc.spawn('cmd'); 

     //console.log(cmd?'CMD started':'CMD not started'); 

     if (cmd.stdout) { 
     //console.log('stdout present'); 
     cmd.stdout.on('data',function(data) { 
      if (data) { 
      //console.log("data: "+data); 
      socket.emit('cmd', ""+data); 
      } 
     }); 
     } 
     if (cmd.stderr) { 
     cmd.stderr.on('data', function(data) { 
      //console.log('stderr present'); 
      if (data) { 
      socket.emit('cmd', ""+data); 
      } 
     }); 
     } 

     cmd.on('exit', function() { 
     //console.log('cmd exited'); 
     socket.emit('cmd', '[CMD Shutdown]'); 
     if (cmd) { 
      cmd.kill(); 
      cmd = null; 
     } 
     }); 
    } 

    socket.on('sendCmd', function(data) { 
     if (data && data.buffer) { 
     var kB = data.buffer.replace("\r","\n"); 
     if (cmd && cmd.stdin) { 
      cmd.stdin.write(kB); 
     } 
     } 
    }); 

    socket.on('disconnect', function() { 
     console.log('connection closed'); 
     if (cmd) { 
     cmd.stdin.end(); //.kill(); 
     if (cmd) { 
      cmd.kill(); 
      cmd = null; 
     } 
     } 
    }); 
    }); 

Edit: In realtà, questa è una porzione di un esempio di lavoro. Manca il lato client in cui si acquisiscono e si inviano le sequenze di tasti al server. Ma dovrebbe darti un'idea generale.