È possibile eseguire il ping di un server da Javascript?

Sto realizzando un'app Web che richiede di verificare se i server remoti sono online o meno. Quando lo eseguo dalla riga di comando, il mio caricamento della pagina arriva fino a un massimo di 60 anni (per 8 voci, si ridimensionerà linearmente con più).

Ho deciso di seguire il percorso del ping sul lato dell'utente. In questo modo, posso caricare la pagina e farli attendere i dati "il server è online" mentre sfoglio i miei contenuti.

Se qualcuno ha la risposta alla domanda di cui sopra, o se conoscono una soluzione per mantenere il caricamento veloce della mia pagina, lo apprezzerei sicuramente.

Ho trovato qualcuno che realizza questo con un uso molto intelligente Imagedell'oggetto nativo .

Dalla loro fonte, questa è la funzione principale (ha dipendenze da altre parti della fonte ma hai l'idea).

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);

  }
}

Funziona su tutti i tipi di server che ho testato (server Web, server ftp e server di gioco). Funziona anche con le porte. Se qualcuno incontra un caso d'uso che non riesce, si prega di pubblicare i commenti e aggiornerò la mia risposta.

Aggiornamento : il link precedente è stato rimosso. Se qualcuno trova o implementa quanto sopra, commenta e lo aggiungerò nella risposta.

Aggiornamento 2 : @trante è stato abbastanza carino da fornire un jsFiddle.

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

Aggiornamento 3 : @Jonathon ha creato un repository GitHub con l'implementazione.

https://github.com/jdfreder/pingjs

Aggiornamento 4 : sembra che questa implementazione non sia più affidabile. Le persone segnalano inoltre che Chrome non supporta più tutto, generando un net::ERR_NAME_NOT_RESOLVEDerrore. Se qualcuno può verificare una soluzione alternativa, la inserirò come risposta accettata.

Il ping è ICMP, ma se sul server remoto è presente una porta TCP aperta, è possibile ottenere così:

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
  }

}

puoi provare questo:

metti ping.html sul server con o senza alcun contenuto, su javascript fai come di seguito:

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

Non è possibile "pingare direttamente" in JavaScript. Ci possono essere alcuni altri modi:

• Ajax
• Utilizzo di un'applet Java con isReachable
• Scrivere uno script sul lato server che esegue il ping e utilizzare AJAX per comunicare con il server
• Potresti anche essere in grado di eseguire il ping in flash (actionscript)

Non è possibile eseguire il ping regolare nel browser Javascript, ma è possibile scoprire se il server remoto è attivo, ad esempio caricando un'immagine dal server remoto. Se il caricamento non riesce -> server inattivo.

Puoi persino calcolare il tempo di caricamento usando onload-event. Ecco un esempio su come utilizzare l'evento onload.

Presentazione con una soluzione WebSocket ...

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);
}

Per mantenere veloci le tue richieste, memorizza nella cache i risultati sul lato server del ping e aggiorna il file ping o il database ogni paio di minuti (o per quanto preciso tu voglia che sia). Puoi usare cron per eseguire un comando shell con i tuoi 8 ping e scrivere l'output in un file, il server web includerà questo file nella tua vista.

Se quello che stai cercando di vedere è se il server "esiste", puoi utilizzare quanto segue:

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;
}

Ciò restituirà un'indicazione vero / falso se il server esiste.

Se vuoi tempo di risposta, una leggera modifica farà:

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'utilizzo è quindi banale:

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

O:

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

Il problema con i ping standard è che sono ICMP, che molti posti non lasciano passare per motivi di sicurezza e traffico . Questo potrebbe spiegare il fallimento.

Ruby prima dell'1.9 aveva un TCP-based ping.rb, che funzionerà con Ruby 1.9+. Tutto quello che devi fare è copiarlo dall'installazione 1.8.7 da qualche altra parte. Ho appena confermato che avrebbe funzionato eseguendo il ping del mio router di casa.

Ci sono molte risposte folli qui e soprattutto su CORS -

È possibile eseguire una richiesta HTTP HEAD (come GET ma senza payload). Vedi https://ochronus.com/http-head-request-good-uses/

NON ha bisogno di un controllo preliminare, la confusione è dovuta a una vecchia versione delle specifiche, vedi Perché una richiesta HEAD di origine incrociata richiede un controllo di verifica preliminare?

Quindi potresti usare la risposta sopra che sta usando la libreria jQuery (non l'ho detto) ma con

type: 'HEAD'

--->

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

Ovviamente puoi anche usare vanilla js o dojo o qualsiasi altra cosa ...

Non so quale versione di Ruby stai utilizzando, ma hai provato a implementare il ping per ruby ​​anziché 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)
});;

se lo esegui con il nodo, la console registrerebbe 200 a condizione che Google non sia inattivo.

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);
    }
  });
};

usare così:

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

È possibile eseguire il comando ping.exe DOS da javaScript utilizzando il seguente:

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;
}

È questo ciò che è stato chiesto o mi sto perdendo qualcosa?

basta sostituire

file_get_contents

con

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

Potrebbe essere molto più semplice di tutto ciò. Se vuoi che la tua pagina venga caricata, verifica la disponibilità o il contenuto di alcune pagine straniere per attivare altre attività della pagina Web, puoi farlo utilizzando solo javascript e php in questo modo.

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>

Questo dovrebbe farlo.

Il javascript attivato dovrebbe includere clearInterval (stopmelater)

Fammi sapere se per te va bene

Jerry

Potresti provare a usare PHP nella tua pagina web ... qualcosa del genere:

<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>";

?>

Questo non è testato quindi potrebbe avere errori di battitura ecc ... ma sono sicuro che funzionerebbe. Potrebbe essere migliorato anche ...