func (c *configCmd) run(config *lxd.Config, args []string) error {
if len(args) < 1 {
return errArgs
}
switch args[0] {
case "unset":
if len(args) < 2 {
return errArgs
}
// 2 args means we're unsetting a server key
if len(args) == 2 {
key := args[1]
c, err := lxd.NewClient(config, config.DefaultRemote)
if err != nil {
return err
}
_, err = c.SetServerConfig(key, "")
return err
}
// 3 args is a container config key
args = append(args, "")
return doSet(config, args)
case "set":
if len(args) < 3 {
return errArgs
}
// 3 args means we're setting a server key
if len(args) == 3 {
key := args[1]
c, err := lxd.NewClient(config, config.DefaultRemote)
if err != nil {
return err
}
_, err = c.SetServerConfig(key, args[2])
return err
}
// 4 args is a container config key
return doSet(config, args)
case "trust":
if len(args) < 2 {
return errArgs
}
switch args[1] {
case "list":
var remote string
if len(args) == 3 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
trust, err := d.CertificateList()
if err != nil {
return err
}
data := [][]string{}
for _, cert := range trust {
fp := cert.Fingerprint[0:12]
certBlock, _ := pem.Decode([]byte(cert.Certificate))
cert, err := x509.ParseCertificate(certBlock.Bytes)
if err != nil {
return err
}
const layout = "Jan 2, 2006 at 3:04pm (MST)"
issue := cert.NotBefore.Format(layout)
expiry := cert.NotAfter.Format(layout)
data = append(data, []string{fp, cert.Subject.CommonName, issue, expiry})
}
table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"FINGERPRINT", "COMMON NAME", "ISSUE DATE", "EXPIRY DATE"})
for _, v := range data {
table.Append(v)
}
table.Render()
return nil
case "add":
var remote string
if len(args) < 3 {
return fmt.Errorf(gettext.Gettext("No cert provided to add"))
} else if len(args) == 4 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
fname := args[len(args)-1]
cert, err := shared.ReadCert(fname)
if err != nil {
return err
}
name, _ := shared.SplitExt(fname)
return d.CertificateAdd(cert, name)
case "remove":
var remote string
if len(args) < 3 {
return fmt.Errorf(gettext.Gettext("No fingerprint specified."))
} else if len(args) == 4 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
return d.CertificateRemove(args[len(args)-1])
default:
return fmt.Errorf(gettext.Gettext("Unkonwn config trust command %s"), args[1])
}
case "show":
remote := config.DefaultRemote
container := ""
if len(args) > 1 {
remote, container = config.ParseRemoteAndContainer(args[1])
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
var data []byte
if len(args) == 1 || container == "" {
config, err := d.ServerStatus()
if err != nil {
return err
}
brief := config.BriefState()
data, err = yaml.Marshal(&brief)
} else {
config, err := d.ContainerStatus(container, false)
if err != nil {
return err
}
brief := config.BriefState()
data, err = yaml.Marshal(&brief)
}
fmt.Printf("%s", data)
return nil
case "get":
if len(args) != 3 {
return errArgs
}
remote, container := config.ParseRemoteAndContainer(args[1])
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
resp, err := d.ContainerStatus(container, false)
if err != nil {
return err
}
fmt.Printf("%s: %s\n", args[2], resp.Config[args[2]])
return nil
case "profile":
case "device":
if len(args) < 2 {
return errArgs
}
switch args[1] {
case "list":
return deviceList(config, "container", args)
case "add":
return deviceAdd(config, "container", args)
case "remove":
return deviceRm(config, "container", args)
case "show":
return deviceShow(config, "container", args)
default:
return errArgs
}
case "edit":
if len(args) != 2 {
return errArgs
}
remote, container := config.ParseRemoteAndContainer(args[1])
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
return doConfigEdit(d, container)
default:
return errArgs
}
return errArgs
}
func (c *configCmd) run(config *lxd.Config, args []string) error {
if len(args) < 1 {
return errArgs
}
switch args[0] {
case "unset":
if len(args) < 2 {
return errArgs
}
// Deal with local server
if len(args) == 2 {
c, err := lxd.NewClient(config, config.DefaultRemote)
if err != nil {
return err
}
ss, err := c.ServerStatus()
if err != nil {
return err
}
_, ok := ss.Config[args[1]]
if !ok {
return fmt.Errorf(i18n.G("Can't unset key '%s', it's not currently set."), args[1])
}
_, err = c.SetServerConfig(args[1], "")
return err
}
// Deal with remote server
remote, container := config.ParseRemoteAndContainer(args[1])
if container == "" {
c, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
ss, err := c.ServerStatus()
if err != nil {
return err
}
_, ok := ss.Config[args[1]]
if !ok {
return fmt.Errorf(i18n.G("Can't unset key '%s', it's not currently set."), args[1])
}
_, err = c.SetServerConfig(args[2], "")
return err
}
// Deal with container
args = append(args, "")
return c.doSet(config, args, true)
case "set":
if len(args) < 3 {
return errArgs
}
// Deal with local server
if len(args) == 3 {
c, err := lxd.NewClient(config, config.DefaultRemote)
if err != nil {
return err
}
_, err = c.SetServerConfig(args[1], args[2])
return err
}
// Deal with remote server
remote, container := config.ParseRemoteAndContainer(args[1])
if container == "" {
c, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
_, err = c.SetServerConfig(args[2], args[3])
return err
}
// Deal with container
return c.doSet(config, args, false)
case "trust":
if len(args) < 2 {
return errArgs
}
switch args[1] {
case "list":
var remote string
if len(args) == 3 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
trust, err := d.CertificateList()
if err != nil {
return err
}
data := [][]string{}
for _, cert := range trust {
fp := cert.Fingerprint[0:12]
certBlock, _ := pem.Decode([]byte(cert.Certificate))
if certBlock == nil {
return fmt.Errorf(i18n.G("Invalid certificate"))
}
cert, err := x509.ParseCertificate(certBlock.Bytes)
if err != nil {
return err
}
const layout = "Jan 2, 2006 at 3:04pm (MST)"
issue := cert.NotBefore.Format(layout)
expiry := cert.NotAfter.Format(layout)
data = append(data, []string{fp, cert.Subject.CommonName, issue, expiry})
}
table := tablewriter.NewWriter(os.Stdout)
table.SetAutoWrapText(false)
table.SetAlignment(tablewriter.ALIGN_LEFT)
table.SetRowLine(true)
table.SetHeader([]string{
i18n.G("FINGERPRINT"),
i18n.G("COMMON NAME"),
i18n.G("ISSUE DATE"),
i18n.G("EXPIRY DATE")})
sort.Sort(SortImage(data))
table.AppendBulk(data)
table.Render()
return nil
case "add":
var remote string
if len(args) < 3 {
return fmt.Errorf(i18n.G("No certificate provided to add"))
} else if len(args) == 4 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
fname := args[len(args)-1]
cert, err := shared.ReadCert(fname)
if err != nil {
return err
}
name, _ := shared.SplitExt(fname)
return d.CertificateAdd(cert, name)
case "remove":
var remote string
if len(args) < 3 {
return fmt.Errorf(i18n.G("No fingerprint specified."))
} else if len(args) == 4 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
return d.CertificateRemove(args[len(args)-1])
default:
return errArgs
}
case "show":
remote := config.DefaultRemote
container := ""
if len(args) > 1 {
remote, container = config.ParseRemoteAndContainer(args[1])
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
var data []byte
if len(args) == 1 || container == "" {
config, err := d.ServerStatus()
if err != nil {
return err
}
brief := config.Brief()
data, err = yaml.Marshal(&brief)
} else {
var brief shared.BriefContainerInfo
if shared.IsSnapshot(container) {
config, err := d.SnapshotInfo(container)
if err != nil {
return err
}
brief = shared.BriefContainerInfo{
Profiles: config.Profiles,
Config: config.Config,
Devices: config.Devices,
Ephemeral: config.Ephemeral,
}
if c.expanded {
brief = shared.BriefContainerInfo{
Profiles: config.Profiles,
Config: config.ExpandedConfig,
Devices: config.ExpandedDevices,
Ephemeral: config.Ephemeral,
}
}
} else {
config, err := d.ContainerInfo(container)
if err != nil {
return err
}
brief = config.Brief()
if c.expanded {
brief = config.BriefExpanded()
}
}
data, err = yaml.Marshal(&brief)
if err != nil {
return err
}
}
fmt.Printf("%s", data)
return nil
case "get":
if len(args) > 3 || len(args) < 2 {
return errArgs
}
remote := config.DefaultRemote
container := ""
key := args[1]
if len(args) > 2 {
remote, container = config.ParseRemoteAndContainer(args[1])
key = args[2]
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
if container != "" {
resp, err := d.ContainerInfo(container)
if err != nil {
return err
}
fmt.Println(resp.Config[key])
} else {
resp, err := d.ServerStatus()
if err != nil {
return err
}
value := resp.Config[key]
if value == nil {
value = ""
} else if value == true {
value = "true"
} else if value == false {
value = "false"
}
fmt.Println(value)
}
return nil
case "profile":
case "device":
if len(args) < 2 {
return errArgs
}
switch args[1] {
case "list":
return c.deviceList(config, "container", args)
case "add":
return c.deviceAdd(config, "container", args)
case "remove":
return c.deviceRm(config, "container", args)
case "get":
return c.deviceGet(config, "container", args)
case "set":
return c.deviceSet(config, "container", args)
case "unset":
return c.deviceUnset(config, "container", args)
case "show":
return c.deviceShow(config, "container", args)
default:
return errArgs
}
case "edit":
if len(args) < 1 {
return errArgs
}
remote := config.DefaultRemote
container := ""
if len(args) > 1 {
remote, container = config.ParseRemoteAndContainer(args[1])
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
if len(args) == 1 || container == "" {
return c.doDaemonConfigEdit(d)
}
return c.doContainerConfigEdit(d, container)
default:
return errArgs
}
return errArgs
}
func (c *configCmd) run(config *lxd.Config, args []string) error {
if len(args) < 1 {
return errArgs
}
switch args[0] {
case "unset":
if len(args) < 2 {
return errArgs
}
// 2 args means we're unsetting a server key
if len(args) == 2 {
key := args[1]
c, err := lxd.NewClient(config, "")
if err != nil {
return err
}
_, err = c.SetServerConfig(key, "")
return err
}
// 3 args is a container config key
args = append(args, "")
return doSet(config, args)
case "set":
if len(args) < 3 {
return errArgs
}
// 3 args means we're setting a server key
if len(args) == 3 {
key := args[1]
c, err := lxd.NewClient(config, "")
if err != nil {
return err
}
_, err = c.SetServerConfig(key, args[2])
return err
}
// 4 args is a container config key
return doSet(config, args)
case "trust":
if len(args) < 2 {
return errArgs
}
switch args[1] {
case "list":
var remote string
if len(args) == 3 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
trust, err := d.CertificateList()
if err != nil {
return err
}
for _, fingerprint := range trust {
fmt.Println(fmt.Sprintf("%s", fingerprint))
}
return nil
case "add":
var remote string
if len(args) < 3 {
return fmt.Errorf(gettext.Gettext("No cert provided to add"))
} else if len(args) == 4 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
fname := args[len(args)-1]
cert, err := shared.ReadCert(fname)
if err != nil {
return err
}
name, _ := shared.SplitExt(fname)
return d.CertificateAdd(cert, name)
case "remove":
var remote string
if len(args) < 3 {
return fmt.Errorf(gettext.Gettext("No fingerprint specified."))
} else if len(args) == 4 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
return d.CertificateRemove(args[len(args)-1])
default:
return fmt.Errorf(gettext.Gettext("Unkonwn config trust command %s"), args[1])
}
case "show":
remote := ""
container := ""
if len(args) > 1 {
remote, container = config.ParseRemoteAndContainer(args[1])
if container == "" {
return fmt.Errorf(gettext.Gettext("Show for remotes is not yet supported\n"))
}
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
var data []byte
if len(args) == 1 || container == "" {
config, err := d.ServerStatus()
if err != nil {
return err
}
brief := config.BriefState()
data, err = yaml.Marshal(&brief)
} else {
config, err := d.ContainerStatus(container, false)
if err != nil {
return err
}
brief := config.BriefState()
data, err = yaml.Marshal(&brief)
}
fmt.Printf("%s", data)
return nil
case "get":
if len(args) != 3 {
return errArgs
}
remote, container := config.ParseRemoteAndContainer(args[1])
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
resp, err := d.ContainerStatus(container, false)
if err != nil {
return err
}
fmt.Printf("%s: %s\n", args[2], resp.Config[args[2]])
return nil
case "profile":
case "device":
if len(args) < 2 {
return errArgs
}
switch args[1] {
case "list":
return deviceList(config, "container", args)
case "add":
return deviceAdd(config, "container", args)
case "remove":
return deviceRm(config, "container", args)
case "show":
return deviceShow(config, "container", args)
default:
return errArgs
}
case "edit":
if len(args) != 2 {
return errArgs
}
remote, container := config.ParseRemoteAndContainer(args[1])
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
return doConfigEdit(d, container)
default:
return errArgs
}
return errArgs
}
func (c *configCmd) run(config *lxd.Config, args []string) error {
if len(args) < 1 {
return errArgs
}
switch args[0] {
case "unset":
if len(args) < 2 {
return errArgs
}
// Deal with local server
if len(args) == 2 {
c, err := lxd.NewClient(config, config.DefaultRemote)
if err != nil {
return err
}
_, err = c.SetServerConfig(args[1], "")
return err
}
// Deal with remote server
remote, container := config.ParseRemoteAndContainer(args[1])
if container == "" {
c, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
_, err = c.SetServerConfig(args[2], "")
return err
}
// Deal with container
args = append(args, "")
return doSet(config, args)
case "set":
if len(args) < 3 {
return errArgs
}
// Deal with local server
if len(args) == 3 {
c, err := lxd.NewClient(config, config.DefaultRemote)
if err != nil {
return err
}
_, err = c.SetServerConfig(args[1], args[2])
return err
}
// Deal with remote server
remote, container := config.ParseRemoteAndContainer(args[1])
if container == "" {
c, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
_, err = c.SetServerConfig(args[2], args[3])
return err
}
// Deal with container
return doSet(config, args)
case "trust":
if len(args) < 2 {
return errArgs
}
switch args[1] {
case "list":
var remote string
if len(args) == 3 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
trust, err := d.CertificateList()
if err != nil {
return err
}
data := [][]string{}
for _, cert := range trust {
fp := cert.Fingerprint[0:12]
certBlock, _ := pem.Decode([]byte(cert.Certificate))
cert, err := x509.ParseCertificate(certBlock.Bytes)
if err != nil {
return err
}
const layout = "Jan 2, 2006 at 3:04pm (MST)"
issue := cert.NotBefore.Format(layout)
expiry := cert.NotAfter.Format(layout)
data = append(data, []string{fp, cert.Subject.CommonName, issue, expiry})
}
table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{
i18n.G("FINGERPRINT"),
i18n.G("COMMON NAME"),
i18n.G("ISSUE DATE"),
i18n.G("EXPIRY DATE")})
for _, v := range data {
table.Append(v)
}
table.Render()
return nil
case "add":
var remote string
if len(args) < 3 {
return fmt.Errorf(i18n.G("No certificate provided to add"))
} else if len(args) == 4 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
fname := args[len(args)-1]
cert, err := shared.ReadCert(fname)
if err != nil {
return err
}
name, _ := shared.SplitExt(fname)
return d.CertificateAdd(cert, name)
case "remove":
var remote string
if len(args) < 3 {
return fmt.Errorf(i18n.G("No fingerprint specified."))
} else if len(args) == 4 {
remote = config.ParseRemote(args[2])
} else {
remote = config.DefaultRemote
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
return d.CertificateRemove(args[len(args)-1])
default:
return errArgs
}
case "show":
remote := config.DefaultRemote
container := ""
if len(args) > 1 {
remote, container = config.ParseRemoteAndContainer(args[1])
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
var data []byte
if len(args) == 1 || container == "" {
config, err := d.ServerStatus()
if err != nil {
return err
}
brief := config.BriefState()
data, err = yaml.Marshal(&brief)
} else {
config, err := d.ContainerStatus(container)
if err != nil {
return err
}
brief := config.BriefState()
if expanded {
brief = config.BriefStateExpanded()
}
data, err = yaml.Marshal(&brief)
}
fmt.Printf("%s", data)
return nil
case "get":
if len(args) > 3 || len(args) < 2 {
return errArgs
}
remote := config.DefaultRemote
container := ""
key := args[1]
if len(args) > 2 {
remote, container = config.ParseRemoteAndContainer(args[1])
key = args[2]
}
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
if container != "" {
resp, err := d.ContainerStatus(container)
if err != nil {
return err
}
fmt.Printf("%s: %s\n", key, resp.Config[key])
} else {
resp, err := d.ServerStatus()
if err != nil {
return err
}
value := resp.Config[key]
if value == nil {
value = ""
} else if value == true {
value = "true"
} else if value == false {
value = "false"
}
fmt.Printf("%s: %s\n", key, value)
}
return nil
case "profile":
case "device":
if len(args) < 2 {
return errArgs
}
switch args[1] {
case "list":
return deviceList(config, "container", args)
case "add":
return deviceAdd(config, "container", args)
case "remove":
return deviceRm(config, "container", args)
case "show":
return deviceShow(config, "container", args)
default:
return errArgs
}
case "edit":
if len(args) != 2 {
return errArgs
}
remote, container := config.ParseRemoteAndContainer(args[1])
d, err := lxd.NewClient(config, remote)
if err != nil {
return err
}
return doConfigEdit(d, container)
default:
return errArgs
}
return errArgs
}
