func (s *configFunctionalSuite) TestUsingTCPRemote(c *gc.C) {
if s.client == nil {
c.Skip("LXD not running locally")
}
// We can't just pass the testingCert as part of the Local connection,
// because Validate() doesn't like Local remotes that have
// Certificates.
lxdclient.PatchGenerateCertificate(&s.CleanupSuite, testingCert, testingKey)
cfg := lxdclient.Config{
Namespace: "my-ns",
Remote: lxdclient.Local,
}
nonlocal, err := cfg.UsingTCPRemote()
c.Assert(err, jc.ErrorIsNil)
checkValidRemote(c, &nonlocal.Remote)
c.Check(nonlocal, jc.DeepEquals, lxdclient.Config{
Namespace: "my-ns",
Remote: lxdclient.Remote{
Name: lxdclient.Local.Name,
Host: nonlocal.Remote.Host,
Cert: nonlocal.Remote.Cert,
Protocol: lxdclient.LXDProtocol,
ServerPEMCert: nonlocal.Remote.ServerPEMCert,
},
})
c.Check(nonlocal.Remote.Host, gc.Not(gc.Equals), "")
c.Check(nonlocal.Remote.Cert.CertPEM, gc.Not(gc.Equals), "")
c.Check(nonlocal.Remote.Cert.KeyPEM, gc.Not(gc.Equals), "")
c.Check(nonlocal.Remote.ServerPEMCert, gc.Not(gc.Equals), "")
// TODO(ericsnow) Check that the server has the certs.
}
func (s *configSuite) TestValidateOnlyRemote(c *gc.C) {
cfg := lxdclient.Config{
Remote: s.remote,
}
err := cfg.Validate()
c.Check(err, jc.ErrorIsNil)
}
func (s *configSuite) TestValidateMissingRemote(c *gc.C) {
cfg := lxdclient.Config{
Namespace: "my-ns",
}
err := cfg.Validate()
c.Check(err, jc.Satisfies, errors.IsNotValid)
}
func (s *configSuite) TestWithDefaultsMissingRemote(c *gc.C) {
cfg := lxdclient.Config{}
updated, err := cfg.WithDefaults()
c.Assert(err, jc.ErrorIsNil)
c.Check(updated, jc.DeepEquals, lxdclient.Config{
Remote: lxdclient.Local,
})
}
func (s *configSuite) TestWithDefaultsOkay(c *gc.C) {
cfg := lxdclient.Config{
Remote: s.remote,
}
updated, err := cfg.WithDefaults()
c.Assert(err, jc.ErrorIsNil)
c.Check(updated, jc.DeepEquals, cfg)
}
func (s *configSuite) TestValidateOkay(c *gc.C) {
cfg := lxdclient.Config{
Namespace: "my-ns",
Remote: s.remote,
}
err := cfg.Validate()
c.Check(err, jc.ErrorIsNil)
}
func (s *configSuite) TestUsingTCPRemoteNoop(c *gc.C) {
cfg := lxdclient.Config{
Namespace: "my-ns",
Remote: s.remote,
}
nonlocal, err := cfg.UsingTCPRemote()
c.Assert(err, jc.ErrorIsNil)
c.Check(nonlocal, jc.DeepEquals, cfg)
}
func (s *configSuite) TestWithDefaultsMissingStream(c *gc.C) {
cfg := lxdclient.Config{
Namespace: "my-ns",
Remote: s.remote,
}
updated, err := cfg.WithDefaults()
c.Assert(err, jc.ErrorIsNil)
c.Check(updated, jc.DeepEquals, lxdclient.Config{
Namespace: "my-ns",
Remote: s.remote,
})
}
func ConnectLocal() (*lxdclient.Client, error) {
cfg := lxdclient.Config{
Remote: lxdclient.Local,
}
cfg, err := cfg.WithDefaults()
if err != nil {
return nil, errors.Trace(err)
}
client, err := lxdclient.Connect(cfg, false)
if err != nil {
return nil, errors.Trace(err)
}
return client, nil
}
func ConnectLocal(namespace string) (*lxdclient.Client, error) {
cfg := lxdclient.Config{
Namespace: namespace,
Remote: lxdclient.Local,
}
cfg, err := cfg.WithDefaults()
if err != nil {
return nil, errors.Trace(err)
}
client, err := lxdclient.Connect(cfg)
if err != nil {
return nil, errors.Trace(err)
}
return client, nil
}
// clientConfig builds a LXD Config based on the env config and returns it.
func (c *environConfig) clientConfig() (lxdclient.Config, error) {
remote := lxdclient.Remote{
Name: "juju-remote",
Host: c.remoteURL(),
ServerPEMCert: c.serverPEMCert(),
}
if c.clientCert() != "" {
certPEM := []byte(c.clientCert())
keyPEM := []byte(c.clientKey())
cert := lxdclient.NewCert(certPEM, keyPEM)
cert.Name = fmt.Sprintf("juju cert for env %q", c.Name())
remote.Cert = &cert
}
cfg := lxdclient.Config{
Namespace: c.namespace(),
Remote: remote,
}
cfg, err := cfg.WithDefaults()
if err != nil {
return cfg, errors.Trace(err)
}
return cfg, nil
}
func (s *configSuite) TestValidateZeroValue(c *gc.C) {
var cfg lxdclient.Config
err := cfg.Validate()
c.Check(err, jc.Satisfies, errors.IsNotValid)
}