github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/worker/reboot/reboot_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package reboot_test
     5  
     6  import (
     7  	"sync"
     8  	"time"
     9  
    10  	"github.com/juju/clock"
    11  	jc "github.com/juju/testing/checkers"
    12  	"github.com/juju/utils"
    13  	gc "gopkg.in/check.v1"
    14  
    15  	"github.com/juju/juju/api"
    16  	apireboot "github.com/juju/juju/api/reboot"
    17  	"github.com/juju/juju/core/instance"
    18  	"github.com/juju/juju/core/machinelock"
    19  	jujutesting "github.com/juju/juju/juju/testing"
    20  	"github.com/juju/juju/juju/version"
    21  	"github.com/juju/juju/state"
    22  	"github.com/juju/juju/worker"
    23  	"github.com/juju/juju/worker/reboot"
    24  )
    25  
    26  type rebootSuite struct {
    27  	jujutesting.JujuConnSuite
    28  
    29  	machine     *state.Machine
    30  	stateAPI    api.Connection
    31  	rebootState apireboot.State
    32  
    33  	ct            *state.Machine
    34  	ctRebootState apireboot.State
    35  
    36  	clock clock.Clock
    37  }
    38  
    39  var _ = gc.Suite(&rebootSuite{})
    40  
    41  func (s *rebootSuite) SetUpTest(c *gc.C) {
    42  	var err error
    43  	template := state.MachineTemplate{
    44  		Series: version.SupportedLTS(),
    45  		Jobs:   []state.MachineJob{state.JobHostUnits},
    46  	}
    47  	s.JujuConnSuite.SetUpTest(c)
    48  
    49  	s.stateAPI, s.machine = s.OpenAPIAsNewMachine(c)
    50  	s.rebootState, err = s.stateAPI.Reboot()
    51  	c.Assert(err, jc.ErrorIsNil)
    52  	c.Assert(s.rebootState, gc.NotNil)
    53  
    54  	//Add container
    55  	s.ct, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.KVM)
    56  	c.Assert(err, jc.ErrorIsNil)
    57  	password, err := utils.RandomPassword()
    58  	c.Assert(err, jc.ErrorIsNil)
    59  	err = s.ct.SetPassword(password)
    60  	c.Assert(err, jc.ErrorIsNil)
    61  	err = s.ct.SetProvisioned("foo", "", "fake_nonce", nil)
    62  	c.Assert(err, jc.ErrorIsNil)
    63  
    64  	// Open api as container
    65  	ctState := s.OpenAPIAsMachine(c, s.ct.Tag(), password, "fake_nonce")
    66  	s.ctRebootState, err = ctState.Reboot()
    67  	c.Assert(err, jc.ErrorIsNil)
    68  	c.Assert(s.ctRebootState, gc.NotNil)
    69  
    70  	s.clock = &fakeClock{delay: time.Millisecond}
    71  }
    72  
    73  func (s *rebootSuite) TearDownTest(c *gc.C) {
    74  	s.JujuConnSuite.TearDownTest(c)
    75  }
    76  
    77  func (s *rebootSuite) TestStartStop(c *gc.C) {
    78  	worker, err := reboot.NewReboot(s.rebootState, s.AgentConfigForTag(c, s.machine.Tag()), &fakemachinelock{}, s.clock)
    79  	c.Assert(err, jc.ErrorIsNil)
    80  	worker.Kill()
    81  	c.Assert(worker.Wait(), gc.IsNil)
    82  }
    83  
    84  func (s *rebootSuite) TestWorkerCatchesRebootEvent(c *gc.C) {
    85  	wrk, err := reboot.NewReboot(s.rebootState, s.AgentConfigForTag(c, s.machine.Tag()), &fakemachinelock{}, s.clock)
    86  	c.Assert(err, jc.ErrorIsNil)
    87  	err = s.rebootState.RequestReboot()
    88  	c.Assert(err, jc.ErrorIsNil)
    89  	c.Assert(wrk.Wait(), gc.Equals, worker.ErrRebootMachine)
    90  	// The flag is cleared.
    91  	rFlag, err := s.machine.GetRebootFlag()
    92  	c.Assert(err, jc.ErrorIsNil)
    93  	c.Assert(rFlag, jc.IsFalse)
    94  
    95  }
    96  
    97  func (s *rebootSuite) TestContainerCatchesParentFlag(c *gc.C) {
    98  	wrk, err := reboot.NewReboot(s.ctRebootState, s.AgentConfigForTag(c, s.ct.Tag()), &fakemachinelock{}, s.clock)
    99  	c.Assert(err, jc.ErrorIsNil)
   100  	err = s.rebootState.RequestReboot()
   101  	c.Assert(err, jc.ErrorIsNil)
   102  	c.Assert(wrk.Wait(), gc.Equals, worker.ErrShutdownMachine)
   103  }
   104  
   105  type fakeClock struct {
   106  	clock.Clock
   107  	delay time.Duration
   108  }
   109  
   110  func (f *fakeClock) After(time.Duration) <-chan time.Time {
   111  	return time.After(f.delay)
   112  }
   113  
   114  type fakemachinelock struct {
   115  	mu sync.Mutex
   116  }
   117  
   118  func (f *fakemachinelock) Acquire(spec machinelock.Spec) (func(), error) {
   119  	f.mu.Lock()
   120  	return func() {
   121  		f.mu.Unlock()
   122  	}, nil
   123  }
   124  func (f *fakemachinelock) Report(opts ...machinelock.ReportOption) (string, error) {
   125  	return "", nil
   126  }