func (c *profileCmd) doProfileDelete(client *lxd.Client, p string) error {
err := client.ProfileDelete(p)
if err == nil {
fmt.Printf(i18n.G("Profile %s deleted")+"\n", p)
}
return err
}
func doProfileCreate(client *lxd.Client, p string) error {
err := client.ProfileCreate(p)
if err == nil {
fmt.Printf(gettext.Gettext("Profile %s created\n"), p)
}
return err
}
func (c *imageCmd) dereferenceAlias(d *lxd.Client, inName string) string {
result := d.GetAlias(inName)
if result == "" {
return inName
}
return result
}
func doProfileSet(client *lxd.Client, p string, args []string) error {
// we shifted @args so so it should read "<key> [<value>]"
if len(args) < 1 {
return errArgs
}
key := args[0]
var value string
if len(args) < 2 {
value = ""
} else {
value = args[1]
}
if !terminal.IsTerminal(syscall.Stdin) && value == "-" {
buf, err := ioutil.ReadAll(os.Stdin)
if err != nil {
return fmt.Errorf("Can't read from stdin: %s", err)
}
value = string(buf[:])
}
err := client.SetProfileConfigItem(p, key, value)
return err
}
func doProfileDelete(client *lxd.Client, p string) error {
err := client.ProfileDelete(p)
if err == nil {
fmt.Printf(gettext.Gettext("Profile %s deleted")+"\n", p)
}
return err
}
func doProfileCreate(client *lxd.Client, p string) error {
err := client.ProfileCreate(p)
if err == nil {
fmt.Printf(i18n.G("Profile %s created")+"\n", p)
}
return err
}
func (c *networkCmd) doNetworkAttachProfile(client *lxd.Client, name string, args []string) error {
if len(args) < 1 || len(args) > 2 {
return errArgs
}
profile := args[0]
devName := name
if len(args) > 1 {
devName = args[1]
}
network, err := client.NetworkGet(name)
if err != nil {
return err
}
nicType := "macvlan"
if network.Type == "bridge" {
nicType = "bridged"
}
props := []string{fmt.Sprintf("nictype=%s", nicType), fmt.Sprintf("parent=%s", name)}
_, err = client.ProfileDeviceAdd(profile, devName, "nic", props)
return err
}
func (c *profileCmd) doProfileRemove(client *lxd.Client, d string, p string) error {
ct, err := client.ContainerInfo(d)
if err != nil {
return err
}
if !shared.StringInSlice(p, ct.Profiles) {
return fmt.Errorf("Profile %s isn't currently applied to %s", p, d)
}
profiles := []string{}
for _, profile := range ct.Profiles {
if profile == p {
continue
}
profiles = append(profiles, profile)
}
ct.Profiles = profiles
err = client.UpdateContainerConfig(d, ct.Brief())
if err != nil {
return err
}
fmt.Printf(i18n.G("Profile %s removed from %s")+"\n", p, d)
return err
}
func getContainerState(client *lxd.Client, name string) *shared.ContainerState {
ct, err := client.ContainerState(name)
if err != nil {
return nil
}
return ct
}
func (c *networkCmd) doNetworkSet(client *lxd.Client, name string, args []string) error {
// we shifted @args so so it should read "<key> [<value>]"
if len(args) < 1 {
return errArgs
}
network, err := client.NetworkGet(name)
if err != nil {
return err
}
key := args[0]
var value string
if len(args) < 2 {
value = ""
} else {
value = args[1]
}
if !termios.IsTerminal(int(syscall.Stdin)) && value == "-" {
buf, err := ioutil.ReadAll(os.Stdin)
if err != nil {
return fmt.Errorf("Can't read from stdin: %s", err)
}
value = string(buf[:])
}
network.Config[key] = value
return client.NetworkPut(name, network)
}
func (c *networkCmd) doNetworkDelete(client *lxd.Client, name string) error {
err := client.NetworkDelete(name)
if err == nil {
fmt.Printf(i18n.G("Network %s deleted")+"\n", name)
}
return err
}
func doDelete(d *lxd.Client, name string) error {
resp, err := d.Delete(name)
if err != nil {
return err
}
return d.WaitForSuccess(resp.Operation)
}
func resourceLxdContainerRefresh(client *lxd.Client, name string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
ct, err := client.ContainerState(name)
if err != nil {
return ct, "Error", err
}
return ct, ct.Status, nil
}
}
func (c *networkCmd) doNetworkShow(client *lxd.Client, name string) error {
network, err := client.NetworkGet(name)
if err != nil {
return err
}
data, err := yaml.Marshal(&network)
fmt.Printf("%s", data)
return nil
}
func doProfileShow(client *lxd.Client, p string) error {
profile, err := client.ProfileConfig(p)
if err != nil {
return err
}
data, err := yaml.Marshal(&profile)
fmt.Printf("%s", data)
return nil
}
func doProfileApply(client *lxd.Client, c string, p string) error {
resp, err := client.ApplyProfile(c, p)
if err == nil {
if p == "" {
p = gettext.Gettext("(none)")
}
fmt.Printf(gettext.Gettext("Profile %s applied to %s")+"\n", p, c)
} else {
return err
}
return client.WaitForSuccess(resp.Operation)
}
// verifyDefaultProfileBridgeConfig takes a LXD API client and extracts the
// network bridge configured on the "default" profile. Additionally, if the
// default bridge bridge is used, its configuration in LXDBridgeFile is also
// inspected to make sure it has a chance to work.
func verifyDefaultProfileBridgeConfig(client *lxd.Client) (string, error) {
const (
defaultProfileName = "default"
configTypeKey = "type"
configTypeNic = "nic"
configNicTypeKey = "nictype"
configBridged = "bridged"
configEth0 = "eth0"
configParentKey = "parent"
)
config, err := client.ProfileConfig(defaultProfileName)
if err != nil {
return "", errors.Trace(err)
}
// If the default profile doesn't have eth0 in it, then the user has messed
// with it, so let's just use whatever they set up.
eth0, ok := config.Devices[configEth0]
if !ok {
return "", errors.Errorf("unexpected LXD %q profile config without eth0: %+v", defaultProfileName, config)
}
// If eth0 is there, but not with the expected attributes, likewise fail
// early.
if eth0[configTypeKey] != configTypeNic || eth0[configNicTypeKey] != configBridged {
return "", errors.Errorf("unexpected LXD %q profile config: %+v", defaultProfileName, config)
}
bridgeName := eth0[configParentKey]
logger.Infof(`LXD "default" profile uses network bridge %q`, bridgeName)
if bridgeName != network.DefaultLXDBridge {
// When the user changed which bridge to use, just return its name and
// check no further.
return bridgeName, nil
}
bridgeConfig, err := ioutil.ReadFile(LXDBridgeFile)
if os.IsNotExist(err) {
return "", bridgeConfigError("lxdbr0 configured but no config file found at " + LXDBridgeFile)
} else if err != nil {
return "", errors.Trace(err)
}
if err := checkLXDBridgeConfiguration(string(bridgeConfig)); err != nil {
return "", errors.Trace(err)
}
return bridgeName, nil
}
func remoteInfo(d *lxd.Client) error {
serverStatus, err := d.ServerStatus()
if err != nil {
return err
}
data, err := yaml.Marshal(&serverStatus)
if err != nil {
return err
}
fmt.Printf("%s", data)
return nil
}
func (c *profileCmd) doProfileAssign(client *lxd.Client, d string, p string) error {
resp, err := client.AssignProfile(d, p)
if err != nil {
return err
}
err = client.WaitForSuccess(resp.Operation)
if err == nil {
if p == "" {
p = i18n.G("(none)")
}
fmt.Printf(i18n.G("Profiles %s applied to %s")+"\n", p, d)
}
return err
}
func (c *initCmd) checkNetwork(d *lxd.Client, name string) {
ct, err := d.ContainerInfo(name)
if err != nil {
return
}
for _, d := range ct.ExpandedDevices {
if d["type"] == "nic" {
return
}
}
fmt.Fprintf(os.Stderr, "\n"+i18n.G("The container you are starting doesn’t have any network attached to it.")+"\n")
fmt.Fprintf(os.Stderr, " "+i18n.G("To create a new network, use: lxc network create")+"\n")
fmt.Fprintf(os.Stderr, " "+i18n.G("To assign a network to a container, use: lxc network assign")+"\n\n")
}
func doProfileSet(client *lxd.Client, p string, args []string) error {
// we shifted @args so so it should read "<key> [<value>]"
if len(args) < 1 {
return errArgs
}
key := args[0]
var value string
if len(args) < 2 {
value = ""
} else {
value = args[1]
}
err := client.SetProfileConfigItem(p, key, value)
return err
}
func doProfileApply(client *lxd.Client, c string, p string) error {
resp, err := client.ApplyProfile(c, p)
if err != nil {
return err
}
err = client.WaitForSuccess(resp.Operation)
if err == nil {
if p == "" {
p = i18n.G("(none)")
}
fmt.Printf(i18n.G("Profile %s applied to %s")+"\n", p, c)
}
return err
}
func doProfileCopy(config *lxd.Config, client *lxd.Client, p string, args []string) error {
if len(args) != 1 {
return errArgs
}
remote, newname := config.ParseRemoteAndContainer(args[0])
if newname == "" {
newname = p
}
dest, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
return client.ProfileCopy(p, newname, dest)
}
func doProfileGet(client *lxd.Client, p string, args []string) error {
// we shifted @args so so it should read "<key>"
if len(args) != 1 {
return errArgs
}
resp, err := client.GetProfileConfig(p)
if err != nil {
return err
}
for k, v := range resp {
if k == args[0] {
fmt.Printf("%s\n", v)
}
}
return nil
}
func (c *profileCmd) doProfileAdd(client *lxd.Client, d string, p string) error {
ct, err := client.ContainerInfo(d)
if err != nil {
return err
}
ct.Profiles = append(ct.Profiles, p)
err = client.UpdateContainerConfig(d, ct.Brief())
if err != nil {
return err
}
fmt.Printf(i18n.G("Profile %s added to %s")+"\n", p, d)
return err
}
func (c *deleteCmd) doDelete(d *lxd.Client, name string) error {
if c.interactive {
reader := bufio.NewReader(os.Stdin)
fmt.Printf(i18n.G("Remove %s (yes/no): "), name)
input, _ := reader.ReadString('\n')
input = strings.TrimSuffix(input, "\n")
if !shared.StringInSlice(strings.ToLower(input), []string{i18n.G("yes")}) {
return fmt.Errorf(i18n.G("User aborted delete operation."))
}
}
resp, err := d.Delete(name)
if err != nil {
return err
}
return d.WaitForSuccess(resp.Operation)
}
func (c *networkCmd) doNetworkGet(client *lxd.Client, name string, args []string) error {
// we shifted @args so so it should read "<key>"
if len(args) != 1 {
return errArgs
}
resp, err := client.NetworkGet(name)
if err != nil {
return err
}
for k, v := range resp.Config {
if k == args[0] {
fmt.Printf("%s\n", v)
}
}
return nil
}
func (c *networkCmd) doNetworkDetachProfile(client *lxd.Client, name string, args []string) error {
if len(args) < 1 || len(args) > 2 {
return errArgs
}
profileName := args[0]
devName := ""
if len(args) > 1 {
devName = args[1]
}
profile, err := client.ProfileConfig(profileName)
if err != nil {
return err
}
if devName == "" {
for n, d := range profile.Devices {
if d["type"] == "nic" && d["parent"] == name {
if devName != "" {
return fmt.Errorf(i18n.G("More than one device matches, specify the device name."))
}
devName = n
}
}
}
if devName == "" {
return fmt.Errorf(i18n.G("No device found for this network"))
}
device, ok := profile.Devices[devName]
if !ok {
return fmt.Errorf(i18n.G("The specified device doesn't exist"))
}
if device["type"] != "nic" || device["parent"] != name {
return fmt.Errorf(i18n.G("The specified device doesn't match the network"))
}
_, err = client.ProfileDeviceDelete(profileName, devName)
return err
}
func (c *networkCmd) doNetworkCreate(client *lxd.Client, name string, args []string) error {
config := map[string]string{}
for i := 0; i < len(args); i++ {
entry := strings.SplitN(args[i], "=", 2)
if len(entry) < 2 {
return errArgs
}
config[entry[0]] = entry[1]
}
err := client.NetworkCreate(name, config)
if err == nil {
fmt.Printf(i18n.G("Network %s created")+"\n", name)
}
return err
}
func lxdForceDelete(d *lxd.Client, name string) error {
resp, err := d.Action(name, "stop", -1, true, false)
if err == nil {
d.WaitForSuccess(resp.Operation)
}
resp, err = d.Delete(name)
if err != nil {
return err
}
return d.WaitForSuccess(resp.Operation)
}