2013-06-09 21:42:34 +04:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
2013-06-21 02:59:23 +04:00
|
|
|
"crypto/tls"
|
|
|
|
"crypto/x509"
|
2013-06-09 21:42:34 +04:00
|
|
|
"encoding/json"
|
2013-06-20 08:03:28 +04:00
|
|
|
"encoding/pem"
|
2013-06-09 21:42:34 +04:00
|
|
|
"flag"
|
|
|
|
"fmt"
|
2013-07-08 20:41:04 +04:00
|
|
|
"github.com/coreos/etcd/store"
|
|
|
|
"github.com/coreos/etcd/web"
|
|
|
|
"github.com/coreos/go-raft"
|
2013-06-29 01:17:16 +04:00
|
|
|
//"io"
|
2013-06-09 21:42:34 +04:00
|
|
|
"io/ioutil"
|
2013-06-21 02:59:23 +04:00
|
|
|
"log"
|
2013-06-09 21:42:34 +04:00
|
|
|
"net/http"
|
|
|
|
"os"
|
2013-06-29 01:17:16 +04:00
|
|
|
//"strconv"
|
2013-06-21 02:59:23 +04:00
|
|
|
"strings"
|
|
|
|
"time"
|
2013-06-09 21:42:34 +04:00
|
|
|
)
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// Initialization
|
|
|
|
//
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
var verbose bool
|
2013-06-29 01:17:16 +04:00
|
|
|
|
|
|
|
var cluster string
|
|
|
|
|
2013-06-13 22:01:06 +04:00
|
|
|
var address string
|
2013-06-29 01:17:16 +04:00
|
|
|
var clientPort int
|
|
|
|
var serverPort int
|
2013-06-18 22:13:24 +04:00
|
|
|
var webPort int
|
2013-06-29 01:17:16 +04:00
|
|
|
|
2013-06-29 01:46:05 +04:00
|
|
|
var serverCertFile string
|
|
|
|
var serverKeyFile string
|
|
|
|
var serverCAFile string
|
|
|
|
|
|
|
|
var clientCertFile string
|
|
|
|
var clientKeyFile string
|
|
|
|
var clientCAFile string
|
2013-06-29 01:17:16 +04:00
|
|
|
|
2013-06-28 22:47:47 +04:00
|
|
|
var dirPath string
|
|
|
|
|
2013-06-29 02:04:05 +04:00
|
|
|
var ignore bool
|
2013-06-09 21:42:34 +04:00
|
|
|
|
2013-07-01 03:30:41 +04:00
|
|
|
var maxSize int
|
2013-06-30 21:09:05 +04:00
|
|
|
|
2013-06-09 21:42:34 +04:00
|
|
|
func init() {
|
|
|
|
flag.BoolVar(&verbose, "v", false, "verbose logging")
|
2013-06-29 01:17:16 +04:00
|
|
|
|
2013-07-01 22:16:30 +04:00
|
|
|
flag.StringVar(&cluster, "C", "", "the ip address and port of a existing cluster")
|
2013-06-29 01:17:16 +04:00
|
|
|
|
2013-07-10 01:07:45 +04:00
|
|
|
flag.StringVar(&address, "a", "0.0.0.0", "the ip address of the local machine")
|
2013-07-01 22:16:30 +04:00
|
|
|
flag.IntVar(&clientPort, "c", 4001, "the port to communicate with clients")
|
|
|
|
flag.IntVar(&serverPort, "s", 7001, "the port to communicate with servers")
|
2013-06-18 22:13:24 +04:00
|
|
|
flag.IntVar(&webPort, "w", -1, "the port of web interface")
|
2013-06-29 01:17:16 +04:00
|
|
|
|
2013-06-29 01:46:05 +04:00
|
|
|
flag.StringVar(&serverCAFile, "serverCAFile", "", "the path of the CAFile")
|
|
|
|
flag.StringVar(&serverCertFile, "serverCert", "", "the cert file of the server")
|
|
|
|
flag.StringVar(&serverKeyFile, "serverKey", "", "the key file of the server")
|
|
|
|
|
2013-07-01 22:16:30 +04:00
|
|
|
flag.StringVar(&clientCAFile, "clientCAFile", "", "the path of the client CAFile")
|
2013-06-29 01:46:05 +04:00
|
|
|
flag.StringVar(&clientCertFile, "clientCert", "", "the cert file of the client")
|
|
|
|
flag.StringVar(&clientKeyFile, "clientKey", "", "the key file of the client")
|
2013-06-29 01:17:16 +04:00
|
|
|
|
2013-07-10 01:07:45 +04:00
|
|
|
flag.StringVar(&dirPath, "d", "/tmp/", "the directory to store log and snapshot")
|
2013-06-29 02:04:05 +04:00
|
|
|
|
2013-06-29 02:37:29 +04:00
|
|
|
flag.BoolVar(&ignore, "i", false, "ignore the old configuration, create a new node")
|
2013-07-01 03:30:41 +04:00
|
|
|
|
|
|
|
flag.IntVar(&maxSize, "m", 1024, "the max size of result buffer")
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|
2013-06-21 02:59:23 +04:00
|
|
|
|
2013-06-21 02:26:31 +04:00
|
|
|
// CONSTANTS
|
2013-06-21 02:59:23 +04:00
|
|
|
const (
|
2013-06-21 02:26:31 +04:00
|
|
|
HTTP = iota
|
|
|
|
HTTPS
|
|
|
|
HTTPSANDVERIFY
|
|
|
|
)
|
2013-06-09 21:42:34 +04:00
|
|
|
|
2013-06-29 01:46:05 +04:00
|
|
|
const (
|
|
|
|
SERVER = iota
|
|
|
|
CLIENT
|
|
|
|
)
|
|
|
|
|
2013-06-13 22:01:06 +04:00
|
|
|
const (
|
2013-06-28 20:58:41 +04:00
|
|
|
ELECTIONTIMTOUT = 200 * time.Millisecond
|
|
|
|
HEARTBEATTIMEOUT = 50 * time.Millisecond
|
2013-06-13 22:01:06 +04:00
|
|
|
)
|
|
|
|
|
2013-06-09 21:42:34 +04:00
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// Typedefs
|
|
|
|
//
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
type Info struct {
|
2013-06-29 02:37:29 +04:00
|
|
|
Address string `json:"address"`
|
2013-06-29 01:17:16 +04:00
|
|
|
ServerPort int `json:"serverPort"`
|
2013-06-29 02:37:29 +04:00
|
|
|
ClientPort int `json:"clientPort"`
|
|
|
|
WebPort int `json:"webPort"`
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// Variables
|
|
|
|
//
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
var raftServer *raft.Server
|
|
|
|
var raftTransporter transporter
|
2013-07-10 00:14:12 +04:00
|
|
|
var etcdStore *store.Store
|
2013-06-19 02:04:30 +04:00
|
|
|
|
2013-06-09 21:42:34 +04:00
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// Functions
|
|
|
|
//
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
//--------------------------------------
|
|
|
|
// Main
|
|
|
|
//--------------------------------------
|
|
|
|
|
|
|
|
func main() {
|
|
|
|
var err error
|
|
|
|
flag.Parse()
|
|
|
|
|
|
|
|
// Setup commands.
|
2013-06-10 08:46:30 +04:00
|
|
|
raft.RegisterCommand(&JoinCommand{})
|
2013-06-09 21:42:34 +04:00
|
|
|
raft.RegisterCommand(&SetCommand{})
|
|
|
|
raft.RegisterCommand(&GetCommand{})
|
|
|
|
raft.RegisterCommand(&DeleteCommand{})
|
2013-07-09 00:16:55 +04:00
|
|
|
raft.RegisterCommand(&WatchCommand{})
|
|
|
|
raft.RegisterCommand(&ListCommand{})
|
|
|
|
raft.RegisterCommand(&TestAndSetCommand{})
|
2013-06-21 02:59:23 +04:00
|
|
|
|
2013-06-28 22:47:47 +04:00
|
|
|
if err := os.MkdirAll(dirPath, 0744); err != nil {
|
|
|
|
fatal("Unable to create path: %v", err)
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Read server info from file or grab it from user.
|
2013-06-28 22:47:47 +04:00
|
|
|
var info *Info = getInfo(dirPath)
|
2013-06-13 22:01:06 +04:00
|
|
|
|
2013-06-29 01:17:16 +04:00
|
|
|
name := fmt.Sprintf("%s:%d", info.Address, info.ServerPort)
|
2013-06-13 22:01:06 +04:00
|
|
|
|
2013-06-29 01:17:16 +04:00
|
|
|
fmt.Printf("ServerName: %s\n\n", name)
|
2013-06-21 02:59:23 +04:00
|
|
|
|
2013-06-20 08:03:28 +04:00
|
|
|
// secrity type
|
2013-06-29 01:46:05 +04:00
|
|
|
st := securityType(SERVER)
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
if st == -1 {
|
|
|
|
panic("ERROR type")
|
|
|
|
}
|
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
raftTransporter = createTransporter(st)
|
2013-06-09 21:42:34 +04:00
|
|
|
|
|
|
|
// Setup new raft server.
|
2013-07-10 00:14:12 +04:00
|
|
|
etcdStore = store.CreateStore(maxSize)
|
2013-06-19 02:04:30 +04:00
|
|
|
|
2013-06-20 08:03:28 +04:00
|
|
|
// create raft server
|
2013-07-10 01:55:45 +04:00
|
|
|
raftServer, err = raft.NewServer(name, dirPath, raftTransporter, etcdStore, nil)
|
2013-06-19 02:04:30 +04:00
|
|
|
|
2013-06-09 21:42:34 +04:00
|
|
|
if err != nil {
|
|
|
|
fatal("%v", err)
|
|
|
|
}
|
2013-06-12 20:46:53 +04:00
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
err = raftServer.LoadSnapshot()
|
2013-07-01 08:17:51 +04:00
|
|
|
|
|
|
|
if err == nil {
|
2013-07-10 01:55:45 +04:00
|
|
|
debug("%s finished load snapshot", raftServer.Name())
|
2013-07-01 08:17:51 +04:00
|
|
|
} else {
|
|
|
|
fmt.Println(err)
|
2013-07-10 01:55:45 +04:00
|
|
|
debug("%s bad snapshot", raftServer.Name())
|
2013-07-01 08:17:51 +04:00
|
|
|
}
|
2013-07-10 01:58:59 +04:00
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
raftServer.Initialize()
|
|
|
|
debug("%s finished init", raftServer.Name())
|
|
|
|
raftServer.SetElectionTimeout(ELECTIONTIMTOUT)
|
|
|
|
raftServer.SetHeartbeatTimeout(HEARTBEATTIMEOUT)
|
|
|
|
debug("%s finished set timeout", raftServer.Name())
|
2013-06-13 22:01:06 +04:00
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
if raftServer.IsLogEmpty() {
|
2013-06-13 22:01:06 +04:00
|
|
|
|
|
|
|
// start as a leader in a new cluster
|
2013-06-29 01:17:16 +04:00
|
|
|
if cluster == "" {
|
2013-07-10 01:55:45 +04:00
|
|
|
raftServer.StartLeader()
|
2013-07-08 20:41:04 +04:00
|
|
|
|
2013-07-07 09:32:08 +04:00
|
|
|
time.Sleep(time.Millisecond * 20)
|
2013-06-13 22:01:06 +04:00
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
// leader need to join self as a peer
|
2013-07-07 09:32:08 +04:00
|
|
|
for {
|
|
|
|
command := &JoinCommand{}
|
2013-07-10 01:55:45 +04:00
|
|
|
command.Name = raftServer.Name()
|
|
|
|
_, err := raftServer.Do(command)
|
2013-07-07 09:32:08 +04:00
|
|
|
if err == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2013-07-10 01:55:45 +04:00
|
|
|
debug("%s start as a leader", raftServer.Name())
|
2013-06-13 22:01:06 +04:00
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
// start as a follower in a existing cluster
|
2013-06-09 21:42:34 +04:00
|
|
|
} else {
|
2013-07-10 01:55:45 +04:00
|
|
|
raftServer.StartFollower()
|
2013-06-12 20:46:53 +04:00
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
err := Join(raftServer, cluster)
|
2013-06-20 08:03:28 +04:00
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
2013-07-10 01:55:45 +04:00
|
|
|
debug("%s success join to the cluster", raftServer.Name())
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|
2013-06-13 22:01:06 +04:00
|
|
|
|
2013-06-12 02:29:25 +04:00
|
|
|
} else {
|
2013-07-10 01:55:45 +04:00
|
|
|
// rejoin the previous cluster
|
|
|
|
raftServer.StartFollower()
|
|
|
|
debug("%s restart as a follower", raftServer.Name())
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|
2013-06-13 22:01:06 +04:00
|
|
|
|
|
|
|
// open the snapshot
|
2013-07-03 22:22:52 +04:00
|
|
|
//go server.Snapshot()
|
2013-06-09 21:42:34 +04:00
|
|
|
|
2013-06-21 02:59:23 +04:00
|
|
|
if webPort != -1 {
|
|
|
|
// start web
|
2013-07-10 00:14:12 +04:00
|
|
|
etcdStore.SetMessager(&storeMsg)
|
2013-06-21 02:59:23 +04:00
|
|
|
go webHelper()
|
2013-07-10 01:55:45 +04:00
|
|
|
go web.Start(raftServer, webPort)
|
2013-06-21 02:59:23 +04:00
|
|
|
}
|
2013-06-20 08:03:28 +04:00
|
|
|
|
2013-06-29 01:17:16 +04:00
|
|
|
go startServTransport(info.ServerPort, st)
|
2013-06-29 01:46:05 +04:00
|
|
|
startClientTransport(info.ClientPort, securityType(CLIENT))
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-07-10 01:55:45 +04:00
|
|
|
func createTransporter(st int) transporter {
|
|
|
|
t := transporter{}
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
switch st {
|
|
|
|
case HTTP:
|
|
|
|
t.client = nil
|
|
|
|
return t
|
|
|
|
|
|
|
|
case HTTPS:
|
|
|
|
fallthrough
|
|
|
|
case HTTPSANDVERIFY:
|
2013-06-29 01:46:05 +04:00
|
|
|
tlsCert, err := tls.LoadX509KeyPair(serverCertFile, serverKeyFile)
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
tr := &http.Transport{
|
2013-06-21 02:59:23 +04:00
|
|
|
TLSClientConfig: &tls.Config{
|
|
|
|
Certificates: []tls.Certificate{tlsCert},
|
2013-06-20 08:03:28 +04:00
|
|
|
InsecureSkipVerify: true,
|
2013-06-21 02:59:23 +04:00
|
|
|
},
|
|
|
|
DisableCompression: true,
|
|
|
|
}
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
t.client = &http.Client{Transport: tr}
|
|
|
|
return t
|
|
|
|
}
|
|
|
|
|
|
|
|
// for complier
|
2013-07-10 01:55:45 +04:00
|
|
|
return transporter{}
|
2013-06-20 08:03:28 +04:00
|
|
|
}
|
|
|
|
|
2013-06-29 01:17:16 +04:00
|
|
|
func startServTransport(port int, st int) {
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
// internal commands
|
2013-06-21 02:59:23 +04:00
|
|
|
http.HandleFunc("/join", JoinHttpHandler)
|
|
|
|
http.HandleFunc("/vote", VoteHttpHandler)
|
|
|
|
http.HandleFunc("/log", GetLogHttpHandler)
|
|
|
|
http.HandleFunc("/log/append", AppendEntriesHttpHandler)
|
|
|
|
http.HandleFunc("/snapshot", SnapshotHttpHandler)
|
2013-06-29 02:37:29 +04:00
|
|
|
http.HandleFunc("/client", clientHttpHandler)
|
2013-06-29 01:17:16 +04:00
|
|
|
|
|
|
|
switch st {
|
|
|
|
|
|
|
|
case HTTP:
|
2013-07-10 01:55:45 +04:00
|
|
|
debug("raft server [%s] listen on http port %v", address, port)
|
2013-06-29 01:17:16 +04:00
|
|
|
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))
|
|
|
|
|
|
|
|
case HTTPS:
|
2013-07-10 01:55:45 +04:00
|
|
|
debug("raft server [%s] listen on https port %v", address, port)
|
|
|
|
log.Fatal(http.ListenAndServeTLS(fmt.Sprintf(":%d", port), serverCertFile, serverKeyFile, nil))
|
2013-06-29 01:17:16 +04:00
|
|
|
|
|
|
|
case HTTPSANDVERIFY:
|
2013-06-29 01:46:05 +04:00
|
|
|
pemByte, _ := ioutil.ReadFile(serverCAFile)
|
2013-06-29 01:17:16 +04:00
|
|
|
|
|
|
|
block, pemByte := pem.Decode(pemByte)
|
|
|
|
|
|
|
|
cert, err := x509.ParseCertificate(block.Bytes)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
certPool := x509.NewCertPool()
|
|
|
|
|
|
|
|
certPool.AddCert(cert)
|
|
|
|
|
|
|
|
server := &http.Server{
|
|
|
|
TLSConfig: &tls.Config{
|
|
|
|
ClientAuth: tls.RequireAndVerifyClientCert,
|
|
|
|
ClientCAs: certPool,
|
|
|
|
},
|
|
|
|
Addr: fmt.Sprintf(":%d", port),
|
|
|
|
}
|
2013-06-29 01:46:05 +04:00
|
|
|
err = server.ListenAndServeTLS(serverCertFile, serverKeyFile)
|
2013-06-29 01:17:16 +04:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func startClientTransport(port int, st int) {
|
2013-06-21 02:59:23 +04:00
|
|
|
// external commands
|
2013-07-01 22:16:30 +04:00
|
|
|
http.HandleFunc("/v1/keys/", Multiplexer)
|
|
|
|
http.HandleFunc("/v1/watch/", WatchHttpHandler)
|
2013-07-06 03:22:45 +04:00
|
|
|
http.HandleFunc("/v1/list/", ListHttpHandler)
|
2013-07-08 22:00:10 +04:00
|
|
|
http.HandleFunc("/v1/testAndSet/", TestAndSetHttpHandler)
|
2013-06-21 02:59:23 +04:00
|
|
|
http.HandleFunc("/master", MasterHttpHandler)
|
2013-06-11 02:09:01 +04:00
|
|
|
|
2013-06-21 02:59:23 +04:00
|
|
|
switch st {
|
2013-06-18 22:13:24 +04:00
|
|
|
|
2013-06-21 02:59:23 +04:00
|
|
|
case HTTP:
|
2013-07-10 01:55:45 +04:00
|
|
|
debug("etcd [%s] listen on http port %v", address, clientPort)
|
2013-06-21 02:59:23 +04:00
|
|
|
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), nil))
|
2013-06-18 22:13:24 +04:00
|
|
|
|
2013-06-21 02:59:23 +04:00
|
|
|
case HTTPS:
|
2013-06-29 01:46:05 +04:00
|
|
|
http.ListenAndServeTLS(fmt.Sprintf(":%d", port), clientCertFile, clientKeyFile, nil)
|
2013-06-20 08:03:28 +04:00
|
|
|
|
2013-06-21 02:59:23 +04:00
|
|
|
case HTTPSANDVERIFY:
|
2013-06-29 01:46:05 +04:00
|
|
|
pemByte, _ := ioutil.ReadFile(clientCAFile)
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
block, pemByte := pem.Decode(pemByte)
|
|
|
|
|
|
|
|
cert, err := x509.ParseCertificate(block.Bytes)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
certPool := x509.NewCertPool()
|
|
|
|
|
|
|
|
certPool.AddCert(cert)
|
|
|
|
|
|
|
|
server := &http.Server{
|
|
|
|
TLSConfig: &tls.Config{
|
|
|
|
ClientAuth: tls.RequireAndVerifyClientCert,
|
2013-06-21 02:59:23 +04:00
|
|
|
ClientCAs: certPool,
|
|
|
|
},
|
|
|
|
Addr: fmt.Sprintf(":%d", port),
|
2013-06-20 08:03:28 +04:00
|
|
|
}
|
2013-06-29 01:46:05 +04:00
|
|
|
err = server.ListenAndServeTLS(clientCertFile, clientKeyFile)
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
log.Fatal(err)
|
|
|
|
}
|
2013-06-21 02:59:23 +04:00
|
|
|
}
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------
|
|
|
|
// Config
|
|
|
|
//--------------------------------------
|
|
|
|
|
2013-06-29 01:46:05 +04:00
|
|
|
func securityType(source int) int {
|
|
|
|
|
2013-06-29 02:37:29 +04:00
|
|
|
var keyFile, certFile, CAFile string
|
2013-06-29 01:46:05 +04:00
|
|
|
|
|
|
|
switch source {
|
|
|
|
case SERVER:
|
|
|
|
keyFile = serverKeyFile
|
|
|
|
certFile = serverCertFile
|
|
|
|
CAFile = serverCAFile
|
|
|
|
|
|
|
|
case CLIENT:
|
|
|
|
keyFile = clientKeyFile
|
|
|
|
certFile = clientCertFile
|
|
|
|
CAFile = clientCAFile
|
|
|
|
}
|
|
|
|
|
2013-06-21 02:59:23 +04:00
|
|
|
if keyFile == "" && certFile == "" && CAFile == "" {
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
return HTTP
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if keyFile != "" && certFile != "" {
|
|
|
|
|
|
|
|
if CAFile != "" {
|
|
|
|
return HTTPSANDVERIFY
|
|
|
|
}
|
|
|
|
|
|
|
|
return HTTPS
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1
|
|
|
|
}
|
|
|
|
|
2013-06-09 21:42:34 +04:00
|
|
|
func getInfo(path string) *Info {
|
|
|
|
info := &Info{}
|
|
|
|
|
|
|
|
// Read in the server info if available.
|
|
|
|
infoPath := fmt.Sprintf("%s/info", path)
|
2013-06-29 02:04:05 +04:00
|
|
|
|
|
|
|
// delete the old configuration if exist
|
|
|
|
if ignore {
|
|
|
|
logPath := fmt.Sprintf("%s/log", path)
|
|
|
|
snapshotPath := fmt.Sprintf("%s/snapshotPath", path)
|
|
|
|
os.Remove(infoPath)
|
|
|
|
os.Remove(logPath)
|
|
|
|
os.RemoveAll(snapshotPath)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-06-09 21:42:34 +04:00
|
|
|
if file, err := os.Open(infoPath); err == nil {
|
|
|
|
if content, err := ioutil.ReadAll(file); err != nil {
|
|
|
|
fatal("Unable to read info: %v", err)
|
|
|
|
} else {
|
|
|
|
if err = json.Unmarshal(content, &info); err != nil {
|
|
|
|
fatal("Unable to parse info: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
file.Close()
|
2013-06-21 02:59:23 +04:00
|
|
|
|
|
|
|
// Otherwise ask user for info and write it to file.
|
2013-06-09 21:42:34 +04:00
|
|
|
} else {
|
2013-06-21 02:59:23 +04:00
|
|
|
|
2013-06-13 22:01:06 +04:00
|
|
|
if address == "" {
|
|
|
|
fatal("Please give the address of the local machine")
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|
|
|
|
|
2013-06-29 01:17:16 +04:00
|
|
|
info.Address = address
|
|
|
|
info.Address = strings.TrimSpace(info.Address)
|
|
|
|
fmt.Println("address ", info.Address)
|
2013-06-21 02:59:23 +04:00
|
|
|
|
2013-06-29 01:17:16 +04:00
|
|
|
info.ServerPort = serverPort
|
|
|
|
info.ClientPort = clientPort
|
|
|
|
info.WebPort = webPort
|
2013-06-09 21:42:34 +04:00
|
|
|
|
|
|
|
// Write to file.
|
|
|
|
content, _ := json.Marshal(info)
|
|
|
|
content = []byte(string(content) + "\n")
|
|
|
|
if err := ioutil.WriteFile(infoPath, content, 0644); err != nil {
|
|
|
|
fatal("Unable to write info to file: %v", err)
|
|
|
|
}
|
|
|
|
}
|
2013-06-21 02:59:23 +04:00
|
|
|
|
2013-06-09 21:42:34 +04:00
|
|
|
return info
|
|
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------
|
|
|
|
// Handlers
|
|
|
|
//--------------------------------------
|
|
|
|
|
|
|
|
// Send join requests to the leader.
|
2013-06-10 08:46:30 +04:00
|
|
|
func Join(s *raft.Server, serverName string) error {
|
2013-06-09 21:42:34 +04:00
|
|
|
var b bytes.Buffer
|
2013-06-21 02:59:23 +04:00
|
|
|
|
2013-06-10 08:46:30 +04:00
|
|
|
command := &JoinCommand{}
|
2013-06-09 21:42:34 +04:00
|
|
|
command.Name = s.Name()
|
|
|
|
|
|
|
|
json.NewEncoder(&b).Encode(command)
|
2013-06-20 08:03:28 +04:00
|
|
|
|
|
|
|
// t must be ok
|
2013-07-10 01:55:45 +04:00
|
|
|
t, _ := raftServer.Transporter().(transporter)
|
2013-06-21 02:26:31 +04:00
|
|
|
debug("Send Join Request to %s", serverName)
|
2013-07-10 01:55:45 +04:00
|
|
|
resp, err := t.Post(fmt.Sprintf("%s/join", serverName), &b)
|
2013-06-20 08:03:28 +04:00
|
|
|
|
2013-06-21 02:26:31 +04:00
|
|
|
for {
|
|
|
|
if resp != nil {
|
|
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode == http.StatusOK {
|
|
|
|
return nil
|
|
|
|
}
|
2013-06-21 04:46:12 +04:00
|
|
|
if resp.StatusCode == http.StatusServiceUnavailable {
|
2013-06-21 02:26:31 +04:00
|
|
|
address, err := ioutil.ReadAll(resp.Body)
|
|
|
|
if err != nil {
|
|
|
|
warn("Cannot Read Leader info: %v", err)
|
|
|
|
}
|
|
|
|
debug("Leader is %s", address)
|
|
|
|
debug("Send Join Request to %s", address)
|
|
|
|
json.NewEncoder(&b).Encode(command)
|
2013-07-10 01:55:45 +04:00
|
|
|
resp, err = t.Post(fmt.Sprintf("%s/join", address), &b)
|
2013-06-21 02:26:31 +04:00
|
|
|
}
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|
|
|
|
}
|
2013-06-21 02:26:31 +04:00
|
|
|
return fmt.Errorf("Unable to join: %v", err)
|
2013-06-09 21:42:34 +04:00
|
|
|
}
|