deleted file mode 100644

@@ -1,2 +0,0 @@

-Michael Crosby <michael@crosbymichael.com> (@crosbymichael)

-Guillaume J. Charmes <guillaume@docker.com> (@creack)

deleted file mode 100644

@@ -1,135 +0,0 @@

-package execdriver

-

-import (

-	"errors"

-	"io"

-	"os"

-	"os/exec"

-)

-

-var (

-	ErrNotRunning              = errors.New("Process could not be started")

-	ErrWaitTimeoutReached      = errors.New("Wait timeout reached")

-	ErrDriverAlreadyRegistered = errors.New("A driver already registered this docker init function")

-	ErrDriverNotFound          = errors.New("The requested docker init has not been found")

-)

-

-var dockerInitFcts map[string]InitFunc

-

-type (

-	StartCallback func(*Command)

-	InitFunc      func(i *InitArgs) error

-)

-

-func RegisterInitFunc(name string, fct InitFunc) error {

-	if dockerInitFcts == nil {

-		dockerInitFcts = make(map[string]InitFunc)

-	}

-	if _, ok := dockerInitFcts[name]; ok {

-		return ErrDriverAlreadyRegistered

-	}

-	dockerInitFcts[name] = fct

-	return nil

-}

-

-func GetInitFunc(name string) (InitFunc, error) {

-	fct, ok := dockerInitFcts[name]

-	if !ok {

-		return nil, ErrDriverNotFound

-	}

-	return fct, nil

-}

-

-// Args provided to the init function for a driver

-type InitArgs struct {

-	User       string

-	Gateway    string

-	Ip         string

-	WorkDir    string

-	Privileged bool

-	Env        []string

-	Args       []string

-	Mtu        int

-	Driver     string

-	Console    string

-	Pipe       int

-	Root       string

-}

-

-// Driver specific information based on

-// processes registered with the driver

-type Info interface {

-	IsRunning() bool

-}

-

-// Terminal in an interface for drivers to implement

-// if they want to support Close and Resize calls from

-// the core

-type Terminal interface {

-	io.Closer

-	Resize(height, width int) error

-}

-

-type TtyTerminal interface {

-	Master() *os.File

-}

-

-type Driver interface {

-	Run(c *Command, pipes *Pipes, startCallback StartCallback) (int, error) // Run executes the process and blocks until the process exits and returns the exit code

-	Kill(c *Command, sig int) error

-	Name() string                                 // Driver name

-	Info(id string) Info                          // "temporary" hack (until we move state from core to plugins)

-	GetPidsForContainer(id string) ([]int, error) // Returns a list of pids for the given container.

-}

-

-// Network settings of the container

-type Network struct {

-	Gateway     string `json:"gateway"`

-	IPAddress   string `json:"ip"`

-	Bridge      string `json:"bridge"`

-	IPPrefixLen int    `json:"ip_prefix_len"`

-	Mtu         int    `json:"mtu"`

-}

-

-type Resources struct {

-	Memory     int64 `json:"memory"`

-	MemorySwap int64 `json:"memory_swap"`

-	CpuShares  int64 `json:"cpu_shares"`

-}

-

-type Mount struct {

-	Source      string `json:"source"`

-	Destination string `json:"destination"`

-	Writable    bool   `json:"writable"`

-	Private     bool   `json:"private"`

-}

-

-// Process wrapps an os/exec.Cmd to add more metadata

-type Command struct {

-	exec.Cmd `json:"-"`

-

-	ID         string     `json:"id"`

-	Privileged bool       `json:"privileged"`

-	User       string     `json:"user"`

-	Rootfs     string     `json:"rootfs"`   // root fs of the container

-	InitPath   string     `json:"initpath"` // dockerinit

-	Entrypoint string     `json:"entrypoint"`

-	Arguments  []string   `json:"arguments"`

-	WorkingDir string     `json:"working_dir"`

-	ConfigPath string     `json:"config_path"` // this should be able to be removed when the lxc template is moved into the driver

-	Tty        bool       `json:"tty"`

-	Network    *Network   `json:"network"` // if network is nil then networking is disabled

-	Config     []string   `json:"config"`  //  generic values that specific drivers can consume

-	Resources  *Resources `json:"resources"`

-	Mounts     []Mount    `json:"mounts"`

-

-	Terminal     Terminal `json:"-"`             // standard or tty terminal

-	Console      string   `json:"-"`             // dev/console path

-	ContainerPid int      `json:"container_pid"` // the pid for the process inside a container

-}

-

-// Return the pid of the process

-// If the process is nil -1 will be returned

-func (c *Command) Pid() int {

-	return c.ContainerPid

-}

deleted file mode 100644

@@ -1,23 +0,0 @@

-package execdrivers

-

-import (

-	"fmt"

-	"github.com/dotcloud/docker/execdriver"

-	"github.com/dotcloud/docker/execdriver/lxc"

-	"github.com/dotcloud/docker/execdriver/native"

-	"github.com/dotcloud/docker/pkg/sysinfo"

-	"path"

-)

-

-func NewDriver(name, root, initPath string, sysInfo *sysinfo.SysInfo) (execdriver.Driver, error) {

-	switch name {

-	case "lxc":

-		// we want to five the lxc driver the full docker root because it needs

-		// to access and write config and template files in /var/lib/docker/containers/*

-		// to be backwards compatible

-		return lxc.NewDriver(root, sysInfo.AppArmor)

-	case "native":

-		return native.NewDriver(path.Join(root, "execdriver", "native"), initPath)

-	}

-	return nil, fmt.Errorf("unknown exec driver %s", name)

-}

deleted file mode 100644

@@ -1,396 +0,0 @@

-package lxc

-

-import (

-	"fmt"

-	"github.com/dotcloud/docker/execdriver"

-	"github.com/dotcloud/docker/pkg/cgroups"

-	"github.com/dotcloud/docker/utils"

-	"io/ioutil"

-	"log"

-	"os"

-	"os/exec"

-	"path"

-	"path/filepath"

-	"strconv"

-	"strings"

-	"syscall"

-	"time"

-)

-

-const DriverName = "lxc"

-

-func init() {

-	execdriver.RegisterInitFunc(DriverName, func(args *execdriver.InitArgs) error {

-		if err := setupEnv(args); err != nil {

-			return err

-		}

-

-		if err := setupHostname(args); err != nil {

-			return err

-		}

-

-		if err := setupNetworking(args); err != nil {

-			return err

-		}

-

-		if err := setupCapabilities(args); err != nil {

-			return err

-		}

-

-		if err := setupWorkingDirectory(args); err != nil {

-			return err

-		}

-

-		if err := changeUser(args); err != nil {

-			return err

-		}

-

-		path, err := exec.LookPath(args.Args[0])

-		if err != nil {

-			log.Printf("Unable to locate %v", args.Args[0])

-			os.Exit(127)

-		}

-		if err := syscall.Exec(path, args.Args, os.Environ()); err != nil {

-			return fmt.Errorf("dockerinit unable to execute %s - %s", path, err)

-		}

-		panic("Unreachable")

-	})

-}

-

-type driver struct {

-	root       string // root path for the driver to use

-	apparmor   bool

-	sharedRoot bool

-}

-

-func NewDriver(root string, apparmor bool) (*driver, error) {

-	// setup unconfined symlink

-	if err := linkLxcStart(root); err != nil {

-		return nil, err

-	}

-	return &driver{

-		apparmor:   apparmor,

-		root:       root,

-		sharedRoot: rootIsShared(),

-	}, nil

-}

-

-func (d *driver) Name() string {

-	version := d.version()

-	return fmt.Sprintf("%s-%s", DriverName, version)

-}

-

-func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallback execdriver.StartCallback) (int, error) {

-	if err := execdriver.SetTerminal(c, pipes); err != nil {

-		return -1, err

-	}

-	configPath, err := d.generateLXCConfig(c)

-	if err != nil {

-		return -1, err

-	}

-	params := []string{

-		"lxc-start",

-		"-n", c.ID,

-		"-f", configPath,

-		"--",

-		c.InitPath,

-		"-driver",

-		DriverName,

-	}

-

-	if c.Network != nil {

-		params = append(params,

-			"-g", c.Network.Gateway,

-			"-i", fmt.Sprintf("%s/%d", c.Network.IPAddress, c.Network.IPPrefixLen),

-			"-mtu", strconv.Itoa(c.Network.Mtu),

-		)

-	}

-

-	if c.User != "" {

-		params = append(params, "-u", c.User)

-	}

-

-	if c.Privileged {

-		if d.apparmor {

-			params[0] = path.Join(d.root, "lxc-start-unconfined")

-

-		}

-		params = append(params, "-privileged")

-	}

-

-	if c.WorkingDir != "" {

-		params = append(params, "-w", c.WorkingDir)

-	}

-

-	params = append(params, "--", c.Entrypoint)

-	params = append(params, c.Arguments...)

-

-	if d.sharedRoot {

-		// lxc-start really needs / to be non-shared, or all kinds of stuff break

-		// when lxc-start unmount things and those unmounts propagate to the main

-		// mount namespace.

-		// What we really want is to clone into a new namespace and then

-		// mount / MS_REC|MS_SLAVE, but since we can't really clone or fork

-		// without exec in go we have to do this horrible shell hack...

-		shellString :=

-			"mount --make-rslave /; exec " +

-				utils.ShellQuoteArguments(params)

-

-		params = []string{

-			"unshare", "-m", "--", "/bin/sh", "-c", shellString,

-		}

-	}

-

-	var (

-		name = params[0]

-		arg  = params[1:]

-	)

-	aname, err := exec.LookPath(name)

-	if err != nil {

-		aname = name

-	}

-	c.Path = aname

-	c.Args = append([]string{name}, arg...)

-

-	if err := c.Start(); err != nil {

-		return -1, err

-	}

-

-	var (

-		waitErr  error

-		waitLock = make(chan struct{})

-	)

-	go func() {

-		if err := c.Wait(); err != nil {

-			if _, ok := err.(*exec.ExitError); !ok { // Do not propagate the error if it's simply a status code != 0

-				waitErr = err

-			}

-		}

-		close(waitLock)

-	}()

-

-	// Poll lxc for RUNNING status

-	pid, err := d.waitForStart(c, waitLock)

-	if err != nil {

-		if c.Process != nil {

-			c.Process.Kill()

-		}

-		return -1, err

-	}

-	c.ContainerPid = pid

-

-	if startCallback != nil {

-		startCallback(c)

-	}

-

-	<-waitLock

-

-	return getExitCode(c), waitErr

-}

-

-/// Return the exit code of the process

-// if the process has not exited -1 will be returned

-func getExitCode(c *execdriver.Command) int {

-	if c.ProcessState == nil {

-		return -1

-	}

-	return c.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()

-}

-

-func (d *driver) Kill(c *execdriver.Command, sig int) error {

-	return KillLxc(c.ID, sig)

-}

-

-func (d *driver) version() string {

-	var (

-		version string

-		output  []byte

-		err     error

-	)

-	if _, errPath := exec.LookPath("lxc-version"); errPath == nil {

-		output, err = exec.Command("lxc-version").CombinedOutput()

-	} else {

-		output, err = exec.Command("lxc-start", "--version").CombinedOutput()

-	}

-	if err == nil {

-		version = strings.TrimSpace(string(output))

-		if parts := strings.SplitN(version, ":", 2); len(parts) == 2 {

-			version = strings.TrimSpace(parts[1])

-		}

-	}

-	return version

-}

-

-func KillLxc(id string, sig int) error {

-	var (

-		err    error

-		output []byte

-	)

-	_, err = exec.LookPath("lxc-kill")

-	if err == nil {

-		output, err = exec.Command("lxc-kill", "-n", id, strconv.Itoa(sig)).CombinedOutput()

-	} else {

-		output, err = exec.Command("lxc-stop", "-k", "-n", id, strconv.Itoa(sig)).CombinedOutput()

-	}

-	if err != nil {

-		return fmt.Errorf("Err: %s Output: %s", err, output)

-	}

-	return nil

-}

-

-// wait for the process to start and return the pid for the process

-func (d *driver) waitForStart(c *execdriver.Command, waitLock chan struct{}) (int, error) {

-	var (

-		err    error

-		output []byte

-	)

-	// We wait for the container to be fully running.

-	// Timeout after 5 seconds. In case of broken pipe, just retry.

-	// Note: The container can run and finish correctly before

-	// the end of this loop

-	for now := time.Now(); time.Since(now) < 5*time.Second; {

-		select {

-		case <-waitLock:

-			// If the process dies while waiting for it, just return

-			return -1, nil

-		default:

-		}

-

-		output, err = d.getInfo(c.ID)

-		if err != nil {

-			output, err = d.getInfo(c.ID)

-			if err != nil {

-				return -1, err

-			}

-		}

-		info, err := parseLxcInfo(string(output))

-		if err != nil {

-			return -1, err

-		}

-		if info.Running {

-			return info.Pid, nil

-		}

-		time.Sleep(50 * time.Millisecond)

-	}

-	return -1, execdriver.ErrNotRunning

-}

-

-func (d *driver) getInfo(id string) ([]byte, error) {

-	return exec.Command("lxc-info", "-n", id).CombinedOutput()

-}

-

-type info struct {

-	ID     string

-	driver *driver

-}

-

-func (i *info) IsRunning() bool {

-	var running bool

-

-	output, err := i.driver.getInfo(i.ID)

-	if err != nil {

-		utils.Errorf("Error getting info for lxc container %s: %s (%s)", i.ID, err, output)

-		return false

-	}

-	if strings.Contains(string(output), "RUNNING") {

-		running = true

-	}

-	return running

-}

-

-func (d *driver) Info(id string) execdriver.Info {

-	return &info{

-		ID:     id,

-		driver: d,

-	}

-}

-

-func (d *driver) GetPidsForContainer(id string) ([]int, error) {

-	pids := []int{}

-

-	// cpu is chosen because it is the only non optional subsystem in cgroups

-	subsystem := "cpu"

-	cgroupRoot, err := cgroups.FindCgroupMountpoint(subsystem)

-	if err != nil {

-		return pids, err

-	}

-

-	cgroupDir, err := cgroups.GetThisCgroupDir(subsystem)

-	if err != nil {

-		return pids, err

-	}

-

-	filename := filepath.Join(cgroupRoot, cgroupDir, id, "tasks")

-	if _, err := os.Stat(filename); os.IsNotExist(err) {

-		// With more recent lxc versions use, cgroup will be in lxc/

-		filename = filepath.Join(cgroupRoot, cgroupDir, "lxc", id, "tasks")

-	}

-

-	output, err := ioutil.ReadFile(filename)

-	if err != nil {

-		return pids, err

-	}

-	for _, p := range strings.Split(string(output), "\n") {

-		if len(p) == 0 {

-			continue

-		}

-		pid, err := strconv.Atoi(p)

-		if err != nil {

-			return pids, fmt.Errorf("Invalid pid '%s': %s", p, err)

-		}

-		pids = append(pids, pid)

-	}

-	return pids, nil

-}

-

-func linkLxcStart(root string) error {

-	sourcePath, err := exec.LookPath("lxc-start")

-	if err != nil {

-		return err

-	}

-	targetPath := path.Join(root, "lxc-start-unconfined")

-

-	if _, err := os.Lstat(targetPath); err != nil && !os.IsNotExist(err) {

-		return err

-	} else if err == nil {

-		if err := os.Remove(targetPath); err != nil {

-			return err

-		}

-	}

-	return os.Symlink(sourcePath, targetPath)

-}

-

-// TODO: This can be moved to the mountinfo reader in the mount pkg

-func rootIsShared() bool {

-	if data, err := ioutil.ReadFile("/proc/self/mountinfo"); err == nil {

-		for _, line := range strings.Split(string(data), "\n") {

-			cols := strings.Split(line, " ")

-			if len(cols) >= 6 && cols[4] == "/" {

-				return strings.HasPrefix(cols[6], "shared")

-			}

-		}

-	}

-

-	// No idea, probably safe to assume so

-	return true

-}

-

-func (d *driver) generateLXCConfig(c *execdriver.Command) (string, error) {

-	root := path.Join(d.root, "containers", c.ID, "config.lxc")

-	fo, err := os.Create(root)

-	if err != nil {

-		return "", err

-	}

-	defer fo.Close()

-

-	if err := LxcTemplateCompiled.Execute(fo, struct {

-		*execdriver.Command

-		AppArmor bool

-	}{

-		Command:  c,

-		AppArmor: d.apparmor,

-	}); err != nil {

-		return "", err

-	}

-	return root, nil

-}

deleted file mode 100644

@@ -1,50 +0,0 @@

-package lxc

-

-import (

-	"bufio"

-	"errors"

-	"strconv"

-	"strings"

-)

-

-var (

-	ErrCannotParse = errors.New("cannot parse raw input")

-)

-

-type lxcInfo struct {

-	Running bool

-	Pid     int

-}

-

-func parseLxcInfo(raw string) (*lxcInfo, error) {

-	if raw == "" {

-		return nil, ErrCannotParse

-	}

-	var (

-		err  error

-		s    = bufio.NewScanner(strings.NewReader(raw))

-		info = &lxcInfo{}

-	)

-	for s.Scan() {

-		text := s.Text()

-

-		if s.Err() != nil {

-			return nil, s.Err()

-		}

-

-		parts := strings.Split(text, ":")

-		if len(parts) < 2 {

-			continue

-		}

-		switch strings.ToLower(strings.TrimSpace(parts[0])) {

-		case "state":

-			info.Running = strings.TrimSpace(parts[1]) == "RUNNING"

-		case "pid":

-			info.Pid, err = strconv.Atoi(strings.TrimSpace(parts[1]))

-			if err != nil {

-				return nil, err

-			}

-		}

-	}

-	return info, nil

-}

deleted file mode 100644

@@ -1,36 +0,0 @@

-package lxc

-

-import (

-	"testing"

-)

-

-func TestParseRunningInfo(t *testing.T) {

-	raw := `

-    state: RUNNING

-    pid:    50`

-

-	info, err := parseLxcInfo(raw)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if !info.Running {

-		t.Fatal("info should return a running state")

-	}

-	if info.Pid != 50 {

-		t.Fatalf("info should have pid 50 got %d", info.Pid)

-	}

-}

-

-func TestEmptyInfo(t *testing.T) {

-	_, err := parseLxcInfo("")

-	if err == nil {

-		t.Fatal("error should not be nil")

-	}

-}

-

-func TestBadInfo(t *testing.T) {

-	_, err := parseLxcInfo("state")

-	if err != nil {

-		t.Fatal(err)

-	}

-}

deleted file mode 100644

@@ -1,176 +0,0 @@

-package lxc

-

-import (

-	"encoding/json"

-	"fmt"

-	"github.com/dotcloud/docker/execdriver"

-	"github.com/dotcloud/docker/pkg/netlink"

-	"github.com/dotcloud/docker/pkg/user"

-	"github.com/syndtr/gocapability/capability"

-	"io/ioutil"

-	"net"

-	"os"

-	"strings"

-	"syscall"

-)

-

-// Clear environment pollution introduced by lxc-start

-func setupEnv(args *execdriver.InitArgs) error {

-	// Get env

-	var env []string

-	content, err := ioutil.ReadFile(".dockerenv")

-	if err != nil {

-		return fmt.Errorf("Unable to load environment variables: %v", err)

-	}

-	if err := json.Unmarshal(content, &env); err != nil {

-		return fmt.Errorf("Unable to unmarshal environment variables: %v", err)

-	}

-	// Propagate the plugin-specific container env variable

-	env = append(env, "container="+os.Getenv("container"))

-

-	args.Env = env

-

-	os.Clearenv()

-	for _, kv := range args.Env {

-		parts := strings.SplitN(kv, "=", 2)

-		if len(parts) == 1 {

-			parts = append(parts, "")

-		}

-		os.Setenv(parts[0], parts[1])

-	}

-

-	return nil

-}

-

-func setupHostname(args *execdriver.InitArgs) error {

-	hostname := getEnv(args, "HOSTNAME")

-	if hostname == "" {

-		return nil

-	}

-	return setHostname(hostname)

-}

-

-// Setup networking

-func setupNetworking(args *execdriver.InitArgs) error {

-	if args.Ip != "" {

-		// eth0

-		iface, err := net.InterfaceByName("eth0")

-		if err != nil {

-			return fmt.Errorf("Unable to set up networking: %v", err)

-		}

-		ip, ipNet, err := net.ParseCIDR(args.Ip)

-		if err != nil {

-			return fmt.Errorf("Unable to set up networking: %v", err)

-		}

-		if err := netlink.NetworkLinkAddIp(iface, ip, ipNet); err != nil {

-			return fmt.Errorf("Unable to set up networking: %v", err)

-		}

-		if err := netlink.NetworkSetMTU(iface, args.Mtu); err != nil {

-			return fmt.Errorf("Unable to set MTU: %v", err)

-		}

-		if err := netlink.NetworkLinkUp(iface); err != nil {

-			return fmt.Errorf("Unable to set up networking: %v", err)

-		}

-

-		// loopback

-		iface, err = net.InterfaceByName("lo")

-		if err != nil {

-			return fmt.Errorf("Unable to set up networking: %v", err)

-		}

-		if err := netlink.NetworkLinkUp(iface); err != nil {

-			return fmt.Errorf("Unable to set up networking: %v", err)

-		}

-	}

-	if args.Gateway != "" {

-		gw := net.ParseIP(args.Gateway)

-		if gw == nil {

-			return fmt.Errorf("Unable to set up networking, %s is not a valid gateway IP", args.Gateway)

-		}

-

-		if err := netlink.AddDefaultGw(gw); err != nil {

-			return fmt.Errorf("Unable to set up networking: %v", err)

-		}

-	}

-

-	return nil

-}

-

-// Setup working directory

-func setupWorkingDirectory(args *execdriver.InitArgs) error {

-	if args.WorkDir == "" {

-		return nil

-	}

-	if err := syscall.Chdir(args.WorkDir); err != nil {

-		return fmt.Errorf("Unable to change dir to %v: %v", args.WorkDir, err)

-	}

-	return nil

-}

-

-// Takes care of dropping privileges to the desired user

-func changeUser(args *execdriver.InitArgs) error {

-	uid, gid, suppGids, err := user.GetUserGroupSupplementary(

-		args.User,

-		syscall.Getuid(), syscall.Getgid(),

-	)

-	if err != nil {

-		return err

-	}

-

-	if err := syscall.Setgroups(suppGids); err != nil {

-		return fmt.Errorf("Setgroups failed: %v", err)

-	}

-	if err := syscall.Setgid(gid); err != nil {

-		return fmt.Errorf("Setgid failed: %v", err)

-	}

-	if err := syscall.Setuid(uid); err != nil {

-		return fmt.Errorf("Setuid failed: %v", err)

-	}

-

-	return nil

-}

-

-func setupCapabilities(args *execdriver.InitArgs) error {

-	if args.Privileged {

-		return nil

-	}

-

-	drop := []capability.Cap{

-		capability.CAP_SETPCAP,

-		capability.CAP_SYS_MODULE,

-		capability.CAP_SYS_RAWIO,

-		capability.CAP_SYS_PACCT,

-		capability.CAP_SYS_ADMIN,

-		capability.CAP_SYS_NICE,

-		capability.CAP_SYS_RESOURCE,

-		capability.CAP_SYS_TIME,

-		capability.CAP_SYS_TTY_CONFIG,

-		capability.CAP_MKNOD,

-		capability.CAP_AUDIT_WRITE,

-		capability.CAP_AUDIT_CONTROL,

-		capability.CAP_MAC_OVERRIDE,

-		capability.CAP_MAC_ADMIN,

-		capability.CAP_NET_ADMIN,

-	}

-

-	c, err := capability.NewPid(os.Getpid())

-	if err != nil {

-		return err

-	}

-

-	c.Unset(capability.CAPS|capability.BOUNDS, drop...)

-

-	if err := c.Apply(capability.CAPS | capability.BOUNDS); err != nil {

-		return err

-	}

-	return nil

-}

-

-func getEnv(args *execdriver.InitArgs, key string) string {

-	for _, kv := range args.Env {

-		parts := strings.SplitN(kv, "=", 2)

-		if parts[0] == key && len(parts) == 2 {

-			return parts[1]

-		}

-	}

-	return ""

-}

deleted file mode 100644

@@ -1,11 +0,0 @@

-// +build amd64

-

-package lxc

-

-import (

-	"syscall"

-)

-

-func setHostname(hostname string) error {

-	return syscall.Sethostname([]byte(hostname))

-}

deleted file mode 100644

@@ -1,7 +0,0 @@

-// +build !linux !amd64

-

-package lxc

-

-func setHostname(hostname string) error {

-	panic("Not supported on darwin")

-}

deleted file mode 100644

@@ -1,155 +0,0 @@

-package lxc