Czy można pingować serwer z JavaScript?

Tworzę aplikację internetową, która wymaga sprawdzenia, czy zdalne serwery są online, czy nie. Kiedy uruchamiam go z wiersza poleceń, ładowanie mojej strony wzrasta do pełnych 60 sekund (dla 8 wpisów będzie skalować liniowo z większą liczbą).

Postanowiłem pójść drogą pingowania po stronie użytkownika. W ten sposób mogę załadować stronę i po prostu pozwolić im czekać na dane „serwer jest online” podczas przeglądania moich treści.

Jeśli ktoś ma odpowiedź na powyższe pytanie lub zna sposób na szybkie ładowanie mojej strony, na pewno bym to docenił.

Znalazłem kogoś, kto osiąga to dzięki bardzo sprytnemu wykorzystaniu natywnego Imageobiektu.

Z ich źródła jest to główna funkcja (ma zależności od innych części źródła, ale masz pomysł).

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

  }
}

Działa to na wszystkich typach serwerów, które testowałem (serwery WWW, serwery ftp i serwery gier). Działa również z portami. Jeśli ktoś napotka przypadek użycia, który się nie powiedzie, napisz w komentarzach, a zaktualizuję moją odpowiedź.

Aktualizacja : poprzedni link został usunięty. Jeśli ktoś znajdzie lub zastosuje powyższe, proszę o komentarz, a ja dodam to do odpowiedzi.

Aktualizacja 2 : @trante było na tyle miłe, aby zapewnić jsFiddle.

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

Aktualizacja 3 : @Jonathon utworzył repozytorium GitHub z implementacją.

https://github.com/jdfreder/pingjs

Aktualizacja 4 : Wygląda na to, że ta implementacja nie jest już niezawodna. Ludzie zgłaszają również, że Chrome nie obsługuje już tego wszystkiego, wyrzucając net::ERR_NAME_NOT_RESOLVEDbłąd. Jeśli ktoś może zweryfikować alternatywne rozwiązanie, umieszczę je jako zaakceptowaną odpowiedź.

Ping to ICMP, ale jeśli na zdalnym serwerze jest otwarty port TCP, można to osiągnąć w następujący sposób:

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
  }

}

możesz spróbować tego:

umieść ping.html na serwerze z treścią lub bez, w javascript zrób to samo, co poniżej:

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

Nie możesz bezpośrednio „pingować” w javascript. Może być kilka innych sposobów:

• Ajax
• Korzystanie z apletu Java z isReachable
• Pisanie skryptu po stronie serwera, który pinguje i używa AJAX do komunikowania się ze skryptem serwera
• Możesz także być w stanie pingować we flashu (skrypt działań)

Nie możesz wykonać zwykłego pingowania w Javascript przeglądarki, ale możesz sprawdzić, czy zdalny serwer działa, na przykład ładując obraz ze zdalnego serwera. Jeśli ładowanie się nie powiedzie -> serwer nie działa.

Możesz nawet obliczyć czas ładowania za pomocą zdarzenia onload. Oto przykład użycia zdarzenia onload.

Dołączanie do rozwiązania 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);
}

Aby żądania były szybkie, buforuj wyniki polecenia ping po stronie serwera i aktualizuj plik ping lub bazę danych co kilka minut (lub jakkolwiek chcesz, aby była dokładna). Możesz użyć crona, aby uruchomić polecenie powłoki z 8 pingami i zapisać wynik do pliku, serwer sieciowy włączy ten plik do twojego widoku.

Jeśli próbujesz sprawdzić, czy serwer „istnieje”, możesz użyć następującego:

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

To zwróci prawdę / fałsz wskazujące, czy serwer istnieje.

Jeśli chcesz uzyskać czas odpowiedzi, wystarczy niewielka modyfikacja:

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

Użycie jest wtedy trywialne:

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

Lub:

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

Problem ze standardowymi pingami polega na tym, że są to ICMP, przez które wiele miejsc nie przepuszcza ze względów bezpieczeństwa i ruchu . To może wyjaśniać niepowodzenie.

Ruby przed 1.9 miał oparty na TCP ping.rb, który będzie działał z Ruby 1.9+. Wszystko, co musisz zrobić, to skopiować go z instalacji 1.8.7 do innego miejsca. Właśnie potwierdziłem, że będzie działać, wysyłając polecenie ping do mojego domowego routera.

Jest tu wiele szalonych odpowiedzi, a zwłaszcza dotyczących CORS -

Możesz wykonać żądanie HTTP HEAD (jak GET, ale bez ładunku). Zobacz https://ochronus.com/http-head-request-good-uses/

NIE wymaga kontroli wstępnej, zamieszanie jest spowodowane starą wersją specyfikacji, zobacz Dlaczego żądanie HEAD z innych źródeł wymaga kontroli wstępnej?

Więc możesz użyć powyższej odpowiedzi, która używa biblioteki jQuery (nie powiedział tego), ale z

type: 'HEAD'

--->

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

Oczywiście możesz także użyć vanilla js, dojo lub cokolwiek innego ...

Nie wiem, jakiej wersji Rubiego używasz, ale czy próbowałeś zaimplementować ping dla Rubiego zamiast 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)
});;

jeśli uruchomisz to z węzłem, konsola zarejestruje 200, o ile Google nie jest wyłączone.

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

użyj w ten sposób:

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

Polecenie ping.exe dla systemu DOS można uruchomić z poziomu javaScript w następujący sposób:

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

Czy o to proszono, czy czegoś mi brakuje?

po prostu wymień

file_get_contents

z

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

To może być o wiele łatwiejsze niż to wszystko. Jeśli chcesz, aby Twoja strona się załadowała, sprawdź dostępność lub zawartość jakiejś obcej strony, aby wywołać inną aktywność na stronie internetowej, możesz to zrobić za pomocą tylko javascript i php, takiego jak ten.

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>

Że należy to zrobić.

Uruchomiony skrypt javascript powinien zawierać clearInterval (stopmelater)

Daj mi znać, jeśli to działa dla Ciebie

Nocnik

Możesz spróbować użyć PHP na swojej stronie internetowej ... coś takiego:

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

?>

To nie jest testowane, więc może zawierać literówki itp ... ale jestem pewien, że zadziała. Można by też poprawić ...