Add start api command

README.md

@@ -22,13 +22,9 @@ gocage create jail1 -r 13.2-RELEASE
 gocage set Config.Ip4_addr="vnet0|192.168.1.91/24" Config.Vnet=1 jail1
 </code></pre>
 
-Create basejail (jail based on a template, system will be nullfs read-only mounted from the template):
+Create basejail (jail based on a release, system will be nullfs read-only mounted from the release directory):
 <pre><code>
-# First create basetpl from 13.2-RELEASE, set it as a template
-gocage create -r 13.2-RELEASE basetpl
-gocage set Config.Jailtype="template" basetpl
-# Then create basejail1 based on basetpl
-gocage create -b basetpl basejail1
+gocage create -b -r 14.0-RELEASE basejail1
 </code></pre>
 
 

TODO.md

@@ -1,8 +1,19 @@
 Replicating jails between two servers (use zrepl)
+Manage remote jails :
+  - Make gocage a service
+  - All commands should become API endpoint
+  - How to handle authentication ?
 
 DEBUG: 
 - cmd/list.go:275:
     // FIXME ??? Shouldn't be ioc-$Name ?
     j.InternalName = rj.Name
 - WriteConfigToDisk don't write neither "release" in cmd stop neither "last_started" in cmd start
+  26/08/2023 : Last_started is updated
+
+BUGS:
+- unable to set values containing equal sign :
+  # gocage set Config.Exec_poststart="jail -m allow.mount.linprocfs=1 name=ioc-poudriere-noo" poudriere-noo
+  Error parsing args: Config.Exec_poststart=jail -m allow.mount.linprocfs=1 name=ioc-poudriere-noo
+- Fix fstab when migrating jail  
 

cmd/api.go

@@ -0,0 +1,96 @@
+package cmd
+
+import (
+	//"io"
+	"fmt"
+	"strings"
+	"net/http"
+	
+	"github.com/gin-gonic/gin"
+	"github.com/gin-contrib/cors"
+)
+
+func printJails(jails []string, fields []string) ([]byte, error) {
+	var res []byte
+	
+	res = append(res, []byte("[")...)
+	
+	// Build a filtered jail list
+	var filteredJails []Jail
+	if (len(jails) >= 1 && len(jails[0]) > 0) {
+		for _, j := range gJails {
+			if isStringInArray(jails, j.Name) {
+				filteredJails = append(filteredJails, j)
+			}
+		}
+	} else {
+		filteredJails = gJails
+	}
+	
+	for i, j := range filteredJails {
+		out, err := j.PrintJSON(fields)
+		if err != nil {
+			return res, err
+		}
+		res = append(res, out...)
+		if i < len(filteredJails) - 1 {
+			res = append(res, []byte(",")...)
+		}
+	}
+	res = append(res, []byte("]")...)
+	return res, nil
+}
+
+func startApi(address string, port int) {
+	// Initialize gJails. 
+	// FIXME: How to update this at running time without doubling the same jails?
+	// core will do this for us in add and delete functions
+	ListJails([]string{""}, false)
+
+	r := gin.Default()
+	
+	// Cross Origin Request Support
+	config := cors.DefaultConfig()
+	// DANGER !
+	config.AllowOrigins = []string{"*"}
+	r.Use(cors.New(config))
+
+	r.GET("/jail/list", func(c *gin.Context) {
+		jailstr := c.Query("jail")
+		fields := c.Query("fields")
+		if len(fields) == 0 {
+			// TODO : Put this default value in (user?) configuration
+			fields = "Name,Running,Config.Release,Config.Ip4_addr"
+		}
+		jsout, err := printJails(strings.Split(jailstr, ","), strings.Split(fields, ","))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"status": 1, "error": err.Error()})
+		} else {
+			c.Data(http.StatusOK, "application/json", jsout)
+		}
+	})
+	
+	r.POST("/jail/start/:jail", func(c *gin.Context) {
+		jailstr := c.Params.ByName("jail")
+		// TODO : Capture or redirect output so we can know if jail was started or not
+		StartJail(strings.Split(jailstr, ","))
+		c.JSON(http.StatusOK, gin.H{"status": 0, "error": ""})
+	})
+	r.POST("/jail/stop/:jail", func(c *gin.Context) {
+		jailstr := c.Params.ByName("jail")
+		// TODO : Capture or redirect output so we can know if jail was started or not
+		StopJail(strings.Split(jailstr, ","))
+		c.JSON(http.StatusOK, gin.H{"status": 0, "error": ""})
+	})
+	
+	r.GET("/jail/properties", func(c *gin.Context) {
+		props, err := ListJailsProps("json")
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"status": 1, "error": err.Error()})
+		} else {
+			c.Data(http.StatusOK, "application/json", []byte(props))
+		}
+	})
+	
+	r.Run(fmt.Sprintf("%s:%d", address, port))
+}

cmd/create.go

@@ -16,6 +16,11 @@ func CreateJail(args []string) {
 	var err error
 	var jtype []string
 
+	if gCreateArgs.BaseJail && gCreateArgs.Release == "" {
+		fmt.Println("Release should be set when creating basejail")
+		os.Exit(1)
+	}
+
 	if len(gCreateArgs.JailType) > 0 {
 		jtype = []string{gCreateArgs.JailType}
 	}
@@ -50,21 +55,20 @@ func CreateJail(args []string) {
 		}
 
 		// Get base template if specified
-		if len(gCreateArgs.BaseTemplate) > 0 {
+		if gCreateArgs.BaseJail {
 			/**************************************************************************
 			*  Create based jail from a template
 			*/
-			log.Debugf("Jail will be created from a base template\n")
-			bj, err := getJailFromArray(gCreateArgs.BaseTemplate, []string{"template"}, gJails)
-			if err != nil {
-				if strings.EqualFold(err.Error(), "Jail not found") {
-					fmt.Printf("Template not found\n")
-					return
-				} else {
-					fmt.Printf("ERROR: %s\n", err.Error())
-					return
-				}
+			log.Debugf("Jail will be created read-only from release %s\n", gCreateArgs.Release)
+
+			// First check if we got release on the same datastore
+			releasePath := fmt.Sprintf("%s/releases/%s/root", ds.Mountpoint, gCreateArgs.Release)
+			_, err := os.Stat(releasePath)
+			if os.IsNotExist(err) {
+				fmt.Printf("ERROR: Release locally not available. Run \"gocage fetch\"\n")
+				return
 			}
+
 			// Create jail datasets
 			dstDset := fmt.Sprintf("%s/jails/%s", ds.ZFSDataset, jname)
 			fmt.Printf("    > Initialize dataset %s\n", dstDset)
@@ -87,7 +91,7 @@ func CreateJail(args []string) {
 			dstRootDir := fmt.Sprintf("%s/jails/%s/root", ds.Mountpoint, jname)
 			for _, d := range append(gBaseDirs, gEmptyDirs...) {
 				dstPath := dstRootDir
-				srcPath := bj.RootPath
+				srcPath := releasePath
 				for _, cd := range strings.Split(d, "/") {
 					srcPath = fmt.Sprintf("%s/%s", srcPath, cd)
 					dstPath = fmt.Sprintf("%s/%s", dstPath, cd)
@@ -110,9 +114,9 @@ func CreateJail(args []string) {
 			// Copy these from basejail
 			fmt.Printf("    > Create base writable directories\n")
 			for _, d := range gCopyDirs {
-				err := cp.Copy(fmt.Sprintf("%s/%s", bj.RootPath, d), fmt.Sprintf("%s/%s", dstRootDir, d))
+				err := cp.Copy(fmt.Sprintf("%s/%s", releasePath, d), fmt.Sprintf("%s/%s", dstRootDir, d))
 				if err != nil {
-					fmt.Printf("ERROR copying %s to %s: %s\n", fmt.Sprintf("%s/%s", bj.RootPath, d),
+					fmt.Printf("ERROR copying %s to %s: %s\n", fmt.Sprintf("%s/%s", releasePath, d),
 						   fmt.Sprintf("%s/%s", dstRootDir, d), err.Error())
 					return
 				}
@@ -150,7 +154,7 @@ func CreateJail(args []string) {
 			// 2. Add a json item to config ("basejail_template" p.e.), but iocage would delete it once jail is started from iocage
 			// 3. Add a gocage specific config ("config.gocage.json" p.e.)
 			j.Config.Jailtype = "basejail"
-			j.Config.Origin = bj.Name
+			j.Config.Origin = gCreateArgs.Release
 			j.Config.Host_hostname = jname
 			j.Config.Host_hostuuid = jname
 
@@ -166,7 +170,7 @@ func CreateJail(args []string) {
 			defer fstabHandle.Close()
 
 			for _, d := range gBaseDirs {
-				fmt.Fprintf(fstabHandle, "%s\t%s\tnullfs\tro\t0\t0\n", fmt.Sprintf("%s/%s", bj.RootPath, d), fmt.Sprintf("%s/%s", dstRootDir, d))
+				fmt.Fprintf(fstabHandle, "%s\t%s\tnullfs\tro\t0\t0\n", fmt.Sprintf("%s/%s", releasePath, d), fmt.Sprintf("%s/%s", dstRootDir, d))
 			}
 
 			fmt.Printf("  > Jail created!\n")

cmd/list.go

@@ -15,23 +15,37 @@ import (
  * List all properties a jail have, with their internal name
  * Only print properties name. To get name & values, use GetJailProperties()
  *******************************************************************************/
-func ListJailsProps(args []string) {
+func ListJailsProps(format string) (string, error) {
 	var conf Jail
-	var result []string
+	var props []string
+	var out string
 	// Mandatory constructor to init default values
 	jailconf, err := NewJailConfig()
 	if err != nil {
 		fmt.Printf("Error allocating JailConfig: %s\n", err.Error())
-		return
+		return out, err
 	}
 
 	conf.Config = jailconf
 
-	result = getStructFieldNames(conf, result, "")
+	props = getStructFieldNames(conf, props, "")
 
-	for _, f := range result {
-		fmt.Printf("%s\n", f)
+	if format == "json" {
+		out = "{\"properties\":["
+		for i, p := range props {
+			out += fmt.Sprintf("\"%s\"", p)
+			if i < len(props) - 1 {
+				out += ","
+			}
+		}
+		out += "]}"
+	} else {
+		for _, p := range props {
+			out += fmt.Sprintf("%s\n", p)
+		}
 	}
+
+	return out, nil
 }
 
 /********************************************************************************

cmd/properties.go

@@ -1,8 +1,9 @@
 package cmd
 
 import (
-	"errors"
+	"os"
 	"fmt"
+	"errors"
 	"reflect"
 	"strconv"
 	"strings"
@@ -20,7 +21,7 @@ func GetJailProperties(args []string) {
 				jail, err = getJailFromArray(a, []string{""}, gJails)
 				if err != nil {
 					fmt.Printf("Error: %s\n", err.Error())
-					return
+					os.Exit(1)
 				}
 			} else {
 				props = append(props, a)
@@ -105,20 +106,20 @@ func SetJailProperties(args []string) {
 		return
 	}
 
-	// Get jail by index to modify it
-	for i, _ := range gJails {
-		if gJails[i].Name == jail.Name {
-			for _, p := range props {
-				err := setStructFieldValue(&gJails[i], p.name, p.value)
-				if err != nil {
-					fmt.Printf("Error: %s\n", err.Error())
-					return
-				} else {
-					fmt.Printf("%s: %s set to %s\n", gJails[i].Name, p.name, p.value)
-					gJails[i].ConfigUpdated = true
-				}
-			}
-			writeConfigToDisk(&gJails[i], false)
+	cj, err := getJailFromArray(jail.Name, []string{""}, gJails)
+	if err != nil {
+		fmt.Printf("Error getting jail %s: %v\n", jail.Name, err)
+		return
+	}
+
+	for _, p := range props {
+		err := setStructFieldValue(cj, p.name, p.value)
+		if err != nil {
+			fmt.Printf("Error: %s\n", err.Error())
+			return
+		} else {
+			fmt.Printf("%s: %s set to %s\n", cj.Name, p.name, p.value)
 		}
 	}
+	cj.WriteConfigToDisk(false)
 }

cmd/root.go

@@ -14,7 +14,7 @@ import (
 )
 
 const (
-	gVersion = "0.38"
+	gVersion = "0.42a"
 	
 	// TODO : Get from $jail_zpool/defaults.json
 	MIN_DYN_DEVFS_RULESET = 1000
@@ -22,12 +22,15 @@ const (
 
 type createArgs struct {
 	Release      string
-	BaseTemplate string
+	BaseJail     bool
 	Datastore    string
 	JailType     string
 }
 
 var (
+	gApiAddress string
+	gApiPort    int
+
 	gJailHost   JailHost
 	gJails      []Jail
 	gDatastores []Datastore
@@ -127,7 +130,12 @@ ex: gocage list srv-db srv-web`,
 		Short: "Print jails properties",
 		Long:  "Display jails properties. You can use properties to filter, get or set them.",
 		Run: func(cmd *cobra.Command, args []string) {
-			ListJailsProps(args)
+			out, err := ListJailsProps("text")
+			if err != nil {
+				fmt.Printf("Error listing properties : %v\n", err)
+			} else {
+				fmt.Printf("%s\n", out)
+			}
 		},
 	}
 
@@ -357,6 +365,14 @@ You can specify multiple datastores.`,
 		},
 	}
 
+	apiCmd = &cobra.Command{
+		Use:   "startapi",
+		Short: "Run docage as a daemon, exposing API",
+		Run: func(cmd *cobra.Command, args []string) {
+			startApi(gApiAddress, gApiPort)
+		},
+	}
+
 	testCmd = &cobra.Command{
 		Use:   "test",
 		Short: "temporary command to test some code snippet",
@@ -420,9 +436,12 @@ func init() {
 	upgradeCmd.MarkFlagRequired("release")
 
 	createCmd.Flags().StringVarP(&gCreateArgs.Release, "release", "r", "", "Release for the jail (e.g.: \"13.1-RELEASE\"")
-	createCmd.Flags().StringVarP(&gCreateArgs.BaseTemplate, "basetpl", "b", "", "Base template. This will create a jail based on basetpl, so every up(date|grade) made to basetpl will immediately propagate to new jail\n")
+	createCmd.Flags().BoolVarP(&gCreateArgs.BaseJail, "basejail", "b", false, "Basejail. This will create a jail mounted read only from a release, so every up(date|grade) made to this release will immediately propagate to new jail.\n")
 	createCmd.Flags().StringVarP(&gCreateArgs.Datastore, "datastore", "d", "", "Datastore to create the jail on. Defaults to first declared in config.")
 
+	apiCmd.Flags().StringVarP(&gApiAddress, "listen-addr", "l", "127.0.0.1", "API listening address")
+	apiCmd.Flags().IntVarP(&gApiPort, "listen-port", "p", 1234, "API listening port")
+
 	// Now declare commands
 	rootCmd.AddCommand(versionCmd)
 	rootCmd.AddCommand(listCmd)
@@ -441,6 +460,7 @@ func init() {
 	rootCmd.AddCommand(updateCmd)
 	rootCmd.AddCommand(upgradeCmd)
 	rootCmd.AddCommand(createCmd)
+	rootCmd.AddCommand(apiCmd)
 	
 	rootCmd.AddCommand(testCmd)
 	

cmd/start.go

@@ -340,7 +340,7 @@ func configureDhcpOrAcceptRtadv(jail *Jail, ipproto int, enable bool) error {
 
 		if ipproto == IPv6 {
 			key = fmt.Sprintf("%s_ipv6", key)
-			value = "inet6 auto_linklocal accept_rtadv autoconf"
+			value = "\"inet6 auto_linklocal accept_rtadv autoconf\""
 		}
 
 		if enable == true {
@@ -363,7 +363,7 @@ func checkRtsold(jail *Jail) error {
 	if strings.Contains(jail.Config.Ip6_addr, "accept_rtadv") == false {
 		return fmt.Errorf("Must set at least one ip6_addr to accept_rtadv!\n")
 	}
-	err := enableRcKeyValue(jail.ConfigPath, "rtsold_enable", "yes")
+	err := enableRcKeyValue(fmt.Sprintf("%s/etc/rc.conf", jail.RootPath), "rtsold_enable", "yes")
 	if err != nil {
 		return fmt.Errorf("ERROR setting rtsold_enable=YES with sysrc for jail %s: %s\n", jail.Name, err)
 	}
@@ -810,7 +810,9 @@ func generateMAC(jail *Jail, nic string) ([]byte, []byte, error) {
 	}
 	
 	hsmac := append(prefix, suffix...)
-	jsmac := append(hsmac[:5], hsmac[5]+1)
+	jsmac := make([]byte, 6)
+	copy(jsmac, hsmac)
+	jsmac[5] = jsmac[5] + 1
 	
 	// Save MACs to config
 	pname := fmt.Sprintf("Config.%s_mac", strings.Title(nic))
@@ -840,7 +842,7 @@ func setupVnetInterfaceHostSide(jail *Jail) ([]string, error) {
 		bridge := v[1]
 		
 		// Get host side MAC
-		pname := fmt.Sprintf("Config.%s_mac", nic)
+		pname := fmt.Sprintf("Config.%s_mac", strings.Title(nic))
 		var val *reflect.Value
 		val, pname, err = getStructFieldValue(jail, pname)
 		if err != nil {
@@ -853,13 +855,22 @@ func setupVnetInterfaceHostSide(jail *Jail) ([]string, error) {
 				return []string{}, err
 			}
 		} else {
-			hsmac = val.Bytes()
+			if strings.EqualFold(val.String(), "none") {
+				hsmac, _, err = generateMAC(jail, nic)
+				if err != nil {
+					return []string{}, err
+				}
+			}
+			hsmac, err = hex.DecodeString(strings.Split(val.String(), " ")[0])
+			if err != nil {
+				return []string{}, fmt.Errorf("Error converting %s to hex\n", strings.Split(val.String(), " ")[0])
+			}
 		}
 		
 		// Get bridge MTU
 		mtu, err := gJailHost.GetBridgeMTU(bridge)
 		if err != nil {
-			return []string{}, fmt.Errorf("Error getting bridge mtu: %v\n", err)
+			return []string{}, fmt.Errorf("Error getting bridge \"%s\" mtu: %v\n", bridge, err)
 		}
 		
 		// Create epair interface
@@ -909,7 +920,9 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
 	
 	for _, i := range strings.Split(jail.Config.Ip4_addr, ",") {
 		v := strings.Split(i, "|")
-		ip4s[v[0]] = v[1]
+		if len(v) > 1 {
+			ip4s[v[0]] = v[1]
+		}
 	}
 	for _, i := range strings.Split(jail.Config.Ip6_addr, ",") {
 		v := strings.Split(i, "|")
@@ -934,7 +947,7 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
 		jsepair := fmt.Sprintf("%sb", strings.TrimSuffix(hostepairs[i], "a"))
 
 		// Get jail side MAC
-		pname := fmt.Sprintf("Config.%s_mac", nic)
+		pname := fmt.Sprintf("Config.%s_mac", strings.Title(nic))
 		var val *reflect.Value
 		val, pname, err = getStructFieldValue(jail, pname)
 		if err != nil {
@@ -947,7 +960,11 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
 				return err
 			}
 		} else {
-			jsmac = val.Bytes()
+			jsmac, err = hex.DecodeString(strings.Split(val.String(), " ")[1])
+                        if err != nil {
+                                return fmt.Errorf("Error converting %s to hex\n", strings.Split(val.String(), " ")[1])
+                        }
+
 		}
 
 		cmd := fmt.Sprintf("/sbin/ifconfig %s vnet %s", jsepair, jail.InternalName)
@@ -959,7 +976,7 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
 		// Get bridge MTU
 		mtu, err := gJailHost.GetBridgeMTU(bridge)
 		if err != nil {
-			return fmt.Errorf("Error getting bridge %s mtu: %v\n", bridge, err)
+			return fmt.Errorf("Error getting bridge \"%s\" mtu: %v\n", bridge, err)
 		}
 
 		cmd = fmt.Sprintf("/usr/sbin/jexec %d ifconfig %s mtu %d", jail.JID, jsepair, mtu)
@@ -1404,6 +1421,25 @@ func StartJail(args []string) {
 			}
 		}
 
+		// Get a reference to current jail, to update its properties in RAM so API will get fresh data
+		for i, j := range gJails {
+			if strings.EqualFold(j.Name, cj.Name) && strings.EqualFold(j.Datastore, cj.Datastore) {
+				if err = setStructFieldValue(&gJails[i], "Running", "true"); err != nil {
+					fmt.Printf("ERROR: setting Running property to true: %s\n", err.Error())
+				}
+				if err = setStructFieldValue(&gJails[i], "JID", fmt.Sprintf("%d", cj.JID)); err != nil {
+					fmt.Printf("ERROR: setting JID property to %d: %s\n", cj.JID, err.Error())
+				}
+				if err = setStructFieldValue(&gJails[i], "InternalName", cj.InternalName); err != nil {
+					fmt.Printf("ERROR: Setting InternalName property: %s\n", err.Error())
+				}
+				// FIXME: this value of devfs_ruleset should not go in Config, it should reside in Jail root properties as it is volatile (only valid while jail is running)
+				/*if err = setStructFieldValue(&gJails[i], "Devfs_ruleset", "0"); err != nil {
+					fmt.Printf("ERROR: setting Devfs_ruleset property to 0: %s\n", err.Error())
+				}*/
+			}
+		}
+
 		hostInt, err := gJailHost.GetInterfaces()
 		if err != nil {
 			fmt.Printf("Error listing jail host interfaces: %v\n", err)
@@ -1431,7 +1467,7 @@ func StartJail(args []string) {
 		fmt.Printf("  > Setup VNet network: OK\n")
 		
 		// Set default route, unless main network is dhcp
-		if ! cj.isFirstNetDhcp() {
+		if ! cj.isFirstNetDhcp() && !strings.EqualFold(cj.Config.Ip4_addr, "none") {
 			fmt.Printf("  > Setup default ipv4 gateway:\n")
 			cmd := fmt.Sprintf("/usr/sbin/setfib %s /usr/sbin/jexec %d route add default %s", cj.Config.Exec_fib, cj.JID, cj.Config.Defaultrouter)
 			out, err := executeCommand(cmd)

cmd/stop.go

@@ -83,15 +83,30 @@ func umountAndUnjailZFS(jail *Jail) error {
 }
 
 func destroyVNetInterfaces(jail *Jail) error {
-	for _, i := range strings.Split(jail.Config.Ip4_addr, ",") {
-		iname := fmt.Sprintf("%s.%d", strings.Split(i, "|")[0], jail.JID)
-		fmt.Printf("%s: ", iname)
-		_, err := executeCommand(fmt.Sprintf("ifconfig %s destroy", iname))
-		//_, err := executeScript(fmt.Sprintf("ifconfig %s destroy >/dev/null 2>&1", iname))
-		if err != nil {
-			return err
-		} else {
-			fmt.Printf("OK\n")
+	if !strings.EqualFold(jail.Config.Ip4_addr, "none") {
+		for _, i := range strings.Split(jail.Config.Ip4_addr, ",") {
+			iname := fmt.Sprintf("%s.%d", strings.Split(i, "|")[0], jail.JID)
+			fmt.Printf("%s: ", iname)
+			_, err := executeCommand(fmt.Sprintf("ifconfig %s destroy", iname))
+			//_, err := executeScript(fmt.Sprintf("ifconfig %s destroy >/dev/null 2>&1", iname))
+			if err != nil {
+				return err
+			} else {
+				fmt.Printf("OK\n")
+			}
+		}
+	}
+	if !strings.EqualFold(jail.Config.Ip6_addr, "none") {
+		for _, i := range strings.Split(jail.Config.Ip6_addr, ",") {
+			iname := fmt.Sprintf("%s.%d", strings.Split(i, "|")[0], jail.JID)
+			fmt.Printf("%s: ", iname)
+			_, err := executeCommand(fmt.Sprintf("ifconfig %s destroy", iname))
+			//_, err := executeScript(fmt.Sprintf("ifconfig %s destroy >/dev/null 2>&1", iname))
+			if err != nil {
+				return err
+			} else {
+				fmt.Printf("OK\n")
+			}
 		}
 	}
 

cmd/struct.go

@@ -1,7 +1,10 @@
 package cmd
 
 import (
+	"fmt"
+	"sort"
 	"time"
+	"strings"
 )
 
 const (
@@ -561,3 +564,90 @@ type DatastoreSort struct {
 	AvailableDec  datastoreLessFunc
 }
 
+type Field struct {
+	Name   string
+	MaxLen int
+	Value  string
+}
+
+
+func (j *Jail) PrintJSON(fields []string) ([]byte, error) {
+	return j.PrintJSONWithUpper("", fields)
+}
+
+func (j *Jail) PrintJSONWithUpper(upper string, fields []string) ([]byte, error) {
+	var res []byte
+
+	if len(fields) < 1 {
+		return res, nil
+	}
+
+	if len(upper) > 0 {
+		res = append(res, []byte(fmt.Sprintf("\"%s\": {", upper))...)
+	} else {
+		res = append(res, []byte("{")...)
+	}
+
+	// Reorder fields so we got fields of a sub-structure adjacents
+	sort.Strings(fields)
+
+	var ffname string
+	offset := 0
+	for i, _ := range fields {
+		if i + offset >= len(fields) {
+			break
+		}
+		// Is this struct in struct?
+		if strings.Contains(fields[i+offset], ".") {
+			// Count items in this struct
+			var subfields []string
+			var newUpper string
+			for _, sf := range fields[i+offset:] {
+				if strings.Split(sf, ".")[0] == strings.Split(fields[i+offset], ".")[0] {
+					newUpper = strings.Split(sf, ".")[0]
+					sub := strings.Join(strings.Split(string(sf), ".")[1:], ".")
+					subfields = append(subfields, sub)
+				}
+			}
+			out, err := j.PrintJSONWithUpper(newUpper, subfields)
+			if err != nil {
+				return []byte{}, err
+			}
+			res = append(res, out...)
+			offset += len(subfields)-1
+			if i + offset < len(fields) - 1 {
+				res = append(res, []byte(",")...)
+			}
+			continue
+		}
+
+		if len(upper) > 0 {
+			ffname = fmt.Sprintf("%s.%s", upper, fields[i+offset])
+		} else {
+			ffname = fields[i+offset]
+		}
+		val, _, err := getStructFieldValue(j, ffname)
+		if err != nil {
+			return []byte{}, fmt.Errorf("Error accessing field \"%s\" : %v\n", fields[i+offset], err)
+		}
+
+		res = append(res, []byte(fmt.Sprintf("\"%s\": ", fields[i+offset]))...)
+		switch val.Interface().(type) {
+			case string:
+				res = append(res, []byte(fmt.Sprintf("\"%s\"", val.Interface().(string)))...)
+			case int:
+				res = append(res, []byte(fmt.Sprintf("%d", val.Interface().(int)))...)
+			case bool:
+				res = append(res, []byte(fmt.Sprintf("%t", val.Interface().(bool)))...)
+			default:
+				fmt.Printf("ERREUR dans Jail.PrintJSONWithUpper() : Type inconnu : %T\n", val.Interface())
+		}
+		if i + offset < len(fields) - 1 {
+			res = append(res, []byte(",")...)
+		}
+	}
+
+	res = append(res, []byte("}")...)
+
+	return res, nil
+}

cmd/update.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	//"log"
 	"time"
+	"strings"
 )
 
 
@@ -62,7 +63,13 @@ func UpdateJail(args []string) {
 			fmt.Printf("Error getting jail: %s\n", err)
 			continue
 		}
-		
+
+		// We cant update basejail as system is readonly
+		if strings.EqualFold(cj.Config.Jailtype, "basejail") {
+			fmt.Printf("%s is a basejail using %s system files. Please update %s!\n", cj.Name, cj.Config.Origin, cj.Config.Origin)
+			continue
+		}
+
 		fmt.Printf("  > Snapshot jail %s\n", cj.Name)
 		// Set snapshot name
 		dt := time.Now()

cmd/utils.go

@@ -628,10 +628,8 @@ func executeCommandInJail(jail *Jail, cmdline string) (string, error) {
 		// else
 		word = word + string(c)
 	}
-	
-	if gDebug {
-		fmt.Printf("DEBUG: executeCommandInJail: prepare to execute \"%s\"\n", cmd)
-	}
+
+	log.Debugf("executeCommandInJail: will execute \"%s\"\n", strings.Join(cmd, " "))
 
 	out, err := exec.Command(cmd[0], cmd[1:]...).CombinedOutput()
 
@@ -917,7 +915,8 @@ func getFstab(path string) ([]Mount, error) {
 	scan := bufio.NewScanner(f)
 	for scan.Scan() {
 		res := strings.Fields(scan.Text())
-		if len(res) != 6 {
+		// iocage create lines like that : "/iocage/releases/13.2-RELEASE/root/bin   /iocage/jails/smtp-router-02/root/bin   nullfs  ro      0       0 # Added by iocage on 2023-10-10 17:20:51"
+		if (len(res) > 6 && !strings.EqualFold(res[6], "#")) || len(res) < 6 {
 			return mounts, fmt.Errorf("Incorrect format for fstab line %s", scan.Text())
 		}
 		freq, err := strconv.Atoi(res[4])

go.mod

@@ -1,32 +1,57 @@
 module gocage
 
-go 1.17
+go 1.21
 
 require (
 	github.com/c-robinson/iplib v1.0.3
 	github.com/c2h5oh/datasize v0.0.0-20220606134207-859f65c6625b
+	github.com/gin-contrib/cors v1.7.2
+	github.com/gin-gonic/gin v1.10.0
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 	github.com/otiai10/copy v1.12.0
 	github.com/sirupsen/logrus v1.8.1
 	github.com/spf13/cobra v1.2.1
 	github.com/spf13/viper v1.9.0
-	golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
+	golang.org/x/net v0.25.0
 )
 
 require (
+	github.com/bytedance/sonic v1.11.6 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
 	github.com/fsnotify/fsnotify v1.5.1 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.20.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/magiconair/properties v1.8.5 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mitchellh/mapstructure v1.4.2 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pelletier/go-toml v1.9.4 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/spf13/afero v1.6.0 // indirect
 	github.com/spf13/cast v1.4.1 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/subosito/gotenv v1.2.0 // indirect
-	golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect
-	golang.org/x/text v0.3.6 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
+	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
+	google.golang.org/protobuf v1.34.1 // indirect
 	gopkg.in/ini.v1 v1.63.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )