func Setup(name string) error {
chroot := filepath.Join(RepoRoot(), name)
u, err := user.Current()
if err != nil {
return err
}
var sc bytes.Buffer
if err := scriptTemplate.Execute(&sc, u); err != nil {
return err
}
plog.Info("Configuring SDK chroot")
sh := exec.Command(
"sudo", sudoPrompt,
"chroot", chroot,
"/usr/bin/env", "-i",
"/bin/bash", "--login")
sh.Stdin = &sc
sh.Stderr = os.Stderr
if plog.LevelAt(capnslog.INFO) {
out, err := sh.StdoutPipe()
if err != nil {
return err
}
go util.LogFrom(capnslog.INFO, out)
}
if plog.LevelAt(capnslog.DEBUG) {
sh.Args = append(sh.Args, "-x")
}
return sh.Run()
}
func extract(tar, dir string) error {
in, err := os.Open(tar)
if err != nil {
return err
}
defer in.Close()
unzipper, err := exec.LookPath("lbzcat")
if err != nil {
unzipper = "bzcat"
}
unzip := exec.Command(unzipper)
unzip.Stdin = in
unzip.Stderr = os.Stderr
unzipped, err := unzip.StdoutPipe()
if err != nil {
return err
}
untar := exec.Command("sudo", sudoPrompt,
"tar", "--numeric-owner", "-x")
untar.Dir = dir
untar.Stdin = unzipped
untar.Stderr = os.Stderr
if err := unzip.Start(); err != nil {
return err
}
if err := untar.Start(); err != nil {
unzip.Kill()
return err
}
if err := untar.Wait(); err != nil {
unzip.Kill()
return err
}
if err := unzip.Wait(); err != nil {
return err
}
return nil
}
func NewDnsmasq() (*Dnsmasq, error) {
dm := &Dnsmasq{}
for s := byte(0); s < numSegments; s++ {
seg, err := newSegment(s)
if err != nil {
return nil, fmt.Errorf("Network setup failed: %v", err)
}
dm.Segments = append(dm.Segments, seg)
}
// setup lo
lo, err := netlink.LinkByName("lo")
if err != nil {
return nil, fmt.Errorf("Network loopback setup failed: %v", err)
}
err = netlink.LinkSetUp(lo)
if err != nil {
return nil, fmt.Errorf("Network loopback setup failed: %v", err)
}
dm.dnsmasq = exec.Command("dnsmasq", "--conf-file=-")
cfg, err := dm.dnsmasq.StdinPipe()
if err != nil {
return nil, err
}
out, err := dm.dnsmasq.StdoutPipe()
if err != nil {
return nil, err
}
dm.dnsmasq.Stderr = dm.dnsmasq.Stdout
go util.LogFrom(capnslog.INFO, out)
if err = dm.dnsmasq.Start(); err != nil {
cfg.Close()
return nil, err
}
if err = configTemplate.Execute(cfg, dm); err != nil {
cfg.Close()
dm.Destroy()
return nil, err
}
cfg.Close()
return dm, nil
}
func OldEnter(name string, args ...string) error {
chroot := filepath.Join(RepoRoot(), name)
// TODO(marineam): the original cros_sdk uses a white list to
// selectively pass through environment variables instead of the
// catch-all -E which is probably a better way to do it.
enterCmd := exec.Command(
"sudo", sudoPrompt, "-E",
"unshare", "--mount", "--",
filepath.Join(RepoRoot(), enterChrootSh),
"--chroot", chroot, "--cache_dir", RepoCache(), "--")
enterCmd.Args = append(enterCmd.Args, args...)
enterCmd.Env = setDefaultEmail(os.Environ())
enterCmd.Stdin = os.Stdin
enterCmd.Stdout = os.Stdout
enterCmd.Stderr = os.Stderr
return enterCmd.Run()
}
func Delete(name string) error {
chroot := filepath.Join(RepoRoot(), name)
if _, err := os.Stat(chroot); err != nil {
if os.IsNotExist(err) {
plog.Infof("Path does not exist: %s", chroot)
return nil
}
return err
}
plog.Noticef("Removing SDK at %s", chroot)
rm := exec.Command("sudo", sudoPrompt, "rm", "-rf", chroot)
rm.Stderr = os.Stderr
if err := rm.Run(); err != nil {
return err
}
plog.Notice("Removed")
return nil
}
// Copy the base image to a new nameless temporary file.
// cp is used since it supports sparse and reflink.
func setupDisk(imageFile string) (*os.File, error) {
dstFile, err := ioutil.TempFile("", "mantle-qemu")
if err != nil {
return nil, err
}
dstFileName := dstFile.Name()
defer os.Remove(dstFileName)
dstFile.Close()
cp := exec.Command("cp", "--force",
"--sparse=always", "--reflink=auto",
imageFile, dstFileName)
cp.Stdout = os.Stdout
cp.Stderr = os.Stderr
if err := cp.Run(); err != nil {
return nil, err
}
return os.OpenFile(dstFileName, os.O_RDWR, 0)
}
func NewNsCommand(ns netns.NsHandle, name string, arg ...string) *NsCmd {
return &NsCmd{
ExecCmd: exec.Command(name, arg...),
NsHandle: ns,
}
}