Golang LoadBackupConfig Examples

Example #1

File: main.go Project: nimbus-cloud/cf-redis-broker

func main() {
	logger := lager.NewLogger("backup")
	logger.RegisterSink(log.NewCliSink(lager.INFO))
	logger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.INFO))

	var configPath string
	flag.StringVar(&configPath, "config", "", "Path to YML config file")

	flag.Parse()

	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		logger.Error("snapshot-main", err, lager.Data{"event": "failed", "config_file": configPath})
		os.Exit(2)
	}

	backupConfig, err := backup.LoadBackupConfig(configPath)
	exitOnError(err, 78, logger, configPath)

	logFile, err := os.OpenFile(backupConfig.LogFilepath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0660)
	if err != nil {
		logger.Error("snapshot-main", err, lager.Data{"event": "failed", "LogFilepath": backupConfig.LogFilepath})
	}
	logger.RegisterSink(lager.NewWriterSink(logFile, lager.INFO))

	// TODO: Should this really be a pointer not a struct?
	if (backupConfig.S3Config == backup.S3Configuration{}) {
		logger.Info("snapshot-main", lager.Data{"event": "cancelled", "message": "S3 configuration not found - skipping backup"})
		os.Exit(0)
	}

	backuper, err := backup.NewInstanceBackuper(*backupConfig, logger)
	exitOnError(err, 70, logger, configPath)

	backupResults := backuper.Backup()
	hasError := false
	for _, result := range backupResults {
		if result.Err != nil {
			hasError = true
			logger.Error(
				"snapshot-main",
				result.Err,
				lager.Data{
					"event":           "failed",
					"InstanceID":      result.InstanceID,
					"RedisConfigPath": result.RedisConfigPath,
					"NodeIP":          result.NodeIP,
				},
			)
		}
	}

	if hasError {
		os.Exit(70)
	}
}

Example #2

File: config_test.go Project: nimbus-cloud/cf-redis-broker

package backup_test

import (
	"path"
	"path/filepath"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	"github.com/pivotal-cf/cf-redis-broker/instance/backup"
)

var _ = Describe("LoadBackupConfig", func() {
	Context("when the file does not exist", func() {
		It("returns an error", func() {
			_, err := backup.LoadBackupConfig("/this/is/an/invalid/path")
			Expect(err.Error()).To(Equal("open /this/is/an/invalid/path: no such file or directory"))
		})
	})

	Context("when the file is successfully loaded", func() {
		var config *backup.BackupConfig

		BeforeEach(func() {
			path, err := filepath.Abs(path.Join("assets", "backup.yml"))
			Expect(err).ToNot(HaveOccurred())

			config, err = backup.LoadBackupConfig(path)
			Expect(err).ToNot(HaveOccurred())
		})

		It("has the correct endpoint_url", func() {

Example #3

File: backuper_test.go Project: nimbus-cloud/cf-redis-broker

		providerFactory.RedisBackuperProviderReturns(redisBackuper)

		redisConfigFinder = new(fakes.FakeRedisConfigFinder)
		providerFactory.RedisConfigFinderProviderReturns(redisConfigFinder)

		instanceIDLocator = new(fakes.FakeInstanceIDLocator)
		providerFactory.SharedInstanceIDLocatorProviderReturns(instanceIDLocator)
		providerFactory.DedicatedInstanceIDLocatorProviderReturns(instanceIDLocator)

		providerFactory.TimeProviderStub = func() time.Time {
			now, _ := time.Parse("200601020304", "200102030405")
			return now
		}

		var err error
		backupConfig, err = backup.LoadBackupConfig(filepath.Join("assets", "backup.yml"))
		Expect(err).ToNot(HaveOccurred())

		backupConfig.PlanName = broker.PlanNameShared
	})

	Describe(".Backup", func() {
		var backupResults []backup.BackupResult

		JustBeforeEach(func() {
			backuper, err := backup.NewInstanceBackuper(
				*backupConfig,
				logger,
				backup.InjectTimeProvider(providerFactory.TimeProvider),
				backup.InjectRedisClientProvider(providerFactory.RedisClientProvider),
				backup.InjectRedisBackuperProvider(providerFactory.RedisBackuperProvider),