Exemple #1
0
func runDataserver(args []string) {
	cfg := &conf.DSConfig{}
	err := cfg.ReadConfig(args[0])
	if err != nil {
		usage(err)
		return
	}
	services, err := integration.NewClient(cfg.NameAddr, cfg.LeaseAddr, 1)
	if err != nil {
		usage(err)
		return
	}
	ds, err := dataserver.NewDataServer(cfg.VolumeRoots, cfg.DataClientBindAddr, cfg.NameDataBindAddr, cfg.WebBindAddr, services.Names, services.Datas)
	if err != nil {
		usage(err)
		return
	}
	ds.Start()
	if len(args) > 1 {
		mountPoint := args[1]

		// start client
		client, err := newMountedClient(services.Leases, services.Names, services.Datas, mountPoint)
		if err != nil {
			usage(err)
			return
		}
		client.Loop()
		ds.Close()
	}
	ds.WaitClosed()
}
Exemple #2
0
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
}
Exemple #3
0
// TODO refactor to use NewConfSet
func NewSingleNodeCluster(nncfg *conf.NSConfig, ds []*conf.DSConfig, format bool) (*SingleNodeCluster, error) {
	cl := &SingleNodeCluster{}

	nls, err := NewNameServer(nncfg, format)
	if err != nil {
		return nil, err
	}
	cl.LeaseServer = nls.leaseServer
	cl.NameServer = nls.nameserver
	fmt.Println("Starting name client")
	cl.Names, err = NewNameClient(nncfg.NameBindAddr)
	if err != nil {
		return cl, err
	}
	fmt.Println("starting lease client")
	cl.Leases, err = leaseserver.NewLeaseClient(nncfg.LeaseBindAddr)
	if err != nil {
		return cl, err
	}
	// start data client
	dc, err := dataserver.NewDataClient(cl.Names, 1)
	if err != nil {
		return cl, fmt.Errorf("error building dataclient : %s", err.Error())
	}
	cl.Datas = dc
	// start dataservers
	cl.DataNodes = make([]*dataserver.DataServer, len(ds))
	for idx, dscfg := range ds {
		fmt.Println("Starting DS with cfg %+v\n", dscfg)
		cl.DataNodes[idx], err = dataserver.NewDataServer(dscfg.VolumeRoots, dscfg.DataClientBindAddr, dscfg.NameDataBindAddr, dscfg.WebBindAddr, cl.Names, dc)
		if err != nil {
			return cl, err
		}
	}
	return cl, nil
}
Exemple #4
0
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
}