Question

我认为这需要更改为while子句，此时它将等到所有10000次ping完成后，我需要它在ping成功时返回。程序“说”是在OSX上它让电脑说话。

#!/bin/bash
echo begin ping
if ping -c 100000 8.8.8.8 | grep timeout;
then echo `say timeout`;
else echo `say the internet is back up`;
fi

好的，我没有权利回答我自己的问题，所以这是我在玩完之后的答案：

谢谢，是的，我不知道$？到现在。无论如何，现在我已经离开并做了这个。我喜欢你的不是永远不会永远，但在我的情况下，我不需要它停止直到它完成。

#!/bin/bash
intertube=0
echo "begin ping"
while [ $intertube -ne 1 ]; do
        ping -c 3 google.com
        if [ $? -eq  0 ]; then
                echo "ping success";
                say success
                intertube=1;
        else
                echo "fail ping"
        fi
done
echo "fin script"

Answer 1

当ping命令gives you a perfectly good return value：

时，您可能不应该依赖命令的文本输出来决定这一点，尤其是

如果从指定的主机听到至少一个响应，ping实用程序将返回零退出状态;如果传输成功但没有收到回复，则为2;如果发生错误，则来自<sysexits.h>的其他值。

换句话说，使用类似的东西：

((count = 100))                            # Maximum number to try.
while [[ $count -ne 0 ]] ; do
    ping -c 1 8.8.8.8                      # Try once.
    rc=$?
    if [[ $rc -eq 0 ]] ; then
        ((count = 1))                      # If okay, flag to exit loop.
    fi
    ((count = count - 1))                  # So we don't go forever.
done

if [[ $rc -eq 0 ]] ; then                  # Make final determination.
    echo `say The internet is back up.`
else
    echo `say Timeout.`
fi

Answer 2

您不需要使用echo或grep。你可以这样做：

ping -oc 100000 8.8.8.8 > /dev/null && say "up" || say "down"

Answer 3

这也可以通过超时来完成：

# Ping until timeout or 1 successful packet
ping -w (timeout) -c 1

Answer 4

如果您使用-o选项，Mac OS X的ping将在收到一个回复包后退出。

进一步阅读：http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man8/ping.8.html

编辑：paxdiablo makes a very good point关于使用ping的退出状态对您有利。我会做类似的事情：

#!/usr/bin/env bash
echo 'Begin ping'
if ping -oc 100000 8.8.8.8 > /dev/null; then
    echo $(say 'timeout')
else
    echo $(say 'the Internet is back up')
fi

ping将发送最多100,000个数据包，然后以失败状态退出 - 除非它收到一个回复数据包，在这种情况下它会以成功状态退出。然后if将执行适当的声明。

Answer 5

我使用这个Bash脚本在OSX上每分钟测试一次互联网状态

#address=192.168.1.99  # forced bad address for testing/debugging
address=23.208.224.170 # www.cisco.com
internet=1             # default to internet is up

while true;
do
    # %a  Day of Week, textual
    # %b  Month, textual, abbreviated
    # %d  Day, numeric
    # %r  Timestamp AM/PM
    echo -n $(date +"%a, %b %d, %r") "-- " 
    ping -c 1 ${address} > /tmp/ping.$
    if [[ $? -ne 0 ]]; then
        if [[ ${internet} -eq 1 ]]; then   # edge trigger -- was up now down
            echo -n $(say "Internet down") # OSX Text-to-Speech
            echo -n "Internet DOWN"
        else
            echo -n "... still down"
        fi
        internet=0
    else
        if [[ ${internet} -eq 0 ]]; then     # edge trigger -- was down now up
            echo -n $(say "Internet back up") # OSX Text-To-Speech
        fi
        internet=1
    fi   
    cat /tmp/ping.$ | head -2 | tail -1
    sleep 60 ; # sleep 60 seconds =1 min
done

Answer 6

这是我的单线解决方案：

screen -S internet-check -d -m -- bash -c 'while ! ping -c 1 google.com; do echo -; done; echo Google responding to ping | mail -s internet-back my-email@example.com'

这会在新的屏幕会话中运行无限ping，直到有响应，此时它会向my-email@example.com发送电子邮件。在发送到手机的电子邮件时代很有用。

（您可能需要先检查mail是否配置正确echo test | mail -s test my-email@example.com。当然，您可以从done;开始执行任何操作，发出响铃，启动网页浏览器，用你的想象力。）

Answer 7

我喜欢paxdiablo的剧本，但想要一个无限期运行的版本。此版本运行ping，直到建立连接，然后打印一条消息说明。

// Settings
var particleCount = 35,
flareCount = 0,
motion = 0.05,
tilt = 0,
particleSizeBase = 1,
particleSizeMultiplier = 0.5,
flareSizeBase = 100,
flareSizeMultiplier = 100,
glareAngle = -60,
glareOpacityMultiplier = 0.4,
renderParticles = true,
renderParticleGlare = true,
renderFlares = false,
renderLinks = false,
renderMesh = false,
flicker = false,
flickerSmoothing = 15, // higher = smoother flicker
blurSize = 0,
orbitTilt = true,
randomMotion = true,
noiseLength = 1000,
noiseStrength = 3;

document.querySelectorAll('.stars').forEach(canvas => {
  var context = canvas.getContext('2d'),
  color = canvas.dataset['color'],
  mouse = { x: 0, y: 0 },
  m = {},
  r = 0,
  c = 1000, // multiplier for delaunay points, since floats too small can mess up the algorithm
  n = 0,
  nAngle = (Math.PI * 2) / noiseLength,
  nRad = 100,
  nScale = 1,
  nPos = {x: 0, y: 0},
  points = [],
  vertices = [],
  triangles = [],
  links = [],
  particles = [],
  flares = [];

  function init() {
    var i, j, k;

    // requestAnimFrame polyfill
    window.requestAnimFrame = (function(){
      return  window.requestAnimationFrame ||
      window.webkitRequestAnimationFrame ||
      window.mozRequestAnimationFrame ||
      function( callback ){
        window.setTimeout(callback, 1000 / 60);
      };
    })();


    // Size canvas
    resize();

    mouse.x = canvas.clientWidth / 2;
    mouse.y = canvas.clientHeight / 2;

    // Create particle positions
    for (i = 0; i < particleCount; i++) {
      var p = new Particle();
      particles.push(p);
      points.push([p.x*c, p.y*c]);
    }


    vertices = Delaunay.triangulate(points);


    var tri = [];
    for (i = 0; i < vertices.length; i++) {
      if (tri.length == 2) {
        triangles.push(tri);
        tri = [];
      }
      tri.push(vertices[i]);
    }


    // Tell all the particles who their neighbors are
    for (i = 0; i < particles.length; i++) {
      // Loop through all tirangles
      for (j = 0; j < triangles.length; j++) {
        // Check if this particle's index is in this triangle
        k = triangles[j].indexOf(i);
        // If it is, add its neighbors to the particles contacts list
        if (k !== -1) {
          triangles[j].forEach(function(value, index, array) {
            if (value !== i && particles[i].neighbors.indexOf(value) == -1) {
              particles[i].neighbors.push(value);
            }
          });
        }
      }
    }

    var fps = 60;
    var now;
    var then = Date.now();
    var interval = 1000/fps;
    var delta;
    // Animation loop
    (function animloop(){
      requestAnimFrame(animloop);
      now = Date.now();
      delta = now - then;
      if (delta > interval) {


        then = now - (delta % interval);

        resize();
        render();
      }

    })();
  }

  function render() {
    if (randomMotion) {
      n++;
      if (n >= noiseLength) {
        n = 0;
      }

      nPos = noisePoint(n);

    }



    if (renderParticles) {
      // Render particles
      for (var i = 0; i < particleCount; i++) {
        particles[i].render();
      }
    }


  }

  function resize() {

    canvas.width = window.innerWidth * (window.devicePixelRatio || 1);
    canvas.height = canvas.width * (canvas.clientHeight / canvas.clientWidth);

  }



  // Particle class
  var Particle = function() {
    this.x = random(-0.1, 1.1, true);
    this.y = random(-0.1, 1.1, true);
    this.z = random(0,4);
    this.color = color;
    this.opacity = random(0.1,1,true);
    this.flicker = 0;
    this.neighbors = []; // placeholder for neighbors
  };
  Particle.prototype.render = function() {
    var pos = position(this.x, this.y, this.z),
    r = ((this.z * particleSizeMultiplier) + particleSizeBase) * (sizeRatio() / 1000),
    o = this.opacity;



    context.fillStyle = this.color;
    context.globalAlpha = o;
    context.beginPath();

    context.fill();
    context.closePath();

    if (renderParticleGlare) {
      context.globalAlpha = o * glareOpacityMultiplier;

      context.ellipse(pos.x, pos.y, r * 100, r, (glareAngle - ((nPos.x - 0.5) * noiseStrength * motion)) * (Math.PI / 180), 0, 2 * Math.PI, false);
      context.fill();
      context.closePath();
    }

    context.globalAlpha = 1;
  };

  // Utils

  function noisePoint(i) {
    var a = nAngle * i,
    cosA = Math.cos(a),
    sinA = Math.sin(a),


    rad = nRad;
    return {
      x: rad * cosA,
      y: rad * sinA
    };
  }

  function position(x, y, z) {
    return {
      x: (x * canvas.width) + ((((canvas.width / 2) - mouse.x + ((nPos.x - 0.5) * noiseStrength)) * z) * motion),
      y: (y * canvas.height) + ((((canvas.height / 2) - mouse.y + ((nPos.y - 0.5) * noiseStrength)) * z) * motion)
    };
  }

  function sizeRatio() {
    return canvas.width >= canvas.height ? canvas.width : canvas.height;
  }

  function random(min, max, float) {
    return float ?
    Math.random() * (max - min) + min :
    Math.floor(Math.random() * (max - min + 1)) + min;
  }


  // init
  if (canvas) init();
});

我还有一个Gist of this script，我会根据需要更新修复和改进。

Bash循环ping成功

7 个答案: