// NewMachine initializes a new Machine struct with any internal vars created. func NewMachine(meta MachineMeta, log logging.Logger, t Transport) (*Machine, error) { log = MachineLogger(meta, log) // Create our Pingers, to be used in the PingTrackers kitePinger := kitepinger.NewKitePinger(t) httpPinger, err := kitepinger.NewKiteHTTPPinger(meta.URL) if err != nil { log.Error( "Unable to create HTTPPinger from meta.URL. url:%s, err:%s", meta.URL, err, ) return nil, err } m := &Machine{ MachineMeta: meta, Log: log, KiteTracker: kitepinger.NewPingTracker(kitePinger), HTTPTracker: kitepinger.NewPingTracker(httpPinger), Transport: t, discover: discover.NewClient(), mountLocker: util.NewMutexWithState(), } m.discover.Log = m.Log.New("discover") // Start our http pinger, to give online/offline statuses for all machines. m.HTTPTracker.Start() return m, nil }
// InitHTTPTracker creates the HTTPTracker for this Machine, if it is // currently nil. // // This allows a caller to simply call this method beforehand on any machine, // valid or not, and access the online/offline status of the remote kite. func (m *Machine) InitHTTPTracker() error { if m.HasHTTPTracker() { return nil } // If the URL is empty, don't bother - nothing we can do. if m.URL == "" { return errors.New("Unable to Init HTTPTracker, Machine.URL is empty.") } httpPinger, err := kitepinger.NewKiteHTTPPinger(m.URL) if err != nil { return err } m.HTTPTracker = kitepinger.NewPingTracker(httpPinger) return nil }
func TestGetMachinesWithoutCache(t *testing.T) { Convey("Given a Remote", t, func() { kg := newMockKiteGetter() store := storage.NewMemoryStorage() r := &Remote{ localKite: &kite.Kite{ Id: "test id", Config: &config.Config{ Username: "******", }, }, kitesGetter: kg, log: discardLogger, machines: machine.NewMachines(discardLogger, store), machinesCacheMax: 1 * time.Second, machineNamesCache: map[string]string{}, storage: store, } // Sanity check our count. So(r.machines.Count(), ShouldEqual, 0) Convey("Given a new machine", func() { kg.AddByUrl("http://testhost1:56789") // Sanity check our config So(kg.Clients[0].Reconnect, ShouldBeFalse) Convey("It should configure the kite Client", func() { r.GetMachinesWithoutCache() So(kg.Clients[0].Reconnect, ShouldBeTrue) }) Convey("It should add the new machine", func() { machines, err := r.GetMachinesWithoutCache() So(err, ShouldBeNil) So(machines, ShouldNotBeNil) So(machines.Count(), ShouldEqual, 1) }) Convey("It should create the HTTPTracker", func() { machines, err := r.GetMachinesWithoutCache() So(err, ShouldBeNil) So(machines, ShouldNotBeNil) mach := machines.Machines()[0] So(mach, ShouldNotBeNil) So(mach.HTTPTracker, ShouldNotBeNil) Convey("It should start the HTTPTracker", func() { So(mach.HTTPTracker.IsPinging(), ShouldBeTrue) }) }) }) Convey("Given a loaded but not yet valid machine", func() { kg.AddByUrl("http://testhost1:56789") // Add a machine, with just enough info to serve our needs r.machines.Add(&machine.Machine{ MachineMeta: machine.MachineMeta{ IP: "testhost1", }, }) // Sanity check our config So(kg.Clients[0].Reconnect, ShouldBeFalse) Convey("It should configure the kite Client", func() { r.GetMachinesWithoutCache() So(kg.Clients[0].Reconnect, ShouldBeTrue) }) Convey("It should not add a new machine for the kite", func() { machines, err := r.GetMachinesWithoutCache() So(err, ShouldBeNil) So(machines, ShouldNotBeNil) So(machines.Count(), ShouldEqual, 1) }) Convey("It should create the HTTPTracker", func() { machines, err := r.GetMachinesWithoutCache() So(err, ShouldBeNil) So(machines, ShouldNotBeNil) mach := machines.Machines()[0] So(mach, ShouldNotBeNil) So(mach.HTTPTracker, ShouldNotBeNil) Convey("It should start the HTTPTracker", func() { So(mach.HTTPTracker.IsPinging(), ShouldBeTrue) }) }) }) Convey("Given an pre existing valid machine", func() { kg.AddByUrl("http://testhost1:56789") // Add a machine, with just enough info to serve our needs validMachine := &machine.Machine{ MachineMeta: machine.MachineMeta{ IP: "testhost1", }, Log: testutil.DiscardLogger, KiteTracker: kitepinger.NewPingTracker(nil), // Invalid ping trackers, but HTTPTracker: kitepinger.NewPingTracker(nil), // okay for this test currently // a bit of a trick, Machine implements Transport, so we're using an empty // machine here to implement transport, and thus make the validMachine instance // "valid". Both this and the pingtrackers above are not usable, but satisfy // the checkvalid requirements. Transport: &machine.Machine{}, } So(r.machines.Add(validMachine), ShouldBeNil) // sanity check, to make sure it's valid So(validMachine.CheckValid(), ShouldBeNil) Convey("It should be the same machine instance", func() { machines, err := r.GetMachinesWithoutCache() So(err, ShouldBeNil) returnedMachine := machines.Machines()[0] So(returnedMachine, ShouldEqual, validMachine) }) Convey("It should only return 1 machine", func() { machines, err := r.GetMachinesWithoutCache() So(err, ShouldBeNil) So(machines.Count(), ShouldEqual, 1) }) Convey("With a label that does not match the local label", func() { kg.Clients[0].MachineLabel = "foobarbaz" // Sanity check So(kg.Clients[0].MachineLabel, ShouldNotEqual, validMachine.MachineLabel) Convey("It should update the machine label", func() { machines, err := r.GetMachinesWithoutCache() So(err, ShouldBeNil) returnedMachine := machines.Machines()[0] So(returnedMachine.MachineLabel, ShouldEqual, validMachine.MachineLabel) }) }) }) }) }