gocage/cmd/list.go

package cmd

import (
	"os"
	"fmt"
	"log"
	"reflect"
	"io/ioutil"
	"gocage/jail"
	"encoding/json"
	"github.com/spf13/viper"
)


var gJails []Jail

/* Pretty display of jails field
   Fields to show are given in a string array parameter
   Ex. : displayJails(["Name", "JID", "RootPath"])
*/
func displayStructFields(jails []Jail, valsToDisplay []string) {
	/* A line is defined by :
		Nr of fields
		For each field :
			Its name
			Its max length
			Its value
	*/
	type Field struct {
		Name	string
		MaxLen	int
		Value	string
	}

	type Line []Field

	type Output []Line
	var out Output

	//fmt.Printf("%d fields in a %d items structure\n", len(valsToDisplay), len(jails))

	// Browse structure to get max length and values
	for _, j := range jails {
		// Have to use a pointer, else reflect.Value.Elem() will panic : https://pkg.go.dev/reflect#Value.Elem
		tj := &j
		
		line := make([]Field, len(valsToDisplay))
		for i, f := range valsToDisplay {
			a := reflect.ValueOf(&tj).Elem()
			//fmt.Printf("Struct : %s, Champ : %s\n", a.String(), f)
			//fmt.Printf("%v", a.Elem().FieldByName(f).Interface())
			field := Field {
				Name: f,
				// For now this just contains this item length, will adjust later
				MaxLen: len(fmt.Sprintf("%v", a.Elem().FieldByName(f).Interface())),
				Value: fmt.Sprintf("%v", a.Elem().FieldByName(f).Interface()),
			}
			line[i] = field
			
		}
		out = append(out, line)
	}

	// Get real maximum length
	maxlen := make([]int, len(valsToDisplay))
	for i := 0; i< len(valsToDisplay); i++ {
		maxlen[i] = 0
	}
	for _, l := range out {
		for i, f := range l {
			if f.MaxLen > maxlen[i] {
				maxlen[i] = f.MaxLen
			}
		}
	}

	// Align maxlen to the real maximum length
	for io, l := range out {
		for ii, _ := range l {
			// We need to access slice by index if we want to modify content
			out[io][ii].MaxLen = maxlen[ii]
		}
	}

	totalLen := 0
	// Add separator and 2 blank spaces 
	for _, f := range out[0] {
		totalLen += f.MaxLen + 3
	}
	// Then add starting delimiter 
	totalLen += 1

	Debug := false
	if Debug == true {
		for _, f := range out[0] {
			fmt.Printf("%s max length : %d\n", f.Name, f.MaxLen)
		}
	}

	// Lets draw things on the screen!
	// First, headers
	for i := 0; i < totalLen ; i++ {
		fmt.Printf("-")
	}
	fmt.Printf("\n")

	for i, f := range out[0] {
		if i == 0 {
			fmt.Printf("|")
		}
		fmt.Printf(" %s", f.Name)
		for i := len(f.Name)+1 ; i < f.MaxLen+1 ; i++ {
			fmt.Printf(" ")
		}
		fmt.Printf(" |")
	}
	fmt.Printf("\n")
	for i := 0; i < totalLen ; i++ {
		fmt.Printf("-")
	}
	fmt.Printf("\n")

	// Then display data
	for _, l := range out {
		for i, f := range l {
			if i == 0 {
				fmt.Printf("|")
			}
			fmt.Printf(" %s", f.Value)
			for i := len(f.Value)+1 ; i < f.MaxLen+1 ; i++ {
				fmt.Printf(" ")
			}
			fmt.Printf(" |")
		}
		fmt.Printf("\n")
	}
	for i := 0; i < totalLen ; i++ {
		fmt.Printf("-")
	}
	fmt.Printf("\n")
}

func listJails(args []string) {
	for _, d := range viper.GetStringSlice("datastore") {
		listJailsFromDatastore(d)
	}

	displayStructFields(gJails, []string{"JID", "Name", "RootPath"})

/*	for _, j := range (gJails) {
		if j.Running {
			fmt.Printf("%d ; %s ; %s ; %s\n", j.JID, j.Name, j.Config.Ip4_addr, j.Config.Release)
		} else {
			fmt.Printf("   ; %s ; %s ; %s\n", j.Name, j.Config.Ip4_addr, j.Config.Release)
		}
	}
*/
}


func listJailsFromDatastore(datastore string) {
	fileInfo, err := os.Stat(datastore)
	if err != nil { log.Fatalln(fmt.Sprintf("Unable to access %s, check path and/or rights", datastore)) }
	if fileInfo.IsDir() == false { log.Fatalln(fmt.Sprintf("%s is not a directory", datastore)) }

	// A datastore have to contain a "jails" directory
	jailsDir := fmt.Sprintf("%s/jails", datastore)
	fileInfo, err = os.Stat(jailsDir)
	if err != nil { log.Fatalln(fmt.Sprintf("Unable to access %s, check path and/or rights", jailsDir)) }
	if fileInfo.IsDir() == false { log.Fatalln(fmt.Sprintf("%s is not a directory", jailsDir)) }

	listJailsFromDirectory(jailsDir)
}


func listJailsFromDirectory(dir string) ([]Jail) {
	files, err := ioutil.ReadDir(dir)
	if err != nil { log.Fatalln(fmt.Sprintf("Unable to browse %s, check path and/or rights", dir)) }

	for _, fi := range files {
		if fi.IsDir() == true {

		// 1. Get conf from config.json
			jailConfPath := fmt.Sprintf("%s/%s/%s", dir, fi.Name(), "config.json")
			jailConf, err := getJailConfig(jailConfPath)
			if err != nil { log.Println("ERROR reading jail config for %s", jailConfPath) }
	
		// 2. Build jail object from config
			jailRootPath := fmt.Sprintf("%s/%s/%s", dir, fi.Name(), "root")
			j := Jail{
				Name: jailConf.Host_hostname,
				Config: jailConf,
				ConfigPath: jailConfPath,
				RootPath: jailRootPath,
				Running: false,
			}

		// 3. Add current running informations
			// FIXME : use rj.host.hostname
			//j.Internal_name = fmt.Sprintf("ioc-%s", j.Name)

			rjails, err := jail.GetJails()
			if err != nil { log.Fatalln("Unable to list running jails") }
			for _, rj := range rjails {
				if rj.Path == j.RootPath {
					j.JID = rj.Jid
					j.Running = true
					j.InternalName = rj.Name
				}
			}

			gJails = append(gJails, j)
		}
	}

	return gJails
}


func getJailConfig(jailConfigPath string) (JailConfig, error) {
	content, err := ioutil.ReadFile(jailConfigPath)
	if err != nil { log.Fatalln(fmt.Sprintf("Unable to read %s, check path and/or rights", jailConfigPath)) }

	var jc JailConfig
	err = json.Unmarshal([]byte(content), &jc)
	if err != nil { log.Fatalln(fmt.Sprintf("Error occured during unmarshaling %s: %s", jailConfigPath, err.Error())) }

	//fmt.Printf("Jail Config: %#v\n", jc)

	return jc, err
}