yo/gocage
1
0
Fork 0
Code Issues Pull Requests Projects Releases1 Wiki Activity

Compare commits

..

No commits in common. "master" and "v0.35" have entirely different histories.
master ... v0.35

19 changed files with 559 additions and 1817 deletions

120
README.md

@ -8,30 +8,22 @@ Gocage can handle multiple datastores, so you can have jails on HDD storage and
From v0.33b, due to multi ZFS pool support, gocage is no longer 100% compatible with iocage.
Zfs datasets now should be specified with the ZFS pool. e.g. :
<pre><code>Config.Jail_zfs = 1
<code>
Config.Jail_zfs = 1
Config.Jail_zfs_dataset = myzfspool/poudriere
Config.Jail_zfs_mountpoint = none
</code></pre>
Create jails
------------
You need to specify release, and optional configuration:
<pre><code>gocage create jail1 -r 13.2-RELEASE -p "Config.Ip4_addr='vnet0|192.168.1.91/24',Config.Ip6=none,Config.Boot=1"
</code></pre>
Create basejail. A basejail is a jail based on a release: system will be nullfs read-only mounted from the release directory. Main advantage is that release updates will immediately apply to jails based on this release. Another advantage is that jail system is mounted read-only, a plus from a security perspective:
<pre><code>gocage create -b -r 14.0-RELEASE basejail1
</code></pre>
</code>
List jails
----------
<pre><code>gocage list</code></pre>
Nothing fancy, just use
`gocage list`
### Specify fields to display
Use -o to specify which fields you want to display:
<pre><code>gocage list -o JID,Name,Running,Config.Boot,Config.Comment
<pre><code>
gocage list -o JID,Name,Running,Config.Boot,Config.Comment
+=====+==========+=========+=============+================+
| JID | Name | Running | Config.Boot | Config.Comment |
+=====+==========+=========+=============+================+
@ -45,7 +37,7 @@ Use -o to specify which fields you want to display:
+-----+----------+---------+-------------+----------------+
</code></pre>
Use `gocage properties`to list available fields.
See [cmd/struct.go](https://git.nosd.in/yo/gocage/src/branch/master/cmd/struct.go) for field names.
Filter jails
@ -53,7 +45,8 @@ Filter jails
### By name
Just add name on gocage list command :
<pre><code>gocage list srv-bdd srv-web
<pre><code>
gocage list srv-bdd srv-web
+=====+=========+=================+=======================+=========+
| JID | Name | Config.Release | Config.Ip4_addr | Running |
+=====+=========+=================+=======================+=========+
@ -61,11 +54,12 @@ Just add name on gocage list command :
+-----+---------+-----------------+-----------------------+---------+
| 41 | srv-web | 13.0-RELEASE-p4 | vnet0|192.168.1.26/24 | true |
+-----+---------+-----------------+-----------------------+---------+
</code></pre>
</pre></code>
### By field value
You can filter jails with -f option, followed by key=value. Suppose you want to see only active at boot jails:
<pre><code>gocage list -f Config.Boot=1 -o JID,Name,Running,Config.Boot,Config.Comment
<pre><code>
gocage list -f Config.Boot=1 -o JID,Name,Running,Config.Boot,Config.Comment
+=====+==========+=========+=============+================+
| JID | Name | Running | Config.Boot | Config.Comment |
+=====+==========+=========+=============+================+
@ -77,10 +71,11 @@ You can filter jails with -f option, followed by key=value. Suppose you want to
+-----+----------+---------+-------------+----------------+
| 22 | srv-dns1 | true | 1 | |
+-----+----------+---------+-------------+----------------+
</code></pre>
</pre></code>
Now, only active at boot and running :
<pre><code>gocage list -f Config.Boot=1,Running=true -o JID,Name,Running,Config.Boot
<pre><code>
gocage list -f Config.Boot=1,Running=true -o JID,Name,Running,Config.Boot
+=====+==========+=========+=============+
| JID | Name | Running | Config.Boot |
+=====+==========+=========+=============+
@ -90,12 +85,13 @@ Now, only active at boot and running :
+-----+----------+---------+-------------+
| 22 | srv-dns1 | true | 1 |
+-----+----------+---------+-------------+
</code></pre>
</pre></code>
Sort jails
----------
Use -s switch followed by sort criteria. Criteria is a field name, prefixed with + or - for sort order (increase/decrease):
<pre><code>gocage list -f Config.Boot=1,Running=true -o JID,Name,Running,Config.Boot -s +JID
<pre><code>
gocage list -f Config.Boot=1,Running=true -o JID,Name,Running,Config.Boot -s +JID
+=====+==========+=========+=============+
| JID | Name | Running | Config.Boot |
+=====+==========+=========+=============+
@ -105,11 +101,12 @@ Use -s switch followed by sort criteria. Criteria is a field name, prefixed with
+-----+----------+---------+-------------+
| 183 | test | true | 1 |
+-----+----------+---------+-------------+
</code></pre>
</pre></code>
You can use up to 3 criteria, delimited with comma.
As an example, you want to list boot priorities of automatically starting jails:
<pre><code>gocage list -o JID,Name,Config.Ip4_addr,Config.Priority,Config.Boot,Running -s -Config.Priority,-Config.Boot -f Running=true
<pre><code>
gocage list -o JID,Name,Config.Ip4_addr,Config.Priority,Config.Boot,Running -s -Config.Priority,-Config.Boot -f Running=true
+=====+==============+=======================+=================+=============+=========+
| JID | Name | Config.Ip4_addr | Config.Priority | Config.Boot | Running |
+=====+==============+=======================+=================+=============+=========+
@ -121,62 +118,39 @@ As an example, you want to list boot priorities of automatically starting jails:
+-----+--------------+-----------------------+-----------------+-------------+---------+
| 4 | coincoin | vnet0|192.168.1.9/24 | 20 | 0 | true |
+-----+--------------+-----------------------+-----------------+-------------+---------+
</code></pre>
</pre></code>
Stop jails
----------
<pre><code>gocage stop test</code></pre>
`gocage stop test`
Update jails
----------
To update jail patch version, use gocage update :
<pre><code>gocage update test</code></pre>
`gocage update test`
Update basejails/releases
----------
To update basejails, you need to update the release they are based on. Specify release with -r, and the datastore storing concerned release with -d :
<pre><code>gocage update -d fastgocage -r 14.1-RELEASE</code></pre>
Upgrade jails
----------
To upgrade jail to newer release, use gocage upgrade :
<pre><code>gocage upgrade -r 13.2-RELEASE test</code></pre>
A pre-upgrade snapshot wil be made so you can rollback if needed.
Upgrading basejail/release
----------
Upgrading basejails currently needs to be done manually, for each jail.
The idea is to stop the jail, change the content of its fstab file to point to the new release, then start jail.
If one change the fstab while the jail is running, its system directories won't be unmounted at stop time and this will provoke stop errors.
To minimize downtime, the change could be scripted:
<pre><code>gocage stop jail1
sed -i .bak 's/14.0-RELEASE/14.1-RELEASE/' /iocage/jails/jail1/fstab
# Avoid race-condition by waiting for the update in fstab
until grep -q 14.1-RELEASE /iocage/jails/jail1/fstab; do sleep 0.2; done
gocage start jail1
</code></pre>
You can now update ports.
Delete jails
----------
<pre><code>gocage destroy test</code></pre>
`gocage destroy test`
Multi datastore
----------
A datastore is a ZFS dataset mounted. It should be declared in gocage.conf.yml, specifying its ZFS mountpoint :
<pre><code>datastore:
<pre><code>
datastore:
- /iocage
- /fastiocage
</code></pre>
</pre></code>
In gocage commands, datastore name is the mountpoint without its "/" prefix.
### List datastores
<pre><code>gocage datastore list
<pre><code>
gocage datastore list
+============+=============+============+===========+==========+============+
| Name | Mountpoint | ZFSDataset | Available | Used | Referenced |
+============+=============+============+===========+==========+============+
@ -184,21 +158,23 @@ In gocage commands, datastore name is the mountpoint without its "/" prefix.
+------------+-------------+------------+-----------+----------+------------+
| fastiocage | /fastiocage | ssd/iocage | 1.5 TB | 65.3 KB | 34.6 KB |
+------------+-------------+------------+-----------+----------+------------+
</code></pre>
</pre></code>
### Filter datastores
As with jails and snapshots, you can filter by name:
<pre><code>gocage datastore list iocage
<pre><code>
gocage datastore list iocage
+============+=============+============+===========+==========+============+
| Name | Mountpoint | ZFSDataset | Available | Used | Referenced |
+============+=============+============+===========+==========+============+
| iocage | /iocage | hdd/iocage | 1.6 TB | 414.9 GB | 27.5 KB |
+------------+-------------+------------+-----------+----------+------------+
</code></pre>
</pre></code>
### Sort datastores
You can sort datastores:
<pre><code>gocage datastore list -s -Available
<pre><code>
gocage datastore list -s -Available
+============+=============+============+===========+==========+============+
| Name | Mountpoint | ZFSDataset | Available | Used | Referenced |
+============+=============+============+===========+==========+============+
@ -206,9 +182,9 @@ You can sort datastores:
+------------+-------------+------------+-----------+----------+------------+
| fastiocage | /fastiocage | ssd/iocage | 1.5 TB | 65.3 KB | 34.6 KB |
+------------+-------------+------------+-----------+----------+------------+
</code></pre>
</pre></code>
Use `gocage properties`to list available fields.
See [cmd/struct.go](https://git.nosd.in/yo/gocage/src/branch/master/cmd/struct.go) for field names.
Migrating jails
----------
@ -221,23 +197,27 @@ Be aware the moment you migrate a jail to another datastore than /iocage default
Then you need to disable iocage service, and enable gocage so the jails will start automatically at boot.
Also make sure, if you don't destroy source jail, that it won't have the "boot" property set or you will have the 2 jails up at boot.
<pre><code>gocage migrate -d fastiocage srv-random
<pre><code>
gocage migrate -d fastiocage srv-random
Snapshot data/iocage/jails/srv-random: Done
Snapshot data/iocage/jails/srv-random/root: Done
Migrate jail config dataset to fastdata/iocage/jails/srv-random: Done
Migrate jail filesystem dataset to fastdata/iocage/jails/srv-random/root: Done
</code></pre>
</pre></code>
Fetch
----------
Files can be fetched from custom repository, or from local directory with "from" option.
For example if you destroyed releases/12.3-RELEASE and still have the downloaded files in /iocage/download/12.3-RELEASE:
<pre><code>gocage fetch -r 12.3 -d iocage -f file:/iocage/download
</code></pre>
<pre><code>
gocage fetch -r 12.3 -o iocage --from file:/iocage/download
</pre></code>
TODO
----------
gocage create from templates
gocage upgrade
gocage create
gocage init
create default pool with defaults.json

11
TODO.md

@ -1,19 +1,8 @@
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

7
cmd/console.go

@ -12,7 +12,7 @@ import (
func ShellJail(args []string) error {
// We cant shell more than one jail bc we replace gocage execution with jexec, so there wont be no return to gocage
if len(args) > 0 {
cj, err := getJailFromArray(args[0], []string{"basejail", "jail"}, gJails)
cj, err := getJailFromArray(args[0], gJails)
if err != nil {
fmt.Printf("Error getting jail %s: %v\n", args[0], err)
return err
@ -30,9 +30,10 @@ func shellJail(jail *Jail) error {
if false == jail.Running {
return errors.New("Jail is not running")
}
jid := strconv.Itoa(jail.JID)
//err := syscall.Exec("/usr/sbin/jexec", []string{"jexec", jid, "/bin/csh"}, os.Environ())
err := syscall.Exec("/usr/sbin/jexec", []string{"jexec", jid, "login", "-f", "root"}, os.Environ())
// We should never get here, as syscall.Exec replace the gocage binary execution with jexec
@ -40,6 +41,6 @@ func shellJail(jail *Jail) error {
if err != nil {
log.Printf("Exec returned %v\n", err)
}
return nil
}

300
cmd/create.go

@ -1,300 +0,0 @@
package cmd
import (
"os"
"fmt"
//"log"
"time"
"errors"
"strings"
cp "github.com/otiai10/copy"
log "github.com/sirupsen/logrus"
)
// TODO : Add a flag to specify which parts of freebsd base we want : Slim jail only need base.txz, neither lib32 nor src.txz
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}
}
for _, jname := range args {
// Check if jail exist and is distinctly named
_, err = getJailFromArray(jname, jtype, gJails)
if err != nil {
if strings.EqualFold(err.Error(), "Jail not found") {
} else {
fmt.Printf("ERROR: %s\n", err.Error())
return
}
} else {
fmt.Printf("Jail exist: %s\n", jname)
continue
}
fmt.Printf(" > create jail %s\n", jname)
var ds *Datastore
if len(gCreateArgs.Datastore) > 0 {
log.Debugf("Use %s datastore\n", gCreateArgs.Datastore)
ds, err = getDatastoreFromArray(gCreateArgs.Datastore, gDatastores)
if err != nil {
fmt.Printf("ERROR Getting datastore: %s\n", gCreateArgs.Datastore, err.Error())
return
}
} else {
ds = &gDatastores[0]
}
// Get base template if specified
if gCreateArgs.BaseJail {
/**************************************************************************
* Create based jail from a template
*/
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)
err = zfsCreateDataset(dstDset, "", "")
if err != nil {
fmt.Printf("ERROR creating dataset %s: %s\n", dstDset, err.Error())
return
}
// Create jail root datasets
dstRootDset := fmt.Sprintf("%s/jails/%s/root", ds.ZFSDataset, jname)
fmt.Printf(" > Initialize dataset %s\n", dstRootDset)
err = zfsCreateDataset(dstRootDset, "", "")
if err != nil {
fmt.Printf("ERROR creating dataset %s: %s\n", dstRootDset, err.Error())
return
}
// Create needed directories with basejail permissions
fmt.Printf(" > Create base read-only directories\n")
dstRootDir := fmt.Sprintf("%s/jails/%s/root", ds.Mountpoint, jname)
for _, d := range append(gBaseDirs, gEmptyDirs...) {
dstPath := dstRootDir
srcPath := releasePath
for _, cd := range strings.Split(d, "/") {
srcPath = fmt.Sprintf("%s/%s", srcPath, cd)
dstPath = fmt.Sprintf("%s/%s", dstPath, cd)
_, err := os.Stat(dstPath)
if errors.Is(err, os.ErrNotExist) {
srcPerm, err := getPermissions(srcPath)
if err != nil {
fmt.Printf("ERROR getting permissions of %s: %s\n", srcPath, err.Error())
return
}
err = os.Mkdir(dstPath, srcPerm.Mode().Perm())
if err != nil {
fmt.Printf("ERROR creating directory %s: %s\n", dstPath, err.Error())
return
}
}
}
}
// Copy these from basejail
fmt.Printf(" > Create base writable directories\n")
for _, d := range gCopyDirs {
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", releasePath, d),
fmt.Sprintf("%s/%s", dstRootDir, d), err.Error())
return
}
}
///////////////////////////////////////////////////////////////////////
// Copy defaults.json...
jailConfPath := fmt.Sprintf("%s/jails/%s/config.json", ds.Mountpoint, jname)
err = copyFile(fmt.Sprintf("%s/defaults.json", ds.Mountpoint),
jailConfPath)
if err != nil {
fmt.Printf("ERROR creating config.json: %s\n", err.Error())
return
}
///////////////////////////////////////////////////////////////////////
// ... and update it
jailConf, err := getJailConfig(jailConfPath)
if err != nil {
log.Println("ERROR reading jail config from %s", jailConfPath)
}
// Build jail object from config
jailRootPath := fmt.Sprintf("%s/jails/%s/%s", ds.Mountpoint, jname, "root")
j := Jail{
Name: jailConf.Host_hostuuid,
Config: jailConf,
ConfigPath: jailConfPath,
Datastore: ds.Name,
RootPath: jailRootPath,
Running: false,
}
// We need to store the basejail template. We could :
// 1. Use "origin" ?
// 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 = gCreateArgs.Release
j.Config.Host_hostname = jname
j.Config.Host_hostuuid = jname
j.WriteConfigToDisk(false)
///////////////////////////////////////////////////////////////////////
// Create fstab
fstabHandle, err := os.Create(fmt.Sprintf("%s/jails/%s/fstab", ds.Mountpoint, jname))
if err != nil {
fmt.Printf("ERROR creating fstab: %s", err.Error())
return
}
defer fstabHandle.Close()
for _, d := range gBaseDirs {
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")
} else {
/**************************************************************************
* Create normal jail with its own freebsd base
*/
log.Debugf("Creating jail with its own freebsd base\n")
// First check if we got release on the same datastore
_, err := os.Stat(fmt.Sprintf("%s/releases/%s/root", ds.Mountpoint, gCreateArgs.Release))
if os.IsNotExist(err) {
fmt.Printf("ERROR: Release locally not available. Run \"gocage fetch\"\n")
return
}
///////////////////////////////////////////////////////////////////////
// Create and populate jail filesystem from release
dstDset := fmt.Sprintf("%s/jails/%s", ds.ZFSDataset, jname)
fmt.Printf(" > Initialize dataset %s\n", dstDset)
sNow := time.Now().Format("20060102150405")
reldset := fmt.Sprintf("%s/releases/%s", ds.ZFSDataset, gCreateArgs.Release)
err = zfsSnapshot(reldset, sNow)
if err != nil {
fmt.Printf("ERROR Creating snapshot of %s: %s\n", reldset, err.Error())
return
}
err = zfsCopy(fmt.Sprintf("%s@%s", reldset, sNow), dstDset)
if err != nil {
fmt.Printf("ERROR sending snapshot to %s: %s\n", dstDset, err.Error())
return
}
// Remove snapshot of release, then snapshot of destination dataset
err = zfsDestroy(fmt.Sprintf("%s@%s", reldset, sNow))
if err != nil {
fmt.Printf("ERROR destroying snapshot %s: %s\n", reldset, err.Error())
return
}
err = zfsDestroy(fmt.Sprintf("%s@%s", dstDset, sNow))
if err != nil {
fmt.Printf("ERROR destroying snapshot %s: %s\n", dstDset, err.Error())
return
}
dstRootDset := fmt.Sprintf("%s/jails/%s/root", ds.ZFSDataset, jname)
fmt.Printf(" > Initialize dataset %s\n", dstRootDset)
relrootdset := fmt.Sprintf("%s/releases/%s/root", ds.ZFSDataset, gCreateArgs.Release)
err = zfsSnapshot(relrootdset, sNow)
if err != nil {
fmt.Printf("ERROR Creating snapshot of %s: %s\n", relrootdset, err.Error())
return
}
err = zfsCopy(fmt.Sprintf("%s@%s", relrootdset, sNow), dstRootDset)
if err != nil {
fmt.Printf("ERROR sending snapshot to %s: %s\n", dstRootDset, err.Error())
return
}
// Remove snapshot of release, then snapshot of destination dataset
err = zfsDestroy(fmt.Sprintf("%s@%s", relrootdset, sNow))
if err != nil {
fmt.Printf("ERROR destroying snapshot %s: %s\n", relrootdset, err.Error())
return
}
err = zfsDestroy(fmt.Sprintf("%s@%s", dstRootDset, sNow))
if err != nil {
fmt.Printf("ERROR destroying snapshot %s: %s\n", dstRootDset, err.Error())
return
}
///////////////////////////////////////////////////////////////////////
// Copy defaults.json...
jailConfPath := fmt.Sprintf("%s/jails/%s/config.json", ds.Mountpoint, jname)
err = copyFile(fmt.Sprintf("%s/defaults.json", ds.Mountpoint),
jailConfPath)
if err != nil {
fmt.Printf("ERROR creating config.json: %s\n", err.Error())
return
}
///////////////////////////////////////////////////////////////////////
// ... and update it
jailConf, err := getJailConfig(jailConfPath)
if err != nil {
log.Println("ERROR reading jail config from %s", jailConfPath)
}
// Build jail object from config
jailRootPath := fmt.Sprintf("%s/jails/%s/%s", ds.Mountpoint, jname, "root")
j := Jail{
Name: jailConf.Host_hostuuid,
Config: jailConf,
ConfigPath: jailConfPath,
Datastore: ds.Name,
RootPath: jailRootPath,
Running: false,
}
j.Config.Release = gCreateArgs.Release
j.Config.Host_hostname = jname
j.Config.Host_hostuuid = jname
j.Config.Jailtype = "jail"
j.WriteConfigToDisk(false)
///////////////////////////////////////////////////////////////////////
// Create fstab
fstabHandle, err := os.Create(fmt.Sprintf("%s/jails/%s/fstab", ds.Mountpoint, jname))
if err != nil {
fmt.Printf("ERROR creating fstab: %s", err.Error())
return
}
defer fstabHandle.Close()
fmt.Printf(" > Jail created!\n")
}
var cmdline []string
for _, props := range strings.Split(gCreateArgs.Properties, ",") {
cmdline = append(cmdline, props)
}
// Reload jail list so SetJailProperties will see it
ListJails(nil, false)
cmdline = append(cmdline, jname)
log.Debugf("cmdline: \"%v\"", cmdline)
SetJailProperties(cmdline)
}
}

12
cmd/destroy.go

@ -3,14 +3,13 @@ package cmd
import (
"fmt"
//"log"
"time"
//"errors"
"strings"
)
func DestroyJails(args []string) {
for _, a := range args {
cj, err := getJailFromArray(a, []string{""}, gJails)
cj, err := getJailFromArray(a, gJails)
if err != nil {
fmt.Printf("Error getting jail: %s\n", err)
return
@ -28,8 +27,6 @@ func DestroyJails(args []string) {
}
fmt.Printf("Stopping jail %s\n", cj.Name)
StopJail([]string{fmt.Sprintf("%s/%s", cj.Datastore, cj.Name)})
// Give some time to the host OS to free all mounts accessing processes
time.Sleep(1 * time.Second)
}
// Get root and config datasets, then destroy
@ -38,7 +35,7 @@ func DestroyJails(args []string) {
fmt.Printf("Error getting root dataset: %s\n", err)
return
}
//fmt.Printf("DEBUG: Prepare to zfs destroy %s\n", dsRootName)
fmt.Printf("DEBUG: Prepare to zfs destroy %s\n", dsRootName)
if err = zfsDestroy(dsRootName); err != nil {
fmt.Printf("Error deleting root dataset: %s\n", err)
return
@ -49,11 +46,12 @@ func DestroyJails(args []string) {
fmt.Printf("Error getting config dataset: %s\n", err)
return
}
//fmt.Printf("DEBUG: Prepare to zfs destroy %s\n", dsConfName)
fmt.Printf("DEBUG: Prepare to zfs destroy %s\n", dsConfName)
if err = zfsDestroy(dsConfName); err != nil {
fmt.Printf("Error deleting config dataset: %s\n", err)
return
}
fmt.Printf("Jail %s is no more!\n", cj.Name)
//TODO: Delete jail named directory
}
}

138
cmd/fetch.go

@ -23,9 +23,7 @@ const (
)
var (
// TODO : Make this a config/cmd line setting
//FetchFiles = []string{"base.txz", "lib32.txz", "src.txz"}
FetchFiles = []string{"base.txz"}
FetchFiles = []string{"base.txz", "lib32.txz", "src.txz"}
)
// TODO: Check if files already exist
@ -68,9 +66,9 @@ func fetchRelease(release string, proto string, arch string, datastore string, f
}
}
// Create download/XX.X dataset if necessary
thisDownloadDsName := fmt.Sprintf("%s/%s", downloadDsName, release)
thisDownloadDsMountPoint := fmt.Sprintf("%s/%s", downloadDsMountPoint, release)
// Create download/XX.X-RELEASE dataset if necessary
thisDownloadDsName := fmt.Sprintf("%s/%s-RELEASE", downloadDsName, release)
thisDownloadDsMountPoint := fmt.Sprintf("%s/%s-RELEASE", downloadDsMountPoint, release)
exist, err = doZfsDatasetExist(thisDownloadDsName)
if err != nil {
return fmt.Errorf("Error accessing dataset %s: %v\n", thisDownloadDsName, err)
@ -84,9 +82,9 @@ func fetchRelease(release string, proto string, arch string, datastore string, f
var fetchUrl string
if len(fetchFrom) > 0 {
fetchUrl = fmt.Sprintf("%s/%s", fetchFrom, release)
fetchUrl = fmt.Sprintf("%s/%s-RELEASE", fetchFrom, release)
} else {
fetchUrl = fmt.Sprintf("%s://%s/%s/%s/%s", proto, ReleaseServer, ReleaseRootDir, arch, release)
fetchUrl = fmt.Sprintf("%s://%s/%s/%s/%s-RELEASE", proto, ReleaseServer, ReleaseRootDir, arch, release)
}
log.Debugf("FetchURL = %s", fetchUrl)
@ -155,9 +153,9 @@ func extractRelease(release string, datastore string) {
}
}
// Create releases/XX.X dataset if necessary
thisReleaseDsName := fmt.Sprintf("%s/%s", releaseDsName, release)
thisReleaseDsMountPoint := fmt.Sprintf("%s/%s", releaseDsMountPoint, release)
// Create releases/XX.X-RELEASE dataset if necessary
thisReleaseDsName := fmt.Sprintf("%s/%s-RELEASE", releaseDsName, release)
thisReleaseDsMountPoint := fmt.Sprintf("%s/%s-RELEASE", releaseDsMountPoint, release)
exist, err = doZfsDatasetExist(thisReleaseDsName)
if err != nil {
fmt.Printf("Error accessing dataset %s: %v\n", thisReleaseDsName, err)
@ -171,7 +169,7 @@ func extractRelease(release string, datastore string) {
}
}
// Create releases/XX.X/root dataset if necessary
// Create releases/XX.X-RELEASE/root dataset if necessary
thisReleaseRootDsName := fmt.Sprintf("%s/root", thisReleaseDsName)
thisReleaseRootDsMountPoint := fmt.Sprintf("%s/root", thisReleaseDsMountPoint)
exist, err = doZfsDatasetExist(thisReleaseRootDsName)
@ -187,9 +185,9 @@ func extractRelease(release string, datastore string) {
}
}
// Now extract download/$RELEASE/*.txz to releases/XX.X/root
// Now extract download/$RELEASE/*.txz to releases/XX.X-RELEASE/root
downloadDsMountPoint := fmt.Sprintf("%s/download", ds.Mountpoint)
downloadDir := fmt.Sprintf("%s/%s", downloadDsMountPoint, release)
downloadDir := fmt.Sprintf("%s/%s-RELEASE", downloadDsMountPoint, release)
d, err := os.Open(downloadDir)
defer d.Close()
@ -203,70 +201,68 @@ func extractRelease(release string, datastore string) {
return
}
// Extract every .txz files in FetchFiles
// Extract every .txz files
for _, fi := range files {
if false == fi.IsDir() {
if strings.HasSuffix(fi.Name(), ".txz") {
if isStringInArray(FetchFiles, fi.Name()) {
ar := fmt.Sprintf("%s/%s", downloadDir, fi.Name())
fmt.Printf("Extracting file %s to %s... ", ar, thisReleaseRootDsMountPoint)
// pure Go method, sorry this is so slow. Also I did not handle permissions in this
/* f, err := os.Open(ar)
defer f.Close()
ar := fmt.Sprintf("%s/%s", downloadDir, fi.Name())
fmt.Printf("Extracting file %s... ", ar)
// pure Go method, sorry this is so slow. Also I did not handle permissions in this
/* f, err := os.Open(ar)
defer f.Close()
if err != nil {
fmt.Printf("Can not open %s: %v\n", ar, err)
return
}
// xz reader
r, err := xz.NewReader(f)
if err != nil {
fmt.Printf("Can not read %s: %v\n", ar, err)
return
}
// tar reader
tr := tar.NewReader(r)
// Iterate through the files in the archive.
for {
hdr, err := tr.Next()
if err == io.EOF {
// end of tar archive
break
}
if err != nil {
fmt.Printf("Can not open %s: %v\n", ar, err)
return
log.Fatal(err)
}
// xz reader
r, err := xz.NewReader(f)
if err != nil {
fmt.Printf("Can not read %s: %v\n", ar, err)
return
}
// tar reader
tr := tar.NewReader(r)
// Iterate through the files in the archive.
for {
hdr, err := tr.Next()
if err == io.EOF {
// end of tar archive
break
}
if err != nil {
log.Fatal(err)
}
switch hdr.Typeflag {
case tar.TypeDir:
// create a directory
dest := fmt.Sprintf("%s/%s", thisReleaseRootDsMountPoint, hdr.Name)
// FIXME: Access rights?
err = os.MkdirAll(dest, 0777)
if err != nil {
log.Fatal(err)
}
case tar.TypeReg, tar.TypeRegA:
// write a file
dest := fmt.Sprintf("%s/%s", thisReleaseRootDsMountPoint, hdr.Name)
w, err := os.Create(dest)
defer w.Close()
if err != nil {
log.Fatal(err)
}
_, err = io.Copy(w, tr)
if err != nil {
log.Fatal(err)
}
}
}
*/
cmd := fmt.Sprintf("/usr/bin/tar xpf %s -C %s", ar, thisReleaseRootDsMountPoint)
out, err := executeCommand(cmd)
if err != nil && len(out) > 0 {
fmt.Printf("Error: %v: %s\n", err, out)
} else {
fmt.Printf("Done\n")
switch hdr.Typeflag {
case tar.TypeDir:
// create a directory
dest := fmt.Sprintf("%s/%s", thisReleaseRootDsMountPoint, hdr.Name)
// FIXME: Access rights?
err = os.MkdirAll(dest, 0777)
if err != nil {
log.Fatal(err)
}
case tar.TypeReg, tar.TypeRegA:
// write a file
dest := fmt.Sprintf("%s/%s", thisReleaseRootDsMountPoint, hdr.Name)
w, err := os.Create(dest)
defer w.Close()
if err != nil {
log.Fatal(err)
}
_, err = io.Copy(w, tr)
if err != nil {
log.Fatal(err)
}
}
}
*/
cmd := fmt.Sprintf("/usr/bin/tar xpf %s -C %s", ar, thisReleaseRootDsMountPoint)
out, err := executeCommand(cmd)
if err != nil && len(out) > 0 {
fmt.Printf("Error: %v: %s\n", err, out)
} else {
fmt.Printf("Done\n")
}
}
}
}

153
cmd/init.go

@ -1,153 +0,0 @@
package cmd
import (
"os"
"fmt"
"strings"
"github.com/spf13/viper"
log "github.com/sirupsen/logrus"
)
/********************************************************************************
* Initialize datastore(s) /iocage, /iocage/jails
* Put defaults.json,
* Update it with hostid, interfaces, and maybe other necessary fields
* Initialize bridge
*******************************************************************************/
func InitGoCage(args []string) {
// Create datastores
for _, dstore := range viper.GetStringSlice("datastore") {
log.Debugf("Ranging over %v\n", dstore)
dset, err := zfsGetDatasetByMountpoint(dstore)
if err != nil && strings.HasSuffix(err.Error(), "No such file or directory\"") {
if len(gZPool) == 0 {
log.Errorf("Datastore mountpoint \"%s\" does not exist. Specify a pool if you want to create it.", dstore)
return
}
// Create dataset /iocage
rootDSName := fmt.Sprintf("%s%s", gZPool, dstore)
log.Debugf("Creating dataset %s mounted on %s\n", rootDSName, dstore)
if err = zfsCreateDataset(rootDSName, dstore, ""); err != nil {
log.Errorf("Error creating dataset %s: %v\n", rootDSName, err)
return
}
// Create /iocage/jail, releases, templates
for _, l := range []string{"jails","releases","templates"} {
cds := fmt.Sprintf("%s/%s", rootDSName, l)
cmp := fmt.Sprintf("%s/%s", dstore, l)
log.Debugf("Creating dataset %s mounted on %s\n", cds, cmp)
if err = zfsCreateDataset(cds, cmp, ""); err != nil {
log.Errorf("Error creating dataset %s: %v\n", cds, err)
return
}
}
// Create /iocage/defaults.json
exists, err := doFileExist(fmt.Sprintf("%s/defaults.json", dstore))
if err != nil {
log.Errorf("Error checking defaults.json: %v\n", err)
return
}
if !exists {
if err = createDefaultsJson(dstore, gBridge); err != nil {
log.Errorf("%v\n", err)
}
}
} else if err != nil {
log.Errorf("Error checking datastore existence: %v\n", err)
return
} else {
log.Debugf("Datastore dataset exist: %s\n", dset)
}
}
// Check and create bridge
// FIXME: What if bridge name is invalid, as we already wrote it in defaults.json in dstore loop?
if len(gBridge) > 0 && len(gInterface) > 0 {
if err := initBridge(); err != nil {
log.Errorf("%v\n", err)
}
}
}
func createDefaultsJson(rootDirectory string, bridge string) error {
hostid, err := os.ReadFile("/etc/hostid")
if err != nil {
log.Fatalf("Unable to read /etc/hostid: %v\n", err)
}
json := strings.Replace(gDefaultsJson, "TO-BE-REPLACED-WITH-HOSTID", strings.Trim(string(hostid), "\n"), 1)
json = strings.Replace(json, "TO-BE-REPLACED-WITH-BRIDGE", bridge, 1)
if err := os.WriteFile(fmt.Sprintf("%s/defaults.json", rootDirectory), []byte(json), 0640); err != nil {
log.Fatal(err)
}
return nil
}
func createInterface(iface string) error {
log.Debugf("creating interface \"%s\"\n", iface)
cmd := fmt.Sprintf("/sbin/ifconfig %s create", iface)
_, err := executeCommand(cmd)
if err != nil {
return err
}
return nil
}
func bringUpInterface(iface string) error {
log.Debugf("bringing up interface \"%s\"\n", iface)
cmd := fmt.Sprintf("/sbin/ifconfig %s up", iface)
_, err := executeCommand(cmd)
if err != nil {
return err
}
return nil
}
func addMemberToBridge(bridge string, iface string) error {
log.Debugf("adding member interface \"%s\" to bridge \"%s\"\n", iface, bridge)
cmd := fmt.Sprintf("/sbin/ifconfig %s addm %s", bridge, iface)
_, err := executeCommand(cmd)
if err != nil {
return err
}
return nil
}
func initBridge() error {
hostInt, err := gJailHost.GetInterfaces()
if err != nil {
return fmt.Errorf("Error listing interfaces: %v\n", err)
}
if !isStringInArray(hostInt, gInterface) {
return fmt.Errorf("Interface not found: %s\n", gInterface)
}
if !isStringInArray(hostInt, gBridge) {
if err := createInterface(gBridge); err != nil {
return fmt.Errorf("Error creating bridge: %v\n", err)
}
if err := bringUpInterface(gBridge); err != nil {
return fmt.Errorf("Error bringing up bridge: %v\n", err)
}
log.Infof("bridge was created, but it won't persist reboot. Configure rc.conf to persist. See https://docs.freebsd.org/en/books/handbook/advanced-networking/#network-bridging\n")
log.Infof("It is strongly suggested you move interface %s IP to bridge %s\n", gInterface, gBridge)
}
// FIXME: Need to check if not already member
members, err := getBridgeMembers(gBridge)
if err != nil {
return fmt.Errorf("Error getting bridge members: %v\n", err)
}
// Return if interface already member of the bridge
for _, m := range members {
log.Debugf("Bridge member: %s\n", m)
if strings.EqualFold(m, gInterface) {
return nil
}
}
if err := addMemberToBridge(gBridge, gInterface); err != nil {
return fmt.Errorf("Error adding interface to bridge: %v\n", err)
}
return nil
}

26
cmd/jailhost.go

@ -4,6 +4,7 @@ import (
"fmt"
"net"
"regexp"
"strconv"
"strings"
"io/ioutil"
"golang.org/x/net/route"
@ -189,17 +190,34 @@ func getArch() (string, error) {
func getFreeBSDVersion() (FreeBSDVersion, error) {
var version FreeBSDVersion
regex := `([0-9]{1,2})(\.)?([0-9]{1,2})?\-([^\-]*)(\-)?(p[0-9]{1,2})?`
re := regexp.MustCompile(regex)
out, err := executeCommand("/bin/freebsd-version")
if err != nil {
return version, fmt.Errorf("Error executing \"/bin/freebsd-version\": %v", err)
}
version, err = freebsdVersionToStruct(out)
if err != nil {
return version, err
if re.MatchString(out) {
version.major, err = strconv.Atoi(re.FindStringSubmatch(out)[1])
if err != nil {
return version, err
}
version.minor, err = strconv.Atoi(re.FindStringSubmatch(out)[3])
if err != nil {
return version, err
}
version.flavor = strings.Trim(re.FindStringSubmatch(out)[4], "\n")
// Skip the 'p' starting patch level
if len(re.FindStringSubmatch(out)[6]) > 0 {
version.patchLevel, err = strconv.Atoi(re.FindStringSubmatch(out)[6][1:])
if err != nil {
return version, err
}
}
}
return version, nil
}

25
cmd/list.go

@ -52,7 +52,7 @@ func ListJails(args []string, display bool) {
for _, ds := range gDatastores {
listJailsFromDatastore(ds, args, display)
}
// Only when displaying jails, we accept to process multiple same name jails
if false == display {
for _, j := range gJails {
@ -68,11 +68,11 @@ func ListJails(args []string, display bool) {
break
}
}
if true == skip {
continue
}
// Initialize if not found in nameChecked
if false == found {
curCheck = &uniqueJailName{jail: j.Name,
@ -81,11 +81,11 @@ func ListJails(args []string, display bool) {
} else {
found = false
}
if countOfJailsWithThisName(j.Name) > 1 {
//fmt.Printf("DEBUG: Jail %s exist multiple times, now checking if specified with full name\n", j.Name)
curCheck.unique = false
for _, a := range args {
//fmt.Printf("DEBUG: comparing %s/%s with %s\n", j.Datastore, j.Name, a)
if strings.EqualFold(a, fmt.Sprintf("%s/%s", j.Datastore, j.Name)) {
@ -96,7 +96,7 @@ func ListJails(args []string, display bool) {
}
nameChecked = append(nameChecked, curCheck)
}
// Now check
for _, a := range args {
for _, n := range nameChecked {
@ -107,9 +107,9 @@ func ListJails(args []string, display bool) {
}
}
}
fields := strings.Split(gDisplayJColumns, ",")
// This is the structure we will filter, then display
var jails []Jail
@ -249,7 +249,7 @@ func listJailsFromDirectory(dir string, dsname string) ([]Jail, error) {
jailConfPath := fmt.Sprintf("%s/%s/%s", dir, fi.Name(), "config.json")
jailConf, err := getJailConfig(jailConfPath)
if err != nil {
fmt.Printf("ERROR reading jail config from %s\n", jailConfPath)
log.Println("ERROR reading jail config for %s", jailConfPath)
}
// 2. Build jail object from config
@ -275,13 +275,6 @@ func listJailsFromDirectory(dir string, dsname string) ([]Jail, error) {
// FIXME ??? Shouldn't be ioc-$Name ?
j.InternalName = rj.Name
j.Devfs_ruleset = rj.Devfs_ruleset
// Update release
r, err := getVersion(&j)
if err != nil {
fmt.Printf("ERROR getting jail %s version: %s\n", j.Name, err.Error())
} else {
j.Config.Release = r
}
break
}
}

4
cmd/migrate.go

@ -26,7 +26,7 @@ func MigrateJail(args []string) {
}
for _, jn := range jailNames {
cj, err := getJailFromArray(jn, []string{""}, gJails)
cj, err := getJailFromArray(jn, gJails)
if cj == nil {
fmt.Printf("Error getting jail %s: Not found\n", jn)
return
@ -177,7 +177,7 @@ func CleanMigrateMess(args []string) error {
}
for _, jn := range jailNames {
cj, err := getJailFromArray(jn, []string{""}, gJails)
cj, err := getJailFromArray(jn, gJails)
if cj == nil {
return errors.New(fmt.Sprintf("Error getting jail %s: Not found\n", jn))
}

34
cmd/properties.go

@ -1,9 +1,8 @@
package cmd
import (
"os"
"fmt"
"errors"
"fmt"
"reflect"
"strconv"
"strings"
@ -18,10 +17,10 @@ func GetJailProperties(args []string) {
for i, a := range args {
// Last arg is the jail name
if i == len(args)-1 {
jail, err = getJailFromArray(a, []string{""}, gJails)
jail, err = getJailFromArray(a, gJails)
if err != nil {
fmt.Printf("Error: %s\n", err.Error())
os.Exit(1)
return
}
} else {
props = append(props, a)
@ -106,20 +105,19 @@ func SetJailProperties(args []string) {
return
}
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)
// 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
}
}
}
}
cj.WriteConfigToDisk(false)
}

217
cmd/root.go

@ -6,6 +6,7 @@ import (
"sync"
"strings"
"io/ioutil"
"encoding/json"
"github.com/spf13/cobra"
"github.com/spf13/viper"
@ -14,20 +15,12 @@ import (
)
const (
gVersion = "0.42h"
gVersion = "0.35"
// TODO : Get from $jail_zpool/defaults.json
MIN_DYN_DEVFS_RULESET = 1000
)
type createArgs struct {
Release string
BaseJail bool
Datastore string
JailType string
Properties string
}
var (
gJailHost JailHost
gJails []Jail
@ -36,8 +29,6 @@ var (
gUseSudo bool
gForce bool
gDebug bool
gCreateArgs createArgs
gConfigFile string
gDisplayJColumns string
@ -52,15 +43,11 @@ var (
gNoJailLineSep bool
gNoSnapLineSep bool
gNoDSLineSep bool
gBridgeStaticMac bool
gHostVersion float64
gTimeZone string
gSnapshotName string
gZPool string
gBridge string
gInterface string
gMigrateDestDatastore string
gYesToAll bool
@ -68,17 +55,6 @@ var (
gFetchRelease string
gFetchIntoDS string
gFetchFrom string
gUpgradeRelease string
gUpdateRelease string
gUpdateReleaseDS string
// For a based jail, these are directories binded to basejail
gBaseDirs = []string{"bin", "boot", "lib", "libexec", "rescue", "sbin", "usr/bin", "usr/include",
"usr/lib", "usr/lib32", "usr/libdata", "usr/libexec", "usr/sbin", "usr/share"}
// These directories are to be created empty
gEmptyDirs = []string{"dev", "media", "mnt", "net", "proc"}
// Copy these from base template
gCopyDirs = []string{"etc", "root", "tmp", "var"}
gMdevfs sync.Mutex
@ -100,19 +76,7 @@ It support iocage jails and can coexist with iocage.`,
Long: `Let this show you how much fail I had to get this *cough* perfect`,
Run: func(cmd *cobra.Command, args []string) {
fv, _ := getFreeBSDVersion()
if fv.patchLevel > 0 {
fmt.Printf("GoCage v.%s on FreeBSD %d.%d-%s-p%d\n", gVersion, fv.major, fv.minor, fv.flavor, fv.patchLevel)
} else {
fmt.Printf("GoCage v.%s on FreeBSD %d.%d-%s\n", gVersion, fv.major, fv.minor, fv.flavor)
}
},
}
initCmd = &cobra.Command{
Use: "init",
Short: "Initialize GoCage",
Run: func(cmd *cobra.Command, args []string) {
InitGoCage(args)
fmt.Printf("GoCage v.%s on FreeBSD %d.%d-%s\n", gVersion, fv.major, fv.minor, fv.flavor)
},
}
@ -172,9 +136,12 @@ ex: gocage list srv-db srv-web`,
} else {
StartJail(args)
}
WriteConfigToDisk("", false, false)
},
}
restartCmd = &cobra.Command{
Use: "restart",
Short: "restart jail",
@ -183,9 +150,10 @@ ex: gocage list srv-db srv-web`,
ListJails(args, false)
StopJail(args)
StartJail(args)
WriteConfigToDisk("", false, false)
},
}
shellCmd = &cobra.Command {
Use: "console",
Short: "Execute shell on jail",
@ -195,7 +163,7 @@ ex: gocage list srv-db srv-web`,
ShellJail(args)
},
}
setCmd = &cobra.Command{
Use: "set",
Short: "Set a jail property",
@ -205,6 +173,7 @@ Multiples properties can be specified, separated with space (Ex: gocage set allo
// Load inventory
ListJails(args, false)
SetJailProperties(args)
WriteConfigToDisk("", true, false)
},
}
@ -286,6 +255,7 @@ You can specify multiple jails.`,
// Load inventory
ListJails(args, false)
MigrateJail(args)
WriteConfigToDisk("", false, false)
},
}
@ -321,7 +291,7 @@ You can specify multiple datastores.`,
ListDatastores(args, true)
},
}
fetchCmd = &cobra.Command{
Use: "fetch",
Short: "Fetch FreeBSD release to local datastore",
@ -332,36 +302,18 @@ You can specify multiple datastores.`,
} else {
extractRelease(gFetchRelease, gFetchIntoDS)
}
},
},
}
updateCmd = &cobra.Command{
UpdateCmd = &cobra.Command{
Use: "update",
Short: "Update FreeBSD release",
Run: func(cmd *cobra.Command, args []string) {
ListJails(args, false)
UpdateJail(args)
},
Short: "Update FreeBSD release",
Run: func(cmd *cobra.Command, args []string) {
ListJails(args, false)
UpdateJail(args)
},
}
upgradeCmd = &cobra.Command{
Use: "upgrade",
Short: "Upgrade FreeBSD release",
Run: func(cmd *cobra.Command, args []string) {
ListJails(args, false)
UpgradeJail(args)
},
}
createCmd = &cobra.Command{
Use: "create",
Short: "Create jail",
Run: func(cmd *cobra.Command, args []string) {
ListJails(args, false)
CreateJail(args)
},
}
testCmd = &cobra.Command{
Use: "test",
Short: "temporary command to test some code snippet",
@ -374,7 +326,7 @@ You can specify multiple datastores.`,
// TODO : Init log level and log output
func init() {
var err error
cobra.OnInitialize(initConfig)
// Global switches
@ -384,11 +336,6 @@ func init() {
rootCmd.PersistentFlags().BoolVar(&gDebug, "debug", false, "Debug mode")
// Command dependant switches
initCmd.Flags().StringVarP(&gZPool, "pool", "p", "", "ZFS pool to create datastore on")
initCmd.Flags().StringVarP(&gBridge, "bridge", "b", "", "bridge to create for jails networking")
initCmd.Flags().StringVarP(&gInterface, "interface", "i", "", "interface to add as bridge member. This should be your main interface")
initCmd.MarkFlagRequired("bridge")
initCmd.MarkFlagsRequiredTogether("bridge", "interface")
// We reuse these flags in "gocage snapshot list myjail" and 'gocage datastore list" commands
listCmd.Flags().StringVarP(&gDisplayJColumns, "outcol", "o", "JID,Name,Config.Release,Config.Ip4_addr,Running", "Show these columns in output")
@ -402,12 +349,12 @@ func init() {
snapshotListCmd.Flags().BoolVarP(&gNoSnapLineSep, "nolinesep", "l", false, "Do not display line separator between snapshots")
snapshotListCmd.Flags().StringVarP(&gFilterSnaps, "filter", "f", "none", "Only display snapshots with these values. Ex: \"gocage snapshot list -f Config.Boot=1\" will only list started on boot jails")
snapshotListCmd.Flags().StringVarP(&gSortSnapFields, "sort", "s", "none", "Display snapshots sorted by field values. Ex: \"gocage snapshot list -s +Jailname,-Used\" will sort snapshots by jail decreasing name, then increasing used space. 3 critera max supported.")
datastoreListCmd.Flags().StringVarP(&gDisplayDColumns, "outcol", "o", "Name,Mountpoint,ZFSDataset,Available,Used,Referenced", "Show these columns in output")
datastoreListCmd.Flags().BoolVarP(&gNoDSLineSep, "nolinesep", "l", false, "Do not display line separator between datastores")
datastoreListCmd.Flags().StringVarP(&gFilterDS, "filter", "f", "none", "Only display datastores with these values. Ex: \"gocage datastore list -f Config.Boot=1\" will only list started on boot jails")
datastoreListCmd.Flags().StringVarP(&gSortDSFields, "sort", "s", "none", "Display datastores sorted by field values. Ex: \"gocage datastore list -s +Jailname,-Used\" will sort snapshots by jail decreasing name, then increasing used space. 3 critera max supported.")
// This is local flag : Only available to gocage snapshot create command
snapshotCreateCmd.Flags().StringVarP(&gSnapshotName, "snapname", "n", "", "Name of the snapshot to create")
snapshotCreateCmd.MarkFlagRequired("snapname")
@ -419,30 +366,18 @@ func init() {
migrateCmd.Flags().StringVarP(&gMigrateDestDatastore, "datastore", "d", "", "Path of destination datastore for jail (Ex: \"/iocage\")")
migrateCmd.Flags().BoolVarP(&gYesToAll, "yes", "y", false, "Answer yes to all questions")
migrateCmd.MarkFlagRequired("datastore")
fetchCmd.Flags().StringVarP(&gFetchRelease, "release", "r", "", "Release to fetch (e.g.: \"13.1-RELEASE\"")
fetchCmd.Flags().StringVarP(&gFetchIntoDS, "datastore", "d", "", "Datastore release will be saved to")
fetchCmd.Flags().StringVarP(&gFetchFrom, "from", "f", "", "Repository to download from. Should contain XY.Z-RELEASE. File protocol supported")
fetchCmd.Flags().StringVarP(&gFetchRelease, "release", "r", "", "Release to fetch (e.g.: \"13.1\"")
fetchCmd.Flags().StringVarP(&gFetchIntoDS, "datastore", "o", "", "Datastore release will be saved to")
fetchCmd.Flags().StringVarP(&gFetchFrom, "from", "d", "", "Repository to download from. Should contain XY.Z-RELEASE. File protocol supported")
fetchCmd.MarkFlagRequired("release")
fetchCmd.MarkFlagRequired("datastore")
upgradeCmd.Flags().StringVarP(&gUpgradeRelease, "release", "r", "", "Release to upgrade to (e.g.: \"13.1-RELEASE\"")
upgradeCmd.MarkFlagRequired("release")
updateCmd.Flags().StringVarP(&gUpdateRelease, "release", "r", "", "Release to update (e.g.: \"13.1-RELEASE\"")
updateCmd.Flags().StringVarP(&gUpdateReleaseDS, "datastore", "d", "", "Datastore release is stored on")
updateCmd.MarkFlagsRequiredTogether("release", "datastore")
createCmd.Flags().StringVarP(&gCreateArgs.Release, "release", "r", "", "Release for the jail (e.g.: \"13.1-RELEASE\"")
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.")
createCmd.Flags().StringVarP(&gCreateArgs.Properties, "configuration", "p", "", "Configuration properties with format k1=v1,k2=v2 (Ex: \"Config.Ip4_addr=vnet0|192.168.1.2,Config.Ip6=none\")")
// Now declare commands
rootCmd.AddCommand(initCmd)
rootCmd.AddCommand(versionCmd)
rootCmd.AddCommand(listCmd)
rootCmd.AddCommand(listPropsCmd)
listCmd.AddCommand(listPropsCmd)
rootCmd.AddCommand(stopCmd)
rootCmd.AddCommand(startCmd)
rootCmd.AddCommand(restartCmd)
@ -454,9 +389,8 @@ func init() {
rootCmd.AddCommand(migrateCmd)
rootCmd.AddCommand(datastoreCmd)
rootCmd.AddCommand(fetchCmd)
rootCmd.AddCommand(updateCmd)
rootCmd.AddCommand(upgradeCmd)
rootCmd.AddCommand(createCmd)
rootCmd.AddCommand(UpdateCmd)
rootCmd.AddCommand(testCmd)
snapshotCmd.AddCommand(snapshotListCmd)
@ -486,6 +420,17 @@ func initConfig() {
fmt.Printf("ERROR reading config file %s : %s\n", gConfigFile, err.Error())
os.Exit(1)
}
// Load default configs from datastores
err := ListDatastores(viper.GetStringSlice("datastore"), false)
if err != nil {
fmt.Printf("ERROR: error checking datastores: %v\n", err)
os.Exit(1)
}
// fmt.Println("Using config file:", viper.ConfigFileUsed())
// fmt.Printf("datastore in config : %s\n", viper.GetStringSlice("datastore"))
// fmt.Printf("datastore.0 in config : %s\n", viper.GetStringSlice("datastore.0"))
// Command line flags have priority on config file
if rootCmd.Flags().Lookup("sudo") != nil && false == rootCmd.Flags().Lookup("sudo").Changed {
@ -519,28 +464,72 @@ func initConfig() {
fmt.Printf("More than 3 sort criteria is not supported!\n")
os.Exit(1)
}
gBridgeStaticMac = viper.GetBool("static-macs")
if gDebug {
log.SetLevel(log.DebugLevel)
log.Debugf("Debug mode enabled\n")
}
}
// no need to check prerequesites if we are initializing gocage
for _, rc := range rootCmd.Commands() {
//fmt.Printf("DEBUG: rootCmd subcommand: %v. Was it called? %s\n", rc.Use, rootCmd.Commands()[i].CalledAs())
if len(rc.CalledAs()) > 0 && strings.EqualFold("init", rc.CalledAs()) {
return
/********************************************************************************
* Write jail(s) config which been updated to disk.
* If name is specified, work on the jail. If name is empty string, work on all.
* If changeauto not set, values which are in "auto" mode on disk
* won't be overwritten (p.ex defaultrouter wont be overwritten with current
* default route, so if route change on jailhost this will reflect on jail next
* start)
*******************************************************************************/
func WriteConfigToDisk(jailName string, changeauto bool, forceWrite bool) {
for _, j := range gJails {
if len(jailName) > 0 && j.Name == jailName || len(jailName) == 0 {
if j.ConfigUpdated || forceWrite {
log.Debug("%s config has changed, write changes to disk\n", j.Name)
// we will manipulate properties so get a copy
jc := j.Config
if changeauto == false {
// Overwrite "auto" properties
ondiskjc, err := getJailConfig(j.ConfigPath)
if err != nil {
panic(err)
}
// TODO : List all fields, then call getStructFieldValue to compare value with "auto"
// If "auto" then keep it that way before writing ondiskjc to disk
var properties []string
properties = getStructFieldNames(ondiskjc, properties, "")
for _, p := range properties {
v, _, err := getStructFieldValue(ondiskjc, p)
if err != nil {
panic(err)
}
if v.String() == "auto" {
err = setStructFieldValue(&jc, p, "auto")
if err != nil {
fmt.Printf("ERROR sanitizing config: %s\n", err.Error())
os.Exit(1)
}
}
}
}
marshaled, err := json.MarshalIndent(jc, "", " ")
if err != nil {
fmt.Printf("ERROR marshaling config: %s\n", err.Error())
}
//fmt.Printf("DEBUG: Will write config to disk, with content:\n")
//fmt.Printf(string(marshaled))
if os.WriteFile(j.ConfigPath, []byte(marshaled), 0644); err != nil {
fmt.Printf("Error writing config file %s: %v\n", j.ConfigPath, err)
os.Exit(1)
}
}
}
}
// Load default configs from datastores
err := ListDatastores(viper.GetStringSlice("datastore"), false)
if err != nil {
fmt.Printf("ERROR: error checking datastores: %v\n", err)
os.Exit(1)
}
}

185
cmd/start.go

@ -330,26 +330,24 @@ func configureDhcpOrAcceptRtadv(jail *Jail, ipproto int, enable bool) error {
for _, n := range nics {
// vnet0 is epair0b inside jail
//if strings.Contains(n, "vnet") {
if strings.HasPrefix(n, "vnet") {
splitd := strings.Split(n, "|")
n = fmt.Sprintf("%sb", strings.Replace(splitd[0], "vnet", "epair", 1))
if strings.Contains(n, "vnet") {
n = fmt.Sprintf("%sb", strings.Replace(n, "vnet", "epair", 1))
}
key := fmt.Sprintf("ifconfig_%s", n)
value := "SYNCDHCP"
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 {
err := enableRcKeyValue(fmt.Sprintf("%s/etc/rc.conf", jail.RootPath), key, value)
err := enableRcKeyValue(jail.ConfigPath, key, value)
if err != nil {
return fmt.Errorf("ERROR setting %s=%s with sysrc for jail %s: %s\n", key, value, jail.Name, err)
}
} else {
err := disableRcKey(fmt.Sprintf("%s/etc/rc.conf", jail.RootPath), key)
err := disableRcKey(jail.ConfigPath, key)
if err != nil {
return fmt.Errorf("ERROR deleting %s with sysrc for jail %s: %v\n", key, jail.Name, err)
}
@ -363,7 +361,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(fmt.Sprintf("%s/etc/rc.conf", jail.RootPath), "rtsold_enable", "yes")
err := enableRcKeyValue(jail.ConfigPath, "rtsold_enable", "yes")
if err != nil {
return fmt.Errorf("ERROR setting rtsold_enable=YES with sysrc for jail %s: %s\n", jail.Name, err)
}
@ -510,7 +508,7 @@ func buildDevfsRuleSet(jail *Jail, m *sync.Mutex) (error, int) {
}
}
log.Debugf("buildDevfsRuleSet: Build ruleset %d\n", ruleset)
log.Debug("buildDevfsRuleSet: Build ruleset %d\n", ruleset)
// Get default devfs_ruleset for the datastore
// UPDATE: We don't need this as every jail have a default Devfs_ruleset value
@ -810,9 +808,7 @@ func generateMAC(jail *Jail, nic string) ([]byte, []byte, error) {
}
hsmac := append(prefix, suffix...)
jsmac := make([]byte, 6)
copy(jsmac, hsmac)
jsmac[5] = jsmac[5] + 1
jsmac := append(hsmac[:5], hsmac[5]+1)
// Save MACs to config
pname := fmt.Sprintf("Config.%s_mac", strings.Title(nic))
@ -842,7 +838,7 @@ func setupVnetInterfaceHostSide(jail *Jail) ([]string, error) {
bridge := v[1]
// Get host side MAC
pname := fmt.Sprintf("Config.%s_mac", strings.Title(nic))
pname := fmt.Sprintf("Config.%s_mac", nic)
var val *reflect.Value
val, pname, err = getStructFieldValue(jail, pname)
if err != nil {
@ -855,22 +851,13 @@ func setupVnetInterfaceHostSide(jail *Jail) ([]string, error) {
return []string{}, err
}
} else {
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])
}
hsmac = val.Bytes()
}
// Get bridge MTU
mtu, err := gJailHost.GetBridgeMTU(bridge)
if err != nil {
return []string{}, fmt.Errorf("Error getting bridge \"%s\" mtu: %v\n", bridge, err)
return []string{}, fmt.Errorf("Error getting bridge mtu: %v\n", err)
}
// Create epair interface
@ -906,11 +893,11 @@ func setupVnetInterfaceHostSide(jail *Jail) ([]string, error) {
}
epairs = append(epairs, hsepair)
}
log.Debugf("setupVnetInterfaceHostSide: returning %v\n", epairs)
return epairs, nil
}
func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
func setupVnetInterfaceJailSide(jail *Jail, hsepair string) error {
var jsmac []byte
var err error
@ -920,9 +907,7 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
for _, i := range strings.Split(jail.Config.Ip4_addr, ",") {
v := strings.Split(i, "|")
if len(v) > 1 {
ip4s[v[0]] = v[1]
}
ip4s[v[0]] = v[1]
}
for _, i := range strings.Split(jail.Config.Ip6_addr, ",") {
v := strings.Split(i, "|")
@ -932,7 +917,7 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
}
// Loop through configured interfaces
for i, nicCnf := range strings.Split(jail.Config.Interfaces, ",") {
for _, nicCnf := range strings.Split(jail.Config.Interfaces, ",") {
v := strings.Split(nicCnf, ":")
if len(v) != 2 {
return fmt.Errorf("Invalid value for Interfaces: %s\n", nicCnf)
@ -943,11 +928,9 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
// inside jail final nic name
jnic := strings.Replace(v[0], "vnet", "epair", 1)
jnic = jnic + "b"
// host side associated jail nic name
jsepair := fmt.Sprintf("%sb", strings.TrimSuffix(hostepairs[i], "a"))
// Get jail side MAC
pname := fmt.Sprintf("Config.%s_mac", strings.Title(nic))
pname := fmt.Sprintf("Config.%s_mac", nic)
var val *reflect.Value
val, pname, err = getStructFieldValue(jail, pname)
if err != nil {
@ -960,45 +943,44 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
return err
}
} else {
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])
}
jsmac = val.Bytes()
}
lasta := strings.LastIndex(hsepair, "a")
jsepair := hsepair[:lasta] + strings.Replace(hsepair[lasta:], "a", "b", 1)
cmd := fmt.Sprintf("/sbin/ifconfig %s vnet %s", jsepair, jail.InternalName)
_, err := executeCommand(cmd)
if err != nil {
return fmt.Errorf("Error linking interface to jail: %v\n", err)
}
// 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)
_, err = executeCommand(cmd)
if err != nil {
return fmt.Errorf("Error setting mtu: %v\n", err)
}
// rename epairXXb to epair0b (or opair1b, ...)
cmd = fmt.Sprintf("/usr/sbin/setfib %s jexec %d ifconfig %s name %s", jail.Config.Exec_fib, jail.JID, jsepair, jnic)
_, err = executeCommand(cmd)
if err != nil {
return fmt.Errorf("Error linking interface to jail: %v\n", err)
}
cmd = fmt.Sprintf("/usr/sbin/setfib %s jexec %d ifconfig %s link %s", jail.Config.Exec_fib,
jail.JID, jnic, hex.EncodeToString(jsmac))
_, err = executeCommand(cmd)
if err != nil {
return fmt.Errorf("Error setting mac: %v\n", err)
}
// TODO: Move outside of this function
// add interface to bridge
if jail.Config.Nat == 0 {
@ -1007,30 +989,17 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
if err != nil {
return fmt.Errorf("Error adding member %s to %s: %v: %s\n", nic, bridge, err, out)
}
// Fix mac flapping and instabilities with bridged vnet network
if gBridgeStaticMac {
printablemac := hex.EncodeToString(jsmac)
for i := 2 ; i < len(printablemac) ; i += 3 {
printablemac = printablemac[:i] + ":" + printablemac[i:]
}
log.Debugf("Set %s.%d as static to %s in %s address cache\n", nic, jail.JID, printablemac, bridge)
cmd = fmt.Sprintf("/sbin/ifconfig %s static %s.%d %s", bridge, nic, jail.JID, printablemac)
out, err := executeCommand(cmd)
if err != nil {
return fmt.Errorf("Error setting %s.%d static with %s on %s: %v: %s\n", nic, jail.JID, printablemac, bridge, err, out)
}
}
}
// Check we have an IP for the nic, and set it into jail
if len(ip4s[nic]) > 0 {
err = setJailVnetIp(jail, jnic, ip4s[nic])
}
if len(ip6s[nic]) > 0 {
err = setJailVnetIp(jail, jnic, ip6s[nic])
}
// finally up interface
if jail.Config.Nat == 0 {
cmd := fmt.Sprintf("/sbin/ifconfig %s.%d up", nic, jail.JID)
@ -1040,9 +1009,7 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
}
}
}
log.Debugf("setupVnetInterfaceJailSide: return with success\n")
return nil
}
@ -1102,9 +1069,9 @@ func StartJailsAtBoot() {
var curThNb int
var curPri int
// Get boot enabled non-template jails
// Get boot enabled jails
for _, j := range gJails {
if j.Config.Boot > 0 && !strings.EqualFold(j.Config.Jailtype, "template") {
if j.Config.Boot > 0 {
startList = append(startList, j)
}
}
@ -1198,7 +1165,7 @@ func StartJail(args []string) {
for _, a := range args {
// Check if jail exist and is distinctly named
cj, err = getJailFromArray(a, []string{"basejail", "jail"}, gJails)
cj, err = getJailFromArray(a, gJails)
if err != nil {
fmt.Printf("Error getting jail: %s\n", err)
continue
@ -1210,7 +1177,7 @@ func StartJail(args []string) {
}
fmt.Printf("> Starting jail %s\n", cj.Name)
// Set InternalName as it is used by some of these
cj.InternalName = fmt.Sprintf("ioc-%s", cj.Name)
@ -1372,34 +1339,34 @@ func StartJail(args []string) {
cj.Config.Defaultrouter = ip4[0]
}
}
// See https://github.com/iocage/iocage/blob/e94863d4c54f02523fb09e62e48be7db9ac92eda/iocage_lib/ioc_start.py:401
if cj.Config.Vnet == 0 {
// Not supported
fmt.Printf("Only VNet jails supported\n")
return
}
var net []string
if false == strings.EqualFold(cj.Config.Vnet_interfaces, "none") {
net = append(net, strings.Split(cj.Config.Vnet_interfaces, " ")...)
}
err, dynrs := buildDevfsRuleSet(cj, &gMdevfs)
if err != nil {
fmt.Printf("%s\n", err.Error())
return
}
err = buildJailParameters(cj, dynrs)
if err != nil {
fmt.Printf("%s\n", err.Error())
return
}
// Synchronize jail config to disk
cj.WriteConfigToDisk(false)
WriteConfigToDisk(cj.Name, false, false)
start_cmd := fmt.Sprintf("/usr/sbin/jail -f /var/run/jail.%s.conf -c", cj.InternalName)
//TODO: handle start_env & prestart_env, could be used by iocage plugins
@ -1409,17 +1376,17 @@ func StartJail(args []string) {
fmt.Printf("Aborting jail start\n")
return
}
fmt.Printf(" > Start jail:\n")
_, err = executeCommand(start_cmd)
if err != nil {
fmt.Printf("Error starting jail %s: %v\n", cj.Name, err)
return
}
fmt.Printf(" > Start jail: OK\n")
fmt.Printf(" > With devfs ruleset %d\n", dynrs)
// Update running state, JID and Devfs_ruleset
cj.Running = true
cj.Devfs_ruleset = dynrs
@ -1433,13 +1400,13 @@ func StartJail(args []string) {
break
}
}
hostInt, err := gJailHost.GetInterfaces()
if err != nil {
fmt.Printf("Error listing jail host interfaces: %v\n", err)
return
}
if false == strings.EqualFold(cj.Config.Vnet_default_interface, "auto") &&
false == strings.EqualFold(cj.Config.Vnet_default_interface, "none") &&
false == isStringInArray(hostInt, cj.Config.Vnet_default_interface) {
@ -1448,30 +1415,30 @@ func StartJail(args []string) {
}
fmt.Printf(" > Setup VNet network:\n")
hsepairs, err := setupVnetInterfaceHostSide(cj);
hsepairs, err := setupVnetInterfaceHostSide(cj);
if err != nil {
fmt.Printf("Error setting VNet interface host side: %v\n", err)
return
}
if err = setupVnetInterfaceJailSide(cj, hsepairs); err != nil {
fmt.Printf("Error setting VNet interface jail side: %v\n", err)
return
for _, ep := range hsepairs {
if err = setupVnetInterfaceJailSide(cj, ep); err != nil {
fmt.Printf("Error setting VNet interface jail side: %v\n", err)
return
}
}
fmt.Printf(" > Setup VNet network: OK\n")
// Set default route, unless main network is dhcp
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)
if err != nil && len(out) > 0 {
fmt.Printf("Error: %v: %s\n", err, out)
} else {
fmt.Printf(" > Setup default ipv4 gateway: OK\n")
}
// TODO: Handle DHCP
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)
if err != nil && len(out) > 0 {
fmt.Printf("Error: %v: %s\n", err, out)
} else {
fmt.Printf(" > Setup default ipv4 gateway: OK\n")
}
if cj.Config.Ip6_addr != "none" {
fmt.Printf(" > Setup default ipv6 gateway:\n")
cmd := fmt.Sprintf("/usr/sbin/setfib %s /usr/sbin/jexec %d route add -6 default %s", cj.Config.Exec_fib, cj.JID, cj.Config.Defaultrouter6)
@ -1482,7 +1449,7 @@ func StartJail(args []string) {
fmt.Printf(" > Setup default ipv6 gateway: OK\n")
}
}
if cj.Config.Jail_zfs > 0 {
fmt.Printf(" > Jail ZFS datasets:\n")
err = jailZfsDatasets(cj)
@ -1497,26 +1464,26 @@ func StartJail(args []string) {
if err != nil {
fmt.Printf("%s\n", err)
}
if cj.Config.Host_time > 0 {
err = copyLocalTime(cj)
if err != nil {
fmt.Printf("%s\n", err)
}
}
// Start services
if len(cj.Config.Exec_start) > 0 {
fmt.Printf(" > Start services:\n")
cmd := fmt.Sprintf("/usr/sbin/setfib %s /usr/sbin/jexec %d %s", cj.Config.Exec_fib, cj.JID, cj.Config.Exec_start)
err := executeCommandNonBlocking(cmd)
if err != nil {
if err != nil && len(out) > 0 {
fmt.Printf("Error: %v\n", err)
} else {
fmt.Printf(" > Start services: OK\n")
}
}
if cj.Config.Rtsold > 0 || strings.EqualFold(cj.Config.Ip6_addr, "accept_rtadv") {
fmt.Printf(" > Start rtsold:\n")
cmd := fmt.Sprintf("/usr/sbin/setfib %s /usr/sbin/jexec %d service rtsold start", cj.Config.Exec_fib, cj.JID)
@ -1527,7 +1494,7 @@ func StartJail(args []string) {
fmt.Printf(" > Start rtsold: OK\n")
}
}
// TODO: Execute Exec_poststart
if len(cj.Config.Exec_poststart) > 0 {
fmt.Printf(" > Execute post-start:\n")
@ -1539,18 +1506,18 @@ func StartJail(args []string) {
fmt.Printf(" > Execute post-start: OK\n")
}
}
// WIP 10/07/2022 : https://github.com/iocage/iocage/blob/master/iocage_lib/ioc_start.py#L891
// TODO: Handle dhcp
// TODO: Apply rctl
// Update last_started
// 23/07/2023 : This is not working, when writing to disk the old value is used
dt := time.Now()
curDate := fmt.Sprintf("%s", dt.Format("2006-01-02 15:04:05"))
cj.Config.Last_started = curDate
writeConfigToDisk(cj, false)
fmt.Sprintf(cj.Config.Last_started, curDate)
WriteConfigToDisk(cj.Name, false, true)
/*
out, err := executeCommand(fmt.Sprintf("rctl jail:%s", cj.InternalName))
if err == nil && len(out) > 0 {

81
cmd/stop.go

@ -83,30 +83,15 @@ func umountAndUnjailZFS(jail *Jail) error {
}
func destroyVNetInterfaces(jail *Jail) error {
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")
}
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")
}
}
@ -138,7 +123,7 @@ func deleteDevfsRuleset(ruleset int) error {
return nil
}
func umountFsFromHost(mountpoint string) error {
func umountJailFsFromHost(jail *Jail, mountpoint string) error {
cmd := "mount -p"
out, err := executeCommand(cmd)
if err != nil {
@ -149,11 +134,11 @@ func umountFsFromHost(mountpoint string) error {
for _, l := range strings.Split(out, "\n") {
f := strings.Split(remSpPtrn.ReplaceAllString(l, " "), " ")
if len(f) > 2 {
if strings.EqualFold(f[1], mountpoint) {
cmd = fmt.Sprintf("umount %s", mountpoint)
if strings.EqualFold(f[1], fmt.Sprintf("%s%s", jail.RootPath, mountpoint)) {
cmd = fmt.Sprintf("umount %s%s", jail.RootPath, mountpoint)
_, err := executeCommand(cmd)
if err != nil {
return errors.New(fmt.Sprintf("Error umounting %s: %s", mountpoint, err.Error()))
return errors.New(fmt.Sprintf("Error umounting %s%s: %s", jail.RootPath, mountpoint, err.Error()))
}
return nil
}
@ -163,10 +148,6 @@ func umountFsFromHost(mountpoint string) error {
return nil
}
func umountJailFsFromHost(jail *Jail, mountpoint string) error {
return umountFsFromHost(fmt.Sprintf("%s%s", jail.RootPath, mountpoint))
}
// Internal usage only
func stopJail(jail *Jail) error {
cmd := "jail -q"
@ -289,7 +270,7 @@ func StopJail(args []string) {
for _, a := range args {
// Check if jail exist and is distinctly named
cj, err = getJailFromArray(a, []string{"basejail", "jail"}, gJails)
cj, err = getJailFromArray(a, gJails)
if err != nil {
fmt.Printf("Error getting jail: %s\n", err)
continue
@ -300,10 +281,25 @@ func StopJail(args []string) {
continue
}
fmt.Printf("> Stopping jail %s\n", cj.Name)
fmt.Printf("> Stopping jail %s\n", a)
// Get and write new release into config.json
updateVersion(cj)
// Get current version to update config.json
cvers, err := executeCommandInJail(cj, "/bin/freebsd-version")
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
return
}
cvers = strings.TrimRight(cvers, "\n")
//fmt.Sprintf(cj.Config.Release, cvers)
//cj.Config.Release = cvers
//cj.ConfigUpdated = true
// This is working in this context, but value is not available in WriteConfigToDisk context :/
setStructFieldValue(cj, "Config.Release", cvers)
fmt.Printf("DEBUG: release was set, now is : %s\n", cj.Config.Release)
// We need to get the real Config object, not a copy of it
out, err := executeCommand(fmt.Sprintf("rctl jail:%s", cj.InternalName))
if err == nil && len(out) > 0 {
@ -423,8 +419,7 @@ func StopJail(args []string) {
fmt.Printf(" > Umount mountpoints from %s\n", fstab)
errs := 0
for _, m := range mounts {
log.Debugf("Umounting %s\n", m.Mountpoint)
err = umountFsFromHost(m.Mountpoint)
err = umountJailFsFromHost(cj, m.Mountpoint)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
errs += 1
@ -434,7 +429,7 @@ func StopJail(args []string) {
fmt.Printf(" > Umount mountpoints from %s: OK\n", fstab)
}
}
// TODO: Execute poststop
if len(cj.Config.Exec_poststop) > 0 {
fmt.Printf(" > Execute post-stop:\n")
@ -445,13 +440,13 @@ func StopJail(args []string) {
fmt.Printf(" > Execute post-stop: OK\n")
}
}
// Remove parameter file
pfile := fmt.Sprintf("/var/run/jail.%s.conf", cj.InternalName)
if err = os.Remove(pfile); err != nil {
fmt.Printf("Error deleting parameter file %s\n", pfile)
}
// We need this to get a reference to cj.Running (bc cj.Running is just a copy of value in the scope of StopJail())
for i, j := range gJails {
if strings.EqualFold(j.Name, cj.Name) && strings.EqualFold(j.Datastore, cj.Datastore) {
@ -469,7 +464,9 @@ func StopJail(args []string) {
}
}
}
writeConfigToDisk(cj, false)
fmt.Printf("DEBUG: release = %s\n", cj.Config.Release)
WriteConfigToDisk(cj.Name, false, true)
}
}

189
cmd/update.go

@ -5,54 +5,119 @@ import (
"fmt"
//"log"
"time"
"strings"
"github.com/spf13/viper"
)
const (
fbsdUpdateConfig = `
# $FreeBSD: releng/12.2/usr.sbin/freebsd-update/freebsd-update.conf 337338 2018-08-04 22:25:41Z brd $
# Trusted keyprint. Changing this is a Bad Idea unless you've received
# a PGP-signed email from <security-officer@FreeBSD.org> telling you to
# change it and explaining why.
KeyPrint 800651ef4b4c71c27e60786d7b487188970f4b4169cc055784e21eb71d410cc5
# Server or server pool from which to fetch updates. You can change
# this to point at a specific server if you want, but in most cases
# using a "nearby" server won't provide a measurable improvement in
# performance.
ServerName update.FreeBSD.org
# Components of the base system which should be kept updated.
Components world
# Example for updating the userland and the kernel source code only:
# Components src/base src/sys world
# Paths which start with anything matching an entry in an IgnorePaths
# statement will be ignored.
IgnorePaths
# Paths which start with anything matching an entry in an IDSIgnorePaths
# statement will be ignored by "freebsd-update IDS".
IDSIgnorePaths /usr/share/man/cat
IDSIgnorePaths /usr/share/man/whatis
IDSIgnorePaths /var/db/locate.database
IDSIgnorePaths /var/log
# Paths which start with anything matching an entry in an UpdateIfUnmodified
# statement will only be updated if the contents of the file have not been
# modified by the user (unless changes are merged; see below).
UpdateIfUnmodified /etc/ /var/ /root/ /.cshrc /.profile
# When upgrading to a new FreeBSD release, files which match MergeChanges
# will have any local changes merged into the version from the new release.
MergeChanges /etc/
### Default configuration options:
# Directory in which to store downloaded updates and temporary
# files used by FreeBSD Update.
# WorkDir /var/db/freebsd-update
# Destination to send output of "freebsd-update cron" if an error
# occurs or updates have been downloaded.
# MailTo root
# Is FreeBSD Update allowed to create new files?
# AllowAdd yes
# Is FreeBSD Update allowed to delete files?
# AllowDelete yes
# If the user has modified file ownership, permissions, or flags, should
# FreeBSD Update retain this modified metadata when installing a new version
# of that file?
# KeepModifiedMetadata yes
# When upgrading between releases, should the list of Components be
# read strictly (StrictComponents yes) or merely as a list of components
# which *might* be installed of which FreeBSD Update should figure out
# which actually are installed and upgrade those (StrictComponents no)?
# StrictComponents no
# When installing a new kernel perform a backup of the old one first
# so it is possible to boot the old kernel in case of problems.
# BackupKernel yes
# If BackupKernel is enabled, the backup kernel is saved to this
# directory.
# BackupKernelDir /boot/kernel.old
# When backing up a kernel also back up debug symbol files?
# BackupKernelSymbolFiles no
# Create a new boot environment when installing patches
# CreateBootEnv yes
`
)
// Internal usage only
func updateJail(jail *Jail, doUpdateVersion bool) error {
func updateJail(jail *Jail) error {
// Create default config as temporary file
cfgFile, err := os.CreateTemp("", "gocage-jail-update-")
if err != nil {
return err
}
// Folder containing update/upgrade temporary files. Mutualized so we save bandwith when upgrading multiple jails
uwd := viper.GetString("updateWorkDir")
if len(uwd) == 0 {
return fmt.Errorf("updateWorkDir not set in configuration")
}
_, err = os.Stat(uwd)
if os.IsNotExist(err) {
if err := os.Mkdir(uwd, 0755); err != nil {
return err
}
}
cfgFile.Write([]byte(strings.Replace(fbsdUpdateConfig, "TO-BE-REPLACED-WITH-UPDATEWORKDIR", uwd, 1)))
cfgFile.Write([]byte(fbsdUpdateConfig))
defer cfgFile.Close()
defer os.Remove(cfgFile.Name())
cmd := fmt.Sprintf("/usr/sbin/freebsd-update --not-running-from-cron -f %s -b %s --currently-running %s fetch",
//defer os.Remove(cfgFile.Name())
cmd := fmt.Sprintf("/usr/sbin/freebsd-update --not-running-from-cron -f %s -b %s --currently-running %s fetch install",
cfgFile.Name(), jail.RootPath, jail.Config.Release)
fmt.Printf("DEBUG: Prepare to execute \"%s\"\n", cmd)
err = executeCommandWithOutputToStdout(cmd)
if err != nil {
return err
}
cmd = fmt.Sprintf("/usr/sbin/freebsd-update --not-running-from-cron -f %s -b %s --currently-running %s install",
cfgFile.Name(), jail.RootPath, jail.Config.Release)
err = executeCommandWithOutputToStdout(cmd)
if err != nil {
return err
}
// Get and write new release into config.json. Don't do that for fake jail (aka release updating)
if doUpdateVersion {
updateVersion(jail)
}
// Get and write new release into config.json
return nil
}
@ -61,71 +126,19 @@ func UpdateJail(args []string) {
var cj *Jail
var err error
// User is updateing a release, fake a jail
if len(gUpdateRelease) > 0 {
// get datastore mountpoing from datastore name
ds, err := getDatastoreFromArray(gUpdateReleaseDS, gDatastores)
if err != nil {
fmt.Printf("Error getting datastore %s: %v\n", gUpdateReleaseDS, err)
return
}
rp := fmt.Sprintf("%s/releases/%s/root", ds.Mountpoint, gUpdateRelease)
fakeJail := Jail{RootPath: rp}
v, err := getVersion(&fakeJail)
if err != nil {
fmt.Printf("Error getting version of release %s: %v\n", gUpdateRelease, err)
return
}
fakeJail.Config.Release = v
// Remove patch level from Release
fv, err := freebsdVersionToStruct(fakeJail.Config.Release)
if err != nil {
fmt.Printf("Error converting release %s: %v\n", fakeJail.Config.Release, err)
return
}
release := fmt.Sprintf("%d.%d-%s", fv.major, fv.minor, fv.flavor)
// Snapshot before updating
dt := time.Now()
curDate := fmt.Sprintf("%s", dt.Format("2006-01-02_15-04-05"))
snapshotName := fmt.Sprintf("gocage_update_%s_%s", v, curDate)
err = zfsSnapshot(fmt.Sprintf("%s/releases/%s", ds.ZFSDataset, release), snapshotName)
if err != nil {
fmt.Printf("Error snapshoting release %s: %v\n", gUpdateRelease, err)
return
}
err = zfsSnapshot(fmt.Sprintf("%s/releases/%s/root", ds.ZFSDataset, release), snapshotName)
if err != nil {
fmt.Printf("Error snapshoting release %s: %v\n", gUpdateRelease, err)
} else {
fmt.Printf("Release %s was snapshoted with success: %s\n", gUpdateRelease, snapshotName)
}
if err = updateJail(&fakeJail, false); err != nil {
fmt.Printf("Error updating release %s: %v\n", gUpdateRelease, err)
}
return
}
for _, a := range args {
// Check if jail exist and is distinctly named
cj, err = getJailFromArray(a, []string{""}, gJails)
cj, err = getJailFromArray(a, gJails)
if err != nil {
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()
curDate := fmt.Sprintf("%s", dt.Format("2006-01-02_15-04-05"))
gSnapshotName = fmt.Sprintf("gocage_update_%s_%s", cj.Config.Release, curDate)
gSnapshotName = fmt.Sprintf("goc_update_%s_%s", cj.Config.Release, curDate)
err := createJailSnapshot(*cj)
if err != nil {
fmt.Printf(" > Snapshot jail %s: ERROR: %s\n", cj.Name, err.Error())
@ -134,7 +147,7 @@ func UpdateJail(args []string) {
fmt.Printf(" > Snapshot jail %s: OK\n", cj.Name)
fmt.Printf(" > Update jail %s\n", cj.Name)
err = updateJail(cj, true)
err = updateJail(cj)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {

126
cmd/upgrade.go

@ -1,126 +0,0 @@
package cmd
import (
"os"
"fmt"
//"log"
"time"
"strings"
"github.com/spf13/viper"
)
// Internal usage only
func upgradeJail(jail *Jail, version string) error {
// Create default config as temporary file
cfgFile, err := os.CreateTemp("", "gocage-jail-upgrade-")
if err != nil {
return err
}
// Folder containing update/upgrade temporary files. Mutualized so we save bandwith when upgrading multiple jails
uwd := viper.GetString("updateWorkDir")
if len(uwd) == 0 {
return fmt.Errorf("updateWorkDir not set in configuration")
}
_, err = os.Stat(uwd)
if os.IsNotExist(err) {
if err := os.Mkdir(uwd, 0755); err != nil {
return err
}
}
cfgFile.Write([]byte(strings.Replace(fbsdUpdateConfig, "TO-BE-REPLACED-WITH-UPDATEWORKDIR", uwd, 1)))
defer cfgFile.Close()
defer os.Remove(cfgFile.Name())
// Get current version. Won't work on stopped jail.
fbsdvers, err := executeCommandInJail(jail, "/bin/freebsd-version")
if err != nil {
fmt.Printf("ERROR executeCommandInJail: %s\n", err.Error())
return err
}
fbsdvers = strings.TrimRight(fbsdvers, "\n")
cmd := fmt.Sprintf("/usr/sbin/freebsd-update -f %s -b %s --currently-running %s -r %s upgrade",
cfgFile.Name(), jail.RootPath, fbsdvers, version)
//fmt.Printf("DEBUG: Prepare to execute \"%s\"\n", cmd)
// Need to give user control, bc there could be merge edit needs
err = executeCommandWithStdinStdoutStderr(cmd)
if err != nil {
return err
}
cmd = fmt.Sprintf("/usr/sbin/freebsd-update -f %s -b %s --currently-running %s -r %s install",
cfgFile.Name(), jail.RootPath, fbsdvers, version)
//fmt.Printf("DEBUG: Prepare to execute \"%s\"\n", cmd)
err = executeCommandWithStdinStdoutStderr(cmd)
if err != nil {
return err
}
cmd = fmt.Sprintf("/usr/sbin/freebsd-update -f %s -b %s --currently-running %s -r %s install",
cfgFile.Name(), jail.RootPath, fbsdvers, version)
//fmt.Printf("DEBUG: Prepare to execute \"%s\"\n", cmd)
err = executeCommandWithStdinStdoutStderr(cmd)
if err != nil {
return err
}
cmd = fmt.Sprintf("/usr/local/sbin/pkg-static -j %d install -q -f -y pkg", jail.JID)
err = executeCommandWithStdinStdoutStderr(cmd)
if err != nil {
return err
}
// Get and write new release into config.json
updateVersion(jail)
return nil
}
func UpgradeJail(args []string) {
// Current jail were stopping
var cj *Jail
var err error
for _, a := range args {
// Check if jail exist and is distinctly named
cj, err = getJailFromArray(a, []string{""}, gJails)
if err != nil {
fmt.Printf("Error getting jail: %s\n", err)
continue
}
if cj.Running == false {
fmt.Printf("Error: jail must be running for upgrade.\n")
return
}
fmt.Printf(" > Snapshot jail %s\n", cj.Name)
// Set snapshot name
dt := time.Now()
curDate := fmt.Sprintf("%s", dt.Format("2006-01-02_15-04-05"))
gSnapshotName = fmt.Sprintf("goc_upgrade_%s_%s", cj.Config.Release, curDate)
err := createJailSnapshot(*cj)
if err != nil {
fmt.Printf(" > Snapshot jail %s: ERROR: %s\n", cj.Name, err.Error())
return
}
fmt.Printf(" > Snapshot jail %s: OK\n", cj.Name)
fmt.Printf(" > Upgrade jail %s to %s\n", cj.Name, gUpgradeRelease)
err = upgradeJail(cj, gUpgradeRelease)
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
} else {
fmt.Printf(" > Upgrade jail %s: OK\n", cj.Name)
}
}
}

686
cmd/utils.go

@ -8,13 +8,11 @@ import (
"sort"
"bufio"
"errors"
"regexp"
"os/exec"
"reflect"
"strconv"
"strings"
"io/ioutil"
"encoding/json"
"github.com/google/shlex"
"github.com/c2h5oh/datasize"
log "github.com/sirupsen/logrus"
@ -25,222 +23,6 @@ const (
ifconfigipv4re = `inet[[:space:]](` + ipv4re + `)`
// Maximum thread qty for start/stop
gMaxThreads = 4
fbsdUpdateConfig = `# $FreeBSD$
# Trusted keyprint. Changing this is a Bad Idea unless you've received
# a PGP-signed email from <security-officer@FreeBSD.org> telling you to
# change it and explaining why.
KeyPrint 800651ef4b4c71c27e60786d7b487188970f4b4169cc055784e21eb71d410cc5
# Server or server pool from which to fetch updates. You can change
# this to point at a specific server if you want, but in most cases
# using a "nearby" server won't provide a measurable improvement in
# performance.
ServerName update.FreeBSD.org
# Components of the base system which should be kept updated.
Components world
# Example for updating the userland and the kernel source code only:
# Components src/base src/sys world
# Paths which start with anything matching an entry in an IgnorePaths
# statement will be ignored.
IgnorePaths
# Paths which start with anything matching an entry in an IDSIgnorePaths
# statement will be ignored by "freebsd-update IDS".
IDSIgnorePaths /usr/share/man/cat
IDSIgnorePaths /usr/share/man/whatis
IDSIgnorePaths /var/db/locate.database
IDSIgnorePaths /var/log
# Paths which start with anything matching an entry in an UpdateIfUnmodified
# statement will only be updated if the contents of the file have not been
# modified by the user (unless changes are merged; see below).
UpdateIfUnmodified /etc/ /var/ /root/ /.cshrc /.profile
# When upgrading to a new FreeBSD release, files which match MergeChanges
# will have any local changes merged into the version from the new release.
MergeChanges /etc/
### Default configuration options:
# Directory in which to store downloaded updates and temporary
# files used by FreeBSD Update.
WorkDir TO-BE-REPLACED-WITH-UPDATEWORKDIR
# Destination to send output of "freebsd-update cron" if an error
# occurs or updates have been downloaded.
# MailTo root
# Is FreeBSD Update allowed to create new files?
# AllowAdd yes
# Is FreeBSD Update allowed to delete files?
# AllowDelete yes
# If the user has modified file ownership, permissions, or flags, should
# FreeBSD Update retain this modified metadata when installing a new version
# of that file?
# KeepModifiedMetadata yes
# When upgrading between releases, should the list of Components be
# read strictly (StrictComponents yes) or merely as a list of components
# which *might* be installed of which FreeBSD Update should figure out
# which actually are installed and upgrade those (StrictComponents no)?
StrictComponents yes
# When installing a new kernel perform a backup of the old one first
# so it is possible to boot the old kernel in case of problems.
BackupKernel no
# If BackupKernel is enabled, the backup kernel is saved to this
# directory.
# BackupKernelDir /boot/kernel.old
# When backing up a kernel also back up debug symbol files?
BackupKernelSymbolFiles no
# Create a new boot environment when installing patches
CreateBootEnv no
`
gDefaultsJson = `{
"CONFIG_VERSION": "27",
"allow_chflags": 0,
"allow_mlock": 0,
"allow_mount": 0,
"allow_mount_devfs": 0,
"allow_mount_fusefs": 0,
"allow_mount_nullfs": 0,
"allow_mount_procfs": 0,
"allow_mount_tmpfs": 0,
"allow_mount_zfs": 0,
"allow_quotas": 0,
"allow_raw_sockets": 0,
"allow_set_hostname": 1,
"allow_socket_af": 0,
"allow_sysvipc": 0,
"allow_tun": 0,
"allow_vmm": 0,
"assign_localhost": 0,
"available": "readonly",
"basejail": 0,
"boot": 0,
"bpf": 0,
"children_max": "0",
"comment": "none",
"compression": "lz4",
"compressratio": "readonly",
"coredumpsize": "off",
"count": "1",
"cpuset": "off",
"cputime": "off",
"datasize": "off",
"dedup": "off",
"defaultrouter": "auto",
"defaultrouter6": "auto",
"depends": "none",
"devfs_ruleset": "4",
"dhcp": 0,
"enforce_statfs": "2",
"exec_clean": 1,
"exec_created": "/usr/bin/true",
"exec_fib": "0",
"exec_jail_user": "root",
"exec_poststart": "/usr/bin/true",
"exec_poststop": "/usr/bin/true",
"exec_prestart": "/usr/bin/true",
"exec_prestop": "/usr/bin/true",
"exec_start": "/bin/sh /etc/rc",
"exec_stop": "/bin/sh /etc/rc.shutdown",
"exec_system_jail_user": "0",
"exec_system_user": "root",
"exec_timeout": "60",
"host_domainname": "none",
"host_time": 1,
"hostid": "TO-BE-REPLACED-WITH-HOSTID",
"hostid_strict_check": 0,
"interfaces": "vnet0:TO-BE-REPLACED-WITH-BRIDGE",
"ip4": "new",
"ip4_addr": "none",
"ip4_saddrsel": 1,
"ip6": "new",
"ip6_addr": "none",
"ip6_saddrsel": 1,
"ip_hostname": 0,
"jail_zfs": 0,
"jail_zfs_mountpoint": "none",
"last_started": "none",
"localhost_ip": "none",
"login_flags": "-f root",
"mac_prefix": "2c44fd",
"maxproc": "off",
"memorylocked": "off",
"memoryuse": "off",
"min_dyn_devfs_ruleset": "1000",
"mount_devfs": 1,
"mount_fdescfs": 1,
"mount_linprocfs": 0,
"mount_procfs": 0,
"mountpoint": "readonly",
"msgqqueued": "off",
"msgqsize": "off",
"nat": 0,
"nat_backend": "ipfw",
"nat_forwards": "none",
"nat_interface": "none",
"nat_prefix": "172.16",
"nmsgq": "off",
"notes": "none",
"nsem": "off",
"nsemop": "off",
"nshm": "off",
"nthr": "off",
"openfiles": "off",
"origin": "readonly",
"owner": "root",
"pcpu": "off",
"plugin_name": "none",
"plugin_repository": "none",
"priority": "99",
"pseudoterminals": "off",
"quota": "none",
"readbps": "off",
"readiops": "off",
"reservation": "none",
"resolver": "/etc/resolv.conf",
"rlimits": "off",
"rtsold": 0,
"securelevel": "2",
"shmsize": "off",
"stacksize": "off",
"stop_timeout": "30",
"swapuse": "off",
"sync_state": "none",
"sync_target": "none",
"sync_tgt_zpool": "none",
"sysvmsg": "new",
"sysvsem": "new",
"sysvshm": "new",
"template": 0,
"type": "jail",
"used": "readonly",
"vmemoryuse": "off",
"vnet": 1,
"vnet0_mac": "none",
"vnet1_mac": "none",
"vnet2_mac": "none",
"vnet3_mac": "none",
"vnet_default_interface": "auto",
"vnet_interfaces": "none",
"wallclock": "off",
"writebps": "off",
"writeiops": "off"
}
`
)
/*****************************************************************************
@ -435,8 +217,6 @@ func executeCommand(cmdline string) (string, error) {
// else
word = word + string(c)
}
log.Debugf("executeCommand: %s\n", strings.Join(cmd, " "))
if len(cmd) > 1 {
out, err = exec.Command(cmd[0], cmd[1:]...).CombinedOutput()
@ -444,7 +224,7 @@ func executeCommand(cmdline string) (string, error) {
out, err = exec.Command(cmd[0]).CombinedOutput()
}
return strings.TrimSuffix(string(out), "\n"), err
return string(out), err
}
/* From iocage:
@ -556,8 +336,6 @@ func executeCommandWithOutputToStdout(cmdline string) (error) {
word = word + string(c)
}
log.Debugf("executeCommandWithOutputToStdout: will execute \"%s\"\n", strings.Join(cmd, " "))
var execHandle *exec.Cmd
if len(cmd) > 1 {
execHandle = exec.Command(cmd[0], cmd[1:]...)
@ -587,83 +365,9 @@ func executeCommandWithOutputToStdout(cmdline string) (error) {
return fmt.Errorf("Unknown error: you shouldn't be here!\n")
}
/* Execute command plugging stdin and stdout to those of the running command.
* Blocking while the command run
*/
func executeCommandWithStdinStdoutStderr(cmdline string) (error) {
var cmd []string
if gUseSudo {
cmd = append(cmd, "sudo")
}
var word string
var in_escaped bool
// Split by words, or " enclosed words
for i, c := range (cmdline) {
if string(c) == "\"" {
if in_escaped {
// This is the closing "
cmd = append(cmd, word)
in_escaped = false
} else {
in_escaped = true
}
continue
}
if string(c) == " " {
if in_escaped {
word = word + string(c)
continue
} else {
cmd = append(cmd, word)
word = ""
continue
}
}
if i == (len(cmdline) - 1) {
word = word + string(c)
cmd = append(cmd, word)
break
}
// else
word = word + string(c)
}
var command *exec.Cmd
if len(cmd) > 1 {
command = exec.Command(cmd[0], cmd[1:]...)
} else {
command = exec.Command(cmd[0])
}
// Get environment
command.Env = os.Environ()
// Connect command to current stdin/out/err
command.Stdin = os.Stdin
command.Stdout = os.Stdout
command.Stderr = os.Stderr
if err := command.Start(); err != nil {
return err
}
err := command.Wait()
return err
}
func executeCommandInJail(jail *Jail, cmdline string) (string, error) {
var cmd []string
// We can't execute on non-running jail
if jail.Running == false {
return "", errors.New("Can't execute command on stopped jail")
}
if gUseSudo {
cmd = append(cmd, "sudo")
}
@ -710,10 +414,6 @@ 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)
}
out, err := exec.Command(cmd[0], cmd[1:]...).CombinedOutput()
@ -752,30 +452,6 @@ func executeScript(script string) (string, error) {
return string(out), err
}
/*****************************************************************************
*
* Network related operations
*
*****************************************************************************/
func getBridgeMembers(bridge string) ([]string, error) {
var members []string
cmd := fmt.Sprintf("/sbin/ifconfig %s", bridge)
out, err := executeCommand(cmd)
if err != nil {
return members, errors.New(fmt.Sprintf("%v; command returned \"%s\"", err, out))
}
for _, line := range strings.Split(out, "\n") {
if strings.HasPrefix(strings.TrimLeft(line, " \t"), "member:") {
m := strings.Split(strings.TrimLeft(strings.Split(line, ":")[1], " "), " ")[0]
log.Debugf("%s is member of %s\n", m, bridge)
members = append(members, m)
}
}
return members, nil
}
/*****************************************************************************
*
* ZFS datasets/pools operations
@ -790,11 +466,8 @@ func zfsSnapshot(dataset string, snapname string) error {
return nil
}
// Copy snapshot to a new dataset
// TODO : Intercept death of sending process, then kill receiving
func zfsCopy(src string, dest string) error {
// First, declare sending process & pipe
log.Debugf("Execute: zfs send %s\n", src)
cmd_send := exec.Command("zfs", "send", src)
stdout_send, err := cmd_send.StdoutPipe()
if err != nil {
@ -803,7 +476,6 @@ func zfsCopy(src string, dest string) error {
}
// then declare receiving process & pipe
log.Debugf("Execute: zfs receive %s\n", dest)
cmd_recv := exec.Command("zfs", "receive", dest)
stdin_recv, err := cmd_recv.StdinPipe()
if err != nil {
@ -817,19 +489,16 @@ func zfsCopy(src string, dest string) error {
// then start processes and wait for finish
if err := cmd_recv.Start(); err != nil {
//fmt.Printf("Error: %v\n", err)
log.Debugf("zfs receive %s started: %v", dest, err)
return errors.New(fmt.Sprintf("Error starting receive process: %v\n", err))
}
//fmt.Printf("DEBUG: Start \"zfs send %s\"\n", dsconf)
if err := cmd_send.Start(); err != nil {
//fmt.Printf("Error: %v\n", err)
log.Debugf("zfs send %s started: %v", src, err)
return errors.New(fmt.Sprintf("Error starting send process: %v\n", err))
}
//fmt.Printf("DEBUG: Wait for zfs send to finish\n")
if err := cmd_send.Wait(); err != nil {
log.Debugf("zfs send %s stopped with %v", err)
//fmt.Printf("Error: zfs send halted with %v\n", err)
return errors.New(fmt.Sprintf("send halted with: %v\n", err))
}
@ -898,20 +567,9 @@ func doZfsDatasetExist(dataset string) (bool, error) {
return true, nil
}
/* Create ZFS dataset
* mountpoint can be "none", then the dataset won't be mounted
* mountpoint can be "", then it will be inherited
* compression can be "", then it wil be inherited
*/
// Create ZFS dataset. mountpoint can be "none", then the dataset won't be mounted
func zfsCreateDataset(dataset, mountpoint, compression string) error {
cmd := "zfs create"
if len(mountpoint) > 0 {
cmd = fmt.Sprintf("%s -o mountpoint=%s", cmd, mountpoint)
}
if len(compression) > 0 {
cmd = fmt.Sprintf("%s -o compression=%s", cmd, compression)
}
cmd = fmt.Sprintf("%s %s", cmd, dataset)
cmd := fmt.Sprintf("zfs create -o mountpoint=%s -o compression=%s %s", mountpoint, compression, dataset)
out, err := executeCommand(cmd)
if err != nil {
return errors.New(fmt.Sprintf("%v; command returned \"%s\"", err, out))
@ -920,9 +578,7 @@ func zfsCreateDataset(dataset, mountpoint, compression string) error {
}
// Return dataset name for a given mountpoint
func zfsGetDatasetByMountpoint(mountpoint string) (string, error) {
// We dont want no recursivity
//cmd := fmt.Sprintf("zfs list -p -r -H -o name %s", mountpoint)
cmd := fmt.Sprintf("zfs list -p -H -o name %s", mountpoint)
cmd := fmt.Sprintf("zfs list -p -r -H -o name %s", mountpoint)
out, err := executeCommand(cmd)
if err != nil {
return "", errors.New(fmt.Sprintf("%v; command returned \"%s\"", err, out))
@ -933,7 +589,6 @@ func zfsGetDatasetByMountpoint(mountpoint string) (string, error) {
// Delete a ZFS Dataset by name
func zfsDestroy(dataset string) error {
log.Debugf("execute \"zfs destroy -r %s\"\n", dataset)
cmd := fmt.Sprintf("zfs destroy -r %s", dataset)
out, err := executeCommand(cmd)
if err != nil {
@ -942,51 +597,6 @@ func zfsDestroy(dataset string) error {
return nil
}
/*****************************************************************************
*
* Filesystem operations
*
*****************************************************************************/
/* Copy file */
func copyFile(src, dst string) error {
srcfinfo, err := os.Stat(src)
if err != nil {
return fmt.Errorf("Cannot find source file: %s", err.Error())
}
if !srcfinfo.Mode().IsRegular() {
return fmt.Errorf("%s is not a regular file", src)
}
srcHandle, err := os.Open(src)
if err != nil {
return fmt.Errorf("Cannot open source file: %s", err.Error())
}
defer srcHandle.Close()
dstHandle, err := os.Create(dst)
if err != nil {
return fmt.Errorf("Cannot create destination file: %s", err.Error())
}
defer dstHandle.Close()
_, err = io.Copy(dstHandle, srcHandle)
return err
}
// Get permissions of file or folder
func getPermissions(path string) (os.FileInfo, error) {
return os.Stat(path)
}
func doFileExist(filePath string) (bool, error) {
if _, err := os.Stat(filePath); err != nil {
if errors.Is(err, os.ErrNotExist) {
return false, nil
} else {
return false, err
}
}
return true, nil
}
/*****************************************************************************
*
* rc.conf management
@ -1012,7 +622,7 @@ func disableRcKey(rcconfpath string, key string) error {
return err
}
}
cmd = fmt.Sprintf("/usr/sbin/sysrc -f %s -x %s", rcconfpath, key)
_, err = executeCommand(cmd)
if err != nil {
@ -1021,44 +631,6 @@ func disableRcKey(rcconfpath string, key string) error {
return nil
}
// returns no error if rc key does not exist
func getCurrentRcKeyValue(rcconfpath string, key string) (string, error) {
cmd := "/usr/sbin/sysrc -a"
kvs, err := executeCommand(cmd)
if err != nil {
return "", err
}
for _, kv := range strings.Split(string(kvs), "\n") {
fmt.Printf("%s\n", kv)
if strings.HasPrefix(kv, fmt.Sprintf("%s:", key)) {
return strings.TrimPrefix(strings.Join(strings.Split(kv, ":")[1:], ":"), " "), nil
}
}
return "", nil
}
// Add a value to current existing key value
func addRcKeyValue(rcconfpath string, key string, value string) error {
var nv string
cv, err := getCurrentRcKeyValue(rcconfpath, key)
if err != nil {
return err
}
if len(cv) > 0 {
log.Debugf("Current value of %s: %s\n", key, cv)
nv = fmt.Sprintf("\"%s %s\"", cv, value)
} else {
nv = fmt.Sprintf("\"%s\"", value)
}
cmd := fmt.Sprintf("/usr/sbin/sysrc -f %s %s=%s", rcconfpath, key, nv)
_, err = executeCommand(cmd)
if err != nil {
return err
}
return nil
}
/*****************************************************************************
* Parse an fstab file, returning an array of Mount
*****************************************************************************/
@ -1074,8 +646,7 @@ func getFstab(path string) ([]Mount, error) {
scan := bufio.NewScanner(f)
for scan.Scan() {
res := strings.Fields(scan.Text())
// 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 {
if len(res) != 6 {
return mounts, fmt.Errorf("Incorrect format for fstab line %s", scan.Text())
}
freq, err := strconv.Atoi(res[4])
@ -1111,10 +682,13 @@ func getDevfsRuleset(ruleset int) []string {
if err != nil {
return []string{}
}
return strings.Split(out, "\n")[:len(strings.Split(out, "\n"))]
// Get rid of the last "\n"
return strings.Split(out, "\n")[:len(strings.Split(out, "\n"))-1]
}
func copyDevfsRuleset(ruleset int, srcrs int) error {
// Resulting ruleset as an array of line
//var result []string
out := getDevfsRuleset(srcrs)
for _, line := range out {
//fields := strings.Fields(line)
@ -1128,6 +702,34 @@ func copyDevfsRuleset(ruleset int, srcrs int) error {
return nil
}
/********************************************************************************
* Returns value of parameter as read in /var/run/jail.$InternalName.conf
* Directives without value will return "true" if found
* Returns an error if parameter not found in file
*******************************************************************************/
func getValueFromRunningConfig(jname string, param string) (string, error) {
content, err := ioutil.ReadFile(fmt.Sprintf("/var/run/jail.%s.conf", jname))
if err != nil {
return "", err
}
for _, line := range strings.Split(string(content), "\n") {
if strings.Contains(line, fmt.Sprintf("%s = ", param)) {
split := strings.Split(line, "=")
switch len(split) {
// directives without value
case 0:
return "true", nil
case 1:
return "", fmt.Errorf("Invalid format: %s", line)
case 2:
return strings.Trim(split[1], " ;\""), nil
}
}
}
return "", fmt.Errorf("Parameter not found: %s", param)
}
/********************************************************************************
* Add a rule to specified ruleset
* Ex.: addDevfsRuleToRuleset("path bpf* unhide", 1002)
@ -1155,35 +757,6 @@ func addDevfsRuleToRuleset(rule string, ruleset int) error {
return nil
}
/********************************************************************************
* Returns value of parameter as read in /var/run/jail.$InternalName.conf
* Directives without value will return "true" if found
* Returns an error if parameter not found in file
*******************************************************************************/
func getValueFromRunningConfig(jname string, param string) (string, error) {
content, err := ioutil.ReadFile(fmt.Sprintf("/var/run/jail.%s.conf", jname))
if err != nil {
return "", err
}
for _, line := range strings.Split(string(content), "\n") {
if strings.Contains(line, fmt.Sprintf("%s = ", param)) {
split := strings.Split(line, "=")
switch len(split) {
// directives without value
case 0:
return "true", nil
case 1:
return "", fmt.Errorf("Invalid format: %s", line)
case 2:
return strings.Trim(split[1], " ;\""), nil
}
}
}
return "", fmt.Errorf("Parameter not found: %s", param)
}
/******************************************************************************
*
@ -1199,29 +772,14 @@ func isStringInArray(strarr []string, searched string) bool {
return false
}
func (j Jail) isFirstNetDhcp() bool {
for _, n := range strings.Split(j.Config.Ip4_addr, ",") {
splitd := strings.Split(n, "|")
if len(splitd) > 1 && strings.EqualFold(splitd[1], "dhcp") {
return true
}
}
return false
}
/********************************************************************************
* Get a specific jail reference, to update properties after a range loop
* Name can be short or long form ("myjail" vs "mystore/myjail")
* An empty jailtype means "all types"
*******************************************************************************/
func getJailFromArray(name string, jailtypes []string, jarray []Jail) (*Jail, error) {
func getJailFromArray(name string, jarray []Jail) (*Jail, error) {
var ds, jail string
var jails []Jail
if (len(jailtypes) == 1 && len(jailtypes[0]) == 0) || len(jailtypes) == 0 {
jailtypes = []string{"basejail", "jail", "template"}
}
if strings.Contains(name, "/") {
split := strings.Split(name, "/")
if len(split) != 2 {
@ -1234,17 +792,16 @@ func getJailFromArray(name string, jailtypes []string, jarray []Jail) (*Jail, er
}
for i, j := range jarray {
//if jail == j.Name {
if strings.HasPrefix(j.Name, jail) {
if isStringInArray(jailtypes, j.Config.Jailtype) {
if len(ds) > 0 {
if strings.EqualFold(ds, j.Datastore) {
return &jarray[i], nil
} else {
continue
}
if len(ds) > 0 {
if strings.EqualFold(ds, j.Datastore) {
return &jarray[i], nil
} else {
jails = append(jails, j)
continue
}
} else {
jails = append(jails, j)
}
}
}
@ -1276,7 +833,7 @@ func setJailConfigUpdated(jail *Jail) error {
return errors.New(fmt.Sprintf("No config path for jail %s", jail.Name))
}
j, err := getJailFromArray(jail.Name, []string{""}, gJails)
j, err := getJailFromArray(jail.Name, gJails)
if err != nil {
return err
}
@ -1285,151 +842,6 @@ func setJailConfigUpdated(jail *Jail) error {
return nil
}
func freebsdVersionToStruct(rawVersion string) (FreeBSDVersion, error) {
var version FreeBSDVersion
var err error
regex := `([0-9]{1,2})(\.)?([0-9]{1,2})?\-([^\-]*)(\-)?(p[0-9]{1,2})?`
re := regexp.MustCompile(regex)
if re.MatchString(rawVersion) {
version.major, err = strconv.Atoi(re.FindStringSubmatch(rawVersion)[1])
if err != nil {
return version, err
}
version.minor, err = strconv.Atoi(re.FindStringSubmatch(rawVersion)[3])
if err != nil {
return version, err
}
version.flavor = strings.Trim(re.FindStringSubmatch(rawVersion)[4], "\n")
// Skip the 'p' starting patch level
if len(re.FindStringSubmatch(rawVersion)[6]) > 0 {
version.patchLevel, err = strconv.Atoi(re.FindStringSubmatch(rawVersion)[6][1:])
if err != nil {
return version, err
}
}
}
return version, nil
}
func getVersion(jail *Jail) (string, error) {
cvers, err := executeCommand(fmt.Sprintf("%s/bin/freebsd-version", jail.RootPath))
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
return "", err
}
return strings.TrimRight(cvers, "\n"), nil
}
func updateVersion(jail *Jail) error {
cvers, err := executeCommand(fmt.Sprintf("%s/bin/freebsd-version", jail.RootPath))
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
return err
}
cvers = strings.TrimRight(cvers, "\n")
jail.Config.Release = cvers
jail.WriteConfigToDisk(false)
return nil
}
/********************************************************************************
* Write jail(s) config which been updated to disk.
* If name is specified, work on the jail. If name is empty string, work on all.
* If changeauto not set, values which are in "auto" mode on disk
* won't be overwritten (p.ex defaultrouter wont be overwritten with current
* default route, so if route change on jailhost this will reflect on jail next
* start)
*******************************************************************************/
func writeConfigToDisk(j *Jail, changeauto bool) {
// we will manipulate properties so get a copy
jc := j.Config
if changeauto == false {
// Overwrite "auto" properties
ondiskjc, err := getJailConfig(j.ConfigPath)
if err != nil {
panic(err)
}
// TODO : List all fields, then call getStructFieldValue to compare value with "auto"
// If "auto" then keep it that way before writing ondiskjc to disk
var properties []string
properties = getStructFieldNames(ondiskjc, properties, "")
for _, p := range properties {
v, _, err := getStructFieldValue(ondiskjc, p)
if err != nil {
panic(err)
}
if v.String() == "auto" {
err = setStructFieldValue(&jc, p, "auto")
if err != nil {
fmt.Printf("ERROR sanitizing config: %s\n", err.Error())
os.Exit(1)
}
}
}
}
marshaled, err := json.MarshalIndent(jc, "", " ")
if err != nil {
fmt.Printf("ERROR marshaling config: %s\n", err.Error())
}
//fmt.Printf("DEBUG: Will write config to disk, with content:\n")
//fmt.Printf(string(marshaled))
if os.WriteFile(j.ConfigPath, []byte(marshaled), 0644); err != nil {
fmt.Printf("Error writing config file %s: %v\n", j.ConfigPath, err)
os.Exit(1)
}
}
func (j Jail) WriteConfigToDisk(changeauto bool) {
// we will manipulate properties so get a copy
jc := j.Config
if changeauto == false {
// Overwrite "auto" properties
ondiskjc, err := getJailConfig(j.ConfigPath)
if err != nil {
panic(err)
}
// TODO : List all fields, then call getStructFieldValue to compare value with "auto"
// If "auto" then keep it that way before writing ondiskjc to disk
var properties []string
properties = getStructFieldNames(ondiskjc, properties, "")
for _, p := range properties {
v, _, err := getStructFieldValue(ondiskjc, p)
if err != nil {
panic(err)
}
if v.String() == "auto" {
err = setStructFieldValue(&jc, p, "auto")
if err != nil {
fmt.Printf("ERROR sanitizing config: %s\n", err.Error())
os.Exit(1)
}
}
}
}
marshaled, err := json.MarshalIndent(jc, "", " ")
if err != nil {
fmt.Printf("ERROR marshaling config: %s\n", err.Error())
}
if os.WriteFile(j.ConfigPath, []byte(marshaled), 0644); err != nil {
fmt.Printf("Error writing config file %s: %v\n", j.ConfigPath, err)
os.Exit(1)
}
}
/******************************************************************************
* Return the quantity of jails with the name passed as parameter
*****************************************************************************/
@ -1445,7 +857,7 @@ func countOfJailsWithThisName(name string) int {
func isNameDistinctive(name string, jails []Jail) bool {
_, err := getJailFromArray(name, []string{""}, jails)
_, err := getJailFromArray(name, jails)
if err != nil {
return false
} else {

59
go.mod

@ -6,53 +6,26 @@ require (
github.com/c-robinson/iplib v1.0.3
github.com/c2h5oh/datasize v0.0.0-20220606134207-859f65c6625b
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.8.1
github.com/spf13/viper v1.19.0
golang.org/x/net v0.25.0
github.com/spf13/cobra v1.2.1
github.com/spf13/viper v1.9.0
golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420
)
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.7.0 // 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/fsnotify/fsnotify v1.5.1 // indirect
github.com/hashicorp/hcl v1.0.0 // indirect
github.com/inconshreveable/mousetrap v1.1.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.7 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/mitchellh/mapstructure v1.5.0 // 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/v2 v2.2.2 // indirect
github.com/sagikazarmark/locafero v0.4.0 // indirect
github.com/sagikazarmark/slog-shim v0.1.0 // indirect
github.com/sourcegraph/conc v0.3.0 // indirect
github.com/spf13/afero v1.11.0 // indirect
github.com/spf13/cast v1.6.0 // indirect
github.com/inconshreveable/mousetrap v1.0.0 // indirect
github.com/magiconair/properties v1.8.5 // indirect
github.com/mitchellh/mapstructure v1.4.2 // indirect
github.com/pelletier/go-toml v1.9.4 // 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.6.0 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.2.12 // indirect
go.uber.org/atomic v1.9.0 // indirect
go.uber.org/multierr v1.9.0 // indirect
golang.org/x/arch v0.8.0 // indirect
golang.org/x/crypto v0.23.0 // indirect
golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // 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.67.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
github.com/subosito/gotenv v1.2.0 // indirect
golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf // indirect
golang.org/x/text v0.3.6 // indirect
gopkg.in/ini.v1 v1.63.2 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
)

3
gocage.conf.yml

@ -5,9 +5,6 @@ datastore:
# Prefix all commands with sudo
sudo: false
# Directory used to store update temporary files. Mutualized so we save bandwith
updateWorkDir: /iocage/freebsd-updates
# Columns to display when "gocage list". Column names are struct fields, see cmd/struct.go
outcol: 'JID,Name,Config.Release,Config.Ip4_addr,Running'