github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/apiserver/client/instanceconfig_test.go (about)

     1  // Copyright 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package client_test
     5  
     6  import (
     7  	"fmt"
     8  	"net"
     9  	"strconv"
    10  
    11  	jc "github.com/juju/testing/checkers"
    12  	"github.com/juju/version"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/agent"
    16  	"github.com/juju/juju/apiserver/client"
    17  	"github.com/juju/juju/apiserver/params"
    18  	envtools "github.com/juju/juju/environs/tools"
    19  	"github.com/juju/juju/instance"
    20  	"github.com/juju/juju/juju/testing"
    21  	"github.com/juju/juju/network"
    22  	"github.com/juju/juju/state"
    23  	"github.com/juju/juju/state/multiwatcher"
    24  	jujutesting "github.com/juju/juju/testing"
    25  	coretools "github.com/juju/juju/tools"
    26  )
    27  
    28  type machineConfigSuite struct {
    29  	testing.JujuConnSuite
    30  }
    31  
    32  var _ = gc.Suite(&machineConfigSuite{})
    33  
    34  func (s *machineConfigSuite) TestMachineConfig(c *gc.C) {
    35  	addrs := network.NewAddresses("1.2.3.4")
    36  	hc := instance.MustParseHardware("mem=4G arch=amd64")
    37  	apiParams := params.AddMachineParams{
    38  		Jobs:       []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
    39  		InstanceId: instance.Id("1234"),
    40  		Nonce:      "foo",
    41  		HardwareCharacteristics: hc,
    42  		Addrs: params.FromNetworkAddresses(addrs),
    43  	}
    44  	machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
    45  	c.Assert(err, jc.ErrorIsNil)
    46  	c.Assert(len(machines), gc.Equals, 1)
    47  
    48  	machineId := machines[0].Machine
    49  	instanceConfig, err := client.InstanceConfig(s.State, machineId, apiParams.Nonce, "")
    50  	c.Assert(err, jc.ErrorIsNil)
    51  
    52  	envConfig, err := s.State.ModelConfig()
    53  	c.Assert(err, jc.ErrorIsNil)
    54  	mongoAddrs := s.State.MongoConnectionInfo().Addrs
    55  	apiAddrs := []string{net.JoinHostPort("localhost", strconv.Itoa(envConfig.APIPort()))}
    56  
    57  	c.Check(instanceConfig.MongoInfo.Addrs, gc.DeepEquals, mongoAddrs)
    58  	c.Check(instanceConfig.APIInfo.Addrs, gc.DeepEquals, apiAddrs)
    59  	toolsURL := fmt.Sprintf("https://%s/model/%s/tools/%s",
    60  		apiAddrs[0], jujutesting.ModelTag.Id(), instanceConfig.AgentVersion())
    61  	c.Assert(instanceConfig.ToolsList().URLs(), jc.DeepEquals, map[version.Binary][]string{
    62  		instanceConfig.AgentVersion(): []string{toolsURL},
    63  	})
    64  	//c.Assert(instanceConfig.ToolsList()[0].URL, gc.Equals, toolsURL)
    65  	c.Assert(instanceConfig.AgentEnvironment[agent.AllowsSecureConnection], gc.Equals, "true")
    66  }
    67  
    68  func (s *machineConfigSuite) TestSecureConnectionDisallowed(c *gc.C) {
    69  	// StateServingInfo without CAPrivateKey will not allow secure connections.
    70  	servingInfo := state.StateServingInfo{
    71  		PrivateKey:   jujutesting.ServerKey,
    72  		Cert:         jujutesting.ServerCert,
    73  		SharedSecret: "really, really secret",
    74  		APIPort:      4321,
    75  		StatePort:    1234,
    76  	}
    77  	s.State.SetStateServingInfo(servingInfo)
    78  	hc := instance.MustParseHardware("mem=4G arch=amd64")
    79  	apiParams := params.AddMachineParams{
    80  		Jobs:       []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
    81  		InstanceId: instance.Id("1234"),
    82  		Nonce:      "foo",
    83  		HardwareCharacteristics: hc,
    84  	}
    85  	machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
    86  	c.Assert(err, jc.ErrorIsNil)
    87  	c.Assert(len(machines), gc.Equals, 1)
    88  
    89  	machineId := machines[0].Machine
    90  	instanceConfig, err := client.InstanceConfig(s.State, machineId, apiParams.Nonce, "")
    91  	c.Assert(err, jc.ErrorIsNil)
    92  	c.Assert(instanceConfig.AgentEnvironment[agent.AllowsSecureConnection], gc.Equals, "false")
    93  }
    94  
    95  func (s *machineConfigSuite) TestMachineConfigNoArch(c *gc.C) {
    96  	apiParams := params.AddMachineParams{
    97  		Jobs:       []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
    98  		InstanceId: instance.Id("1234"),
    99  		Nonce:      "foo",
   100  	}
   101  	machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
   102  	c.Assert(err, jc.ErrorIsNil)
   103  	c.Assert(len(machines), gc.Equals, 1)
   104  	_, err = client.InstanceConfig(s.State, machines[0].Machine, apiParams.Nonce, "")
   105  	c.Assert(err, gc.ErrorMatches, fmt.Sprintf("arch is not set for %q", "machine-"+machines[0].Machine))
   106  }
   107  
   108  func (s *machineConfigSuite) TestMachineConfigNoTools(c *gc.C) {
   109  	s.PatchValue(&envtools.DefaultBaseURL, "")
   110  	addrs := network.NewAddresses("1.2.3.4")
   111  	hc := instance.MustParseHardware("mem=4G arch=amd64")
   112  	apiParams := params.AddMachineParams{
   113  		Series:     "quantal",
   114  		Jobs:       []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
   115  		InstanceId: instance.Id("1234"),
   116  		Nonce:      "foo",
   117  		HardwareCharacteristics: hc,
   118  		Addrs: params.FromNetworkAddresses(addrs),
   119  	}
   120  	machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
   121  	c.Assert(err, jc.ErrorIsNil)
   122  	_, err = client.InstanceConfig(s.State, machines[0].Machine, apiParams.Nonce, "")
   123  	c.Assert(err, gc.ErrorMatches, "finding tools: "+coretools.ErrNoMatches.Error())
   124  }