add vendoring with go dep

vendor/github.com/influxdata/influxdb/cmd/influxd/backup/backup.go

@@ -0,0 +1,387 @@
+// Package backup is the backup subcommand for the influxd command.
+package backup
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/influxdata/influxdb/services/snapshotter"
+	"github.com/influxdata/influxdb/tcp"
+)
+
+const (
+	// Suffix is a suffix added to the backup while it's in-process.
+	Suffix = ".pending"
+
+	// Metafile is the base name given to the metastore backups.
+	Metafile = "meta"
+
+	// BackupFilePattern is the beginning of the pattern for a backup
+	// file. They follow the scheme <database>.<retention>.<shardID>.<increment>
+	BackupFilePattern = "%s.%s.%05d"
+)
+
+// Command represents the program execution for "influxd backup".
+type Command struct {
+	// The logger passed to the ticker during execution.
+	Logger *log.Logger
+
+	// Standard input/output, overridden for testing.
+	Stderr io.Writer
+	Stdout io.Writer
+
+	host     string
+	path     string
+	database string
+}
+
+// NewCommand returns a new instance of Command with default settings.
+func NewCommand() *Command {
+	return &Command{
+		Stderr: os.Stderr,
+		Stdout: os.Stdout,
+	}
+}
+
+// Run executes the program.
+func (cmd *Command) Run(args ...string) error {
+	// Set up logger.
+	cmd.Logger = log.New(cmd.Stderr, "", log.LstdFlags)
+
+	// Parse command line arguments.
+	retentionPolicy, shardID, since, err := cmd.parseFlags(args)
+	if err != nil {
+		return err
+	}
+
+	// based on the arguments passed in we only backup the minimum
+	if shardID != "" {
+		// always backup the metastore
+		if err := cmd.backupMetastore(); err != nil {
+			return err
+		}
+		err = cmd.backupShard(retentionPolicy, shardID, since)
+	} else if retentionPolicy != "" {
+		err = cmd.backupRetentionPolicy(retentionPolicy, since)
+	} else if cmd.database != "" {
+		err = cmd.backupDatabase(since)
+	} else {
+		err = cmd.backupMetastore()
+	}
+
+	if err != nil {
+		cmd.Logger.Printf("backup failed: %v", err)
+		return err
+	}
+
+	cmd.Logger.Println("backup complete")
+
+	return nil
+}
+
+// parseFlags parses and validates the command line arguments into a request object.
+func (cmd *Command) parseFlags(args []string) (retentionPolicy, shardID string, since time.Time, err error) {
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+
+	fs.StringVar(&cmd.host, "host", "localhost:8088", "")
+	fs.StringVar(&cmd.database, "database", "", "")
+	fs.StringVar(&retentionPolicy, "retention", "", "")
+	fs.StringVar(&shardID, "shard", "", "")
+	var sinceArg string
+	fs.StringVar(&sinceArg, "since", "", "")
+
+	fs.SetOutput(cmd.Stderr)
+	fs.Usage = cmd.printUsage
+
+	err = fs.Parse(args)
+	if err != nil {
+		return
+	}
+	if sinceArg != "" {
+		since, err = time.Parse(time.RFC3339, sinceArg)
+		if err != nil {
+			return
+		}
+	}
+
+	// Ensure that only one arg is specified.
+	if fs.NArg() == 0 {
+		return "", "", time.Unix(0, 0), errors.New("backup destination path required")
+	} else if fs.NArg() != 1 {
+		return "", "", time.Unix(0, 0), errors.New("only one backup path allowed")
+	}
+	cmd.path = fs.Arg(0)
+
+	err = os.MkdirAll(cmd.path, 0700)
+
+	return
+}
+
+// backupShard will write a tar archive of the passed in shard with any TSM files that have been
+// created since the time passed in
+func (cmd *Command) backupShard(retentionPolicy string, shardID string, since time.Time) error {
+	id, err := strconv.ParseUint(shardID, 10, 64)
+	if err != nil {
+		return err
+	}
+
+	shardArchivePath, err := cmd.nextPath(filepath.Join(cmd.path, fmt.Sprintf(BackupFilePattern, cmd.database, retentionPolicy, id)))
+	if err != nil {
+		return err
+	}
+
+	cmd.Logger.Printf("backing up db=%v rp=%v shard=%v to %s since %s",
+		cmd.database, retentionPolicy, shardID, shardArchivePath, since)
+
+	req := &snapshotter.Request{
+		Type:            snapshotter.RequestShardBackup,
+		Database:        cmd.database,
+		RetentionPolicy: retentionPolicy,
+		ShardID:         id,
+		Since:           since,
+	}
+
+	// TODO: verify shard backup data
+	return cmd.downloadAndVerify(req, shardArchivePath, nil)
+}
+
+// backupDatabase will request the database information from the server and then backup the metastore and
+// every shard in every retention policy in the database. Each shard will be written to a separate tar.
+func (cmd *Command) backupDatabase(since time.Time) error {
+	cmd.Logger.Printf("backing up db=%s since %s", cmd.database, since)
+
+	req := &snapshotter.Request{
+		Type:     snapshotter.RequestDatabaseInfo,
+		Database: cmd.database,
+	}
+
+	response, err := cmd.requestInfo(req)
+	if err != nil {
+		return err
+	}
+
+	return cmd.backupResponsePaths(response, since)
+}
+
+// backupRetentionPolicy will request the retention policy information from the server and then backup
+// the metastore and every shard in the retention policy. Each shard will be written to a separate tar.
+func (cmd *Command) backupRetentionPolicy(retentionPolicy string, since time.Time) error {
+	cmd.Logger.Printf("backing up rp=%s since %s", retentionPolicy, since)
+
+	req := &snapshotter.Request{
+		Type:            snapshotter.RequestRetentionPolicyInfo,
+		Database:        cmd.database,
+		RetentionPolicy: retentionPolicy,
+	}
+
+	response, err := cmd.requestInfo(req)
+	if err != nil {
+		return err
+	}
+
+	return cmd.backupResponsePaths(response, since)
+}
+
+// backupResponsePaths will backup the metastore and all shard paths in the response struct
+func (cmd *Command) backupResponsePaths(response *snapshotter.Response, since time.Time) error {
+	if err := cmd.backupMetastore(); err != nil {
+		return err
+	}
+
+	// loop through the returned paths and back up each shard
+	for _, path := range response.Paths {
+		rp, id, err := retentionAndShardFromPath(path)
+		if err != nil {
+			return err
+		}
+
+		if err := cmd.backupShard(rp, id, since); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// backupMetastore will backup the metastore on the host to the passed in path. Database and retention policy backups
+// will force a backup of the metastore as well as requesting a specific shard backup from the command line
+func (cmd *Command) backupMetastore() error {
+	metastoreArchivePath, err := cmd.nextPath(filepath.Join(cmd.path, Metafile))
+	if err != nil {
+		return err
+	}
+
+	cmd.Logger.Printf("backing up metastore to %s", metastoreArchivePath)
+
+	req := &snapshotter.Request{
+		Type: snapshotter.RequestMetastoreBackup,
+	}
+
+	return cmd.downloadAndVerify(req, metastoreArchivePath, func(file string) error {
+		binData, err := ioutil.ReadFile(file)
+		if err != nil {
+			return err
+		}
+
+		magic := binary.BigEndian.Uint64(binData[:8])
+		if magic != snapshotter.BackupMagicHeader {
+			cmd.Logger.Println("Invalid metadata blob, ensure the metadata service is running (default port 8088)")
+			return errors.New("invalid metadata received")
+		}
+
+		return nil
+	})
+}
+
+// nextPath returns the next file to write to.
+func (cmd *Command) nextPath(path string) (string, error) {
+	// Iterate through incremental files until one is available.
+	for i := 0; ; i++ {
+		s := fmt.Sprintf(path+".%02d", i)
+		if _, err := os.Stat(s); os.IsNotExist(err) {
+			return s, nil
+		} else if err != nil {
+			return "", err
+		}
+	}
+}
+
+// downloadAndVerify will download either the metastore or shard to a temp file and then
+// rename it to a good backup file name after complete
+func (cmd *Command) downloadAndVerify(req *snapshotter.Request, path string, validator func(string) error) error {
+	tmppath := path + Suffix
+	if err := cmd.download(req, tmppath); err != nil {
+		return err
+	}
+
+	if validator != nil {
+		if err := validator(tmppath); err != nil {
+			if rmErr := os.Remove(tmppath); rmErr != nil {
+				cmd.Logger.Printf("Error cleaning up temporary file: %v", rmErr)
+			}
+			return err
+		}
+	}
+
+	f, err := os.Stat(tmppath)
+	if err != nil {
+		return err
+	}
+
+	// There was nothing downloaded, don't create an empty backup file.
+	if f.Size() == 0 {
+		return os.Remove(tmppath)
+	}
+
+	// Rename temporary file to final path.
+	if err := os.Rename(tmppath, path); err != nil {
+		return fmt.Errorf("rename: %s", err)
+	}
+
+	return nil
+}
+
+// download downloads a snapshot of either the metastore or a shard from a host to a given path.
+func (cmd *Command) download(req *snapshotter.Request, path string) error {
+	// Create local file to write to.
+	f, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("open temp file: %s", err)
+	}
+	defer f.Close()
+
+	for i := 0; i < 10; i++ {
+		if err = func() error {
+			// Connect to snapshotter service.
+			conn, err := tcp.Dial("tcp", cmd.host, snapshotter.MuxHeader)
+			if err != nil {
+				return err
+			}
+			defer conn.Close()
+
+			// Write the request
+			if err := json.NewEncoder(conn).Encode(req); err != nil {
+				return fmt.Errorf("encode snapshot request: %s", err)
+			}
+
+			// Read snapshot from the connection
+			if n, err := io.Copy(f, conn); err != nil || n == 0 {
+				return fmt.Errorf("copy backup to file: err=%v, n=%d", err, n)
+			}
+			return nil
+		}(); err == nil {
+			break
+		} else if err != nil {
+			cmd.Logger.Printf("Download shard %v failed %s.  Retrying (%d)...\n", req.ShardID, err, i)
+			time.Sleep(time.Second)
+		}
+	}
+
+	return err
+}
+
+// requestInfo will request the database or retention policy information from the host
+func (cmd *Command) requestInfo(request *snapshotter.Request) (*snapshotter.Response, error) {
+	// Connect to snapshotter service.
+	conn, err := tcp.Dial("tcp", cmd.host, snapshotter.MuxHeader)
+	if err != nil {
+		return nil, err
+	}
+	defer conn.Close()
+
+	// Write the request
+	if err := json.NewEncoder(conn).Encode(request); err != nil {
+		return nil, fmt.Errorf("encode snapshot request: %s", err)
+	}
+
+	// Read the response
+	var r snapshotter.Response
+	if err := json.NewDecoder(conn).Decode(&r); err != nil {
+		return nil, err
+	}
+
+	return &r, nil
+}
+
+// printUsage prints the usage message to STDERR.
+func (cmd *Command) printUsage() {
+	fmt.Fprintf(cmd.Stdout, `Downloads a snapshot of a data node and saves it to disk.
+
+Usage: influxd backup [flags] PATH
+
+    -host <host:port>
+            The host to connect to snapshot. Defaults to 127.0.0.1:8088.
+    -database <name>
+            The database to backup.
+    -retention <name>
+            Optional. The retention policy to backup.
+    -shard <id>
+            Optional. The shard id to backup. If specified, retention is required.
+    -since <2015-12-24T08:12:23>
+            Optional. Do an incremental backup since the passed in RFC3339
+            formatted time.
+
+`)
+}
+
+// retentionAndShardFromPath will take the shard relative path and split it into the
+// retention policy name and shard ID. The first part of the path should be the database name.
+func retentionAndShardFromPath(path string) (retention, shard string, err error) {
+	a := strings.Split(path, string(filepath.Separator))
+	if len(a) != 3 {
+		return "", "", fmt.Errorf("expected database, retention policy, and shard id in path: %s", path)
+	}
+
+	return a[1], a[2], nil
+}

vendor/github.com/influxdata/influxdb/cmd/influxd/help/help.go

@@ -0,0 +1,46 @@
+// Package help is the help subcommand of the influxd command.
+package help
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+// Command displays help for command-line sub-commands.
+type Command struct {
+	Stdout io.Writer
+}
+
+// NewCommand returns a new instance of Command.
+func NewCommand() *Command {
+	return &Command{
+		Stdout: os.Stdout,
+	}
+}
+
+// Run executes the command.
+func (cmd *Command) Run(args ...string) error {
+	fmt.Fprintln(cmd.Stdout, strings.TrimSpace(usage))
+	return nil
+}
+
+const usage = `
+Configure and start an InfluxDB server.
+
+Usage: influxd [[command] [arguments]]
+
+The commands are:
+
+    backup               downloads a snapshot of a data node and saves it to disk
+    config               display the default configuration
+    help                 display this help message
+    restore              uses a snapshot of a data node to rebuild a cluster
+    run                  run node with existing configuration
+    version              displays the InfluxDB version
+
+"run" is the default command.
+
+Use "influxd [command] -help" for more information about a command.
+`

vendor/github.com/influxdata/influxdb/cmd/influxd/main.go

@@ -0,0 +1,177 @@
+// Command influxd is the InfluxDB server.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"math/rand"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/influxdata/influxdb/cmd"
+	"github.com/influxdata/influxdb/cmd/influxd/backup"
+	"github.com/influxdata/influxdb/cmd/influxd/help"
+	"github.com/influxdata/influxdb/cmd/influxd/restore"
+	"github.com/influxdata/influxdb/cmd/influxd/run"
+	"github.com/uber-go/zap"
+)
+
+// These variables are populated via the Go linker.
+var (
+	version string
+	commit  string
+	branch  string
+)
+
+func init() {
+	// If commit, branch, or build time are not set, make that clear.
+	if version == "" {
+		version = "unknown"
+	}
+	if commit == "" {
+		commit = "unknown"
+	}
+	if branch == "" {
+		branch = "unknown"
+	}
+}
+
+func main() {
+	rand.Seed(time.Now().UnixNano())
+
+	m := NewMain()
+	if err := m.Run(os.Args[1:]...); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+// Main represents the program execution.
+type Main struct {
+	Logger zap.Logger
+
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewMain return a new instance of Main.
+func NewMain() *Main {
+	return &Main{
+		Logger: zap.New(
+			zap.NewTextEncoder(),
+			zap.Output(os.Stderr),
+		),
+		Stdin:  os.Stdin,
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
+	}
+}
+
+// Run determines and runs the command specified by the CLI args.
+func (m *Main) Run(args ...string) error {
+	name, args := cmd.ParseCommandName(args)
+
+	// Extract name from args.
+	switch name {
+	case "", "run":
+		cmd := run.NewCommand()
+
+		// Tell the server the build details.
+		cmd.Version = version
+		cmd.Commit = commit
+		cmd.Branch = branch
+		cmd.Logger = m.Logger
+
+		if err := cmd.Run(args...); err != nil {
+			return fmt.Errorf("run: %s", err)
+		}
+
+		signalCh := make(chan os.Signal, 1)
+		signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)
+		m.Logger.Info("Listening for signals")
+
+		// Block until one of the signals above is received
+		<-signalCh
+		m.Logger.Info("Signal received, initializing clean shutdown...")
+		go cmd.Close()
+
+		// Block again until another signal is received, a shutdown timeout elapses,
+		// or the Command is gracefully closed
+		m.Logger.Info("Waiting for clean shutdown...")
+		select {
+		case <-signalCh:
+			m.Logger.Info("second signal received, initializing hard shutdown")
+		case <-time.After(time.Second * 30):
+			m.Logger.Info("time limit reached, initializing hard shutdown")
+		case <-cmd.Closed:
+			m.Logger.Info("server shutdown completed")
+		}
+
+		// goodbye.
+
+	case "backup":
+		name := backup.NewCommand()
+		if err := name.Run(args...); err != nil {
+			return fmt.Errorf("backup: %s", err)
+		}
+	case "restore":
+		name := restore.NewCommand()
+		if err := name.Run(args...); err != nil {
+			return fmt.Errorf("restore: %s", err)
+		}
+	case "config":
+		if err := run.NewPrintConfigCommand().Run(args...); err != nil {
+			return fmt.Errorf("config: %s", err)
+		}
+	case "version":
+		if err := NewVersionCommand().Run(args...); err != nil {
+			return fmt.Errorf("version: %s", err)
+		}
+	case "help":
+		if err := help.NewCommand().Run(args...); err != nil {
+			return fmt.Errorf("help: %s", err)
+		}
+	default:
+		return fmt.Errorf(`unknown command "%s"`+"\n"+`Run 'influxd help' for usage`+"\n\n", name)
+	}
+
+	return nil
+}
+
+// VersionCommand represents the command executed by "influxd version".
+type VersionCommand struct {
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewVersionCommand return a new instance of VersionCommand.
+func NewVersionCommand() *VersionCommand {
+	return &VersionCommand{
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
+	}
+}
+
+// Run prints the current version and commit info.
+func (cmd *VersionCommand) Run(args ...string) error {
+	// Parse flags in case -h is specified.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.Usage = func() { fmt.Fprintln(cmd.Stderr, versionUsage) }
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+
+	// Print version info.
+	fmt.Fprintf(cmd.Stdout, "InfluxDB v%s (git: %s %s)\n", version, branch, commit)
+
+	return nil
+}
+
+var versionUsage = `Displays the InfluxDB version, build branch and git commit hash.
+
+Usage: influxd version
+`

vendor/github.com/influxdata/influxdb/cmd/influxd/restore/restore.go

@@ -0,0 +1,355 @@
+// Package restore is the restore subcommand for the influxd command,
+// for restoring from a backup.
+package restore
+
+import (
+	"archive/tar"
+	"bytes"
+	"encoding/binary"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"github.com/influxdata/influxdb/cmd/influxd/backup"
+	"github.com/influxdata/influxdb/services/meta"
+	"github.com/influxdata/influxdb/services/snapshotter"
+)
+
+// Command represents the program execution for "influxd restore".
+type Command struct {
+	Stdout io.Writer
+	Stderr io.Writer
+
+	backupFilesPath string
+	metadir         string
+	datadir         string
+	database        string
+	retention       string
+	shard           string
+
+	// TODO: when the new meta stuff is done this should not be exported or be gone
+	MetaConfig *meta.Config
+}
+
+// NewCommand returns a new instance of Command with default settings.
+func NewCommand() *Command {
+	return &Command{
+		Stdout:     os.Stdout,
+		Stderr:     os.Stderr,
+		MetaConfig: meta.NewConfig(),
+	}
+}
+
+// Run executes the program.
+func (cmd *Command) Run(args ...string) error {
+	if err := cmd.parseFlags(args); err != nil {
+		return err
+	}
+
+	if cmd.metadir != "" {
+		if err := cmd.unpackMeta(); err != nil {
+			return err
+		}
+	}
+
+	if cmd.shard != "" {
+		return cmd.unpackShard(cmd.shard)
+	} else if cmd.retention != "" {
+		return cmd.unpackRetention()
+	} else if cmd.datadir != "" {
+		return cmd.unpackDatabase()
+	}
+	return nil
+}
+
+// parseFlags parses and validates the command line arguments.
+func (cmd *Command) parseFlags(args []string) error {
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.StringVar(&cmd.metadir, "metadir", "", "")
+	fs.StringVar(&cmd.datadir, "datadir", "", "")
+	fs.StringVar(&cmd.database, "database", "", "")
+	fs.StringVar(&cmd.retention, "retention", "", "")
+	fs.StringVar(&cmd.shard, "shard", "", "")
+	fs.SetOutput(cmd.Stdout)
+	fs.Usage = cmd.printUsage
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+
+	cmd.MetaConfig = meta.NewConfig()
+	cmd.MetaConfig.Dir = cmd.metadir
+
+	// Require output path.
+	cmd.backupFilesPath = fs.Arg(0)
+	if cmd.backupFilesPath == "" {
+		return fmt.Errorf("path with backup files required")
+	}
+
+	// validate the arguments
+	if cmd.metadir == "" && cmd.database == "" {
+		return fmt.Errorf("-metadir or -database are required to restore")
+	}
+
+	if cmd.database != "" && cmd.datadir == "" {
+		return fmt.Errorf("-datadir is required to restore")
+	}
+
+	if cmd.shard != "" {
+		if cmd.database == "" {
+			return fmt.Errorf("-database is required to restore shard")
+		}
+		if cmd.retention == "" {
+			return fmt.Errorf("-retention is required to restore shard")
+		}
+	} else if cmd.retention != "" && cmd.database == "" {
+		return fmt.Errorf("-database is required to restore retention policy")
+	}
+
+	return nil
+}
+
+// unpackMeta reads the metadata from the backup directory and initializes a raft
+// cluster and replaces the root metadata.
+func (cmd *Command) unpackMeta() error {
+	// find the meta file
+	metaFiles, err := filepath.Glob(filepath.Join(cmd.backupFilesPath, backup.Metafile+".*"))
+	if err != nil {
+		return err
+	}
+
+	if len(metaFiles) == 0 {
+		return fmt.Errorf("no metastore backups in %s", cmd.backupFilesPath)
+	}
+
+	latest := metaFiles[len(metaFiles)-1]
+
+	fmt.Fprintf(cmd.Stdout, "Using metastore snapshot: %v\n", latest)
+	// Read the metastore backup
+	f, err := os.Open(latest)
+	if err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	if _, err := io.Copy(&buf, f); err != nil {
+		return fmt.Errorf("copy: %s", err)
+	}
+
+	b := buf.Bytes()
+	var i int
+
+	// Make sure the file is actually a meta store backup file
+	magic := binary.BigEndian.Uint64(b[:8])
+	if magic != snapshotter.BackupMagicHeader {
+		return fmt.Errorf("invalid metadata file")
+	}
+	i += 8
+
+	// Size of the meta store bytes
+	length := int(binary.BigEndian.Uint64(b[i : i+8]))
+	i += 8
+	metaBytes := b[i : i+length]
+	i += int(length)
+
+	// Size of the node.json bytes
+	length = int(binary.BigEndian.Uint64(b[i : i+8]))
+	i += 8
+	nodeBytes := b[i : i+length]
+
+	// Unpack into metadata.
+	var data meta.Data
+	if err := data.UnmarshalBinary(metaBytes); err != nil {
+		return fmt.Errorf("unmarshal: %s", err)
+	}
+
+	// Copy meta config and remove peers so it starts in single mode.
+	c := cmd.MetaConfig
+	c.Dir = cmd.metadir
+
+	// Create the meta dir
+	if os.MkdirAll(c.Dir, 0700); err != nil {
+		return err
+	}
+
+	// Write node.json back to meta dir
+	if err := ioutil.WriteFile(filepath.Join(c.Dir, "node.json"), nodeBytes, 0655); err != nil {
+		return err
+	}
+
+	client := meta.NewClient(c)
+	if err := client.Open(); err != nil {
+		return err
+	}
+	defer client.Close()
+
+	// Force set the full metadata.
+	if err := client.SetData(&data); err != nil {
+		return fmt.Errorf("set data: %s", err)
+	}
+
+	// remove the raft.db file if it exists
+	err = os.Remove(filepath.Join(cmd.metadir, "raft.db"))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+
+	// remove the node.json file if it exists
+	err = os.Remove(filepath.Join(cmd.metadir, "node.json"))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+
+	return nil
+}
+
+// unpackShard will look for all backup files in the path matching this shard ID
+// and restore them to the data dir
+func (cmd *Command) unpackShard(shardID string) error {
+	// make sure the shard isn't already there so we don't clobber anything
+	restorePath := filepath.Join(cmd.datadir, cmd.database, cmd.retention, shardID)
+	if _, err := os.Stat(restorePath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("shard already present: %s", restorePath)
+	}
+
+	id, err := strconv.ParseUint(shardID, 10, 64)
+	if err != nil {
+		return err
+	}
+
+	// find the shard backup files
+	pat := filepath.Join(cmd.backupFilesPath, fmt.Sprintf(backup.BackupFilePattern, cmd.database, cmd.retention, id))
+	return cmd.unpackFiles(pat + ".*")
+}
+
+// unpackDatabase will look for all backup files in the path matching this database
+// and restore them to the data dir
+func (cmd *Command) unpackDatabase() error {
+	// make sure the shard isn't already there so we don't clobber anything
+	restorePath := filepath.Join(cmd.datadir, cmd.database)
+	if _, err := os.Stat(restorePath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("database already present: %s", restorePath)
+	}
+
+	// find the database backup files
+	pat := filepath.Join(cmd.backupFilesPath, cmd.database)
+	return cmd.unpackFiles(pat + ".*")
+}
+
+// unpackRetention will look for all backup files in the path matching this retention
+// and restore them to the data dir
+func (cmd *Command) unpackRetention() error {
+	// make sure the shard isn't already there so we don't clobber anything
+	restorePath := filepath.Join(cmd.datadir, cmd.database, cmd.retention)
+	if _, err := os.Stat(restorePath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("retention already present: %s", restorePath)
+	}
+
+	// find the retention backup files
+	pat := filepath.Join(cmd.backupFilesPath, cmd.database)
+	return cmd.unpackFiles(fmt.Sprintf("%s.%s.*", pat, cmd.retention))
+}
+
+// unpackFiles will look for backup files matching the pattern and restore them to the data dir
+func (cmd *Command) unpackFiles(pat string) error {
+	fmt.Printf("Restoring from backup %s\n", pat)
+
+	backupFiles, err := filepath.Glob(pat)
+	if err != nil {
+		return err
+	}
+
+	if len(backupFiles) == 0 {
+		return fmt.Errorf("no backup files for %s in %s", pat, cmd.backupFilesPath)
+	}
+
+	for _, fn := range backupFiles {
+		if err := cmd.unpackTar(fn); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// unpackTar will restore a single tar archive to the data dir
+func (cmd *Command) unpackTar(tarFile string) error {
+	f, err := os.Open(tarFile)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	tr := tar.NewReader(f)
+
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			return nil
+		} else if err != nil {
+			return err
+		}
+
+		if err := cmd.unpackFile(tr, hdr.Name); err != nil {
+			return err
+		}
+	}
+}
+
+// unpackFile will copy the current file from the tar archive to the data dir
+func (cmd *Command) unpackFile(tr *tar.Reader, fileName string) error {
+	nativeFileName := filepath.FromSlash(fileName)
+	fn := filepath.Join(cmd.datadir, nativeFileName)
+	fmt.Printf("unpacking %s\n", fn)
+
+	if err := os.MkdirAll(filepath.Dir(fn), 0777); err != nil {
+		return fmt.Errorf("error making restore dir: %s", err.Error())
+	}
+
+	ff, err := os.Create(fn)
+	if err != nil {
+		return err
+	}
+	defer ff.Close()
+
+	if _, err := io.Copy(ff, tr); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// printUsage prints the usage message to STDERR.
+func (cmd *Command) printUsage() {
+	fmt.Fprintf(cmd.Stdout, `Uses backups from the PATH to restore the metastore, databases,
+retention policies, or specific shards. The InfluxDB process must not be
+running during a restore.
+
+Usage: influxd restore [flags] PATH
+
+    -metadir <path>
+            Optional. If set the metastore will be recovered to the given path.
+    -datadir <path>
+            Optional. If set the restore process will recover the specified
+            database, retention policy or shard to the given directory.
+    -database <name>
+            Optional. Required if no metadir given. Will restore the database
+            TSM files.
+    -retention <name>
+            Optional. If given, database is required. Will restore the retention policy's
+            TSM files.
+    -shard <id>
+            Optional. If given, database and retention are required. Will restore the shard's
+            TSM files.
+
+`)
+}

vendor/github.com/influxdata/influxdb/cmd/influxd/run/command.go

@@ -0,0 +1,261 @@
+// Package run is the run (default) subcommand for the influxd command.
+package run
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"time"
+
+	"github.com/uber-go/zap"
+)
+
+const logo = `
+ 8888888           .d888 888                   8888888b.  888888b.
+   888            d88P"  888                   888  "Y88b 888  "88b
+   888            888    888                   888    888 888  .88P
+   888   88888b.  888888 888 888  888 888  888 888    888 8888888K.
+   888   888 "88b 888    888 888  888  Y8bd8P' 888    888 888  "Y88b
+   888   888  888 888    888 888  888   X88K   888    888 888    888
+   888   888  888 888    888 Y88b 888 .d8""8b. 888  .d88P 888   d88P
+ 8888888 888  888 888    888  "Y88888 888  888 8888888P"  8888888P"
+
+`
+
+// Command represents the command executed by "influxd run".
+type Command struct {
+	Version   string
+	Branch    string
+	Commit    string
+	BuildTime string
+
+	closing chan struct{}
+	Closed  chan struct{}
+
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+	Logger zap.Logger
+
+	Server *Server
+}
+
+// NewCommand return a new instance of Command.
+func NewCommand() *Command {
+	return &Command{
+		closing: make(chan struct{}),
+		Closed:  make(chan struct{}),
+		Stdin:   os.Stdin,
+		Stdout:  os.Stdout,
+		Stderr:  os.Stderr,
+		Logger:  zap.New(zap.NullEncoder()),
+	}
+}
+
+// Run parses the config from args and runs the server.
+func (cmd *Command) Run(args ...string) error {
+	// Parse the command line flags.
+	options, err := cmd.ParseFlags(args...)
+	if err != nil {
+		return err
+	}
+
+	// Print sweet InfluxDB logo.
+	fmt.Print(logo)
+
+	// Mark start-up in log.
+	cmd.Logger.Info(fmt.Sprintf("InfluxDB starting, version %s, branch %s, commit %s",
+		cmd.Version, cmd.Branch, cmd.Commit))
+	cmd.Logger.Info(fmt.Sprintf("Go version %s, GOMAXPROCS set to %d", runtime.Version(), runtime.GOMAXPROCS(0)))
+
+	// Write the PID file.
+	if err := cmd.writePIDFile(options.PIDFile); err != nil {
+		return fmt.Errorf("write pid file: %s", err)
+	}
+
+	// Parse config
+	config, err := cmd.ParseConfig(options.GetConfigPath())
+	if err != nil {
+		return fmt.Errorf("parse config: %s", err)
+	}
+
+	// Apply any environment variables on top of the parsed config
+	if err := config.ApplyEnvOverrides(); err != nil {
+		return fmt.Errorf("apply env config: %v", err)
+	}
+
+	// Validate the configuration.
+	if err := config.Validate(); err != nil {
+		return fmt.Errorf("%s. To generate a valid configuration file run `influxd config > influxdb.generated.conf`", err)
+	}
+
+	if config.HTTPD.PprofEnabled {
+		// Turn on block profiling to debug stuck databases
+		runtime.SetBlockProfileRate(int(1 * time.Second))
+	}
+
+	// Create server from config and start it.
+	buildInfo := &BuildInfo{
+		Version: cmd.Version,
+		Commit:  cmd.Commit,
+		Branch:  cmd.Branch,
+		Time:    cmd.BuildTime,
+	}
+	s, err := NewServer(config, buildInfo)
+	if err != nil {
+		return fmt.Errorf("create server: %s", err)
+	}
+	s.Logger = cmd.Logger
+	s.CPUProfile = options.CPUProfile
+	s.MemProfile = options.MemProfile
+	if err := s.Open(); err != nil {
+		return fmt.Errorf("open server: %s", err)
+	}
+	cmd.Server = s
+
+	// Begin monitoring the server's error channel.
+	go cmd.monitorServerErrors()
+
+	return nil
+}
+
+// Close shuts down the server.
+func (cmd *Command) Close() error {
+	defer close(cmd.Closed)
+	close(cmd.closing)
+	if cmd.Server != nil {
+		return cmd.Server.Close()
+	}
+	return nil
+}
+
+func (cmd *Command) monitorServerErrors() {
+	logger := log.New(cmd.Stderr, "", log.LstdFlags)
+	for {
+		select {
+		case err := <-cmd.Server.Err():
+			logger.Println(err)
+		case <-cmd.closing:
+			return
+		}
+	}
+}
+
+// ParseFlags parses the command line flags from args and returns an options set.
+func (cmd *Command) ParseFlags(args ...string) (Options, error) {
+	var options Options
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	fs.StringVar(&options.ConfigPath, "config", "", "")
+	fs.StringVar(&options.PIDFile, "pidfile", "", "")
+	// Ignore hostname option.
+	_ = fs.String("hostname", "", "")
+	fs.StringVar(&options.CPUProfile, "cpuprofile", "", "")
+	fs.StringVar(&options.MemProfile, "memprofile", "", "")
+	fs.Usage = func() { fmt.Fprintln(cmd.Stderr, usage) }
+	if err := fs.Parse(args); err != nil {
+		return Options{}, err
+	}
+	return options, nil
+}
+
+// writePIDFile writes the process ID to path.
+func (cmd *Command) writePIDFile(path string) error {
+	// Ignore if path is not set.
+	if path == "" {
+		return nil
+	}
+
+	// Ensure the required directory structure exists.
+	err := os.MkdirAll(filepath.Dir(path), 0777)
+	if err != nil {
+		return fmt.Errorf("mkdir: %s", err)
+	}
+
+	// Retrieve the PID and write it.
+	pid := strconv.Itoa(os.Getpid())
+	if err := ioutil.WriteFile(path, []byte(pid), 0666); err != nil {
+		return fmt.Errorf("write file: %s", err)
+	}
+
+	return nil
+}
+
+// ParseConfig parses the config at path.
+// It returns a demo configuration if path is blank.
+func (cmd *Command) ParseConfig(path string) (*Config, error) {
+	// Use demo configuration if no config path is specified.
+	if path == "" {
+		cmd.Logger.Info("no configuration provided, using default settings")
+		return NewDemoConfig()
+	}
+
+	cmd.Logger.Info(fmt.Sprintf("Using configuration at: %s", path))
+
+	config := NewConfig()
+	if err := config.FromTomlFile(path); err != nil {
+		return nil, err
+	}
+
+	return config, nil
+}
+
+const usage = `Runs the InfluxDB server.
+
+Usage: influxd run [flags]
+
+    -config <path>
+            Set the path to the configuration file.
+            This defaults to the environment variable INFLUXDB_CONFIG_PATH,
+            ~/.influxdb/influxdb.conf, or /etc/influxdb/influxdb.conf if a file
+            is present at any of these locations.
+            Disable the automatic loading of a configuration file using
+            the null device (such as /dev/null).
+    -pidfile <path>
+            Write process ID to a file.
+    -cpuprofile <path>
+            Write CPU profiling information to a file.
+    -memprofile <path>
+            Write memory usage information to a file.
+`
+
+// Options represents the command line options that can be parsed.
+type Options struct {
+	ConfigPath string
+	PIDFile    string
+	CPUProfile string
+	MemProfile string
+}
+
+// GetConfigPath returns the config path from the options.
+// It will return a path by searching in this order:
+//   1. The CLI option in ConfigPath
+//   2. The environment variable INFLUXDB_CONFIG_PATH
+//   3. The first influxdb.conf file on the path:
+//        - ~/.influxdb
+//        - /etc/influxdb
+func (opt *Options) GetConfigPath() string {
+	if opt.ConfigPath != "" {
+		if opt.ConfigPath == os.DevNull {
+			return ""
+		}
+		return opt.ConfigPath
+	} else if envVar := os.Getenv("INFLUXDB_CONFIG_PATH"); envVar != "" {
+		return envVar
+	}
+
+	for _, path := range []string{
+		os.ExpandEnv("${HOME}/.influxdb/influxdb.conf"),
+		"/etc/influxdb/influxdb.conf",
+	} {
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+	}
+	return ""
+}

vendor/github.com/influxdata/influxdb/cmd/influxd/run/config.go

@@ -0,0 +1,363 @@
+package run
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/user"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/BurntSushi/toml"
+	"github.com/influxdata/influxdb/coordinator"
+	"github.com/influxdata/influxdb/monitor"
+	"github.com/influxdata/influxdb/monitor/diagnostics"
+	"github.com/influxdata/influxdb/services/collectd"
+	"github.com/influxdata/influxdb/services/continuous_querier"
+	"github.com/influxdata/influxdb/services/graphite"
+	"github.com/influxdata/influxdb/services/httpd"
+	"github.com/influxdata/influxdb/services/meta"
+	"github.com/influxdata/influxdb/services/opentsdb"
+	"github.com/influxdata/influxdb/services/precreator"
+	"github.com/influxdata/influxdb/services/retention"
+	"github.com/influxdata/influxdb/services/subscriber"
+	"github.com/influxdata/influxdb/services/udp"
+	"github.com/influxdata/influxdb/tsdb"
+)
+
+const (
+	// DefaultBindAddress is the default address for various RPC services.
+	DefaultBindAddress = "127.0.0.1:8088"
+)
+
+// Config represents the configuration format for the influxd binary.
+type Config struct {
+	Meta        *meta.Config       `toml:"meta"`
+	Data        tsdb.Config        `toml:"data"`
+	Coordinator coordinator.Config `toml:"coordinator"`
+	Retention   retention.Config   `toml:"retention"`
+	Precreator  precreator.Config  `toml:"shard-precreation"`
+
+	Monitor        monitor.Config    `toml:"monitor"`
+	Subscriber     subscriber.Config `toml:"subscriber"`
+	HTTPD          httpd.Config      `toml:"http"`
+	GraphiteInputs []graphite.Config `toml:"graphite"`
+	CollectdInputs []collectd.Config `toml:"collectd"`
+	OpenTSDBInputs []opentsdb.Config `toml:"opentsdb"`
+	UDPInputs      []udp.Config      `toml:"udp"`
+
+	ContinuousQuery continuous_querier.Config `toml:"continuous_queries"`
+
+	// Server reporting
+	ReportingDisabled bool `toml:"reporting-disabled"`
+
+	// BindAddress is the address that all TCP services use (Raft, Snapshot, Cluster, etc.)
+	BindAddress string `toml:"bind-address"`
+}
+
+// NewConfig returns an instance of Config with reasonable defaults.
+func NewConfig() *Config {
+	c := &Config{}
+	c.Meta = meta.NewConfig()
+	c.Data = tsdb.NewConfig()
+	c.Coordinator = coordinator.NewConfig()
+	c.Precreator = precreator.NewConfig()
+
+	c.Monitor = monitor.NewConfig()
+	c.Subscriber = subscriber.NewConfig()
+	c.HTTPD = httpd.NewConfig()
+
+	c.GraphiteInputs = []graphite.Config{graphite.NewConfig()}
+	c.CollectdInputs = []collectd.Config{collectd.NewConfig()}
+	c.OpenTSDBInputs = []opentsdb.Config{opentsdb.NewConfig()}
+	c.UDPInputs = []udp.Config{udp.NewConfig()}
+
+	c.ContinuousQuery = continuous_querier.NewConfig()
+	c.Retention = retention.NewConfig()
+	c.BindAddress = DefaultBindAddress
+
+	return c
+}
+
+// NewDemoConfig returns the config that runs when no config is specified.
+func NewDemoConfig() (*Config, error) {
+	c := NewConfig()
+
+	var homeDir string
+	// By default, store meta and data files in current users home directory
+	u, err := user.Current()
+	if err == nil {
+		homeDir = u.HomeDir
+	} else if os.Getenv("HOME") != "" {
+		homeDir = os.Getenv("HOME")
+	} else {
+		return nil, fmt.Errorf("failed to determine current user for storage")
+	}
+
+	c.Meta.Dir = filepath.Join(homeDir, ".influxdb/meta")
+	c.Data.Dir = filepath.Join(homeDir, ".influxdb/data")
+	c.Data.WALDir = filepath.Join(homeDir, ".influxdb/wal")
+
+	return c, nil
+}
+
+// trimBOM trims the Byte-Order-Marks from the beginning of the file.
+// This is for Windows compatability only.
+// See https://github.com/influxdata/telegraf/issues/1378.
+func trimBOM(f []byte) []byte {
+	return bytes.TrimPrefix(f, []byte("\xef\xbb\xbf"))
+}
+
+// FromTomlFile loads the config from a TOML file.
+func (c *Config) FromTomlFile(fpath string) error {
+	bs, err := ioutil.ReadFile(fpath)
+	if err != nil {
+		return err
+	}
+	bs = trimBOM(bs)
+	return c.FromToml(string(bs))
+}
+
+// FromToml loads the config from TOML.
+func (c *Config) FromToml(input string) error {
+	// Replace deprecated [cluster] with [coordinator]
+	re := regexp.MustCompile(`(?m)^\s*\[cluster\]`)
+	input = re.ReplaceAllStringFunc(input, func(in string) string {
+		in = strings.TrimSpace(in)
+		out := "[coordinator]"
+		log.Printf("deprecated config option %s replaced with %s; %s will not be supported in a future release\n", in, out, in)
+		return out
+	})
+
+	_, err := toml.Decode(input, c)
+	return err
+}
+
+// Validate returns an error if the config is invalid.
+func (c *Config) Validate() error {
+	if err := c.Meta.Validate(); err != nil {
+		return err
+	}
+
+	if err := c.Data.Validate(); err != nil {
+		return err
+	}
+
+	if err := c.Monitor.Validate(); err != nil {
+		return err
+	}
+
+	if err := c.ContinuousQuery.Validate(); err != nil {
+		return err
+	}
+
+	if err := c.Retention.Validate(); err != nil {
+		return err
+	}
+
+	if err := c.Precreator.Validate(); err != nil {
+		return err
+	}
+
+	if err := c.Subscriber.Validate(); err != nil {
+		return err
+	}
+
+	for _, graphite := range c.GraphiteInputs {
+		if err := graphite.Validate(); err != nil {
+			return fmt.Errorf("invalid graphite config: %v", err)
+		}
+	}
+
+	for _, collectd := range c.CollectdInputs {
+		if err := collectd.Validate(); err != nil {
+			return fmt.Errorf("invalid collectd config: %v", err)
+		}
+	}
+
+	return nil
+}
+
+// ApplyEnvOverrides apply the environment configuration on top of the config.
+func (c *Config) ApplyEnvOverrides() error {
+	return c.applyEnvOverrides("INFLUXDB", reflect.ValueOf(c), "")
+}
+
+func (c *Config) applyEnvOverrides(prefix string, spec reflect.Value, structKey string) error {
+	// If we have a pointer, dereference it
+	element := spec
+	if spec.Kind() == reflect.Ptr {
+		element = spec.Elem()
+	}
+
+	value := os.Getenv(prefix)
+
+	switch element.Kind() {
+	case reflect.String:
+		if len(value) == 0 {
+			return nil
+		}
+		element.SetString(value)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		var intValue int64
+
+		// Handle toml.Duration
+		if element.Type().Name() == "Duration" {
+			dur, err := time.ParseDuration(value)
+			if err != nil {
+				return fmt.Errorf("failed to apply %v to %v using type %v and value '%v'", prefix, structKey, element.Type().String(), value)
+			}
+			intValue = dur.Nanoseconds()
+		} else {
+			var err error
+			intValue, err = strconv.ParseInt(value, 0, element.Type().Bits())
+			if err != nil {
+				return fmt.Errorf("failed to apply %v to %v using type %v and value '%v'", prefix, structKey, element.Type().String(), value)
+			}
+		}
+		element.SetInt(intValue)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		intValue, err := strconv.ParseUint(value, 0, element.Type().Bits())
+		if err != nil {
+			return fmt.Errorf("failed to apply %v to %v using type %v and value '%v'", prefix, structKey, element.Type().String(), value)
+		}
+		element.SetUint(intValue)
+	case reflect.Bool:
+		boolValue, err := strconv.ParseBool(value)
+		if err != nil {
+			return fmt.Errorf("failed to apply %v to %v using type %v and value '%v'", prefix, structKey, element.Type().String(), value)
+		}
+		element.SetBool(boolValue)
+	case reflect.Float32, reflect.Float64:
+		floatValue, err := strconv.ParseFloat(value, element.Type().Bits())
+		if err != nil {
+			return fmt.Errorf("failed to apply %v to %v using type %v and value '%v'", prefix, structKey, element.Type().String(), value)
+		}
+		element.SetFloat(floatValue)
+	case reflect.Slice:
+		// If the type is s slice, apply to each using the index as a suffix, e.g. GRAPHITE_0, GRAPHITE_0_TEMPLATES_0 or GRAPHITE_0_TEMPLATES="item1,item2"
+		for j := 0; j < element.Len(); j++ {
+			f := element.Index(j)
+			if err := c.applyEnvOverrides(prefix, f, structKey); err != nil {
+				return err
+			}
+
+			if err := c.applyEnvOverrides(fmt.Sprintf("%s_%d", prefix, j), f, structKey); err != nil {
+				return err
+			}
+		}
+
+		// If the type is s slice but have value not parsed as slice e.g. GRAPHITE_0_TEMPLATES="item1,item2"
+		if element.Len() == 0 && len(value) > 0 {
+			rules := strings.Split(value, ",")
+
+			for _, rule := range rules {
+				element.Set(reflect.Append(element, reflect.ValueOf(rule)))
+			}
+		}
+	case reflect.Struct:
+		typeOfSpec := element.Type()
+		for i := 0; i < element.NumField(); i++ {
+			field := element.Field(i)
+
+			// Skip any fields that we cannot set
+			if !field.CanSet() && field.Kind() != reflect.Slice {
+				continue
+			}
+
+			fieldName := typeOfSpec.Field(i).Name
+
+			configName := typeOfSpec.Field(i).Tag.Get("toml")
+			// Replace hyphens with underscores to avoid issues with shells
+			configName = strings.Replace(configName, "-", "_", -1)
+
+			envKey := strings.ToUpper(configName)
+			if prefix != "" {
+				envKey = strings.ToUpper(fmt.Sprintf("%s_%s", prefix, configName))
+			}
+
+			// If it's a sub-config, recursively apply
+			if field.Kind() == reflect.Struct || field.Kind() == reflect.Ptr ||
+				field.Kind() == reflect.Slice || field.Kind() == reflect.Array {
+				if err := c.applyEnvOverrides(envKey, field, fieldName); err != nil {
+					return err
+				}
+				continue
+			}
+
+			value := os.Getenv(envKey)
+			// Skip any fields we don't have a value to set
+			if len(value) == 0 {
+				continue
+			}
+
+			if err := c.applyEnvOverrides(envKey, field, fieldName); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// Diagnostics returns a diagnostics representation of Config.
+func (c *Config) Diagnostics() (*diagnostics.Diagnostics, error) {
+	return diagnostics.RowFromMap(map[string]interface{}{
+		"reporting-disabled": c.ReportingDisabled,
+		"bind-address":       c.BindAddress,
+	}), nil
+}
+
+func (c *Config) diagnosticsClients() map[string]diagnostics.Client {
+	// Config settings that are always present.
+	m := map[string]diagnostics.Client{
+		"config": c,
+
+		"config-data":        c.Data,
+		"config-meta":        c.Meta,
+		"config-coordinator": c.Coordinator,
+		"config-retention":   c.Retention,
+		"config-precreator":  c.Precreator,
+
+		"config-monitor":    c.Monitor,
+		"config-subscriber": c.Subscriber,
+		"config-httpd":      c.HTTPD,
+
+		"config-cqs": c.ContinuousQuery,
+	}
+
+	// Config settings that can be repeated and can be disabled.
+	if g := graphite.Configs(c.GraphiteInputs); g.Enabled() {
+		m["config-graphite"] = g
+	}
+	if cc := collectd.Configs(c.CollectdInputs); cc.Enabled() {
+		m["config-collectd"] = cc
+	}
+	if t := opentsdb.Configs(c.OpenTSDBInputs); t.Enabled() {
+		m["config-opentsdb"] = t
+	}
+	if u := udp.Configs(c.UDPInputs); u.Enabled() {
+		m["config-udp"] = u
+	}
+
+	return m
+}
+
+// registerDiagnostics registers the config settings with the Monitor.
+func (c *Config) registerDiagnostics(m *monitor.Monitor) {
+	for name, dc := range c.diagnosticsClients() {
+		m.RegisterDiagnosticsClient(name, dc)
+	}
+}
+
+// registerDiagnostics deregisters the config settings from the Monitor.
+func (c *Config) deregisterDiagnostics(m *monitor.Monitor) {
+	for name := range c.diagnosticsClients() {
+		m.DeregisterDiagnosticsClient(name)
+	}
+}

vendor/github.com/influxdata/influxdb/cmd/influxd/run/config_command.go

@@ -0,0 +1,92 @@
+package run
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/BurntSushi/toml"
+)
+
+// PrintConfigCommand represents the command executed by "influxd config".
+type PrintConfigCommand struct {
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// NewPrintConfigCommand return a new instance of PrintConfigCommand.
+func NewPrintConfigCommand() *PrintConfigCommand {
+	return &PrintConfigCommand{
+		Stdin:  os.Stdin,
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
+	}
+}
+
+// Run parses and prints the current config loaded.
+func (cmd *PrintConfigCommand) Run(args ...string) error {
+	// Parse command flags.
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	configPath := fs.String("config", "", "")
+	fs.Usage = func() { fmt.Fprintln(cmd.Stderr, printConfigUsage) }
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+
+	// Parse config from path.
+	opt := Options{ConfigPath: *configPath}
+	config, err := cmd.parseConfig(opt.GetConfigPath())
+	if err != nil {
+		return fmt.Errorf("parse config: %s", err)
+	}
+
+	// Apply any environment variables on top of the parsed config
+	if err := config.ApplyEnvOverrides(); err != nil {
+		return fmt.Errorf("apply env config: %v", err)
+	}
+
+	// Validate the configuration.
+	if err := config.Validate(); err != nil {
+		return fmt.Errorf("%s. To generate a valid configuration file run `influxd config > influxdb.generated.conf`", err)
+	}
+
+	toml.NewEncoder(cmd.Stdout).Encode(config)
+	fmt.Fprint(cmd.Stdout, "\n")
+
+	return nil
+}
+
+// ParseConfig parses the config at path.
+// Returns a demo configuration if path is blank.
+func (cmd *PrintConfigCommand) parseConfig(path string) (*Config, error) {
+	config, err := NewDemoConfig()
+	if err != nil {
+		config = NewConfig()
+	}
+
+	if path == "" {
+		return config, nil
+	}
+
+	fmt.Fprintf(os.Stderr, "Merging with configuration at: %s\n", path)
+
+	if err := config.FromTomlFile(path); err != nil {
+		return nil, err
+	}
+	return config, nil
+}
+
+var printConfigUsage = `Displays the default configuration.
+
+Usage: influxd config [flags]
+
+    -config <path>
+            Set the path to the initial configuration file.
+            This defaults to the environment variable INFLUXDB_CONFIG_PATH,
+            ~/.influxdb/influxdb.conf, or /etc/influxdb/influxdb.conf if a file
+            is present at any of these locations.
+            Disable the automatic loading of a configuration file using
+            the null device (such as /dev/null).
+`

vendor/github.com/influxdata/influxdb/cmd/influxd/run/config_test.go

@@ -0,0 +1,312 @@
+package run_test
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/BurntSushi/toml"
+	"github.com/influxdata/influxdb/cmd/influxd/run"
+)
+
+// Ensure the configuration can be parsed.
+func TestConfig_Parse(t *testing.T) {
+	// Parse configuration.
+	var c run.Config
+	if err := c.FromToml(`
+[meta]
+dir = "/tmp/meta"
+
+[data]
+dir = "/tmp/data"
+
+[coordinator]
+
+[http]
+bind-address = ":8087"
+
+[[graphite]]
+protocol = "udp"
+
+[[graphite]]
+protocol = "tcp"
+
+[[collectd]]
+bind-address = ":1000"
+
+[[collectd]]
+bind-address = ":1010"
+
+[[opentsdb]]
+bind-address = ":2000"
+
+[[opentsdb]]
+bind-address = ":2010"
+
+[[opentsdb]]
+bind-address = ":2020"
+
+[[udp]]
+bind-address = ":4444"
+
+[monitoring]
+enabled = true
+
+[subscriber]
+enabled = true
+
+[continuous_queries]
+enabled = true
+`); err != nil {
+		t.Fatal(err)
+	}
+
+	// Validate configuration.
+	if c.Meta.Dir != "/tmp/meta" {
+		t.Fatalf("unexpected meta dir: %s", c.Meta.Dir)
+	} else if c.Data.Dir != "/tmp/data" {
+		t.Fatalf("unexpected data dir: %s", c.Data.Dir)
+	} else if c.HTTPD.BindAddress != ":8087" {
+		t.Fatalf("unexpected api bind address: %s", c.HTTPD.BindAddress)
+	} else if len(c.GraphiteInputs) != 2 {
+		t.Fatalf("unexpected graphiteInputs count: %d", len(c.GraphiteInputs))
+	} else if c.GraphiteInputs[0].Protocol != "udp" {
+		t.Fatalf("unexpected graphite protocol(0): %s", c.GraphiteInputs[0].Protocol)
+	} else if c.GraphiteInputs[1].Protocol != "tcp" {
+		t.Fatalf("unexpected graphite protocol(1): %s", c.GraphiteInputs[1].Protocol)
+	} else if c.CollectdInputs[0].BindAddress != ":1000" {
+		t.Fatalf("unexpected collectd bind address: %s", c.CollectdInputs[0].BindAddress)
+	} else if c.CollectdInputs[1].BindAddress != ":1010" {
+		t.Fatalf("unexpected collectd bind address: %s", c.CollectdInputs[1].BindAddress)
+	} else if c.OpenTSDBInputs[0].BindAddress != ":2000" {
+		t.Fatalf("unexpected opentsdb bind address: %s", c.OpenTSDBInputs[0].BindAddress)
+	} else if c.OpenTSDBInputs[1].BindAddress != ":2010" {
+		t.Fatalf("unexpected opentsdb bind address: %s", c.OpenTSDBInputs[1].BindAddress)
+	} else if c.OpenTSDBInputs[2].BindAddress != ":2020" {
+		t.Fatalf("unexpected opentsdb bind address: %s", c.OpenTSDBInputs[2].BindAddress)
+	} else if c.UDPInputs[0].BindAddress != ":4444" {
+		t.Fatalf("unexpected udp bind address: %s", c.UDPInputs[0].BindAddress)
+	} else if c.Subscriber.Enabled != true {
+		t.Fatalf("unexpected subscriber enabled: %v", c.Subscriber.Enabled)
+	} else if c.ContinuousQuery.Enabled != true {
+		t.Fatalf("unexpected continuous query enabled: %v", c.ContinuousQuery.Enabled)
+	}
+}
+
+// Ensure the configuration can be parsed.
+func TestConfig_Parse_EnvOverride(t *testing.T) {
+	// Parse configuration.
+	var c run.Config
+	if _, err := toml.Decode(`
+[meta]
+dir = "/tmp/meta"
+
+[data]
+dir = "/tmp/data"
+
+[coordinator]
+
+[admin]
+bind-address = ":8083"
+
+[http]
+bind-address = ":8087"
+
+[[graphite]]
+protocol = "udp"
+templates = [
+  "default.* .template.in.config"
+]
+
+[[graphite]]
+protocol = "tcp"
+
+[[collectd]]
+bind-address = ":1000"
+
+[[collectd]]
+bind-address = ":1010"
+
+[[opentsdb]]
+bind-address = ":2000"
+
+[[opentsdb]]
+bind-address = ":2010"
+
+[[udp]]
+bind-address = ":4444"
+
+[[udp]]
+
+[monitoring]
+enabled = true
+
+[continuous_queries]
+enabled = true
+`, &c); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := os.Setenv("INFLUXDB_UDP_BIND_ADDRESS", ":1234"); err != nil {
+		t.Fatalf("failed to set env var: %v", err)
+	}
+
+	if err := os.Setenv("INFLUXDB_UDP_0_BIND_ADDRESS", ":5555"); err != nil {
+		t.Fatalf("failed to set env var: %v", err)
+	}
+
+	if err := os.Setenv("INFLUXDB_GRAPHITE_0_TEMPLATES_0", "overide.* .template.0"); err != nil {
+		t.Fatalf("failed to set env var: %v", err)
+	}
+
+	if err := os.Setenv("INFLUXDB_GRAPHITE_1_TEMPLATES", "overide.* .template.1.1,overide.* .template.1.2"); err != nil {
+		t.Fatalf("failed to set env var: %v", err)
+	}
+
+	if err := os.Setenv("INFLUXDB_GRAPHITE_1_PROTOCOL", "udp"); err != nil {
+		t.Fatalf("failed to set env var: %v", err)
+	}
+
+	if err := os.Setenv("INFLUXDB_COLLECTD_1_BIND_ADDRESS", ":1020"); err != nil {
+		t.Fatalf("failed to set env var: %v", err)
+	}
+
+	if err := os.Setenv("INFLUXDB_OPENTSDB_0_BIND_ADDRESS", ":2020"); err != nil {
+		t.Fatalf("failed to set env var: %v", err)
+	}
+
+	// uint64 type
+	if err := os.Setenv("INFLUXDB_DATA_CACHE_MAX_MEMORY_SIZE", "1000"); err != nil {
+		t.Fatalf("failed to set env var: %v", err)
+	}
+
+	if err := c.ApplyEnvOverrides(); err != nil {
+		t.Fatalf("failed to apply env overrides: %v", err)
+	}
+
+	if c.UDPInputs[0].BindAddress != ":5555" {
+		t.Fatalf("unexpected udp bind address: %s", c.UDPInputs[0].BindAddress)
+	}
+
+	if c.UDPInputs[1].BindAddress != ":1234" {
+		t.Fatalf("unexpected udp bind address: %s", c.UDPInputs[1].BindAddress)
+	}
+
+	if len(c.GraphiteInputs[0].Templates) != 1 || c.GraphiteInputs[0].Templates[0] != "overide.* .template.0" {
+		t.Fatalf("unexpected graphite 0 templates: %+v", c.GraphiteInputs[0].Templates)
+	}
+
+	if len(c.GraphiteInputs[1].Templates) != 2 || c.GraphiteInputs[1].Templates[1] != "overide.* .template.1.2" {
+		t.Fatalf("unexpected graphite 1 templates: %+v", c.GraphiteInputs[1].Templates)
+	}
+
+	if c.GraphiteInputs[1].Protocol != "udp" {
+		t.Fatalf("unexpected graphite protocol: %s", c.GraphiteInputs[1].Protocol)
+	}
+
+	if c.CollectdInputs[1].BindAddress != ":1020" {
+		t.Fatalf("unexpected collectd bind address: %s", c.CollectdInputs[1].BindAddress)
+	}
+
+	if c.OpenTSDBInputs[0].BindAddress != ":2020" {
+		t.Fatalf("unexpected opentsdb bind address: %s", c.OpenTSDBInputs[0].BindAddress)
+	}
+
+	if c.Data.CacheMaxMemorySize != 1000 {
+		t.Fatalf("unexpected cache max memory size: %v", c.Data.CacheMaxMemorySize)
+	}
+}
+
+func TestConfig_ValidateNoServiceConfigured(t *testing.T) {
+	var c run.Config
+	if _, err := toml.Decode(`
+[meta]
+enabled = false
+
+[data]
+enabled = false
+`, &c); err != nil {
+		t.Fatal(err)
+	}
+
+	if e := c.Validate(); e == nil {
+		t.Fatalf("got nil, expected error")
+	}
+}
+
+func TestConfig_ValidateMonitorStore_MetaOnly(t *testing.T) {
+	c := run.NewConfig()
+	if _, err := toml.Decode(`
+[monitor]
+store-enabled = true
+
+[meta]
+dir = "foo"
+
+[data]
+enabled = false
+`, &c); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := c.Validate(); err == nil {
+		t.Fatalf("got nil, expected error")
+	}
+}
+
+func TestConfig_DeprecatedOptions(t *testing.T) {
+	// Parse configuration.
+	var c run.Config
+	if err := c.FromToml(`
+[cluster]
+max-select-point = 100
+`); err != nil {
+		t.Fatal(err)
+	}
+
+	// Validate configuration.
+	if c.Coordinator.MaxSelectPointN != 100 {
+		t.Fatalf("unexpected coordinator max select points: %d", c.Coordinator.MaxSelectPointN)
+
+	}
+}
+
+// Ensure that Config.Validate correctly validates the individual subsections.
+func TestConfig_InvalidSubsections(t *testing.T) {
+	// Precondition: NewDemoConfig must validate correctly.
+	c, err := run.NewDemoConfig()
+	if err != nil {
+		t.Fatalf("error creating demo config: %s", err)
+	}
+	if err := c.Validate(); err != nil {
+		t.Fatalf("new demo config failed validation: %s", err)
+	}
+
+	// For each subsection, load a config with a single invalid setting.
+	for _, tc := range []struct {
+		section string
+		kv      string
+	}{
+		{"meta", `dir = ""`},
+		{"data", `dir = ""`},
+		{"monitor", `store-database = ""`},
+		{"continuous_queries", `run-interval = "0s"`},
+		{"subscriber", `http-timeout = "0s"`},
+		{"retention", `check-interval = "0s"`},
+		{"shard-precreation", `advance-period = "0s"`},
+	} {
+		c, err := run.NewDemoConfig()
+		if err != nil {
+			t.Fatalf("error creating demo config: %s", err)
+		}
+
+		s := fmt.Sprintf("\n[%s]\n%s\n", tc.section, tc.kv)
+		if err := c.FromToml(s); err != nil {
+			t.Fatalf("error loading toml %q: %s", s, err)
+		}
+
+		if err := c.Validate(); err == nil {
+			t.Fatalf("expected error but got nil for config: %s", s)
+		}
+	}
+}

vendor/github.com/influxdata/influxdb/cmd/influxd/run/server.go

@@ -0,0 +1,616 @@
+package run
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/pprof"
+	"time"
+
+	"github.com/influxdata/influxdb"
+	"github.com/influxdata/influxdb/coordinator"
+	"github.com/influxdata/influxdb/influxql"
+	"github.com/influxdata/influxdb/models"
+	"github.com/influxdata/influxdb/monitor"
+	"github.com/influxdata/influxdb/services/collectd"
+	"github.com/influxdata/influxdb/services/continuous_querier"
+	"github.com/influxdata/influxdb/services/graphite"
+	"github.com/influxdata/influxdb/services/httpd"
+	"github.com/influxdata/influxdb/services/meta"
+	"github.com/influxdata/influxdb/services/opentsdb"
+	"github.com/influxdata/influxdb/services/precreator"
+	"github.com/influxdata/influxdb/services/retention"
+	"github.com/influxdata/influxdb/services/snapshotter"
+	"github.com/influxdata/influxdb/services/subscriber"
+	"github.com/influxdata/influxdb/services/udp"
+	"github.com/influxdata/influxdb/tcp"
+	"github.com/influxdata/influxdb/tsdb"
+	client "github.com/influxdata/usage-client/v1"
+	"github.com/uber-go/zap"
+
+	// Initialize the engine & index packages
+	_ "github.com/influxdata/influxdb/tsdb/engine"
+	_ "github.com/influxdata/influxdb/tsdb/index"
+)
+
+var startTime time.Time
+
+func init() {
+	startTime = time.Now().UTC()
+}
+
+// BuildInfo represents the build details for the server code.
+type BuildInfo struct {
+	Version string
+	Commit  string
+	Branch  string
+	Time    string
+}
+
+// Server represents a container for the metadata and storage data and services.
+// It is built using a Config and it manages the startup and shutdown of all
+// services in the proper order.
+type Server struct {
+	buildInfo BuildInfo
+
+	err     chan error
+	closing chan struct{}
+
+	BindAddress string
+	Listener    net.Listener
+
+	Logger zap.Logger
+
+	MetaClient *meta.Client
+
+	TSDBStore     *tsdb.Store
+	QueryExecutor *influxql.QueryExecutor
+	PointsWriter  *coordinator.PointsWriter
+	Subscriber    *subscriber.Service
+
+	Services []Service
+
+	// These references are required for the tcp muxer.
+	SnapshotterService *snapshotter.Service
+
+	Monitor *monitor.Monitor
+
+	// Server reporting and registration
+	reportingDisabled bool
+
+	// Profiling
+	CPUProfile string
+	MemProfile string
+
+	// httpAPIAddr is the host:port combination for the main HTTP API for querying and writing data
+	httpAPIAddr string
+
+	// httpUseTLS specifies if we should use a TLS connection to the http servers
+	httpUseTLS bool
+
+	// tcpAddr is the host:port combination for the TCP listener that services mux onto
+	tcpAddr string
+
+	config *Config
+}
+
+// NewServer returns a new instance of Server built from a config.
+func NewServer(c *Config, buildInfo *BuildInfo) (*Server, error) {
+	// We need to ensure that a meta directory always exists even if
+	// we don't start the meta store.  node.json is always stored under
+	// the meta directory.
+	if err := os.MkdirAll(c.Meta.Dir, 0777); err != nil {
+		return nil, fmt.Errorf("mkdir all: %s", err)
+	}
+
+	// 0.10-rc1 and prior would sometimes put the node.json at the root
+	// dir which breaks backup/restore and restarting nodes.  This moves
+	// the file from the root so it's always under the meta dir.
+	oldPath := filepath.Join(filepath.Dir(c.Meta.Dir), "node.json")
+	newPath := filepath.Join(c.Meta.Dir, "node.json")
+
+	if _, err := os.Stat(oldPath); err == nil {
+		if err := os.Rename(oldPath, newPath); err != nil {
+			return nil, err
+		}
+	}
+
+	_, err := influxdb.LoadNode(c.Meta.Dir)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	if err := raftDBExists(c.Meta.Dir); err != nil {
+		return nil, err
+	}
+
+	// In 0.10.0 bind-address got moved to the top level. Check
+	// The old location to keep things backwards compatible
+	bind := c.BindAddress
+
+	s := &Server{
+		buildInfo: *buildInfo,
+		err:       make(chan error),
+		closing:   make(chan struct{}),
+
+		BindAddress: bind,
+
+		Logger: zap.New(
+			zap.NewTextEncoder(),
+			zap.Output(os.Stderr),
+		),
+
+		MetaClient: meta.NewClient(c.Meta),
+
+		reportingDisabled: c.ReportingDisabled,
+
+		httpAPIAddr: c.HTTPD.BindAddress,
+		httpUseTLS:  c.HTTPD.HTTPSEnabled,
+		tcpAddr:     bind,
+
+		config: c,
+	}
+	s.Monitor = monitor.New(s, c.Monitor)
+	s.config.registerDiagnostics(s.Monitor)
+
+	if err := s.MetaClient.Open(); err != nil {
+		return nil, err
+	}
+
+	s.TSDBStore = tsdb.NewStore(c.Data.Dir)
+	s.TSDBStore.EngineOptions.Config = c.Data
+
+	// Copy TSDB configuration.
+	s.TSDBStore.EngineOptions.EngineVersion = c.Data.Engine
+	s.TSDBStore.EngineOptions.IndexVersion = c.Data.Index
+
+	// Create the Subscriber service
+	s.Subscriber = subscriber.NewService(c.Subscriber)
+
+	// Initialize points writer.
+	s.PointsWriter = coordinator.NewPointsWriter()
+	s.PointsWriter.WriteTimeout = time.Duration(c.Coordinator.WriteTimeout)
+	s.PointsWriter.TSDBStore = s.TSDBStore
+	s.PointsWriter.Subscriber = s.Subscriber
+
+	// Initialize query executor.
+	s.QueryExecutor = influxql.NewQueryExecutor()
+	s.QueryExecutor.StatementExecutor = &coordinator.StatementExecutor{
+		MetaClient:  s.MetaClient,
+		TaskManager: s.QueryExecutor.TaskManager,
+		TSDBStore:   coordinator.LocalTSDBStore{Store: s.TSDBStore},
+		ShardMapper: &coordinator.LocalShardMapper{
+			MetaClient: s.MetaClient,
+			TSDBStore:  coordinator.LocalTSDBStore{Store: s.TSDBStore},
+		},
+		Monitor:           s.Monitor,
+		PointsWriter:      s.PointsWriter,
+		MaxSelectPointN:   c.Coordinator.MaxSelectPointN,
+		MaxSelectSeriesN:  c.Coordinator.MaxSelectSeriesN,
+		MaxSelectBucketsN: c.Coordinator.MaxSelectBucketsN,
+	}
+	s.QueryExecutor.TaskManager.QueryTimeout = time.Duration(c.Coordinator.QueryTimeout)
+	s.QueryExecutor.TaskManager.LogQueriesAfter = time.Duration(c.Coordinator.LogQueriesAfter)
+	s.QueryExecutor.TaskManager.MaxConcurrentQueries = c.Coordinator.MaxConcurrentQueries
+
+	// Initialize the monitor
+	s.Monitor.Version = s.buildInfo.Version
+	s.Monitor.Commit = s.buildInfo.Commit
+	s.Monitor.Branch = s.buildInfo.Branch
+	s.Monitor.BuildTime = s.buildInfo.Time
+	s.Monitor.PointsWriter = (*monitorPointsWriter)(s.PointsWriter)
+	return s, nil
+}
+
+// Statistics returns statistics for the services running in the Server.
+func (s *Server) Statistics(tags map[string]string) []models.Statistic {
+	var statistics []models.Statistic
+	statistics = append(statistics, s.QueryExecutor.Statistics(tags)...)
+	statistics = append(statistics, s.TSDBStore.Statistics(tags)...)
+	statistics = append(statistics, s.PointsWriter.Statistics(tags)...)
+	statistics = append(statistics, s.Subscriber.Statistics(tags)...)
+	for _, srv := range s.Services {
+		if m, ok := srv.(monitor.Reporter); ok {
+			statistics = append(statistics, m.Statistics(tags)...)
+		}
+	}
+	return statistics
+}
+
+func (s *Server) appendSnapshotterService() {
+	srv := snapshotter.NewService()
+	srv.TSDBStore = s.TSDBStore
+	srv.MetaClient = s.MetaClient
+	s.Services = append(s.Services, srv)
+	s.SnapshotterService = srv
+}
+
+// SetLogOutput sets the logger used for all messages. It must not be called
+// after the Open method has been called.
+func (s *Server) SetLogOutput(w io.Writer) {
+	s.Logger = zap.New(zap.NewTextEncoder(), zap.Output(zap.AddSync(w)))
+}
+
+func (s *Server) appendMonitorService() {
+	s.Services = append(s.Services, s.Monitor)
+}
+
+func (s *Server) appendRetentionPolicyService(c retention.Config) {
+	if !c.Enabled {
+		return
+	}
+	srv := retention.NewService(c)
+	srv.MetaClient = s.MetaClient
+	srv.TSDBStore = s.TSDBStore
+	s.Services = append(s.Services, srv)
+}
+
+func (s *Server) appendHTTPDService(c httpd.Config) {
+	if !c.Enabled {
+		return
+	}
+	srv := httpd.NewService(c)
+	srv.Handler.MetaClient = s.MetaClient
+	srv.Handler.QueryAuthorizer = meta.NewQueryAuthorizer(s.MetaClient)
+	srv.Handler.WriteAuthorizer = meta.NewWriteAuthorizer(s.MetaClient)
+	srv.Handler.QueryExecutor = s.QueryExecutor
+	srv.Handler.Monitor = s.Monitor
+	srv.Handler.PointsWriter = s.PointsWriter
+	srv.Handler.Version = s.buildInfo.Version
+
+	s.Services = append(s.Services, srv)
+}
+
+func (s *Server) appendCollectdService(c collectd.Config) {
+	if !c.Enabled {
+		return
+	}
+	srv := collectd.NewService(c)
+	srv.MetaClient = s.MetaClient
+	srv.PointsWriter = s.PointsWriter
+	s.Services = append(s.Services, srv)
+}
+
+func (s *Server) appendOpenTSDBService(c opentsdb.Config) error {
+	if !c.Enabled {
+		return nil
+	}
+	srv, err := opentsdb.NewService(c)
+	if err != nil {
+		return err
+	}
+	srv.PointsWriter = s.PointsWriter
+	srv.MetaClient = s.MetaClient
+	s.Services = append(s.Services, srv)
+	return nil
+}
+
+func (s *Server) appendGraphiteService(c graphite.Config) error {
+	if !c.Enabled {
+		return nil
+	}
+	srv, err := graphite.NewService(c)
+	if err != nil {
+		return err
+	}
+
+	srv.PointsWriter = s.PointsWriter
+	srv.MetaClient = s.MetaClient
+	srv.Monitor = s.Monitor
+	s.Services = append(s.Services, srv)
+	return nil
+}
+
+func (s *Server) appendPrecreatorService(c precreator.Config) error {
+	if !c.Enabled {
+		return nil
+	}
+	srv, err := precreator.NewService(c)
+	if err != nil {
+		return err
+	}
+
+	srv.MetaClient = s.MetaClient
+	s.Services = append(s.Services, srv)
+	return nil
+}
+
+func (s *Server) appendUDPService(c udp.Config) {
+	if !c.Enabled {
+		return
+	}
+	srv := udp.NewService(c)
+	srv.PointsWriter = s.PointsWriter
+	srv.MetaClient = s.MetaClient
+	s.Services = append(s.Services, srv)
+}
+
+func (s *Server) appendContinuousQueryService(c continuous_querier.Config) {
+	if !c.Enabled {
+		return
+	}
+	srv := continuous_querier.NewService(c)
+	srv.MetaClient = s.MetaClient
+	srv.QueryExecutor = s.QueryExecutor
+	s.Services = append(s.Services, srv)
+}
+
+// Err returns an error channel that multiplexes all out of band errors received from all services.
+func (s *Server) Err() <-chan error { return s.err }
+
+// Open opens the meta and data store and all services.
+func (s *Server) Open() error {
+	// Start profiling, if set.
+	startProfile(s.CPUProfile, s.MemProfile)
+
+	// Open shared TCP connection.
+	ln, err := net.Listen("tcp", s.BindAddress)
+	if err != nil {
+		return fmt.Errorf("listen: %s", err)
+	}
+	s.Listener = ln
+
+	// Multiplex listener.
+	mux := tcp.NewMux()
+	go mux.Serve(ln)
+
+	// Append services.
+	s.appendMonitorService()
+	s.appendPrecreatorService(s.config.Precreator)
+	s.appendSnapshotterService()
+	s.appendContinuousQueryService(s.config.ContinuousQuery)
+	s.appendHTTPDService(s.config.HTTPD)
+	s.appendRetentionPolicyService(s.config.Retention)
+	for _, i := range s.config.GraphiteInputs {
+		if err := s.appendGraphiteService(i); err != nil {
+			return err
+		}
+	}
+	for _, i := range s.config.CollectdInputs {
+		s.appendCollectdService(i)
+	}
+	for _, i := range s.config.OpenTSDBInputs {
+		if err := s.appendOpenTSDBService(i); err != nil {
+			return err
+		}
+	}
+	for _, i := range s.config.UDPInputs {
+		s.appendUDPService(i)
+	}
+
+	s.Subscriber.MetaClient = s.MetaClient
+	s.Subscriber.MetaClient = s.MetaClient
+	s.PointsWriter.MetaClient = s.MetaClient
+	s.Monitor.MetaClient = s.MetaClient
+
+	s.SnapshotterService.Listener = mux.Listen(snapshotter.MuxHeader)
+
+	// Configure logging for all services and clients.
+	if s.config.Meta.LoggingEnabled {
+		s.MetaClient.WithLogger(s.Logger)
+	}
+	s.TSDBStore.WithLogger(s.Logger)
+	if s.config.Data.QueryLogEnabled {
+		s.QueryExecutor.WithLogger(s.Logger)
+	}
+	s.PointsWriter.WithLogger(s.Logger)
+	s.Subscriber.WithLogger(s.Logger)
+	for _, svc := range s.Services {
+		svc.WithLogger(s.Logger)
+	}
+	s.SnapshotterService.WithLogger(s.Logger)
+	s.Monitor.WithLogger(s.Logger)
+
+	// Open TSDB store.
+	if err := s.TSDBStore.Open(); err != nil {
+		return fmt.Errorf("open tsdb store: %s", err)
+	}
+
+	// Open the subcriber service
+	if err := s.Subscriber.Open(); err != nil {
+		return fmt.Errorf("open subscriber: %s", err)
+	}
+
+	// Open the points writer service
+	if err := s.PointsWriter.Open(); err != nil {
+		return fmt.Errorf("open points writer: %s", err)
+	}
+
+	for _, service := range s.Services {
+		if err := service.Open(); err != nil {
+			return fmt.Errorf("open service: %s", err)
+		}
+	}
+
+	// Start the reporting service, if not disabled.
+	if !s.reportingDisabled {
+		go s.startServerReporting()
+	}
+
+	return nil
+}
+
+// Close shuts down the meta and data stores and all services.
+func (s *Server) Close() error {
+	stopProfile()
+
+	// Close the listener first to stop any new connections
+	if s.Listener != nil {
+		s.Listener.Close()
+	}
+
+	// Close services to allow any inflight requests to complete
+	// and prevent new requests from being accepted.
+	for _, service := range s.Services {
+		service.Close()
+	}
+
+	s.config.deregisterDiagnostics(s.Monitor)
+
+	if s.PointsWriter != nil {
+		s.PointsWriter.Close()
+	}
+
+	if s.QueryExecutor != nil {
+		s.QueryExecutor.Close()
+	}
+
+	// Close the TSDBStore, no more reads or writes at this point
+	if s.TSDBStore != nil {
+		s.TSDBStore.Close()
+	}
+
+	if s.Subscriber != nil {
+		s.Subscriber.Close()
+	}
+
+	if s.MetaClient != nil {
+		s.MetaClient.Close()
+	}
+
+	close(s.closing)
+	return nil
+}
+
+// startServerReporting starts periodic server reporting.
+func (s *Server) startServerReporting() {
+	s.reportServer()
+
+	ticker := time.NewTicker(24 * time.Hour)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-s.closing:
+			return
+		case <-ticker.C:
+			s.reportServer()
+		}
+	}
+}
+
+// reportServer reports usage statistics about the system.
+func (s *Server) reportServer() {
+	dbs := s.MetaClient.Databases()
+	numDatabases := len(dbs)
+
+	var (
+		numMeasurements int64
+		numSeries       int64
+	)
+
+	for _, db := range dbs {
+		name := db.Name
+		n, err := s.TSDBStore.SeriesCardinality(name)
+		if err != nil {
+			s.Logger.Error(fmt.Sprintf("Unable to get series cardinality for database %s: %v", name, err))
+		} else {
+			numSeries += n
+		}
+
+		n, err = s.TSDBStore.MeasurementsCardinality(name)
+		if err != nil {
+			s.Logger.Error(fmt.Sprintf("Unable to get measurement cardinality for database %s: %v", name, err))
+		} else {
+			numMeasurements += n
+		}
+	}
+
+	clusterID := s.MetaClient.ClusterID()
+	cl := client.New("")
+	usage := client.Usage{
+		Product: "influxdb",
+		Data: []client.UsageData{
+			{
+				Values: client.Values{
+					"os":               runtime.GOOS,
+					"arch":             runtime.GOARCH,
+					"version":          s.buildInfo.Version,
+					"cluster_id":       fmt.Sprintf("%v", clusterID),
+					"num_series":       numSeries,
+					"num_measurements": numMeasurements,
+					"num_databases":    numDatabases,
+					"uptime":           time.Since(startTime).Seconds(),
+				},
+			},
+		},
+	}
+
+	s.Logger.Info("Sending usage statistics to usage.influxdata.com")
+
+	go cl.Save(usage)
+}
+
+// Service represents a service attached to the server.
+type Service interface {
+	WithLogger(log zap.Logger)
+	Open() error
+	Close() error
+}
+
+// prof stores the file locations of active profiles.
+var prof struct {
+	cpu *os.File
+	mem *os.File
+}
+
+// StartProfile initializes the cpu and memory profile, if specified.
+func startProfile(cpuprofile, memprofile string) {
+	if cpuprofile != "" {
+		f, err := os.Create(cpuprofile)
+		if err != nil {
+			log.Fatalf("cpuprofile: %v", err)
+		}
+		log.Printf("writing CPU profile to: %s\n", cpuprofile)
+		prof.cpu = f
+		pprof.StartCPUProfile(prof.cpu)
+	}
+
+	if memprofile != "" {
+		f, err := os.Create(memprofile)
+		if err != nil {
+			log.Fatalf("memprofile: %v", err)
+		}
+		log.Printf("writing mem profile to: %s\n", memprofile)
+		prof.mem = f
+		runtime.MemProfileRate = 4096
+	}
+
+}
+
+// StopProfile closes the cpu and memory profiles if they are running.
+func stopProfile() {
+	if prof.cpu != nil {
+		pprof.StopCPUProfile()
+		prof.cpu.Close()
+		log.Println("CPU profile stopped")
+	}
+	if prof.mem != nil {
+		pprof.Lookup("heap").WriteTo(prof.mem, 0)
+		prof.mem.Close()
+		log.Println("mem profile stopped")
+	}
+}
+
+// monitorPointsWriter is a wrapper around `coordinator.PointsWriter` that helps
+// to prevent a circular dependency between the `cluster` and `monitor` packages.
+type monitorPointsWriter coordinator.PointsWriter
+
+func (pw *monitorPointsWriter) WritePoints(database, retentionPolicy string, points models.Points) error {
+	return (*coordinator.PointsWriter)(pw).WritePointsPrivileged(database, retentionPolicy, models.ConsistencyLevelAny, points)
+}
+
+func raftDBExists(dir string) error {
+	// Check to see if there is a raft db, if so, error out with a message
+	// to downgrade, export, and then import the meta data
+	raftFile := filepath.Join(dir, "raft.db")
+	if _, err := os.Stat(raftFile); err == nil {
+		return fmt.Errorf("detected %s. To proceed, you'll need to either 1) downgrade to v0.11.x, export your metadata, upgrade to the current version again, and then import the metadata or 2) delete the file, which will effectively reset your database. For more assistance with the upgrade, see: https://docs.influxdata.com/influxdb/v0.12/administration/upgrading/", raftFile)
+	}
+	return nil
+}