func (ns *NameServer) Start() error {
var err error = nil
ns.rpcServer, err = mrpc.CloseableRPC(ns.listenAddr, mrpc.NewNameServiceService(ns), "NameService")
if err != nil {
return err
}
ns.rpcServer.Start()
go func() {
ns.webServer.Serve(ns.webListen)
}()
return err
}
func NewPeer(cfg *PeerConfig, debug bool) (*Peer, error) {
cl, err := NewClient(cfg.MasterAddr)
if err != nil {
return nil, err
}
ret := &Peer{}
ret.Cfg = cfg
ret.Datanode, err = dataserver.NewDataServer(cfg.BindAddr, cfg.VolumeRoots, cl.Names, cl.Datas)
if err != nil {
return ret, err
}
dnStat, err := ret.Datanode.HeartBeat()
if err != nil {
return ret, err
}
fuseConnector, err := client.NewMaggieFuse(cl.Leases, cl.Names, cl.Datas, &dnStat.DnId)
if err != nil {
return ret, err
}
ret.Mfs = fuseConnector
ret.Mountpoint, err = NewMount(fuseConnector, cfg.MountPoint, false)
opMap := make(map[uint32]func(*net.TCPConn))
opMap[dataserver.DIAL_READ] = ret.Datanode.ServeReadConn
opMap[dataserver.DIAL_WRITE] = ret.Datanode.ServeWriteConn
dataServ, err := mrpc.CloseableRPC(cfg.BindAddr, "Peer", maggiefs.NewPeerService(ret.Datanode), opMap)
if err != nil {
return ret, err
}
multiServ := NewMultiService()
err = multiServ.AddService(dataServ)
if err != nil {
return ret, err
}
err = multiServ.AddService(ret.Mountpoint)
if err != nil {
return ret, err
}
// now that services are started, tell master to connect to us
err = cl.Names.Join(dnStat.DnId, cfg.BindAddr)
ret.svc = multiServ
return ret, err
}
// returns a started nameserver -- we must start lease server in order to boot up nameserver, so
func NewMaster(cfg *MasterConfig, format bool) (*Master, error) {
nls := &Master{}
var err error = nil
nls.leaseServer = leaseserver.NewLeaseServer()
nls.nameserver, err = nameserver.NewNameServer(cfg.NameHome, cfg.ReplicationFactor, format)
if err != nil {
log.Printf("Error creating nameserver: %s\n\n Nameserver config: %+v\n", err.Error(), cfg)
return nls, err
}
opMap := make(map[uint32]func(*net.TCPConn))
opMap[SERVNO_LEASESERVER] = nls.leaseServer.ServeConn
log.Printf("Starting master on addr %s", cfg.BindAddr)
nls.serv, err = mrpc.CloseableRPC(cfg.BindAddr, "NameService", maggiefs.NewNameServiceService(nls.nameserver), opMap)
if err != nil {
return nls, err
}
_, port, _ := net.SplitHostPort(cfg.BindAddr)
nls.port, _ = strconv.Atoi(port)
return nls, err
}
// create a new dataserver serving the specified volumes, on the specified addrs, joining the specified nameservice
func NewDataServer(volRoots []string,
dataClientBindAddr string,
nameDataBindAddr string,
webBindAddr string,
ns maggiefs.NameService,
dc *DataClient) (ds *DataServer, err error) {
// scan volumes
volumes := make(map[uint32]*volume)
unformatted := make([]string, 0)
for _, volRoot := range volRoots {
if validVolume(volRoot) {
// initialize existing volume
vol, err := loadVolume(volRoot)
if err != nil {
return nil, err
}
volumes[vol.id] = vol
} else {
// mark unformatted, wait for order from namenode to format
unformatted = append(unformatted, volRoot)
}
}
// form consensus on host across volumes or error
var dnInfo maggiefs.DataNodeInfo = maggiefs.DataNodeInfo{}
for _, vol := range volumes {
if dnInfo.DnId != 0 {
dnInfo = vol.info.DnInfo
} else {
// compare new to previous
if !dnInfo.Equals(vol.info.DnInfo) {
return nil, errors.New("Incompatible dataNodeInfo across volumes!")
}
}
}
if dnInfo.DnId == 0 {
dnInfo.DnId, err = ns.NextDnId()
}
dnInfo.Addr = dataClientBindAddr
// format unformatted volumes
for _, path := range unformatted {
volId, err := ns.NextVolId()
if err != nil {
return nil, err
}
vol, err := formatVolume(path, maggiefs.VolumeInfo{volId, dnInfo})
if err != nil {
return nil, err
}
volumes[volId] = vol
}
// start up listeners
dataClientBind, err := net.ResolveTCPAddr("tcp", dataClientBindAddr)
if err != nil {
return nil, err
}
dataClientListen, err := net.ListenTCP("tcp", dataClientBind)
if err != nil {
return nil, err
}
// start servicing namedata
ds = &DataServer{ns, dnInfo, volumes, dataClientListen, nil, dc}
ds.nameDataIface, err = mrpc.CloseableRPC(nameDataBindAddr, mrpc.NewNameDataIfaceService(ds), "NameDataIface")
if err != nil {
return ds, err
}
ds.nameDataIface.Start()
// start servicing client data
go ds.serveClientData()
// register ourselves with namenode, namenode will query us for volumes
err = ns.Join(dnInfo.DnId, nameDataBindAddr)
return ds, nil
}
func NewSingleNodeCluster(startPort int, numDNs int, volsPerDn int, replicationFactor uint32, baseDir string, mountPoint string, debugMode bool) (*SingleNodeCluster, error) {
cl := &SingleNodeCluster{}
nncfg, ds, err := NewConfSet2(startPort, numDNs, volsPerDn, replicationFactor, baseDir)
if err != nil {
return nil, err
}
log.Printf("Creating singleNodeCluster with master conf: %s, ds confs: %s", nncfg, ds)
nls, err := NewMaster(nncfg, true)
if err != nil {
return nil, err
}
cl.LeaseServer = nls.leaseServer
cl.NameServer = nls.nameserver
// make service wrapper
multiServ := NewMultiService()
cl.svc = multiServ
multiServ.AddService(nls) // add nameLeaseServer
masterAddr := fmt.Sprintf("127.0.0.1:%d", nls.port)
log.Printf("Connecting client to started master at %s", masterAddr)
cli, err := NewClient(masterAddr)
if err != nil {
return cl, err
}
cl.Names = cli.Names
cl.Leases = cli.Leases
cl.Datas = cli.Datas
// start dataservers
cl.DataNodes = make([]*dataserver.DataServer, len(ds))
cl.DataNodeServs = make([]*mrpc.CloseableServer, len(ds))
for idx, dscfg := range ds {
log.Printf("Starting DS with cfg %+v", dscfg)
// create and register with SingleNodeCluster struct
ds, err := dataserver.NewDataServer(dscfg.BindAddr, dscfg.VolumeRoots, cl.Names, cl.Datas)
if err != nil {
return cl, err
}
cl.DataNodes[idx] = ds
// start and register with MultiServ
opMap := make(map[uint32]func(*net.TCPConn))
opMap[dataserver.DIAL_READ] = ds.ServeReadConn
opMap[dataserver.DIAL_WRITE] = ds.ServeWriteConn
dataServ, err := mrpc.CloseableRPC(dscfg.BindAddr, "Peer", maggiefs.NewPeerService(ds), opMap)
if err != nil {
return cl, err
}
cl.DataNodeServs[idx] = dataServ
err = multiServ.AddService(dataServ)
if err != nil {
return cl, err
}
dnInfo, _ := ds.HeartBeat()
err = cl.Names.Join(dnInfo.DnId, dscfg.BindAddr)
if err != nil {
return cl, err
}
}
// create mountpoint if necessary
if mountPoint != "" {
maggieFuse, err := client.NewMaggieFuse(cl.Leases, cl.Names, cl.Datas, nil)
if err != nil {
return cl, err
}
mount, err := NewMount(maggieFuse, mountPoint, debugMode)
if err != nil {
return cl, err
}
err = multiServ.AddService(mount)
if err != nil {
return cl, err
}
}
time.Sleep(1 * time.Second)
return cl, nil
}