Discussion :

[vrahi]

Bonjour,

Je souhaite réaliser un compilateur web dans l'esprit de cpp.sh ou replit (https://repl.it/languages/c). Mon interface web se connecte au serveur grâce à SSH (librairie libssh2 de php).
Lorsque l'utilisateur appuie sur le bouton run, le code est envoyé au serveur sous forme de fichier, le serveur le compile et l'exécute, l'interface doit récupéré la sortie et l'afficher dans un div Console.
Pour ce faire, l'interface lit la sortie tant que celle ci est non nulle.

Mon problème est qu'à chaque nouvelle requête, Symfony réinstancie le service qui gère la connexion SSH. En effet, si le programme de l'utilisateur contient une fonction de lecture (scanf en C par exemple) alors cela devient très problématique de répondre au serveur pour qu'il puisse terminer l'exécution du programme.

Je souhaiterais donc savoir s'il est possible de faire en sorte que Symfony garde le même objet Service durant toute l'exécution du programme de l'utilisateur ?

Je met ici le code de la classe qui gère la connexion SSH:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
 
<?php
 
namespace MainBundle\Services;
 
class GestionSSH{
 
    private $m_host;
    private $m_login;
    private $m_mdp;
    private $m_connexion;
    private $m_stream;
 
 
    public function __construct($ssh_adr,$ssh_login,$ssh_password){
 
        $this->m_host=$ssh_adr;
        $this->m_login = $ssh_login;
        $this->m_mdp = $ssh_password;
 
        $this->m_connexion = ssh2_connect($this->m_host);
	ssh2_auth_password($this->m_connexion,$this->m_login,$this->m_mdp);
 
        $this->setStream("./a.out"); //./a.out est un programme qui lit une chaine de caractère et l'affiche ensuite 
    }
 
    function setStream($cmd){
        $this->m_stream = ssh2_exec($this->m_connexion,$cmd);
        stream_set_blocking($this->m_stream, true);
    }
 
    function lire(){
 
        return fread($this->m_stream, 4096);
    }
 
    function ecrire($msg){
        flush();
        fwrite($this->m_stream,$msg.PHP_EOL);
 
    }
 
};
?>

Ainsi que ma classe Controller:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
<?php
 
namespace MainBundle\Controller;
 
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Request;
 
 
class MainController extends Controller{
 
    public function indexAction(){
 
        $content=$this->get('templating')->render('MainBundle:Console:console.html.twig',array(""));
 
        return new Response($content);
 
 
    }
 
//Envoie les messages au serveur
        public function inputAction(Request $request){
            $logger = $this->get('logger');
 
            $ssh = $this->container->get('gestionssh');
 
 
            $msg = $request->request->get('msg');
 
            $ssh->ecrire($msg);
 
            return new Response();
 
	}
 
//Lit les messages du serveurs et les envoie à l'interface
        public function outputAction(Request $request){
            $logger = $this->get('logger');
            $ssh = $this->container->get('gestionssh');
 
            $output = $ssh->lire();
            $logger->info("Log output : ".$output);
            if($output){
                $logger->info("Log output : ".$output);
                return new Response($output);
            }
            else{
                return new Response("END");
            }  
        }   
}
 
?>

Merci d'avance pour vos réponses.

[MehrezLabidi]

Globalement Symfony ne peux pas dépasser les limites de PHP lui même. Pourquoi ne pas utiliser un outil comme REDIS pour garde le même objet Service durant toute l'exécution du programme de l'utilisateur , un stockage sur la ram puis à l'utilisateur de décider l'exécution

[vrahi]

Je ne connais pas cet outil, je vais aller voir ce que c'est exactement ! En tout cas, c'est bien dommage qu'il n'y ait pas une façon simple de faire !