Added sample comments to fix golint errors

chaos/chaos-server.go

@@ -34,7 +34,10 @@ import (
 // const LockMaintenanceLoop       = 1 * time.Minute
 // const LockCheckValidityInterval = 2 * time.Minute
 //
+
+// LockMaintenanceLoop is the locking time for maintenance loop
 const LockMaintenanceLoop = 1 * time.Second
+// LockCheckValidityInterval is the time to check validity interval 
 const LockCheckValidityInterval = 5 * time.Second
 
 func startRPCServer(port int) {

chaos/chaos.go

@@ -524,43 +524,50 @@ func testTwoClientsThatHaveReadLocksCrash(wg *sync.WaitGroup, ds *dsync.Dsync) {
 	log.Println("**PASSED** testTwoClientsThatHaveReadLocksCrash")
 }
 
+// RWLocker Interface
 type RWLocker interface {
 	Lock(id, source string)
 	RLock(id, source string)
 	Unlock()
 	RUnlock()
 }
 
+// DRWMutexNoWriterStarvation Struct
 type DRWMutexNoWriterStarvation struct {
 	excl *dsync.DRWMutex
 	rw   *dsync.DRWMutex
 }
 
+// NewDRWMutexNoWriterStarvation function
 func NewDRWMutexNoWriterStarvation(name string, ds *dsync.Dsync) *DRWMutexNoWriterStarvation {
 	return &DRWMutexNoWriterStarvation{
 		excl: dsync.NewDRWMutex(context.Background(), name+"-excl-no-writer-starvation", ds),
 		rw:   dsync.NewDRWMutex(context.Background(), name, ds),
 	}
 }
 
+// Lock function
 func (d *DRWMutexNoWriterStarvation) Lock(id, source string) {
 	d.excl.Lock(id+"-excl-no-writer-starvation", source)
 	defer d.excl.Unlock()
 
 	d.rw.Lock(id, source)
 }
 
+// Unlock function
 func (d *DRWMutexNoWriterStarvation) Unlock() {
 	d.rw.Unlock()
 }
 
+// RLock function
 func (d *DRWMutexNoWriterStarvation) RLock(id, source string) {
 	d.excl.Lock(id+"-excl-no-writer-starvation", source)
 	defer d.excl.Unlock()
 
 	d.rw.RLock(id, source)
 }
 
+// RUnlock function
 func (d *DRWMutexNoWriterStarvation) RUnlock() {
 	d.rw.RUnlock()
 }

chaos/net-rpc-client.go

@@ -81,35 +81,42 @@ func (rpcClient *ReconnectRPCClient) Call(serviceMethod string, args interface{}
 	return err
 }
 
+// RLock function
 func (rpcClient *ReconnectRPCClient) RLock(args dsync.LockArgs) (status bool, err error) {
 	err = rpcClient.Call("Dsync.RLock", &args, &status)
 	return status, err
 }
 
+// Lock function
 func (rpcClient *ReconnectRPCClient) Lock(args dsync.LockArgs) (status bool, err error) {
 	err = rpcClient.Call("Dsync.Lock", &args, &status)
 	return status, err
 }
 
+// RUnlock function
 func (rpcClient *ReconnectRPCClient) RUnlock(args dsync.LockArgs) (status bool, err error) {
 	err = rpcClient.Call("Dsync.RUnlock", &args, &status)
 	return status, err
 }
 
+// Unlock function
 func (rpcClient *ReconnectRPCClient) Unlock(args dsync.LockArgs) (status bool, err error) {
 	err = rpcClient.Call("Dsync.Unlock", &args, &status)
 	return status, err
 }
 
+// ForceUnlock function
 func (rpcClient *ReconnectRPCClient) ForceUnlock(args dsync.LockArgs) (status bool, err error) {
 	err = rpcClient.Call("Dsync.ForceUnlock", &args, &status)
 	return status, err
 }
 
+// ServerAddr function
 func (rpcClient *ReconnectRPCClient) ServerAddr() string {
 	return rpcClient.addr
 }
 
+// ServiceEndpoint function 
 func (rpcClient *ReconnectRPCClient) ServiceEndpoint() string {
 	return rpcClient.endpoint
 }