func openReplication(s *torus.Server, addr *url.URL) error {
var err error
if s.ReplicationOpen {
return torus.ErrExists
}
dist, err := newDistributor(s, addr)
if err != nil {
return err
}
s.Blocks = dist
s.INodes = torus.NewINodeStore(dist)
err = s.BeginHeartbeat(addr)
if err != nil {
return err
}
s.ReplicationOpen = true
return nil
}
func runServer(cmd *cobra.Command, args []string) {
if completion {
cmd.Root().GenBashCompletion(os.Stdout)
os.Exit(0)
}
var (
srv *torus.Server
err error
)
switch {
case cfg.MetadataAddress == "":
srv, err = torus.NewServer(cfg, "temp", "mfile")
case debugInit:
err = torus.InitMDS("etcd", cfg, torus.GlobalMetadata{
BlockSize: 512 * 1024,
DefaultBlockSpec: blockset.MustParseBlockLayerSpec("crc,base"),
}, ring.Ketama)
if err != nil {
if err == torus.ErrExists {
fmt.Println("debug-init: Already exists")
} else {
fmt.Printf("Couldn't debug-init: %s\n", err)
os.Exit(1)
}
}
fallthrough
default:
srv, err = torus.NewServer(cfg, "etcd", "mfile")
}
if err != nil {
fmt.Printf("Couldn't start: %s\n", err)
os.Exit(1)
}
if autojoin {
err = doAutojoin(srv)
if err != nil {
fmt.Printf("Couldn't auto-join: %s\n", err)
os.Exit(1)
}
}
mainClose := make(chan bool)
signalChan := make(chan os.Signal, 1)
signal.Notify(signalChan, os.Interrupt)
if peerAddress != "" {
var u *url.URL
u, err = url.Parse(peerAddress)
if err != nil {
fmt.Printf("Couldn't parse peer address %s: %s\n", peerAddress, err)
os.Exit(1)
}
if u.Scheme == "" {
fmt.Printf("Peer address %s does not have URL scheme (http:// or tdp://)\n", peerAddress)
os.Exit(1)
}
err = distributor.ListenReplication(srv, u)
} else {
err = distributor.OpenReplication(srv)
}
defer srv.Close()
go func() {
for _ = range signalChan {
fmt.Println("\nReceived an interrupt, stopping services...")
close(mainClose)
os.Exit(0)
}
}()
if err != nil {
fmt.Println("couldn't use server:", err)
os.Exit(1)
}
if httpAddress != "" {
http.ServeHTTP(httpAddress, srv)
}
// Wait
<-mainClose
}