// redis-cli对monitor指令进行特殊处理，只要monitor不断输出StatusReply，可以实现不间断的流输出
// 适用于海量数据的扫描输出，比如iterator扫描整个数据库
func (server *GoRedisServer) OnMONITOR(session *Session, cmd *Command) (reply *Reply) {
// 特殊使用，monitor输出全部key
if cmd.Len() > 1 {
switch strings.ToUpper(cmd.StringAtIndex(1)) {
case "KEYS":
server.monitorKeys(session, cmd)
default:
reply = ErrorReply("bad monitor command")
go func() {
time.Sleep(time.Millisecond * 100)
session.Close()
}()
}
return
}
session.WriteReply(StatusReply("OK"))
client := NewMonClient(session)
remoteHost := session.RemoteAddr().String()
go func() {
stdlog.Printf("[%s] monitor start\n", remoteHost)
// sleep一下，避免启动瞬间输出 +1394530022.495448 [0 127.0.0.1:51980] "monitor"
time.Sleep(time.Millisecond * 10)
server.monmgr.Put(remoteHost, client)
client.Start()
server.monmgr.Remove(remoteHost)
stdlog.Printf("[%s] monitor exit\n", remoteHost)
}()
return
}
func TestPause(t *testing.T) {
log.SetOutput(ioutil.Discard)
defer log.SetOutput(os.Stdout)
_, _, nsqd := mustStartNSQD(NewNSQDOptions())
defer nsqd.Exit()
topicName := "test_topic_pause" + strconv.Itoa(int(time.Now().Unix()))
topic := nsqd.GetTopic(topicName)
err := topic.Pause()
assert.Equal(t, err, nil)
channel := topic.GetChannel("ch1")
assert.NotEqual(t, channel, nil)
msg := nsq.NewMessage(<-nsqd.idChan, []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaa"))
err = topic.PutMessage(msg)
assert.Equal(t, err, nil)
time.Sleep(15 * time.Millisecond)
assert.Equal(t, topic.Depth(), int64(1))
assert.Equal(t, channel.Depth(), int64(0))
err = topic.UnPause()
assert.Equal(t, err, nil)
time.Sleep(15 * time.Millisecond)
assert.Equal(t, topic.Depth(), int64(0))
assert.Equal(t, channel.Depth(), int64(1))
}
func configurer(done chan bool, errLog, infoLog chan string, config chan configTask, configName string) {
var (
fd *os.File
err error
// settings settingsBlock
configBlocks []*configBlock
)
for {
select {
case <-done:
return
default:
if fd, err = os.Open(configName); err != nil {
errLog <- fmt.Sprintf("can't read configuration from %s", configName)
time.Sleep(waitForValidConfigFile)
}
_, configBlocks, err = parseConfigFile(fd)
// XXX compare with prev parsed blocks (или делать это в контроллере)
if err != nil {
errLog <- err.Error()
}
for _, b := range configBlocks {
fmt.Printf("%+v %+v\n", b, b.Checks)
}
time.Sleep(1 * time.Second)
}
}
}
func TestBackToInitialFilter(t *testing.T) {
_, guard := setDummyScreen()
defer guard()
ctx := newCtx(nil, 25)
defer ctx.Stop()
ctx.config.Keymap["C-q"] = "peco.BackToInitialFilter"
ctx.startInput()
if ctx.filters.current != 0 {
t.Errorf("Expected filter to be at position 0, got %d", ctx.filters.current)
return
}
screen.SendEvent(termbox.Event{Key: termbox.KeyCtrlR})
time.Sleep(time.Second)
if ctx.filters.current != 1 {
t.Errorf("Expected filter to be at position 1, got %d", ctx.filters.current)
return
}
screen.SendEvent(termbox.Event{Key: termbox.KeyCtrlQ})
time.Sleep(time.Second)
if ctx.filters.current != 0 {
t.Errorf("Expected filter to be at position 0, got %d", ctx.filters.current)
return
}
}
// New Go Routine based server with auth
func RunServerWithAuth(opts *server.Options, auth server.Auth) *server.Server {
if opts == nil {
opts = &DefaultTestOptions
}
s := server.New(opts)
if s == nil {
panic("No NATS Server object returned.")
}
if auth != nil {
s.SetAuthMethod(auth)
}
// Run server in Go routine.
go s.Start()
end := time.Now().Add(10 * time.Second)
for time.Now().Before(end) {
addr := s.Addr()
if addr == nil {
time.Sleep(50 * time.Millisecond)
// Retry. We might take a little while to open a connection.
continue
}
conn, err := net.Dial("tcp", addr.String())
if err != nil {
// Retry after 50ms
time.Sleep(50 * time.Millisecond)
continue
}
conn.Close()
return s
}
panic("Unable to start NATS Server in Go Routine")
}
func (m *MonstiService) EmitSignal(args *Receive, ret *[][]byte) error {
*ret = make([][]byte, len(m.subscriptions[args.Name]))
for i, id := range m.subscriptions[args.Name] {
retChan := make(chan emitRet)
done := false
go func() {
time.Sleep(time.Second)
for !done {
time.Sleep(30 * time.Second)
m.Logger.Printf(
"Waiting for signal response. Signal: %v, Subscriber: %v",
args.Name, id)
}
}()
m.subscriber[id] <- &signal{args.Name, args.Args, retChan}
emitRet := <-retChan
if len(emitRet.Error) > 0 {
done = true
return fmt.Errorf("Received error as signal response: %v", emitRet.Error)
}
(*ret)[i] = emitRet.Ret
done = true
}
return nil
}
func IsLeaderAlive(currentLeader string) {
if retryCount > 0 {
fmt.Println("Trying......", retryCount)
transport := http.Transport{
Dial: dialTimeout,
}
client := http.Client{
Transport: &transport,
}
url := fmt.Sprintf("http://localhost:%s/isalive", currentLeader)
res, err := client.Get(url)
if err != nil {
time.Sleep(5000 * time.Millisecond)
retryCount--
IsLeaderAlive(currentLeader)
}
fmt.Println("Response Status:", res.StatusCode)
if res.StatusCode == 200 {
time.Sleep(5000 * time.Millisecond)
IsLeaderAlive(currentLeader)
}
} else {
resp, _ := http.Get("http://localhost:9999/flushall")
resp.Body.Close()
initiateElection()
}
}
func main() {
input_channel := make(chan interface{})
go func() {
for i := 0; i < 100; i++ {
// This helps reveal time-dependant bugs
time.Sleep(1000000)
input_channel <- i
}
close(input_channel)
}()
result := mapreduce.MapReduce(
func(x interface{}, output chan interface{}) {
fmt.Println("Mapping ", x)
time.Sleep(100000000)
output <- x.(int) * x.(int)
},
func(input chan interface{}, output chan interface{}) {
total := 0
for item := range input {
fmt.Println("Reducing: ", item.(int))
total += item.(int)
}
output <- total
},
input_channel, 10)
if result.(int) != 328350 {
fmt.Println(result.(int), "Unexpected MapReduce result")
} else {
fmt.Println("OK")
}
}
func (s *DockerSuite) TestRestartContainerwithRestartPolicy(c *check.C) {
out1, _ := dockerCmd(c, "run", "-d", "--restart=on-failure:3", "busybox", "false")
out2, _ := dockerCmd(c, "run", "-d", "--restart=always", "busybox", "false")
id1 := strings.TrimSpace(string(out1))
id2 := strings.TrimSpace(string(out2))
err := waitInspect(id1, "{{ .State.Restarting }} {{ .State.Running }}", "false false", 30*time.Second)
c.Assert(err, checker.IsNil)
// TODO: fix racey problem during restart:
// https://jenkins.dockerproject.org/job/Docker-PRs-Win2Lin/24665/console
// Error response from daemon: Cannot restart container 6655f620d90b390527db23c0a15b3e46d86a58ecec20a5697ab228d860174251: remove /var/run/docker/libcontainerd/6655f620d90b390527db23c0a15b3e46d86a58ecec20a5697ab228d860174251/rootfs: device or resource busy
if _, _, err := dockerCmdWithError("restart", id1); err != nil {
// if restart met racey problem, try again
time.Sleep(500 * time.Millisecond)
dockerCmd(c, "restart", id1)
}
if _, _, err := dockerCmdWithError("restart", id2); err != nil {
// if restart met racey problem, try again
time.Sleep(500 * time.Millisecond)
dockerCmd(c, "restart", id2)
}
dockerCmd(c, "stop", id1)
dockerCmd(c, "stop", id2)
dockerCmd(c, "start", id1)
dockerCmd(c, "start", id2)
}
func (b *board) initBoard() {
for {
b.queryFirmware()
time.Sleep(50 * time.Millisecond)
b.readAndProcess()
if len(b.findEvents("firmware_query")) > 0 {
break
}
}
for {
b.queryCapabilities()
time.Sleep(50 * time.Millisecond)
b.readAndProcess()
if len(b.findEvents("capability_query")) > 0 {
break
}
}
for {
b.queryAnalogMapping()
time.Sleep(50 * time.Millisecond)
b.readAndProcess()
if len(b.findEvents("analog_mapping_query")) > 0 {
break
}
}
b.togglePinReporting(0, High, ReportDigital)
time.Sleep(50 * time.Millisecond)
b.togglePinReporting(1, High, ReportDigital)
time.Sleep(50 * time.Millisecond)
}
func RedisDo(commandName string, args ...interface{}) (interface{}, error) {
var redisConn redis.Conn
var err error
for i := 0; i < redisRetryCount; i++ {
if redisConn, err = redis.Dial("tcp", redisAddress); err != nil {
fog.Warn("redis.Dial: %s", err)
time.Sleep(5 * time.Second)
continue
}
result, err := redisConn.Do(commandName, args...)
redisConn.Close()
if err != nil {
fog.Warn("RedisDo: %s", err)
time.Sleep(1 * time.Second)
continue
}
return result, nil
}
return nil, fmt.Errorf("RedisDo: failed after %d retries %s",
redisRetryCount, err)
}
func join(c *cli.Context) {
dflag := getDiscovery(c)
if dflag == "" {
log.Fatalf("discovery required to join a cluster. See '%s join --help'.", c.App.Name)
}
addr := c.String("advertise")
if addr == "" {
log.Fatal("missing mandatory --advertise flag")
}
if !checkAddrFormat(addr) {
log.Fatal("--advertise should be of the form ip:port or hostname:port")
}
joinDelay, err := time.ParseDuration(c.String("delay"))
if err != nil {
log.Fatalf("invalid --delay: %v", err)
}
if joinDelay < time.Duration(0)*time.Second {
log.Fatalf("--delay should not be a negative number")
}
hb, err := time.ParseDuration(c.String("heartbeat"))
if err != nil {
log.Fatalf("invalid --heartbeat: %v", err)
}
if hb < 1*time.Second {
log.Fatal("--heartbeat should be at least one second")
}
ttl, err := time.ParseDuration(c.String("ttl"))
if err != nil {
log.Fatalf("invalid --ttl: %v", err)
}
if ttl <= hb {
log.Fatal("--ttl must be strictly superior to the heartbeat value")
}
d, err := discovery.New(dflag, hb, ttl, getDiscoveryOpt(c))
if err != nil {
log.Fatal(err)
}
// if joinDelay is 0, no delay will be executed
// if joinDelay is larger than 0,
// add a random delay between 0s and joinDelay at start to avoid synchronized registration
if joinDelay > 0 {
r := rand.New(rand.NewSource(time.Now().UTC().UnixNano()))
delay := time.Duration(r.Int63n(int64(joinDelay)))
log.Infof("Add a random delay %s to avoid synchronized registration", delay)
time.Sleep(delay)
}
for {
log.WithFields(log.Fields{"addr": addr, "discovery": dflag}).Infof("Registering on the discovery service every %s...", hb)
if err := d.Register(addr); err != nil {
log.Error(err)
}
time.Sleep(hb)
}
}
func (self *ProtobufClient) readResponses() {
message := make([]byte, 0, MAX_RESPONSE_SIZE)
buff := bytes.NewBuffer(message)
for !self.stopped {
buff.Reset()
conn := self.getConnection()
if conn == nil {
time.Sleep(200 * time.Millisecond)
continue
}
var messageSizeU uint32
var err error
err = binary.Read(conn, binary.LittleEndian, &messageSizeU)
if err != nil {
log.Error("Error while reading messsage size: %d", err)
time.Sleep(200 * time.Millisecond)
continue
}
messageSize := int64(messageSizeU)
messageReader := io.LimitReader(conn, messageSize)
_, err = io.Copy(buff, messageReader)
if err != nil {
log.Error("Error while reading message: %d", err)
time.Sleep(200 * time.Millisecond)
continue
}
response, err := protocol.DecodeResponse(buff)
if err != nil {
log.Error("error unmarshaling response: %s", err)
time.Sleep(200 * time.Millisecond)
} else {
self.sendResponse(response)
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Printf("%d, %d\n", i, <-c) // ここで読み出すと、case c <- x が評価され、fibonacci内のloopが回る
}
quit <- 0
}()
fibonacci(c, quit)
tick := time.Tick(100 * time.Millisecond)
boom := time.After(500 * time.Millisecond)
for {
select {
case <-tick:
fmt.Println("tick.")
case <-boom:
fmt.Println("BOOM!")
return
default:
fmt.Println(" .")
time.Sleep(50 * time.Millisecond)
}
}
}
// waitInspect will wait for the specified container to have the specified string
// in the inspect output. It will wait until the specified timeout (in seconds)
// is reached.
func waitInspect(name, expr, expected string, timeout time.Duration) error {
after := time.After(timeout)
for {
cmd := exec.Command(dockerBinary, "inspect", "-f", expr, name)
out, _, err := runCommandWithOutput(cmd)
if err != nil {
if !strings.Contains(out, "No such") {
return fmt.Errorf("error executing docker inspect: %v\n%s", err, out)
}
select {
case <-after:
return err
default:
time.Sleep(10 * time.Millisecond)
continue
}
}
out = strings.TrimSpace(out)
if out == expected {
break
}
select {
case <-after:
return fmt.Errorf("condition \"%q == %q\" not true in time", out, expected)
default:
}
time.Sleep(100 * time.Millisecond)
}
return nil
}
func waitForSync() {
for {
Trace.Println("Waiting for Sync")
r, err := http.NewRequest("GET", target+"/rest/system/config/insync", nil)
res, err := performRequest(r)
defer func() {
if res != nil && res.Body != nil {
res.Body.Close()
}
}()
if err != nil {
Warning.Println("Failed to perform request /rest/system/config/insync", err)
time.Sleep(configSyncTimeout)
continue
}
if res.StatusCode != 200 {
Warning.Printf("Status %d != 200 for GET", res.StatusCode)
time.Sleep(configSyncTimeout)
continue
}
bs, err := ioutil.ReadAll(res.Body)
if err != nil {
time.Sleep(configSyncTimeout)
continue
}
var inSync map[string]bool
err = json.Unmarshal(bs, &inSync)
if inSync["configInSync"] {
return
}
time.Sleep(configSyncTimeout)
}
}
func TestClientHeartbeat(t *testing.T) {
heartbeatInterval = 10 * time.Millisecond
addr, err := net.ResolveTCPAddr("tcp", testAddr)
if err != nil {
t.Fatalf("invalid test server address %s: %s", testAddr, err)
}
s := NewServer(addr)
go s.ListenAndServe()
// Delve into rpc server struct to ensure we get correct address since we're
// picking an unused port. If we don't wait for the server to start listening,
// the address will be incorrect.
<-s.listening
c := NewClient(s.Addr())
time.Sleep(heartbeatInterval * 2)
if c != NewClient(s.Addr()) {
t.Error("expected cached client to be returned while healthy")
}
s.Close()
c.Close()
// Wait for the heartbeat interval, which should see a failure on
// the client. Then get a new client and verify it's a new client
// struct.
time.Sleep(heartbeatInterval + 1*time.Millisecond)
if c == NewClient(s.Addr()) {
t.Error("expected failed client to not be returned in 2nd call to NewClient")
}
}
func (self *ServerSuite) TestRestartAfterCompaction(c *C) {
data := `
[{
"points": [[1]],
"name": "test_restart_after_compaction",
"columns": ["val"]
}]
`
self.serverProcesses[0].Post("/db/test_rep/series?u=paul&p=pass", data, c)
collection := self.serverProcesses[0].Query("test_rep", "select * from test_restart_after_compaction", false, c)
c.Assert(collection.Members, HasLen, 1)
series := collection.GetSeries("test_restart_after_compaction", c)
c.Assert(series.Points, HasLen, 1)
resp := self.serverProcesses[0].Post("/raft/force_compaction?u=root&p=root", "", c)
c.Assert(resp.StatusCode, Equals, http.StatusOK)
self.serverProcesses[0].Stop()
time.Sleep(time.Second)
self.serverProcesses[0].Start()
time.Sleep(time.Second * 3)
collection = self.serverProcesses[0].Query("test_rep", "select * from test_restart_after_compaction", false, c)
c.Assert(collection.Members, HasLen, 1)
series = collection.GetSeries("test_restart_after_compaction", c)
c.Assert(series.Points, HasLen, 1)
}
func (s *DockerSuite) TestEventsTimestampFormats(c *check.C) {
name := "events-time-format-test"
// Start stopwatch, generate an event
start := daemonTime(c)
time.Sleep(1100 * time.Millisecond) // so that first event occur in different second from since (just for the case)
dockerCmd(c, "run", "--rm", "--name", name, "busybox", "true")
time.Sleep(1100 * time.Millisecond) // so that until > since
end := daemonTime(c)
// List of available time formats to --since
unixTs := func(t time.Time) string { return fmt.Sprintf("%v", t.Unix()) }
rfc3339 := func(t time.Time) string { return t.Format(time.RFC3339) }
duration := func(t time.Time) string { return time.Now().Sub(t).String() }
// --since=$start must contain only the 'untag' event
for _, f := range []func(time.Time) string{unixTs, rfc3339, duration} {
since, until := f(start), f(end)
out, _ := dockerCmd(c, "events", "--since="+since, "--until="+until)
events := strings.Split(out, "\n")
events = events[:len(events)-1]
nEvents := len(events)
c.Assert(nEvents, checker.GreaterOrEqualThan, 5) //Missing expected event
containerEvents := eventActionsByIDAndType(c, events, name, "container")
c.Assert(containerEvents, checker.HasLen, 5, check.Commentf("events: %v", events))
c.Assert(containerEvents[0], checker.Equals, "create", check.Commentf(out))
c.Assert(containerEvents[1], checker.Equals, "attach", check.Commentf(out))
c.Assert(containerEvents[2], checker.Equals, "start", check.Commentf(out))
c.Assert(containerEvents[3], checker.Equals, "die", check.Commentf(out))
c.Assert(containerEvents[4], checker.Equals, "destroy", check.Commentf(out))
}
}
// For issue #140 https://github.com/influxdb/influxdb/issues/140
func (self *ServerSuite) TestRestartServers(c *C) {
data := `
[{
"points": [[1]],
"name": "test_restart",
"columns": ["val"]
}]
`
self.serverProcesses[0].Post("/db/test_rep/series?u=paul&p=pass", data, c)
collection := self.serverProcesses[0].Query("test_rep", "select * from test_restart", false, c)
c.Assert(collection.Members, HasLen, 1)
series := collection.GetSeries("test_restart", c)
c.Assert(series.Points, HasLen, 1)
for _, s := range self.serverProcesses {
s.Stop()
}
time.Sleep(time.Second)
err := self.serverProcesses[0].Start()
c.Assert(err, IsNil)
time.Sleep(time.Second)
err = self.serverProcesses[1].Start()
c.Assert(err, IsNil)
err = self.serverProcesses[2].Start()
time.Sleep(time.Second * 5)
collection = self.serverProcesses[0].Query("test_rep", "select * from test_restart", false, c)
c.Assert(collection.Members, HasLen, 1)
series = collection.GetSeries("test_restart", c)
c.Assert(series.Points, HasLen, 1)
}
func TestDoAcceptChar(t *testing.T) {
_, guard := setDummyScreen()
defer guard()
ctx := newCtx(nil, 25)
defer ctx.Stop()
ctx.startInput()
message := "Hello, World!"
writeQueryToPrompt(t, message)
time.Sleep(500 * time.Millisecond)
if qs := ctx.QueryString(); qs != message {
t.Errorf("Expected query to be populated as '%s', but got '%s'", message, qs)
}
ctx.MoveCaretPos(-1 * len("World!"))
writeQueryToPrompt(t, "Cruel ")
time.Sleep(500 * time.Millisecond)
expected := "Hello, Cruel World!"
if qs := ctx.QueryString(); qs != expected {
t.Errorf("Expected query to be populated as '%s', but got '%s'", expected, qs)
}
}
func (self *ServerSuite) TestDropSeries(c *C) {
for i := 0; i < 2; i++ {
self.serverProcesses[0].Post("/db?u=root&p=root", `{"name": "drop_series", "replicationFactor": 3}`, c)
self.serverProcesses[0].Post("/db/drop_series/users?u=root&p=root", `{"name": "paul", "password": "******"}`, c)
data := `[{
"name": "cluster_query",
"columns": ["val1"],
"points": [[1]]
}]`
self.serverProcesses[0].Post("/db/drop_series/series?u=paul&p=pass", data, c)
time.Sleep(time.Second)
if i == 0 {
fmt.Printf("Using the http api\n")
resp := self.serverProcesses[0].Request("DELETE", "/db/drop_series/series/cluster_query?u=root&p=root", "", c)
c.Assert(resp.StatusCode, Equals, http.StatusNoContent)
} else {
fmt.Printf("Using the drop series\n")
self.serverProcesses[0].Query("drop_series", "drop series cluster_query", false, c)
}
time.Sleep(time.Second)
for _, s := range self.serverProcesses {
fmt.Printf("Running query against: %d\n", s.apiPort)
collection := s.Query("drop_series", "select * from cluster_query", true, c)
c.Assert(collection.Members, HasLen, 0)
}
}
}
// #18453
func (s *DockerSuite) TestEventsContainerFilterBeforeCreate(c *check.C) {
testRequires(c, DaemonIsLinux)
var (
out string
ch chan struct{}
)
ch = make(chan struct{})
// calculate the time it takes to create and start a container and sleep 2 seconds
// this is to make sure the docker event will recevie the event of container
since := daemonTime(c).Unix()
id, _ := dockerCmd(c, "run", "-d", "busybox", "top")
cID := strings.TrimSpace(id)
waitRun(cID)
time.Sleep(2 * time.Second)
duration := daemonTime(c).Unix() - since
go func() {
out, _ = dockerCmd(c, "events", "-f", "container=foo", "--since=0", fmt.Sprintf("--until=%d", daemonTime(c).Unix()+2*duration))
close(ch)
}()
// Sleep 2 second to wait docker event to start
time.Sleep(2 * time.Second)
id, _ = dockerCmd(c, "run", "--name=foo", "-d", "busybox", "top")
cID = strings.TrimSpace(id)
waitRun(cID)
<-ch
c.Assert(out, checker.Contains, cID, check.Commentf("Missing event of container (foo)"))
}
func TestCache(t *testing.T) {
foobar := "foobar"
Set("foobar", foobar, time.Duration(10*time.Second))
obj, err := Get("foobar")
if err != nil {
t.Error(err)
}
str, ok := obj.(string)
if !ok {
t.Error("Type assertions error")
}
if str != foobar {
t.Error("Set/Get were not conform.")
}
go Set("foobar", foobar, time.Duration(1*time.Microsecond))
time.Sleep(20 * time.Microsecond)
obj, err = Get("foobar")
if err == nil {
t.Error("Time out is not working.")
}
go Set("foobar", foobar, time.Duration(1*time.Microsecond))
time.Sleep(time.Minute)
if HasKey("foobar") {
t.Error("GC is not working.")
}
}
func main() {
worker, _ := zmq.NewSocket(zmq.REQ)
defer worker.Close()
// Set random identity to make tracing easier
rand.Seed(time.Now().UnixNano())
identity := fmt.Sprintf("%04X-%04X", rand.Intn(0x10000), rand.Intn(0x10000))
worker.SetIdentity(identity)
worker.Connect("tcp://localhost:5556")
// Tell broker we're ready for work
fmt.Printf("I: (%s) worker ready\n", identity)
worker.Send(WORKER_READY, 0)
for cycles := 0; true; {
msg, err := worker.RecvMessage(0)
if err != nil {
break // Interrupted
}
// Simulate various problems, after a few cycles
cycles++
if cycles > 3 && rand.Intn(5) == 0 {
fmt.Printf("I: (%s) simulating a crash\n", identity)
break
} else if cycles > 3 && rand.Intn(5) == 0 {
fmt.Printf("I: (%s) simulating CPU overload\n", identity)
time.Sleep(3 * time.Second)
}
fmt.Printf("I: (%s) normal reply\n", identity)
time.Sleep(time.Second) // Do some heavy work
worker.SendMessage(msg)
}
}
func main() {
c1 := make(chan string, 3)
c2 := make(chan string, 3)
go func() {
time.Sleep(time.Second * 2)
c1 <- "c1 resource"
}()
select {
case msg := <-c1:
fmt.Println(msg)
case <-time.After(time.Second * 2):
fmt.Println("timeout 2")
}
go func() {
time.Sleep(time.Second * 1)
c2 <- "c2 resource"
}()
select {
case msg := <-c2:
fmt.Println(msg)
case <-time.After(time.Second * 3):
fmt.Println("timeout 3")
}
}
func (d *Driver) Start() error {
log.Debugf("Starting VM %s", d.MachineName)
d.validateVMRef()
err := d.VM.Create()
if err != nil {
log.Warnf("Failed to start: %s", err)
return err
}
// They wont start immediately
time.Sleep(5 * time.Second)
for i := 0; i < 90; i++ {
time.Sleep(time.Second)
ip, _ := d.GetIP()
if ip != "" {
// Add a second to let things settle
time.Sleep(time.Second)
return nil
}
log.Debugf("Waiting for the VM to come up... %d", i)
}
log.Warnf("Unable to determine VM's IP address, did it fail to boot?")
return err
}
func fileWriter(t *testing.T, file *os.File, logs []string) {
filename := file.Name()
time.Sleep(1 * time.Second) // wait for start Tail...
for _, line := range logs {
if strings.Index(line, RotateMarker) != -1 {
log.Println("fileWriter: rename file => file.old")
os.Rename(filename, filename+".old")
file.Close()
file, _ = os.OpenFile(filename, os.O_CREATE|os.O_WRONLY, 0644)
log.Println("fileWriter: re-opened file")
} else if strings.Index(line, TruncateMarker) != -1 {
time.Sleep(1 * time.Second)
log.Println("fileWriter: truncate(file, 0)")
os.Truncate(filename, 0)
file.Seek(int64(0), os.SEEK_SET)
}
_, err := file.WriteString(line)
log.Print("fileWriter: wrote ", line)
if err != nil {
log.Println("write failed", err)
}
time.Sleep(1 * time.Millisecond)
}
file.Close()
}
func (S) TestAttemptNextHasNext(c *C) {
a := aws.AttemptStrategy{}.Start()
c.Assert(a.Next(), Equals, true)
c.Assert(a.Next(), Equals, false)
a = aws.AttemptStrategy{}.Start()
c.Assert(a.Next(), Equals, true)
c.Assert(a.HasNext(), Equals, false)
c.Assert(a.Next(), Equals, false)
a = aws.AttemptStrategy{Total: 2e8}.Start()
c.Assert(a.Next(), Equals, true)
c.Assert(a.HasNext(), Equals, true)
time.Sleep(2e8)
c.Assert(a.HasNext(), Equals, true)
c.Assert(a.Next(), Equals, true)
c.Assert(a.Next(), Equals, false)
a = aws.AttemptStrategy{Total: 1e8, Min: 2}.Start()
time.Sleep(1e8)
c.Assert(a.Next(), Equals, true)
c.Assert(a.HasNext(), Equals, true)
c.Assert(a.Next(), Equals, true)
c.Assert(a.HasNext(), Equals, false)
c.Assert(a.Next(), Equals, false)
}
func TestSelectDuplicateChannel(t *testing.T) {
// This test makes sure we can queue a G on
// the same channel multiple times.
c := make(chan int)
d := make(chan int)
e := make(chan int)
// goroutine A
go func() {
select {
case <-c:
case <-c:
case <-d:
}
e <- 9
}()
time.Sleep(time.Millisecond) // make sure goroutine A gets qeueued first on c
// goroutine B
go func() {
<-c
}()
time.Sleep(time.Millisecond) // make sure goroutine B gets queued on c before continuing
d <- 7 // wake up A, it dequeues itself from c. This operation used to corrupt c.recvq.
<-e // A tells us it's done
c <- 8 // wake up B. This operation used to fail because c.recvq was corrupted (it tries to wake up an already running G instead of B)
}