// Creates a new server.
func New(path, listen string) (*Server, error) {
sqlPath := filepath.Join(path, "storage.sql")
util.EnsureAbsent(sqlPath)
s := &Server{
received: make(map[string]bool),
path: path,
listen: listen,
sql: sql.NewSQL(sqlPath),
router: mux.NewRouter(),
client: transport.NewClient(),
}
// Read existing name or generate a new one.
if b, err := ioutil.ReadFile(filepath.Join(path, "name")); err == nil {
s.name = string(b)
} else {
s.name = fmt.Sprintf("%07x", rand.Int())[0:7]
if err = ioutil.WriteFile(filepath.Join(path, "name"), []byte(s.name), 0644); err != nil {
panic(err)
}
}
return s, nil
}
// Creates a new server.
func New(path, listen string) (*Server, error) {
s := &Server{
name: listen,
path: path,
listen: listen,
sql: sql.NewSQL(),
router: mux.NewRouter(),
client: transport.NewClient(),
}
return s, nil
}
// Creates a new HTTP transporter with the given path prefix.
func NewHTTPTransporter(prefix string) *HTTPTransporter {
cli := transport.NewClient()
t := &HTTPTransporter{
DisableKeepAlives: false,
prefix: prefix,
appendEntriesPath: joinPath(prefix, "/appendEntries"),
requestVotePath: joinPath(prefix, "/requestVote"),
snapshotPath: joinPath(prefix, "/snapshot"),
snapshotRecoveryPath: joinPath(prefix, "/snapshotRecovery"),
Transport: &http.Transport{},
client: cli,
httpClient: cli.Internal(),
}
return t
}
// Creates a new server.
func New(path, listen string) (*Server, error) {
s := &Server{
name: listen,
path: path,
listen: listen,
router: mux.NewRouter(),
client: transport.NewClient(),
db: NewDB(path),
outstanding: NewOutstanding(),
joined: false,
leaderNotify: make(chan string, 1000),
}
return s, nil
}
// Creates a new server.
func New(path, listen string) (*Server, error) {
sqlPath := filepath.Join(path, "storage.sql")
util.EnsureAbsent(sqlPath)
s := &Server{
name: listen,
path: path,
listen: listen,
sql: sql.NewSQL(sqlPath),
router: mux.NewRouter(),
client: transport.NewClient(),
}
return s, nil
}
// Creates a new server.
func New(path, listen string) (*Server, error) {
cs, err := transport.Encode(listen)
if err != nil {
return nil, err
}
sqlPath := filepath.Join(path, "storage.sql")
util.EnsureAbsent(sqlPath)
s := &Server{
path: path,
listen: listen,
sql: sql.NewSQL(sqlPath),
router: mux.NewRouter(),
client: transport.NewClient(),
cluster: NewCluster(path, cs),
}
return s, nil
}
// Creates a new server.
func New(path, listen string) (*Server, error) {
cs, err := transport.Encode(listen)
if err != nil {
return nil, err
}
log.Printf("My connection string is %s", cs)
sqlPath := filepath.Join(path, "storage.sql")
util.EnsureAbsent(sqlPath)
s := &Server{
path: path,
name: strings.Replace(listen, "/", "-", -1),
listen: listen,
connection_string: cs,
sql: sql.NewSQL(sqlPath),
router: mux.NewRouter(),
client: transport.NewClient(),
}
return s, nil
}
// Creates a new server.
func New(path, listen, join string) (*Server, error) {
cs, err := transport.Encode(listen)
if err != nil {
return nil, err
}
sqlPath := filepath.Join(path, "storage.sql")
util.EnsureAbsent(sqlPath)
s := &Server{
path: path,
listen: listen,
name: path,
connectionString: cs,
sql: sql.NewSQL(sqlPath),
router: mux.NewRouter(),
client: transport.NewClient(),
execCommand: make(chan *ExecCommand),
}
return s, nil
}
// Creates a new server.
func New(path, listen string) (*Server, error) {
cs, err := transport.Encode(listen)
if err != nil {
return nil, err
}
log.Printf("Starting server at" + cs)
sqlPath := filepath.Join(path, "storage.sql")
util.EnsureAbsent(sqlPath)
s := &Server{
path: path,
listen: listen,
sql: sql.NewSQL(sqlPath),
router: mux.NewRouter(),
client: transport.NewClient(),
block: false,
}
return s, nil
}
// Starts the server.
func (s *Server) ListenAndServe(primary string) error {
var err error
rand.Seed(int64(time.Now().Nanosecond()))
s.primary = primary
s.name = "name-" + s.listen
raft.RegisterCommand(&BatchCommand{})
// Initialize and start HTTP server.
s.httpServer = &http.Server{
Handler: s.router,
}
httpTransport := transport.NewClient().GetHTTPClient()
//log.Printf(("Initializing Raft Server")
transporter := NewHTTPTransporter("/raft", *httpTransport)
s.raftServer, err = raft.NewServer(s.name, s.path, transporter, nil, s.db, "")
if err != nil {
log.Fatal(err)
}
transporter.Install(s.raftServer, s)
s.raftServer.Start()
s.raftServer.SetElectionTimeout(400 * time.Millisecond)
s.raftServer.AddEventListener("addPeer", func(e raft.Event) {
//log.Printf("Joined!")
s.joined = true
})
s.raftServer.AddEventListener("leaderChange", func(e raft.Event) {
leader := e.Value().(string)
if leader == s.name {
//log.Printf("Leader Changed to %v", leader)
s.leaderNotify <- leader
}
})
if primary == "" {
cs, err := transport.Encode(s.listen)
if err != nil {
log.Fatal(err)
}
//log.Printf(("Starting as Leader")
_, err = s.raftServer.Do(&raft.DefaultJoinCommand{
Name: s.raftServer.Name(),
ConnectionString: cs,
})
//log.Printf(("I am Leader")
if err != nil {
log.Fatal(err)
}
} else {
//log.Printf("Waiting 100 milliseconds to join Primary")
time.AfterFunc(10*time.Millisecond, func() {
maxTries := 25
tries := 0
for !s.joined {
//log.Printf("Trying to Join")
tries++
//log.Printf("Attempting to Join")
s.Join(primary)
// if err != nil {
// //log.Printf("Failed to join")
// } else {
// //log.Printf("Joined!")
// break
// }
if tries > maxTries {
log.Fatal("Could not join!")
}
time.Sleep(JOIN_TIMEOUT)
}
})
}
s.router.HandleFunc("/sql", s.sqlHandler).Methods("POST")
s.router.HandleFunc("/healthcheck", s.healthcheckHandler).Methods("GET")
s.router.HandleFunc("/join", s.joinHandler).Methods("POST")
s.router.HandleFunc("/forward", s.forwardHandler).Methods("POST")
// Start Unix transport
l, err := transport.Listen(s.listen)
if err != nil {
log.Fatal(err)
}
//log.Printf(("Serving?")
go s.healthChecker()
go s.processQueue()
go s.processNotifications()
s.httpServer.Serve(l)
return nil
}