2013-06-09 21:42:34 +04:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
2014-09-16 23:32:03 +04:00
|
|
|
"errors"
|
2014-09-03 00:48:38 +04:00
|
|
|
"flag"
|
2014-09-05 08:15:39 +04:00
|
|
|
"fmt"
|
2014-07-06 21:19:23 +04:00
|
|
|
"log"
|
2014-09-19 02:27:41 +04:00
|
|
|
"net"
|
2014-07-06 21:19:23 +04:00
|
|
|
"net/http"
|
2014-09-05 08:15:39 +04:00
|
|
|
"os"
|
|
|
|
"path"
|
2014-09-03 01:46:07 +04:00
|
|
|
"strconv"
|
2014-09-16 23:32:03 +04:00
|
|
|
"strings"
|
2014-09-03 01:46:07 +04:00
|
|
|
"time"
|
2014-01-18 22:09:54 +04:00
|
|
|
|
2014-09-03 08:36:14 +04:00
|
|
|
"github.com/coreos/etcd/etcdserver"
|
|
|
|
"github.com/coreos/etcd/etcdserver/etcdhttp"
|
2014-09-25 03:06:28 +04:00
|
|
|
"github.com/coreos/etcd/pkg"
|
2014-09-25 21:47:14 +04:00
|
|
|
"github.com/coreos/etcd/pkg/transport"
|
2014-09-10 22:19:11 +04:00
|
|
|
"github.com/coreos/etcd/proxy"
|
2014-09-03 00:48:38 +04:00
|
|
|
"github.com/coreos/etcd/raft"
|
2014-09-17 05:18:45 +04:00
|
|
|
"github.com/coreos/etcd/snap"
|
2014-09-03 02:04:57 +04:00
|
|
|
"github.com/coreos/etcd/store"
|
2014-09-05 08:15:39 +04:00
|
|
|
"github.com/coreos/etcd/wal"
|
2014-07-06 21:19:23 +04:00
|
|
|
)
|
|
|
|
|
2014-09-09 02:45:58 +04:00
|
|
|
const (
|
|
|
|
// the owner can make/remove files inside the directory
|
|
|
|
privateDirMode = 0700
|
2014-09-18 18:50:52 +04:00
|
|
|
|
2014-09-18 21:34:16 +04:00
|
|
|
proxyFlagValueOff = "off"
|
|
|
|
proxyFlagValueReadonly = "readonly"
|
|
|
|
proxyFlagValueOn = "on"
|
2014-09-25 04:08:42 +04:00
|
|
|
|
|
|
|
version = "0.5.0-alpha"
|
2014-07-06 21:19:23 +04:00
|
|
|
)
|
|
|
|
|
2014-09-03 00:48:38 +04:00
|
|
|
var (
|
2014-09-25 06:51:27 +04:00
|
|
|
name = flag.String("name", "default", "Unique human-readable name for this node")
|
2014-09-25 04:08:42 +04:00
|
|
|
timeout = flag.Duration("timeout", 10*time.Second, "Request Timeout")
|
|
|
|
paddr = flag.String("peer-bind-addr", ":7001", "Peer service address (e.g., ':7001')")
|
|
|
|
dir = flag.String("data-dir", "", "Path to the data directory")
|
|
|
|
snapCount = flag.Int64("snapshot-count", etcdserver.DefaultSnapCount, "Number of committed transactions to trigger a snapshot")
|
|
|
|
printVersion = flag.Bool("version", false, "Print the version and exit")
|
2014-09-05 22:59:23 +04:00
|
|
|
|
2014-09-25 06:51:27 +04:00
|
|
|
cluster = &etcdserver.Cluster{}
|
2014-09-18 18:50:52 +04:00
|
|
|
addrs = &Addrs{}
|
2014-09-25 22:43:24 +04:00
|
|
|
cors = &pkg.CORSInfo{}
|
2014-09-18 18:50:52 +04:00
|
|
|
proxyFlag = new(ProxyFlag)
|
|
|
|
|
|
|
|
proxyFlagValues = []string{
|
|
|
|
proxyFlagValueOff,
|
2014-09-18 21:34:16 +04:00
|
|
|
proxyFlagValueReadonly,
|
2014-09-18 18:50:52 +04:00
|
|
|
proxyFlagValueOn,
|
|
|
|
}
|
2014-09-23 03:50:26 +04:00
|
|
|
|
|
|
|
clientTLSInfo = transport.TLSInfo{}
|
2014-09-23 19:21:16 +04:00
|
|
|
peerTLSInfo = transport.TLSInfo{}
|
2014-09-24 22:28:41 +04:00
|
|
|
|
|
|
|
deprecated = []string{
|
2014-09-25 03:49:11 +04:00
|
|
|
"addr",
|
|
|
|
"cluster-active-size",
|
|
|
|
"cluster-remove-delay",
|
|
|
|
"cluster-sync-interval",
|
2014-09-24 22:28:41 +04:00
|
|
|
"config",
|
2014-09-25 03:49:11 +04:00
|
|
|
"force",
|
2014-09-24 22:28:41 +04:00
|
|
|
"max-result-buffer",
|
|
|
|
"max-retry-attempts",
|
2014-09-25 03:49:11 +04:00
|
|
|
"peer-addr",
|
|
|
|
"peer-heartbeat-interval",
|
|
|
|
"peer-election-timeout",
|
2014-09-24 22:28:41 +04:00
|
|
|
"retry-interval",
|
|
|
|
"snapshot",
|
2014-09-25 03:44:32 +04:00
|
|
|
"v",
|
|
|
|
"vv",
|
2014-09-24 22:28:41 +04:00
|
|
|
}
|
2014-09-03 00:48:38 +04:00
|
|
|
)
|
2014-07-06 21:19:23 +04:00
|
|
|
|
2014-09-03 01:46:07 +04:00
|
|
|
func init() {
|
2014-09-25 06:51:27 +04:00
|
|
|
flag.Var(cluster, "bootstrap-config", "Initial cluster configuration for bootstrapping")
|
2014-09-16 23:32:03 +04:00
|
|
|
flag.Var(addrs, "bind-addr", "List of HTTP service addresses (e.g., '127.0.0.1:4001,10.0.0.1:8080')")
|
2014-09-20 01:58:00 +04:00
|
|
|
flag.Var(cors, "cors", "Comma-separated white list of origins for CORS (cross-origin resource sharing).")
|
2014-09-18 18:50:52 +04:00
|
|
|
flag.Var(proxyFlag, "proxy", fmt.Sprintf("Valid values include %s", strings.Join(proxyFlagValues, ", ")))
|
2014-09-25 06:51:27 +04:00
|
|
|
cluster.Set("default=localhost:8080")
|
2014-09-16 23:32:03 +04:00
|
|
|
addrs.Set("127.0.0.1:4001")
|
2014-09-18 18:50:52 +04:00
|
|
|
proxyFlag.Set(proxyFlagValueOff)
|
2014-09-23 03:50:26 +04:00
|
|
|
|
|
|
|
flag.StringVar(&clientTLSInfo.CAFile, "ca-file", "", "Path to the client server TLS CA file.")
|
|
|
|
flag.StringVar(&clientTLSInfo.CertFile, "cert-file", "", "Path to the client server TLS cert file.")
|
|
|
|
flag.StringVar(&clientTLSInfo.KeyFile, "key-file", "", "Path to the client server TLS key file.")
|
2014-09-23 19:21:16 +04:00
|
|
|
|
|
|
|
flag.StringVar(&peerTLSInfo.CAFile, "peer-ca-file", "", "Path to the peer server TLS CA file.")
|
|
|
|
flag.StringVar(&peerTLSInfo.CertFile, "peer-cert-file", "", "Path to the peer server TLS cert file.")
|
|
|
|
flag.StringVar(&peerTLSInfo.KeyFile, "peer-key-file", "", "Path to the peer server TLS key file.")
|
2014-09-24 22:28:41 +04:00
|
|
|
|
|
|
|
for _, f := range deprecated {
|
2014-09-25 03:06:28 +04:00
|
|
|
flag.Var(&pkg.DeprecatedFlag{f}, f, "")
|
2014-09-24 22:28:41 +04:00
|
|
|
}
|
2014-09-03 01:46:07 +04:00
|
|
|
}
|
|
|
|
|
2014-09-03 00:48:38 +04:00
|
|
|
func main() {
|
2014-09-25 03:06:28 +04:00
|
|
|
flag.Usage = pkg.UsageWithIgnoredFlagsFunc(flag.CommandLine, deprecated)
|
2014-09-03 02:04:57 +04:00
|
|
|
flag.Parse()
|
|
|
|
|
2014-09-25 04:08:42 +04:00
|
|
|
if *printVersion {
|
|
|
|
fmt.Println("etcd version", version)
|
|
|
|
os.Exit(0)
|
|
|
|
}
|
|
|
|
|
2014-09-25 03:29:47 +04:00
|
|
|
pkg.SetFlagsFromEnv(flag.CommandLine)
|
2014-09-17 23:05:36 +04:00
|
|
|
|
2014-09-18 18:50:52 +04:00
|
|
|
if string(*proxyFlag) == proxyFlagValueOff {
|
2014-09-16 22:36:37 +04:00
|
|
|
startEtcd()
|
2014-09-18 18:50:52 +04:00
|
|
|
} else {
|
|
|
|
startProxy()
|
2014-09-10 22:19:11 +04:00
|
|
|
}
|
2014-09-16 23:32:03 +04:00
|
|
|
|
|
|
|
// Block indefinitely
|
|
|
|
<-make(chan struct{})
|
2014-09-10 22:06:31 +04:00
|
|
|
}
|
|
|
|
|
2014-09-16 22:36:37 +04:00
|
|
|
// startEtcd launches the etcd server and HTTP handlers for client/server communication.
|
|
|
|
func startEtcd() {
|
2014-09-25 06:51:27 +04:00
|
|
|
self := cluster.FindName(*name)
|
|
|
|
if self == nil {
|
|
|
|
log.Fatalf("etcd: no member with name=%q exists", *name)
|
2014-09-15 09:44:59 +04:00
|
|
|
}
|
2014-09-03 00:48:38 +04:00
|
|
|
|
2014-09-25 06:51:27 +04:00
|
|
|
if self.ID == raft.None {
|
|
|
|
log.Fatalf("etcd: cannot use None(%d) as member id", raft.None)
|
2014-09-03 02:15:10 +04:00
|
|
|
}
|
|
|
|
|
2014-09-17 05:18:45 +04:00
|
|
|
if *snapCount <= 0 {
|
|
|
|
log.Fatalf("etcd: snapshot-count must be greater than 0: snapshot-count=%d", *snapCount)
|
|
|
|
}
|
|
|
|
|
2014-09-05 08:15:39 +04:00
|
|
|
if *dir == "" {
|
2014-09-25 06:51:27 +04:00
|
|
|
*dir = fmt.Sprintf("%v_etcd_data", self.ID)
|
2014-09-08 21:32:49 +04:00
|
|
|
log.Printf("main: no data-dir is given, using default data-dir ./%s", *dir)
|
2014-09-05 08:15:39 +04:00
|
|
|
}
|
2014-09-09 02:45:58 +04:00
|
|
|
if err := os.MkdirAll(*dir, privateDirMode); err != nil {
|
2014-09-05 21:02:46 +04:00
|
|
|
log.Fatalf("main: cannot create data directory: %v", err)
|
2014-09-05 08:15:39 +04:00
|
|
|
}
|
2014-09-17 05:18:45 +04:00
|
|
|
snapdir := path.Join(*dir, "snap")
|
|
|
|
if err := os.MkdirAll(snapdir, privateDirMode); err != nil {
|
|
|
|
log.Fatalf("etcd: cannot create snapshot directory: %v", err)
|
|
|
|
}
|
|
|
|
snapshotter := snap.New(snapdir)
|
2014-09-05 08:15:39 +04:00
|
|
|
|
2014-09-17 05:18:45 +04:00
|
|
|
waldir := path.Join(*dir, "wal")
|
|
|
|
var w *wal.WAL
|
|
|
|
var n raft.Node
|
2014-09-25 06:51:27 +04:00
|
|
|
var err error
|
2014-09-17 05:18:45 +04:00
|
|
|
st := store.New()
|
|
|
|
|
|
|
|
if !wal.Exist(waldir) {
|
|
|
|
w, err = wal.Create(waldir)
|
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
2014-09-25 06:51:27 +04:00
|
|
|
n = raft.StartNode(self.ID, cluster.IDs(), 10, 1)
|
2014-09-17 05:18:45 +04:00
|
|
|
} else {
|
|
|
|
var index int64
|
|
|
|
snapshot, err := snapshotter.Load()
|
|
|
|
if err != nil && err != snap.ErrNoSnapshot {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
if snapshot != nil {
|
|
|
|
log.Printf("etcd: restart from snapshot at index %d", snapshot.Index)
|
|
|
|
st.Recovery(snapshot.Data)
|
|
|
|
index = snapshot.Index
|
|
|
|
}
|
|
|
|
|
|
|
|
// restart a node from previous wal
|
|
|
|
if w, err = wal.OpenAtIndex(waldir, index); err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
wid, st, ents, err := w.ReadAll()
|
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
// TODO(xiangli): save/recovery nodeID?
|
|
|
|
if wid != 0 {
|
|
|
|
log.Fatalf("unexpected nodeid %d: nodeid should always be zero until we save nodeid into wal", wid)
|
|
|
|
}
|
2014-09-25 06:51:27 +04:00
|
|
|
n = raft.RestartNode(self.ID, cluster.IDs(), 10, 1, snapshot, st, ents)
|
2014-09-17 05:18:45 +04:00
|
|
|
}
|
2014-09-03 02:57:15 +04:00
|
|
|
|
2014-09-23 19:21:16 +04:00
|
|
|
pt, err := transport.NewTransport(peerTLSInfo)
|
2014-09-23 19:43:20 +04:00
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
2014-09-23 19:38:26 +04:00
|
|
|
}
|
|
|
|
|
2014-09-25 06:51:27 +04:00
|
|
|
cls := etcdserver.NewClusterStore(st, *cluster)
|
|
|
|
|
2014-09-12 04:14:41 +04:00
|
|
|
s := &etcdserver.EtcdServer{
|
2014-09-17 05:18:45 +04:00
|
|
|
Store: st,
|
|
|
|
Node: n,
|
|
|
|
Storage: struct {
|
|
|
|
*wal.WAL
|
|
|
|
*snap.Snapshotter
|
|
|
|
}{w, snapshotter},
|
2014-09-25 06:51:27 +04:00
|
|
|
Send: etcdserver.Sender(pt, cls),
|
|
|
|
Ticker: time.Tick(100 * time.Millisecond),
|
|
|
|
SyncTicker: time.Tick(500 * time.Millisecond),
|
|
|
|
SnapCount: *snapCount,
|
|
|
|
ClusterStore: cls,
|
2014-07-09 01:07:25 +04:00
|
|
|
}
|
2014-09-12 04:14:41 +04:00
|
|
|
s.Start()
|
2014-09-16 22:36:37 +04:00
|
|
|
|
2014-09-25 22:43:24 +04:00
|
|
|
ch := &pkg.CORSHandler{
|
2014-09-25 06:51:27 +04:00
|
|
|
Handler: etcdhttp.NewClientHandler(s, cls, *timeout),
|
2014-09-20 01:58:00 +04:00
|
|
|
Info: cors,
|
|
|
|
}
|
2014-09-25 22:58:11 +04:00
|
|
|
ph := etcdhttp.NewPeerHandler(s)
|
2014-09-16 22:36:37 +04:00
|
|
|
|
2014-09-23 19:21:16 +04:00
|
|
|
l, err := transport.NewListener(*paddr, peerTLSInfo)
|
2014-09-23 03:35:00 +04:00
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2014-09-16 22:36:37 +04:00
|
|
|
// Start the peer server in a goroutine
|
|
|
|
go func() {
|
2014-09-16 23:32:03 +04:00
|
|
|
log.Print("Listening for peers on ", *paddr)
|
2014-09-23 03:35:00 +04:00
|
|
|
log.Fatal(http.Serve(l, ph))
|
2014-09-16 22:36:37 +04:00
|
|
|
}()
|
|
|
|
|
2014-09-16 23:32:03 +04:00
|
|
|
// Start a client server goroutine for each listen address
|
|
|
|
for _, addr := range *addrs {
|
|
|
|
addr := addr
|
2014-09-23 03:50:26 +04:00
|
|
|
l, err := transport.NewListener(addr, clientTLSInfo)
|
2014-09-23 03:35:00 +04:00
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2014-09-16 23:32:03 +04:00
|
|
|
go func() {
|
|
|
|
log.Print("Listening for client requests on ", addr)
|
2014-09-23 03:35:00 +04:00
|
|
|
log.Fatal(http.Serve(l, ch))
|
2014-09-16 23:32:03 +04:00
|
|
|
}()
|
2014-09-16 22:36:37 +04:00
|
|
|
}
|
2014-07-09 01:07:25 +04:00
|
|
|
}
|
2014-09-05 21:16:55 +04:00
|
|
|
|
2014-09-16 23:32:03 +04:00
|
|
|
// startProxy launches an HTTP proxy for client communication which proxies to other etcd nodes.
|
2014-09-16 22:36:37 +04:00
|
|
|
func startProxy() {
|
2014-09-23 21:19:01 +04:00
|
|
|
pt, err := transport.NewTransport(clientTLSInfo)
|
2014-09-10 22:19:11 +04:00
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
2014-09-23 21:19:01 +04:00
|
|
|
|
2014-09-25 06:51:27 +04:00
|
|
|
ph, err := proxy.NewHandler(pt, (*cluster).Endpoints())
|
2014-09-23 21:19:01 +04:00
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2014-09-25 22:43:24 +04:00
|
|
|
ph = &pkg.CORSHandler{
|
2014-09-20 01:58:00 +04:00
|
|
|
Handler: ph,
|
|
|
|
Info: cors,
|
|
|
|
}
|
2014-09-18 21:34:16 +04:00
|
|
|
|
|
|
|
if string(*proxyFlag) == proxyFlagValueReadonly {
|
|
|
|
ph = proxy.NewReadonlyHandler(ph)
|
|
|
|
}
|
|
|
|
|
2014-09-16 23:32:03 +04:00
|
|
|
// Start a proxy server goroutine for each listen address
|
|
|
|
for _, addr := range *addrs {
|
|
|
|
addr := addr
|
2014-09-23 03:50:26 +04:00
|
|
|
l, err := transport.NewListener(addr, clientTLSInfo)
|
2014-09-23 03:35:00 +04:00
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2014-09-16 23:32:03 +04:00
|
|
|
go func() {
|
|
|
|
log.Print("Listening for client requests on ", addr)
|
2014-09-23 03:35:00 +04:00
|
|
|
log.Fatal(http.Serve(l, ph))
|
2014-09-16 23:32:03 +04:00
|
|
|
}()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Addrs implements the flag.Value interface to allow users to define multiple
|
|
|
|
// listen addresses on the command-line
|
|
|
|
type Addrs []string
|
|
|
|
|
|
|
|
// Set parses a command line set of listen addresses, formatted like:
|
2014-09-19 02:27:41 +04:00
|
|
|
// 127.0.0.1:7001,10.1.1.2:80
|
2014-09-16 23:32:03 +04:00
|
|
|
func (as *Addrs) Set(s string) error {
|
|
|
|
parsed := make([]string, 0)
|
2014-09-19 02:27:41 +04:00
|
|
|
for _, in := range strings.Split(s, ",") {
|
|
|
|
a := strings.TrimSpace(in)
|
|
|
|
if err := validateAddr(a); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
parsed = append(parsed, a)
|
2014-09-16 23:32:03 +04:00
|
|
|
}
|
|
|
|
if len(parsed) == 0 {
|
|
|
|
return errors.New("no valid addresses given!")
|
|
|
|
}
|
|
|
|
*as = parsed
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (as *Addrs) String() string {
|
|
|
|
return strings.Join(*as, ",")
|
2014-09-10 22:19:11 +04:00
|
|
|
}
|
2014-09-17 23:05:36 +04:00
|
|
|
|
2014-09-19 02:27:41 +04:00
|
|
|
// validateAddr ensures that the provided string is a valid address. Valid
|
|
|
|
// addresses are of the form IP:port.
|
|
|
|
// Returns an error if the address is invalid, else nil.
|
|
|
|
func validateAddr(s string) error {
|
|
|
|
parts := strings.SplitN(s, ":", 2)
|
|
|
|
if len(parts) != 2 {
|
|
|
|
return errors.New("bad format in address specification")
|
|
|
|
}
|
|
|
|
if net.ParseIP(parts[0]) == nil {
|
|
|
|
return errors.New("bad IP in address specification")
|
|
|
|
}
|
|
|
|
if _, err := strconv.Atoi(parts[1]); err != nil {
|
|
|
|
return errors.New("bad port in address specification")
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-09-18 18:50:52 +04:00
|
|
|
// ProxyFlag implements the flag.Value interface.
|
|
|
|
type ProxyFlag string
|
|
|
|
|
|
|
|
// Set verifies the argument to be a valid member of proxyFlagValues
|
|
|
|
// before setting the underlying flag value.
|
|
|
|
func (pf *ProxyFlag) Set(s string) error {
|
|
|
|
for _, v := range proxyFlagValues {
|
|
|
|
if s == v {
|
|
|
|
*pf = ProxyFlag(s)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return errors.New("invalid value")
|
|
|
|
}
|
|
|
|
|
|
|
|
func (pf *ProxyFlag) String() string {
|
|
|
|
return string(*pf)
|
|
|
|
}
|