mgo 驱动新加重连

mgo 驱动目前没有实现远端server挂掉后，(当远端的session挂掉其实底层已经做了重连的机制，但是没有通知上层的sesion.)更新当前的session。而致使当前的session不可以用。目前我们可以采取两种方式来更新。

原文解释：

yoou can do that, but you don't *have* to. One common pattern, for 
example when handling http requests, is to Copy [1] a master session, 
use the copied session for the duration of a request, and then Close 
it. The closing is also commonly done with defer, so the Close [2] is 
right after the Copy, ensuring it's properly taken care of. 

For other tasks, it's also fine to just use one master session for the 
whole application. 

If you intend the application to remain running when there are hard 
errors (disconnections, etc), please just remember to Refresh [3] the 
session at some point in the application loop, so that after mgo 
notifies you about them, the error can be put away and a new 
connection allocated for the session. In practice, this just means 
something along the lines of: 

    // Main application loop. 
    for { 
        session.Refresh() 
        select { 
        case ... 
        } 
    } 

assuming the application would be using such a structure for the main loop. 

> and what about collections (ex: 
> session.DB("127.0.0.1:1234").C("collectionName")) 
> 
> should I create then once, or should I recreate them every single time I'm 
> really reading or writing smth from/to mongo 

A Database [4] holds a Session field, and a Collection [5] holds a 
Database field, so w'hat was just explained above for a session 
applies to both given their association with one. 

1) Call Refresh on the session, which makes it discard (or put back in 

the pool, if the connection is good) the connection it's holding, and 
pick a new one when necessary. 

2) Instead of using a single session, use many by calling session.Copy 
when you need a new session, and then call session.Close when you're 

done with it. This will also mean you're using multiple connections to 

the database, when necessary.

实现方式：

采用单独的goroutines来管理session.关键代码：
if info.AutoReconnect {
session.stopMonitor = make(chan bool, 1)
go func() {
c := time.Tick(interval)
loop := true
for loop {
select {
case <-c:
if err := session.Ping(); err != nil && err == io.EOF {
session.Refresh()
} else {
}
case <-session.stopMonitor:
loop = false
break
}
}
}()
}

问题：

 I assume that calling Refresh() is also thread safe, that means I can call it in concurrent goroutines? 

That's not a good idea, as it will interfere with the other 
goroutines. In fact, that's the exact point of the error not being 
automatically reset: you don't want goroutines that are running to see 
a completely different server and state without any notice. They 
should all fail and go back to the start of your processing routine 
(loop, request handling, whatever) so you can move on again. 

附件是针对session.go做的修改。

参考：

https://groups.google.com/forum/#!topic/mgo-users/XM0rc6p-V-8