gistfile1.go

type slowReader struct {
    readChan chan int
    inReader chan struct{}
    id       int
}

func (s *slowReader) Read(p []byte) (i int, err error) {
    if s.inReader != nil {
        s.inReader <- struct{}{}
        close(s.inReader)
        s.inReader = nil
    }
    data := <-s.readChan
    fmt.Println(">>", s.id, data)
    if data == 2 {
        fmt.Println("I AM DONE", s.id)
        return 0, io.EOF
    }
    p[0] = byte('a')
    return 1, nil
}

func (s *slowReader) Close() error {
    return nil
}

func (s *slowReader) waitUntilReading() {
    <-s.inReader
}

func (s *slowReader) sendByte() {
    s.readChan <- 0
}

func (s *slowReader) sendEOF() {
    s.readChan <- 2
}

func TestAcquireDevice(t *testing.T) {
    ts, err := makeObjectServer("disk_limit", "1/10")
    assert.Nil(t, err)
    defer ts.Close()

    sr1 := &slowReader{id: 1, inReader: make(chan struct{}), readChan: make(chan int)}
    req1, err := http.NewRequest("PUT", fmt.Sprintf("http://%s:%d/sda/0/a/c/o", ts.host, ts.port), sr1)
    assert.Nil(t, err)
    req1.Header.Set("Content-Type", "text")
    req1.Header.Set("Content-Length", "1")
    req1.Header.Set("X-Timestamp", common.GetTimestamp())

    sr2 := &slowReader{id: 2, inReader: make(chan struct{}), readChan: make(chan int)}
    req2, err := http.NewRequest("PUT", fmt.Sprintf("http://%s:%d/sda/0/a/c/o2", ts.host, ts.port), sr2)
    assert.Nil(t, err)
    req2.Header.Set("Content-Type", "text")
    req2.Header.Set("Content-Length", "1")
    req2.Header.Set("X-Timestamp", common.GetTimestamp())

    done1 := make(chan bool)
    go func() {
        fmt.Println("LAUNCHING 1")
        resp, err := http.DefaultClient.Do(req1)
        assert.Equal(t, 201, resp.StatusCode)
        assert.Nil(t, err)
        done1 <- true
    }()
    sr1.waitUntilReading()
    
    done2 := make(chan bool)
    go func() {
        resp, err := http.DefaultClient.Do(req2)
        assert.Nil(t, err)
        assert.Equal(t, 503, resp.StatusCode)
        assert.Equal(t, "1", resp.Header.Get("X-Disk-Usage"))
        done2 <- true
    }()
    sr2.waitUntilReading()

    sr1.sendByte()
    sr2.sendByte()
    sr2.sendEOF()
    <-done2
    sr1.sendEOF()
    <-done1
}