/**@brief helper function for sorting
* @param server master storage server addr
* @param myhostport trib server's port
* @param flags
* @return *Libstore
* @return error
*/
func iNewLibstore(server, myhostport string, flags int) (*Libstore, error) {
var store Libstore
var master *rpc.Client
var args storageproto.GetServersArgs
var reply storageproto.RegisterReply
var err error
store.Addr = myhostport
store.Flags = flags
if store.Addr != "" {
rpc.Register(cacherpc.NewCacheRPC(&store))
}
lsplog.Vlogf(3, "libstore try to connect to master storage %s", server)
master, err = rpc.DialHTTP("tcp", server)
if lsplog.CheckReport(1, err) {
return nil, err
}
lsplog.Vlogf(3, "try to call GetServers")
master.Call("StorageRPC.GetServers", &args, &reply)
if !reply.Ready {
for i := 0; i < 5; i++ {
time.Sleep(1000 * time.Millisecond)
master.Call("StorageRPC.GetServers", &args, &reply)
}
}
err = master.Close()
if lsplog.CheckReport(1, err) {
lsplog.Vlogf(3, "WARNING close master failed")
}
// couldn't get list of servers from master
if (reply.Ready == false) || (reply.Servers == nil) {
return nil, lsplog.MakeErr("Storage system not ready.")
}
store.Nodes = reply.Servers
store.RPCConn = make([]*rpc.Client, len(store.Nodes))
sort.Sort(store.Nodes)
/*
for i := 0; i < len(store.Nodes); i++ {
fmt.Printf("%v\n", store.Nodes[i])
}*/
store.Leases = cache.NewCache()
if lsplog.CheckReport(1, err) {
return nil, err
}
lsplog.Vlogf(3, "libstore create complete")
return &store, nil
}
func initStorageTester(server string, myhostport string) *StorageTester {
tester := &StorageTester{}
tester.myhostport = myhostport
tester.recv_revoke = make(map[string]bool)
tester.comp_revoke = make(map[string]bool)
// Create RPC connection to storage server
srv, err := rpc.DialHTTP("tcp", server)
if err != nil {
fmt.Printf("Could not connect to server %s, returning nil\n", server)
return nil
}
// Listen cacherpc
rpc.Register(cacherpc.NewCacheRPC(tester))
rpc.HandleHTTP()
l, e := net.Listen("tcp", fmt.Sprintf(":%d", *portnum))
if e != nil {
log.Fatal("listen error:", e)
}
go http.Serve(l, nil)
tester.srv = srv
return tester
}
func (ls *Libstore) revokeLeasesListenerInit(myhostport string) {
lsplog.Vlogf(1, "Creating cache callback in %s", myhostport)
cacheimpl := cacherpc.NewCacheRPC(ls)
rpc.Register(cacheimpl)
}
func iNewLibstore(server string, myhostport string, flags int) (*Libstore, error) {
ls := &Libstore{}
ls.flags = flags
ls.myhostport = myhostport
// Create RPC connection to storage server
cli, err := rpc.DialHTTP("tcp", server)
if err != nil {
fmt.Printf("Could not connect to server %s, returning nil\n", server)
return nil, err
}
ls.cli = cli
// Get list of storage servers from master storage server
// will retry five times after waiting for 1 second each try
triesLeft := 5
for triesLeft > 0 {
args := storageproto.GetServersArgs{}
var reply storageproto.RegisterReply
err = cli.Call("StorageRPC.GetServers", args, &reply)
if err != nil {
return nil, err
}
if reply.Ready {
ls.nodelist = reply.Servers
break
}
triesLeft--
time.Sleep(time.Duration(1) * time.Second)
}
if ls.nodelist == nil {
return nil, lsplog.MakeErr("Storage system not ready")
}
sort.Sort(byID{ls.nodelist})
//initialize the connCache
ls.connCache = make(map[string]*rpc.Client)
ls.cacheM = make(chan int, 1)
ls.cacheM <- 1
ls.getCache = make(map[string]string)
ls.getM = make(chan int, 1)
ls.getM <- 1
ls.getListCache = make(map[string]([]string))
ls.getListM = make(chan int, 1)
ls.getListM <- 1
ls.leaseMap = make(map[string]LeaseQuery)
ls.leaseM = make(chan int, 1)
ls.leaseM <- 1
ls.crpc = cacherpc.NewCacheRPC(ls)
rpc.Register(ls.crpc)
// do NOT connect to other storage servers here
// this should be done in a lazy fashion upon the first use
// of the storage server, and then the rpc connection can be cached
//Start up garbage collector
go ls.GarbageCollector()
return ls, nil
}