deploy

package main

import (
	"fmt"

	"strconv"

	"github.com/rvflash/eve/client"
	"github.com/rvflash/eve/deploy"

	cache "github.com/rvflash/eve/rpc"
)

// rpc is the test's RPC client.
type rpc int

// Call implements the client.Caller interface
func (c rpc) Call(service string, args, reply interface{}) error {
	switch service {
	case "Cache.Bulk":
		switch int(c) {
		case 0:
			*reply.(*bool) = false
		default:
			*reply.(*bool) = true
		}
		return nil
	case "Cache.Get":
		switch args {
		case "0_BOOL":
			reply.(*cache.Item).Value = false
			return nil
		case "0_INT":
			reply.(*cache.Item).Value = 12
			return nil
		case "0_STR":
			reply.(*cache.Item).Value = "rv"
			return nil
		}
		return cache.ErrNotFound
	}
	return nil
}

// Close implements the client.Caller interface
func (c rpc) Close() error {
	return nil
}

var rpcClient = client.NewRPC(rpc(1))

// src is the test's source.
type src int

// Key implements the deploy.Source interface.
func (s src) Key() []byte {
	return []byte(strconv.Itoa(int(s)))
}

// EnvsValues implements the deploy.Source interface.
func (s src) EnvsValues() (firstEnvValues, secondEnvValues []string) {
	switch s {
	case twoEnv:
		return []string{"dev"}, []string{"fr", "en"}
	case oneEnv:
		return []string{"dev"}, []string{""}
	case errEnv:
		return nil, nil

	}
	return []string{""}, []string{""}
}

// ToDeploy implements the deploy.Source interface.
func (s src) ToDeploy(firstEnvValues, secondEnvValues []string) map[string]interface{} {
	switch s {
	case twoEnv:
		return map[string]interface{}{"2_DEV_FR_BOOL": true, "2_DEV_FR_FLOAT": 3.14}
	case oneEnv:
		return map[string]interface{}{"1_DEV_BOOL": true, "1_DEV_FLOAT": 3.14}
	case noEnv:
		if len(firstEnvValues) == 0 || len(secondEnvValues) == 0 {
			return nil
		}
		return map[string]interface{}{"0_BOOL": true, "0_FLOAT": 3.14, "0_STR": nil, "0_INT": 12}
	}
	return nil
}

// Sources without, or with one or two environments.
const (
	noEnv src = iota
	oneEnv
	twoEnv
	errEnv
)

func main() {
	// Defines the project to deploy and which values of environments to push.
	r := deploy.New(noEnv, rpcClient)
	if err := r.Checkout(); err != nil {
		fmt.Println(err.Error())
		return
	}
	// Gets the list of variables to change.
	for key, value := range r.Diff() {
		fmt.Printf("%v: %s\n", key, value)
	}
	// Gets counters to show differences with cached data.
	task := r.Status()
	fmt.Printf(
		"Add: %d (%d%%), Delete: %d (%d%%), Update: %d (%d%%), No change: %d (%d%%)\n",
		task.Add, task.PctOfAdd(),
		task.Del, task.PctOfDel(),
		task.Upd, task.PctOfDel(),
		task.NoOp, task.PctOfNoOp(),
	)
	// Pushes these changes in production.
	if err := r.Push(); err != nil {
		fmt.Println(err.Error())
	}
}

Output: