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

Compare commits

base: yo:cdcb466417a4a22b9a0d9116c223bd840d961381
Branches Tags
yo:master
yo:api
yo:v0.42
yo:v0.41
yo:v0.40
yo:v0.39
yo:v0.38
yo:v0.37
yo:v0.35
yo:v0.34
yo:v0.31
yo:v0.30
yo:v0.29f
yo:v0.25
yo:v0.24
yo:v0.23
yo:v0.22a
yo:v0.2
..
compare: yo:684d97cc212093067d1245e249d28673018e8ded
Branches Tags
yo:master
yo:api
yo:v0.42
yo:v0.41
yo:v0.40
yo:v0.39
yo:v0.38
yo:v0.37
yo:v0.35
yo:v0.34
yo:v0.31
yo:v0.30
yo:v0.29f
yo:v0.25
yo:v0.24
yo:v0.23
yo:v0.22a
yo:v0.2

No commits in common. "cdcb466417a4a22b9a0d9116c223bd840d961381" and "684d97cc212093067d1245e249d28673018e8ded" have entirely different histories.
cdcb466417 ... 684d97cc21

9 changed files with 70 additions and 121 deletions
Show Stats Expand all files Collapse all files

8
README.md
View File

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

2
cmd/console.go
View File

@ -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], []string{"jail"}, gJails)
if err != nil {
fmt.Printf("Error getting jail %s: %v\n", args[0], err)
return err

35
cmd/create.go
View File

@ -5,7 +5,6 @@ import (
"fmt"
//"log"
"time"
"errors"
"strings"
cp "github.com/otiai10/copy"
log "github.com/sirupsen/logrus"
@ -86,24 +85,15 @@ func CreateJail(args []string) {
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 := bj.RootPath
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
}
}
srcPerm, err := getPermissions(fmt.Sprintf("%s/%s", bj.RootPath, d))
if err != nil {
fmt.Printf("ERROR getting permissions of %s/%s: %s\n", bj.RootPath, d, err.Error())
return
}
err = os.Mkdir(fmt.Sprintf("%s/%s", dstRootDir, d), srcPerm.Mode().Perm())
if err != nil {
fmt.Printf("ERROR creating directory %s/%s: %s\n", dstRootDir, d, err.Error())
return
}
}
@ -164,11 +154,6 @@ func CreateJail(args []string) {
return
}
defer fstabHandle.Close()
for _, d := range gBaseDirs {
fmt.Fprintf(fstabHandle, "%s\t%s\tnullfs\tro\t0\t0\n", fmt.Sprintf("%s/%s", bj.RootPath, d), fmt.Sprintf("%s/%s", dstRootDir, d))
}
fmt.Printf(" > Jail created!\n")
} else {
/**************************************************************************
@ -267,7 +252,6 @@ func CreateJail(args []string) {
j.Config.Release = gCreateArgs.Release
j.Config.Host_hostname = jname
j.Config.Host_hostuuid = jname
j.Config.Jailtype = "jail"
j.WriteConfigToDisk(false)
@ -281,5 +265,6 @@ func CreateJail(args []string) {
defer fstabHandle.Close()
fmt.Printf(" > Jail created!\n")
}
// TODO : Set JailType
}
}

7
cmd/list.go
View File

@ -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
}
}

6
cmd/root.go
View File

@ -14,7 +14,7 @@ import (
)
const (
gVersion = "0.38"
gVersion = "0.37a"
// TODO : Get from $jail_zpool/defaults.json
MIN_DYN_DEVFS_RULESET = 1000
@ -66,8 +66,8 @@ var (
gUpgradeRelease 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"}
gBaseDirs = []string{"bin", "boot", "lib", "libexec", "rescue", "sbin", "usr", "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

25
cmd/start.go
View File

@ -899,7 +899,7 @@ func setupVnetInterfaceHostSide(jail *Jail) ([]string, error) {
return epairs, nil
}
func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
func setupVnetInterfaceJailSide(jail *Jail) error {
var jsmac []byte
var err error
@ -919,7 +919,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)
@ -930,8 +930,6 @@ 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", nic)
@ -950,7 +948,7 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
jsmac = val.Bytes()
}
cmd := fmt.Sprintf("/sbin/ifconfig %s vnet %s", jsepair, jail.InternalName)
cmd := fmt.Sprintf("/sbin/ifconfig %s vnet %s", jnic, jail.InternalName)
_, err := executeCommand(cmd)
if err != nil {
return fmt.Errorf("Error linking interface to jail: %v\n", err)
@ -962,14 +960,14 @@ func setupVnetInterfaceJailSide(jail *Jail, hostepairs []string) error {
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)
cmd = fmt.Sprintf("/usr/sbin/jexec %d ifconfig %s mtu %d", jail.JID, jnic, 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)
cmd = fmt.Sprintf("/usr/sbin/setfib %s jexec %d ifconfig %s name %s", jail.Config.Exec_fib, jail.JID, jnic, jnic)
_, err = executeCommand(cmd)
if err != nil {
return fmt.Errorf("Error linking interface to jail: %v\n", err)
@ -1072,9 +1070,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)
}
}
@ -1168,7 +1166,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, []string{"jail"}, gJails)
if err != nil {
fmt.Printf("Error getting jail: %s\n", err)
continue
@ -1368,7 +1366,7 @@ func StartJail(args []string) {
}
// Synchronize jail config to disk
cj.WriteConfigToDisk(false)
writeConfigToDisk(cj, false)
start_cmd := fmt.Sprintf("/usr/sbin/jail -f /var/run/jail.%s.conf -c", cj.InternalName)
@ -1418,13 +1416,13 @@ func StartJail(args []string) {
}
fmt.Printf(" > Setup VNet network:\n")
hsepairs, err := setupVnetInterfaceHostSide(cj);
_, 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 {
if err = setupVnetInterfaceJailSide(cj); err != nil {
fmt.Printf("Error setting VNet interface jail side: %v\n", err)
return
}
@ -1521,6 +1519,7 @@ func StartJail(args []string) {
cj.Config.Last_started = curDate
writeConfigToDisk(cj, false)
/*
out, err := executeCommand(fmt.Sprintf("rctl jail:%s", cj.InternalName))
if err == nil && len(out) > 0 {

17
cmd/stop.go
View File

@ -123,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 {
@ -134,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
}
@ -148,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"
@ -274,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, []string{"jail"}, gJails)
if err != nil {
fmt.Printf("Error getting jail: %s\n", err)
continue
@ -408,8 +404,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

12
cmd/update.go
View File

@ -21,7 +21,7 @@ func updateJail(jail *Jail) error {
defer cfgFile.Close()
defer os.Remove(cfgFile.Name())
// Folder containing update/upgrade temporary files. Common so we save bandwith when upgrading multiple jails
// Folder containing update/uipgrade temporary files. Common so we save bandwith when upgrading multiple jails
// TODO: Variabilize /iocage/freebsd-update
_, err = os.Stat("/iocage/freebsd-update")
if os.IsNotExist(err) {
@ -30,15 +30,11 @@ func updateJail(jail *Jail) error {
}
}
cmd := fmt.Sprintf("/usr/sbin/freebsd-update --not-running-from-cron -f %s -b %s --currently-running %s fetch",
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)
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)
//fmt.Printf("DEBUG: Prepare to execute \"%s\"\n", cmd)
err = executeCommandWithOutputToStdout(cmd)
if err != nil {
return err

17
cmd/utils.go
View File

@ -474,8 +474,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:]...)
@ -1064,7 +1062,7 @@ func getJailFromArray(name string, jailtypes []string, jarray []Jail) (*Jail, er
var jails []Jail
if (len(jailtypes) == 1 && len(jailtypes[0]) == 0) || len(jailtypes) == 0 {
jailtypes = []string{"basejail", "jail", "template"}
jailtypes = []string{"jail", "basetpl"}
}
if strings.Contains(name, "/") {
@ -1130,24 +1128,15 @@ func setJailConfigUpdated(jail *Jail) error {
return 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))
cvers, err := executeCommandInJail(jail, "/bin/freebsd-version")
if err != nil {
fmt.Printf("ERROR: %s\n", err.Error())
return err
}
cvers = strings.TrimRight(cvers, "\n")
jail.Config.Release = cvers
jail.WriteConfigToDisk(false)
writeConfigToDisk(jail, false)
return nil
}