my-rook-config/pkg/etcdmgr/bootstrap/etcd.go

/*
Copyright 2016 The Rook Authors. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package bootstrap

import (
	"fmt"
	"net"
	"net/http"
	"os"

	"github.com/coreos/etcd/etcdserver"
	"github.com/coreos/etcd/etcdserver/api/v2http"
	"github.com/coreos/etcd/pkg/cors"
	"github.com/coreos/etcd/pkg/types"
)

type EtcdFactory interface {
	NewEmbeddedEtcd(token string, conf *Config, newCluster bool) (*EmbeddedEtcd, error)
}

type EmbeddedEtcdFactory struct {
}

// EmbeddedEtcd represents an instance of etcd server.
type EmbeddedEtcd struct {
	Server          *etcdserver.EtcdServer
	peerListeners   []net.Listener
	clientListeners []net.Listener
	config          *Config
}

// NewEmbeddedEtcd creates a new inproc instance of etcd.
func (e *EmbeddedEtcdFactory) NewEmbeddedEtcd(token string, conf *Config, newCluster bool) (*EmbeddedEtcd, error) {
	var err error
	instance := &EmbeddedEtcd{config: conf}
	err = instance.InitializeListeners()
	if err != nil {
		return nil, fmt.Errorf("error initializing listeners. %+v", err)
	}

	serverConfig := getServerConfig(token, conf, newCluster)

	instance.Server, err = etcdserver.NewServer(serverConfig)
	if err != nil {
		return nil, err
	}

	instance.Server.Start()
	for _, pl := range instance.peerListeners {
		go func(l net.Listener) {
			http.Serve(l, v2http.NewPeerHandler(instance.Server))
		}(pl)
	}

	clientHandler := http.Handler(&cors.CORSHandler{
		Handler: v2http.NewClientHandler(instance.Server, instance.Server.Cfg.ReqTimeout()),
		Info:    &cors.CORSInfo{},
	})
	for _, cl := range instance.clientListeners {
		go func(l net.Listener) {
			http.Serve(l, clientHandler)
		}(cl)
	}

	// wait until server is stable and ready
	<-instance.Server.ReadyNotify()
	return instance, nil
}

func (ee *EmbeddedEtcd) InitializeListeners() error {
	//initializing client listeners
	logger.Infof("client urls to set listeners for: %+v", ee.config.ListenClientURLs)
	for _, url := range ee.config.ListenClientURLs {
		l, err := net.Listen("tcp", url.Host)
		if err != nil {
			return err
		}
		ee.clientListeners = append(ee.clientListeners, l)
	}

	//initialize peer listeners
	logger.Infof("peer urls to set listeners for: %+v", ee.config.ListenPeerURLs)
	for _, url := range ee.config.ListenPeerURLs {
		l, err := net.Listen("tcp", url.Host)
		if err != nil {
			return err
		}
		ee.peerListeners = append(ee.peerListeners, l)
	}

	return nil
}

// Destroy wipes out the current instance of etcd and makes the necessary cleanup.
func (ee *EmbeddedEtcd) Destroy(conf *Config) error {
	var err error

	for _, pl := range ee.peerListeners {
		if pl != nil {
			pl.Close()
		}
	}
	for _, cl := range ee.clientListeners {
		if cl != nil {
			cl.Close()
		}
	}

	if ee.Server != nil {
		ee.Server.Stop()
	}

	if conf.DataDir != "" {
		err := os.RemoveAll(conf.DataDir)
		if err != nil {
			return err
		}
	}

	return err
}

func getServerConfig(token string, conf *Config, newCluster bool) *etcdserver.ServerConfig {
	// if this config if for a member that is joining an exsiting cluster, the token should be empty
	if !newCluster {
		token = ""
	}

	var initialPeerURLsMap types.URLsMap
	if len(conf.URLsMap) == 0 {
		initialPeerURLsMap = types.URLsMap{
			conf.InstanceName: conf.AdvertisePeerURLs,
		}
	} else {
		initialPeerURLsMap = conf.URLsMap
	}
	return &etcdserver.ServerConfig{
		Name:                conf.InstanceName,
		DiscoveryURL:        token,
		InitialClusterToken: token,
		ClientURLs:          conf.AdvertiseClientURLs,
		PeerURLs:            conf.AdvertisePeerURLs,
		DataDir:             conf.DataDir,
		NewCluster:          newCluster,
		TickMs:              100,
		ElectionTicks:       10,
		InitialPeerURLsMap:  initialPeerURLsMap,
	}
}