É possível executar ping em um servidor a partir de Javascript?

Estou criando um aplicativo Web que exige que eu verifique se os servidores remotos estão online ou não. Quando o executo a partir da linha de comando, o carregamento da minha página chega aos 60 anos (para 8 entradas, ele será dimensionado linearmente com mais).

Eu decidi seguir a rota do ping no final do usuário. Dessa forma, eu posso carregar a página e esperar que os dados do "servidor estejam online" enquanto navego no meu conteúdo.

Se alguém tiver a resposta para a pergunta acima ou se souber uma solução para manter minha página carregada rapidamente, eu certamente apreciaria.

Eu encontrei alguém que realiza isso com um uso muito inteligente do Imageobjeto nativo .

Da fonte deles, essa é a função principal (ela depende de outras partes da fonte, mas você entendeu).

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

  }
}

Isso funciona em todos os tipos de servidores que eu testei (servidores web, servidores ftp e servidores de jogos). Também funciona com portas. Se alguém encontrar um caso de uso que falhar, poste nos comentários e eu atualizarei minha resposta.

Atualização : o link anterior foi removido. Se alguém encontrar ou implementar o acima, comente e eu o adicionarei na resposta.

Atualização 2 : @trante foi bom o suficiente para fornecer um jsFiddle.

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

Atualização 3 : o @Jonathon criou um repositório do GitHub com a implementação.

https://github.com/jdfreder/pingjs

Atualização 4 : Parece que esta implementação não é mais confiável. As pessoas também estão relatando que o Chrome não suporta mais tudo, gerando um net::ERR_NAME_NOT_RESOLVEDerro. Se alguém puder verificar uma solução alternativa, colocarei isso como a resposta aceita.

O ping é ICMP, mas se houver alguma porta TCP aberta no servidor remoto, isso pode ser alcançado da seguinte maneira:

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
  }

}

você pode tentar isso:

coloque ping.html no servidor com ou sem conteúdo, no javascript faça o mesmo que abaixo:

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

Você não pode "pingar" diretamente em javascript. Pode haver algumas outras maneiras:

• Ajax
• Usando um applet java com isReachable
• Escrevendo um script do lado do servidor que faz ping e usando o AJAX para se comunicar com o lado do servidor
• Você também pode executar ping no flash (actionscript)

Você não pode executar ping regularmente no Javascript do navegador, mas pode descobrir se o servidor remoto está ativo, carregando, por exemplo, uma imagem do servidor remoto. Se o carregamento falhar -> servidor inoperante.

Você pode até calcular o tempo de carregamento usando onload-event. Aqui está um exemplo de como usar o evento onload.

Apresentando uma solução 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);
}

Para manter suas solicitações rápidas, armazene em cache os resultados do ping no servidor e atualize o arquivo ou o banco de dados ping a cada dois minutos (ou por mais preciso que você queira). Você pode usar o cron para executar um comando shell com seus 8 pings e gravar a saída em um arquivo, o servidor da Web incluirá esse arquivo em sua visualização.

Se o que você está tentando ver é se o servidor "existe", você pode usar o seguinte:

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

Isso retornará uma indicação verdadeira / falsa se o servidor existe.

Se você deseja tempo de resposta, uma pequena modificação 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();
}

O uso é então trivial:

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

Ou:

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

O problema dos pings padrão é que eles são ICMP, que muitos lugares não deixam passar por razões de segurança e tráfego . Isso pode explicar o fracasso.

O Ruby anterior ao 1.9 tinha um baseado em TCP ping.rb, que será executado com o Ruby 1.9+. Tudo o que você precisa fazer é copiá-lo da instalação 1.8.7 para outro lugar. Acabei de confirmar que seria executado executando ping no meu roteador doméstico.

Há muitas respostas loucas aqui e especialmente sobre o CORS -

Você pode fazer uma solicitação http HEAD (como GET, mas sem carga útil). Consulte https://ochronus.com/http-head-request-good-uses/

NÃO precisa de uma verificação prévia, a confusão ocorre devido a uma versão antiga da especificação, consulte Por que uma solicitação HEAD de origem cruzada precisa de uma verificação prévia?

Então você pode usar a resposta acima, que está usando a biblioteca jQuery (não disse), mas com

type: 'HEAD'

--->

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

Claro que você também pode usar vanilla js ou dojo ou qualquer outra coisa ...

Não sei qual versão do Ruby você está executando, mas você tentou implementar o ping para ruby ​​em vez 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)
});;

se você executar isso com o nó, o console 200 será registrado, desde que o google não esteja inativo.

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

use assim:

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

Você pode executar o comando DOS ping.exe no javaScript usando o seguinte:

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

Foi isso que foi solicitado ou estou faltando alguma coisa?

apenas substitua

file_get_contents

com

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

Pode ser muito mais fácil do que tudo isso. Se você deseja que sua página carregue, verifique a disponibilidade ou o conteúdo de alguma página estrangeira para acionar outras atividades da página da web, você pode fazê-lo usando apenas javascript e php como este.

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>

Isso deve resolver.

O javascript acionado deve incluir clearInterval (stopmelater)

Deixe-me saber se isso funciona para você

Jerry

Você pode tentar usar PHP na sua página da Web ... algo como isto:

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

?>

Isso não foi testado, portanto pode haver erros de digitação, etc ... mas estou confiante de que funcionaria. Poderia ser melhorado também ...