Example #1
0
func (c *Client) lock(keys []string, wait, release time.Duration) (err error) {
	if c.tcpConn == nil {
		if err = c.Connect(); err != nil {
			return err
		}
	}

	request := &dlock.Request{
		Type: dlock.RequestType_Lock.Enum(),
		Lock: &dlock.RequestLock{
			Keys:         keys,
			WaitMicro:    new(uint64),
			ReleaseMicro: new(uint64),
		},
	}
	*request.Lock.WaitMicro = uint64(wait / time.Microsecond)
	*request.Lock.ReleaseMicro = uint64(release / time.Microsecond)
	if err = dlock.SendMessage(c.w, request); err != nil {
		return err
	}
	if err = c.w.Flush(); err != nil {
		return err
	}

	response := &dlock.Response{}
	if err = dlock.ReadMessage(c.r, response, c.ConfigMaxMessage); err != nil {
		return err
	}
	if response.GetStatus() != dlock.ResponseStatus_Ok {
		return errors.New(fmt.Sprintf("Remote error locking keys %v: %s %s failed keys: %v",
			keys, response.GetStatus().String(), response.GetErrorText(), response.Keys))
	}

	return nil
}
Example #2
0
func (c *Client) Ping() (err error) {
	defer c.profileTime("Client.Ping", time.Now())
	if c.tcpConn == nil {
		if err = c.Connect(); err != nil {
			return err
		}
	}

	request := &dlock.Request{
		Type: dlock.RequestType_Ping.Enum(),
	}
	if err = dlock.SendMessage(c.w, request); err != nil {
		return err
	}
	if err = c.w.Flush(); err != nil {
		return err
	}

	response := &dlock.Response{}
	if err = dlock.ReadMessage(c.r, response, c.ConfigMaxMessage); err != nil {
		return err
	}
	if response.GetStatus() != dlock.ResponseStatus_Ok {
		return errors.New(fmt.Sprintf("Ping: Remote error: %s %s",
			response.GetStatus().String(), response.GetErrorText()))
	}

	return nil
}
Example #3
0
func TestFunctionalLock01(t *testing.T) {
	server := initTestServer(t, 10*time.Millisecond)

	conn1, err := net.Dial("tcp", server.listeners[0].Addr().String())
	assertNil(err)
	err = conn1.SetDeadline(time.Now().Add(100 * time.Millisecond))
	assertNil(err)

	request1 := &dlock.Request{
		Type: dlock.RequestType_Lock.Enum(),
		Lock: &dlock.RequestLock{
			Keys: []string{"q"},
		},
	}
	err = dlock.SendMessage(conn1, request1)
	assertNil(err)

	response1 := &dlock.Response{}
	err = dlock.ReadMessage(conn1, response1, server.ConfigMaxMessage)
	assertNil(err)
	if response1.GetStatus() != dlock.ResponseStatus_Ok {
		t.Fatal("Status != Ok:", response1.GetStatus().String())
	}

	conn2, err := net.Dial("tcp", server.listeners[0].Addr().String())
	assertNil(err)
	err = conn2.SetDeadline(time.Now().Add(100 * time.Millisecond))
	assertNil(err)

	request2 := &dlock.Request{
		Type: dlock.RequestType_Lock.Enum(),
		Lock: &dlock.RequestLock{
			Keys: []string{"q"},
		},
	}
	err = dlock.SendMessage(conn2, request2)
	assertNil(err)

	conn1.Close()

	response2 := &dlock.Response{}
	err = dlock.ReadMessage(conn2, response2, server.ConfigMaxMessage)
	assertNil(err)
	if response1.GetStatus() != dlock.ResponseStatus_Ok {
		t.Fatal("Status != Ok:", response1.GetStatus().String())
	}
}
Example #4
0
func (conn *Connection) readLoop() {
	defer conn.server.releaseClient(&conn.clientId)
	defer conn.ioWait.Done()
	defer close(conn.Rch)

	var err error
	for {
		conn.messageCount++

		conn.funResetIdleTimeout()
		_, err = conn.r.Peek(4)
		if err != nil {
			log.Printf("Connection.readLoop: %s #%d peek error: %s",
				conn.clientId, conn.messageCount, err.Error())
			return
		}

		request := &dlock.Request{}
		conn.funResetReadTimeout()
		err = dlock.ReadMessage(conn.r, request, conn.server.ConfigMaxMessage)

		if err == nil && request.Lock != nil && len(request.Lock.Keys) > 1 {
			sort.Strings(request.Lock.Keys)
		}
		if err != nil {
			// On EOF, close silently.
			if err == io.EOF {
				return
			}
			log.Printf("Connection.readLoop: %s #%d read error: %s",
				conn.clientId, conn.messageCount, err.Error())
			return
		}
		conn.LastRequestTime = time.Now()
		conn.Rch <- request
	}
}