// StartInstanceWithConstraintsAndNetworks is a test helper function that
// starts an instance with the given networks, and a plausible but invalid
// configuration, and returns the result of Environ.StartInstance.
func StartInstanceWithConstraintsAndNetworks(
env environs.Environ, machineId string, cons constraints.Value,
includeNetworks, excludeNetworks []string,
) (
instance.Instance, *instance.HardwareCharacteristics, []network.Info, error,
) {
series := config.PreferredSeries(env.Config())
agentVersion, ok := env.Config().AgentVersion()
if !ok {
return nil, nil, nil, fmt.Errorf("missing agent version in environment config")
}
possibleTools, err := tools.FindInstanceTools(env, agentVersion, series, cons.Arch)
if err != nil {
return nil, nil, nil, err
}
machineNonce := "fake_nonce"
stateInfo := FakeStateInfo(machineId)
apiInfo := FakeAPIInfo(machineId)
machineConfig := environs.NewMachineConfig(
machineId, machineNonce,
includeNetworks, excludeNetworks,
stateInfo, apiInfo)
return env.StartInstance(environs.StartInstanceParams{
Constraints: cons,
Tools: possibleTools,
MachineConfig: machineConfig,
})
}
func (s *UpgradeJujuSuite) TestUpgradeJujuWithRealUpload(c *gc.C) {
s.Reset(c)
_, err := coretesting.RunCommand(c, &UpgradeJujuCommand{}, []string{"--upload-tools"})
c.Assert(err, gc.IsNil)
vers := version.Current
vers.Build = 1
tools, err := envtools.FindInstanceTools(s.Conn.Environ, vers.Number, vers.Series, &vers.Arch)
c.Assert(err, gc.IsNil)
c.Assert(len(tools), gc.Equals, 1)
}
func findInstanceTools(env environs.Environ, series, arch string) (*tools.Tools, error) {
agentVersion, ok := env.Config().AgentVersion()
if !ok {
return nil, fmt.Errorf("no agent version set in environment configuration")
}
possibleTools, err := envtools.FindInstanceTools(env, agentVersion, series, &arch)
if err != nil {
return nil, err
}
return possibleTools[0], nil
}
func (task *provisionerTask) possibleTools(series string, cons constraints.Value) (coretools.List, error) {
if env, ok := task.broker.(environs.Environ); ok {
agentVersion, ok := env.Config().AgentVersion()
if !ok {
return nil, fmt.Errorf("no agent version set in environment configuration")
}
return tools.FindInstanceTools(env, agentVersion, series, cons.Arch)
}
if hasTools, ok := task.broker.(coretools.HasTools); ok {
return hasTools.Tools(series), nil
}
panic(fmt.Errorf("broker of type %T does not provide any tools", task.broker))
}
func (s *SimpleStreamsToolsSuite) TestFindInstanceTools(c *gc.C) {
for i, test := range findInstanceToolsTests {
c.Logf("\ntest %d: %s", i, test.info)
s.reset(c, map[string]interface{}{
"agent-version": test.agentVersion.String(),
})
available := s.uploadCustom(c, test.available...)
agentVersion, _ := s.env.Config().AgentVersion()
actual, err := envtools.FindInstanceTools(s.env, agentVersion, test.series, &test.arch)
if test.err != nil {
if len(actual) > 0 {
c.Logf(actual.String())
}
c.Check(err, jc.Satisfies, errors.IsNotFound)
continue
}
expect := map[version.Binary]string{}
for _, expected := range test.expect {
expect[expected] = available[expected]
}
c.Check(actual.URLs(), gc.DeepEquals, expect)
}
}