Est-il possible d'envoyer un ping à un serveur à partir de Javascript?

Je crée une application Web qui nécessite de vérifier si les serveurs distants sont en ligne ou non. Lorsque je l'exécute à partir de la ligne de commande, le chargement de ma page atteint 60 s (pour 8 entrées, il sera mis à l'échelle linéairement avec plus).

J'ai décidé d'emprunter la voie du ping du côté de l'utilisateur. De cette façon, je peux charger la page et leur demander d'attendre les données "le serveur est en ligne" tout en parcourant mon contenu.

Si quelqu'un a la réponse à la question ci-dessus, ou s'il connaît une solution pour que ma page se charge rapidement, je l'apprécierais certainement.

J'ai trouvé quelqu'un qui accomplit cela avec une utilisation très intelligente de l' Imageobjet natif .

De leur source, c'est la fonction principale (elle a des dépendances sur d'autres parties de la source mais vous voyez l'idée).

function Pinger_ping(ip, callback) {

  if(!this.inUse) {

    this.inUse = true;
    this.callback = callback
    this.ip = ip;

    var _that = this;

    this.img = new Image();

    this.img.onload = function() {_that.good();};
    this.img.onerror = function() {_that.good();};

    this.start = new Date().getTime();
    this.img.src = "http://" + ip;
    this.timer = setTimeout(function() { _that.bad();}, 1500);

  }
}

Cela fonctionne sur tous les types de serveurs que j'ai testés (serveurs Web, serveurs ftp et serveurs de jeux). Cela fonctionne également avec les ports. Si quelqu'un rencontre un cas d'utilisation qui échoue, veuillez poster dans les commentaires et je mettrai à jour ma réponse.

Mise à jour : le lien précédent a été supprimé. Si quelqu'un trouve ou met en œuvre ce qui précède, veuillez commenter et je l'ajouterai dans la réponse.

Mise à jour 2 : @trante était assez gentil pour fournir un jsFiddle.

http://jsfiddle.net/GSSCD/203/

Mise à jour 3 : @Jonathon a créé un dépôt GitHub avec l'implémentation.

https://github.com/jdfreder/pingjs

Mise à jour 4 : il semble que cette implémentation n'est plus fiable. Les gens signalent également que Chrome ne prend plus en charge tout cela, ce qui génère une net::ERR_NAME_NOT_RESOLVEDerreur. Si quelqu'un peut vérifier une autre solution, je la placerai comme réponse acceptée.

Ping est ICMP, mais s'il y a un port TCP ouvert sur le serveur distant, cela peut être réalisé comme ceci:

function ping(host, port, pong) {

  var started = new Date().getTime();

  var http = new XMLHttpRequest();

  http.open("GET", "http://" + host + ":" + port, /*async*/true);
  http.onreadystatechange = function() {
    if (http.readyState == 4) {
      var ended = new Date().getTime();

      var milliseconds = ended - started;

      if (pong != null) {
        pong(milliseconds);
      }
    }
  };
  try {
    http.send(null);
  } catch(exception) {
    // this is expected
  }

}

vous pouvez essayer ceci:

mettez ping.html sur le serveur avec ou sans contenu, sur le javascript, faites la même chose que ci-dessous:

<script>
    function ping(){
       $.ajax({
          url: 'ping.html',
          success: function(result){
             alert('reply');
          },     
          error: function(result){
              alert('timeout/error');
          }
       });
    }
</script>

Vous ne pouvez pas directement "ping" en javascript. Il peut y avoir plusieurs autres façons:

• Ajax
• Utilisation d'une applet Java avec isReachable
• Ecrire un script côté serveur qui pings et utiliser AJAX pour communiquer avec votre script serveur
• Vous pourrez peut-être également envoyer un ping en flash (actionscript)

Vous ne pouvez pas faire de ping régulier dans le Javascript du navigateur, mais vous pouvez savoir si le serveur distant est actif en chargeant par exemple une image depuis le serveur distant. Si le chargement échoue -> serveur arrêté.

Vous pouvez même calculer le temps de chargement en utilisant onload-event. Voici un exemple d'utilisation de l'événement onload.

Pitching in with a websocket solution ...

function ping(ip, isUp, isDown) {
  var ws = new WebSocket("ws://" + ip);
  ws.onerror = function(e){
    isUp();
    ws = null;
  };
  setTimeout(function() { 
    if(ws != null) {
      ws.close();
      ws = null;
      isDown();
    }
  },2000);
}

Pour garder vos demandes rapides, mettez en cache les résultats côté serveur du ping et mettez à jour le fichier ping ou la base de données toutes les deux minutes (ou quelle que soit la précision que vous souhaitez). Vous pouvez utiliser cron pour exécuter une commande shell avec vos 8 pings et écrire la sortie dans un fichier, le serveur Web inclura ce fichier dans votre vue.

Si vous essayez de voir si le serveur "existe", vous pouvez utiliser ce qui suit:

function isValidURL(url) {
    var encodedURL = encodeURIComponent(url);
    var isValid = false;

    $.ajax({
      url: "http://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20html%20where%20url%3D%22" + encodedURL + "%22&format=json",
      type: "get",
      async: false,
      dataType: "json",
      success: function(data) {
        isValid = data.query.results != null;
      },
      error: function(){
        isValid = false;
      }
    });

    return isValid;
}

Cela renverra une indication vrai / faux si le serveur existe.

Si vous souhaitez un temps de réponse, une légère modification fera

function ping(url) {
    var encodedURL = encodeURIComponent(url);
    var startDate = new Date();
    var endDate = null;
    $.ajax({
      url: "http://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20html%20where%20url%3D%22" + encodedURL + "%22&format=json",
      type: "get",
      async: false,
      dataType: "json",
      success: function(data) {
        if (data.query.results != null) {
            endDate = new Date();
        } else {
            endDate = null;
        }
      },
      error: function(){
        endDate = null;
      }
    });

    if (endDate == null) {
        throw "Not responsive...";
    }

    return endDate.getTime() - startDate.getTime();
}

L'usage est alors trivial:

var isValid = isValidURL("http://example.com");
alert(isValid ? "Valid URL!!!" : "Damn...");

Ou:

var responseInMillis = ping("example.com");
alert(responseInMillis);

Le problème avec les pings standard est qu'ils sont ICMP, que beaucoup d'endroits ne laissent pas passer pour des raisons de sécurité et de trafic . Cela pourrait expliquer l'échec.

Ruby avant 1.9 avait un TCP ping.rb, qui fonctionnera avec Ruby 1.9+. Tout ce que vous avez à faire est de le copier de l'installation 1.8.7 vers un autre emplacement. Je viens de confirmer qu'il fonctionnerait en envoyant une requête ping à mon routeur domestique.

Il y a beaucoup de réponses folles ici et en particulier sur CORS -

Vous pouvez faire une requête http HEAD (comme GET mais sans charge utile). Voir https://ochronus.com/http-head-request-good-uses/

Il n'a PAS besoin d'une vérification avant le vol, la confusion est due à une ancienne version de la spécification, voir Pourquoi une demande HEAD d'origine croisée a-t-elle besoin d'une vérification avant vol?

Vous pouvez donc utiliser la réponse ci-dessus qui utilise la bibliothèque jQuery (je ne l'ai pas dit) mais avec

type: 'HEAD'

--->

<script>
    function ping(){
       $.ajax({
          url: 'ping.html',
          type: 'HEAD',
          success: function(result){
             alert('reply');
          },     
          error: function(result){
              alert('timeout/error');
          }
       });
    }
</script>

Bien sûr, vous pouvez également utiliser vanilla js ou dojo ou autre chose ...

Je ne sais pas quelle version de Ruby vous utilisez, mais avez-vous essayé d'implémenter ping pour ruby ​​au lieu de javascript? http://raa.ruby-lang.org/project/net-ping/

let webSite = 'https://google.com/' 
https.get(webSite, function (res) {
    // If you get here, you have a response.
    // If you want, you can check the status code here to verify that it's `200` or some other `2xx`.
    console.log(webSite + ' ' + res.statusCode)
}).on('error', function(e) {
    // Here, an error occurred.  Check `e` for the error.
    console.log(e.code)
});;

si vous exécutez ceci avec node, il consignera le journal 200 tant que Google n'est pas en panne.

const ping = (url, timeout = 6000) => {
  return new Promise((reslove, reject) => {
    const urlRule = new RegExp('(https?|ftp|file)://[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]');
    if (!urlRule.test(url)) reject('invalid url');
    try {
      fetch(url)
        .then(() => reslove(true))
        .catch(() => reslove(false));
      setTimeout(() => {
        reslove(false);
      }, timeout);
    } catch (e) {
      reject(e);
    }
  });
};

utiliser comme ceci:

ping('https://stackoverflow.com/')
  .then(res=>console.log(res))
  .catch(e=>console.log(e))

Vous pouvez exécuter la commande DOS ping.exe à partir de javaScript en utilisant les éléments suivants:

function ping(ip)
{
    var input = "";
    var WshShell = new ActiveXObject("WScript.Shell");
    var oExec = WshShell.Exec("c:/windows/system32/ping.exe " + ip);

    while (!oExec.StdOut.AtEndOfStream)
    {
            input += oExec.StdOut.ReadLine() + "<br />";
    }
    return input;
}

Est-ce ce qui a été demandé ou est-ce que je manque quelque chose?

juste remplacer

file_get_contents

avec

$ip = $_SERVER['xxx.xxx.xxx.xxx'];
exec("ping -n 4 $ip 2>&1", $output, $retval);
if ($retval != 0) { 
  echo "no!"; 
} 
else{ 
  echo "yes!"; 
}

Cela pourrait être beaucoup plus facile que tout ça. Si vous voulez que votre page se charge, puis vérifiez la disponibilité ou le contenu d'une page étrangère pour déclencher une autre activité de page Web, vous pouvez le faire en utilisant uniquement javascript et php comme celui-ci.

yourpage.php

<?php
if (isset($_GET['urlget'])){
  if ($_GET['urlget']!=''){
    $foreignpage= file_get_contents('http://www.foreignpage.html');
    // you could also use curl for more fancy internet queries or if http wrappers aren't active in your php.ini
    // parse $foreignpage for data that indicates your page should proceed
    echo $foreignpage; // or a portion of it as you parsed
    exit();  // this is very important  otherwise you'll get the contents of your own page returned back to you on each call
  }
}
?>

<html>
  mypage html content
  ...

<script>
var stopmelater= setInterval("getforeignurl('?urlget=doesntmatter')", 2000);

function getforeignurl(url){
  var handle= browserspec();
  handle.open('GET', url, false);
  handle.send();
  var returnedPageContents= handle.responseText;
  // parse page contents for what your looking and trigger javascript events accordingly.
  // use handle.open('GET', url, true) to allow javascript to continue executing. must provide a callback function to accept the page contents with handle.onreadystatechange()
}
function browserspec(){
  if (window.XMLHttpRequest){
    return new XMLHttpRequest();
  }else{
    return new ActiveXObject("Microsoft.XMLHTTP");
  }
}

</script>

Ça devrait le faire.

Le javascript déclenché doit inclure clearInterval (stopmelater)

Laissez-moi savoir si cela fonctionne pour vous

Jerry

Vous pouvez essayer d'utiliser PHP dans votre page Web ... quelque chose comme ceci:

<html><body>
<form method="post" name="pingform" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<h1>Host to ping:</h1>
<input type="text" name="tgt_host" value='<?php echo $_POST['tgt_host']; ?>'><br>
<input type="submit" name="submit" value="Submit" >
</form></body>
</html>
<?php

$tgt_host = $_POST['tgt_host'];
$output = shell_exec('ping -c 10 '. $tgt_host.');

echo "<html><body style=\"background-color:#0080c0\">
<script type=\"text/javascript\" language=\"javascript\">alert(\"Ping Results: " . $output . ".\");</script>
</body></html>";

?>

Ce n'est pas testé, il peut donc y avoir des fautes de frappe, etc. mais je suis convaincu que cela fonctionnerait. Pourrait être amélioré aussi ...