update defers for convention of coming after the call they relate to

Author: Al S-M

filestore.go

@@ -52,8 +52,8 @@ func NewFileStore(directory string) *FileStore {
 
 // Open will allow the FileStore to be used.
 func (store *FileStore) Open() {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	// if no store directory was specified in ClientOpts, by default use the
 	// current working directory
 	if store.directory == "" {
@@ -72,17 +72,17 @@ func (store *FileStore) Open() {
 
 // Close will disallow the FileStore from being used.
 func (store *FileStore) Close() {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	store.opened = false
 	store.t.Trace_W(STR, "store is not open")
 }
 
 // Put will put a message into the store, associated with the provided
 // key value.
 func (store *FileStore) Put(key string, m *Message) {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	chkcond(store.opened)
 	full := fullpath(store.directory, key)
 	if exists(full) {
@@ -96,8 +96,8 @@ func (store *FileStore) Put(key string, m *Message) {
 // Get will retrieve a message from the store, the one associated with
 // the provided key value.
 func (store *FileStore) Get(key string) (m *Message) {
-	defer store.RUnlock()
 	store.RLock()
+	defer store.RUnlock()
 	chkcond(store.opened)
 	filepath := fullpath(store.directory, key)
 	if !exists(filepath) {
@@ -116,23 +116,23 @@ func (store *FileStore) Get(key string) (m *Message) {
 // All will provide a list of all of the keys associated with messages
 // currenly residing in the FileStore.
 func (store *FileStore) All() []string {
-	defer store.RUnlock()
 	store.RLock()
+	defer store.RUnlock()
 	return store.all()
 }
 
 // Del will remove the persisted message associated with the provided
 // key from the FileStore.
 func (store *FileStore) Del(key string) {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	store.del(key)
 }
 
 // Reset will remove all persisted messages from the FileStore.
 func (store *FileStore) Reset() {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	store.t.Trace_W(STR, "FileStore Reset")
 	for _, key := range store.all() {
 		store.del(key)

memstore.go

@@ -33,7 +33,7 @@ type MemoryStore struct {
 // use until Open() has been called on it.
 func NewMemoryStore() *MemoryStore {
 	store := &MemoryStore{
-		messages: nil,
+		messages: make(map[string]*Message),
 		opened:   false,
 		t:        nil,
 	}
@@ -42,27 +42,26 @@ func NewMemoryStore() *MemoryStore {
 
 // Open initializes a MemoryStore instance.
 func (store *MemoryStore) Open() {
-	defer store.Unlock()
 	store.Lock()
-	store.messages = make(map[string]*Message)
+	defer store.Unlock()
 	store.opened = true
 	store.t.Trace_V(STR, "memorystore initialized")
 }
 
 // Put takes a key and a pointer to a Message and stores the
 // message.
 func (store *MemoryStore) Put(key string, message *Message) {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	chkcond(store.opened)
 	store.messages[key] = message
 }
 
 // Get takes a key and looks in the store for a matching Message
 // returning either the Message pointer or nil.
 func (store *MemoryStore) Get(key string) *Message {
-	defer store.RUnlock()
 	store.RLock()
+	defer store.RUnlock()
 	chkcond(store.opened)
 	mid := key2mid(key)
 	m := store.messages[key]
@@ -77,8 +76,8 @@ func (store *MemoryStore) Get(key string) *Message {
 // All returns a slice of strings containing all the keys currently
 // in the MemoryStore.
 func (store *MemoryStore) All() []string {
-	defer store.RUnlock()
 	store.RLock()
+	defer store.RUnlock()
 	chkcond(store.opened)
 	keys := []string{}
 	for k, _ := range store.messages {
@@ -90,8 +89,8 @@ func (store *MemoryStore) All() []string {
 // Del takes a key, searches the MemoryStore and if the key is found
 // deletes the Message pointer associated with it.
 func (store *MemoryStore) Del(key string) {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	mid := key2mid(key)
 	m := store.messages[key]
 	if m == nil {
@@ -104,24 +103,24 @@ func (store *MemoryStore) Del(key string) {
 
 // Close will disallow modifications to the state of the store.
 func (store *MemoryStore) Close() {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	chkcond(store.opened)
 	store.opened = false
 	store.t.Trace_V(STR, "memorystore closed")
 }
 
 // Reset eliminates all persisted message data in the store.
 func (store *MemoryStore) Reset() {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	chkcond(store.opened)
 	store.messages = make(map[string]*Message)
 	store.t.Trace_W(STR, "memorystore wiped")
 }
 
 func (store *MemoryStore) SetTracer(tracer *Tracer) {
-	defer store.Unlock()
 	store.Lock()
+	defer store.Unlock()
 	store.t = tracer
 }

messageids.go

@@ -52,15 +52,12 @@ func (mids *messageIds) generateMsgIds() {
 }
 
 func (mids *messageIds) freeId(id MId) {
-	defer mids.Unlock()
 	mids.Lock()
+	defer mids.Unlock()
 	//trace_v(MID, "freeing message id: %v", id)
 	mids.index[id] = false
 }
 
 func (mids *messageIds) getId() MId {
-	// defer mids.Unlock()
-	// mids.Lock()
-	id := <-mids.idChan // Does this need to be locked?
-	return id
+	return <-mids.idChan
 }

ping.go

@@ -25,15 +25,15 @@ type lastcontact struct {
 }
 
 func (l *lastcontact) update() {
-	defer l.Unlock()
 	l.Lock()
+	defer l.Unlock()
 	l.lasttime = time.Now()
 
 }
 
 func (l *lastcontact) get() time.Time {
-	defer l.Unlock()
 	l.Lock()
+	defer l.Unlock()
 	return l.lasttime
 }
 

receipts.go

@@ -34,20 +34,20 @@ func newReceiptMap() *receiptMap {
 }
 
 func (m *receiptMap) put(mid MId, c chan Receipt) {
-	defer m.Unlock()
 	m.Lock()
+	defer m.Unlock()
 	m.contents[mid] = c
 }
 
 func (m *receiptMap) get(mid MId) chan Receipt {
-	defer m.RUnlock()
 	m.RLock()
+	defer m.RUnlock()
 	return m.contents[mid]
 }
 
 func (m *receiptMap) end(mid MId) {
-	defer m.Unlock()
 	m.Lock()
+	defer m.Unlock()
 	close(m.contents[mid])
 	delete(m.contents, mid)
 }

router.go

@@ -89,8 +89,8 @@ func newRouter() (*router, chan bool) {
 // routes to see if there is already a matching Route. If there is it replaces the current
 // callback with the new one. If not it add a new entry to the list of Routes.
 func (r *router) addRoute(topic string, callback MessageHandler) {
-	defer r.Unlock()
 	r.Lock()
+	defer r.Unlock()
 	for e := r.routes.Front(); e != nil; e = e.Next() {
 		if e.Value.(*route).match(topic) {
 			r := e.Value.(*route)
@@ -104,8 +104,8 @@ func (r *router) addRoute(topic string, callback MessageHandler) {
 // deleteRoute takes a route string, looks for a matching Route in the list of Routes. If
 // found it removes the Route from the list.
 func (r *router) deleteRoute(topic string) {
-	defer r.Unlock()
 	r.Lock()
+	defer r.Unlock()
 	for e := r.routes.Front(); e != nil; e = e.Next() {
 		if e.Value.(*route).match(topic) {
 			r.routes.Remove(e)