func (s *TestSuite) TestMakeCoMasterAndBackAndFailOthersToBecomeCoMasters(c *C) {
clearTestMaintenance()
slave1, err := inst.MakeCoMaster(&slave1Key)
c.Assert(err, IsNil)
// Now master & slave1 expected to be co-masters. Check!
master, _, _ := inst.ReadInstance(&masterKey)
c.Assert(master.MasterKey.Port, Not(Equals), inst.InvalidPort)
c.Assert(master.IsSlaveOf(slave1), Equals, true)
c.Assert(slave1.IsSlaveOf(master), Equals, true)
// Verify can't have additional co-masters
_, err = inst.MakeCoMaster(&masterKey)
c.Assert(err, Not(IsNil))
_, err = inst.MakeCoMaster(&slave1Key)
c.Assert(err, Not(IsNil))
_, err = inst.MakeCoMaster(&slave2Key)
c.Assert(err, Not(IsNil))
// detach - resotre to original state
master, err = inst.DetachSlaveFromMaster(&masterKey)
c.Assert(err, IsNil)
c.Assert(master.MasterKey.Port, Equals, inst.InvalidPort)
}
// MakeCoMaster attempts to make an instance co-master with its own master
func (this *HttpAPI) MakeCoMaster(params martini.Params, r render.Render) {
instanceKey, err := this.getInstanceKey(params["host"], params["port"])
if err != nil {
r.JSON(200, &APIResponse{Code: ERROR, Message: err.Error()})
return
}
instance, err := inst.MakeCoMaster(&instanceKey)
if err != nil {
r.JSON(200, &APIResponse{Code: ERROR, Message: err.Error()})
return
}
r.JSON(200, &APIResponse{Code: OK, Message: "Instance made co-master", Details: instance})
}
func (s *TestSuite) TestMakeCoMasterAndBack(c *C) {
clearTestMaintenance()
slave1, err := inst.MakeCoMaster(&slave1Key)
c.Assert(err, IsNil)
// Now master & slave1 expected to be co-masters. Check!
master, _ := inst.ReadTopologyInstance(&masterKey)
c.Assert(master.MasterKey.Port, Not(Equals), inst.InvalidPort)
c.Assert(master.IsSlaveOf(slave1), Equals, true)
c.Assert(slave1.IsSlaveOf(master), Equals, true)
// detach - resotre to original state
master, err = inst.DetachSlaveFromMaster(&masterKey)
slave1, _ = inst.ReadTopologyInstance(&slave1Key)
c.Assert(err, IsNil)
c.Assert(master.MasterKey.Port, Equals, inst.InvalidPort)
}
// Cli initiates a command line interface, executing requested command.
func Cli(command string, instance string, sibling string, owner string, reason string) {
instanceKey, err := inst.ParseInstanceKey(instance)
if err != nil {
instanceKey = nil
}
siblingKey, err := inst.ParseInstanceKey(sibling)
if err != nil {
siblingKey = nil
}
if len(owner) == 0 {
// get os username as owner
usr, err := user.Current()
if err != nil {
log.Fatale(err)
}
owner = usr.Username
}
if len(command) == 0 {
log.Fatal("expected command (-c) (discover|forget|continuous|move-up|move-below|make-co-master|begin-maintenance|end-maintenance|clusters|topology|resolve)")
}
switch command {
case "move-up":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
_, err := inst.MoveUp(instanceKey)
if err != nil {
log.Errore(err)
}
}
case "move-below":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
if siblingKey == nil {
log.Fatal("Cannot deduce sibling:", sibling)
}
_, err := inst.MoveBelow(instanceKey, siblingKey)
if err != nil {
log.Errore(err)
}
}
case "make-co-master":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
_, err := inst.MakeCoMaster(instanceKey)
if err != nil {
log.Errore(err)
}
}
case "detach-slave":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
_, err := inst.DetachSlaveFromMaster(instanceKey)
if err != nil {
log.Errore(err)
}
}
case "discover":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
orchestrator.StartDiscovery(*instanceKey)
}
case "forget":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
inst.ForgetInstance(instanceKey)
}
case "begin-maintenance":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
if owner == "" {
log.Fatal("--owner option required")
}
if reason == "" {
log.Fatal("--reason option required")
}
maintenanceKey, err := inst.BeginMaintenance(instanceKey, owner, reason)
if err == nil {
log.Infof("Maintenance key: %+v", maintenanceKey)
}
if err != nil {
log.Errore(err)
}
}
case "end-maintenance":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
err := inst.EndMaintenanceByInstanceKey(instanceKey)
if err != nil {
log.Errore(err)
}
}
case "clusters":
{
clusters, err := inst.ReadClusters()
if err != nil {
log.Errore(err)
} else {
fmt.Println(strings.Join(clusters, "\n"))
}
}
case "topology":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
output, err := inst.AsciiTopology(instance)
if err != nil {
log.Errore(err)
} else {
fmt.Println(output)
}
}
case "continuous":
{
orchestrator.ContinuousDiscovery()
}
case "resolve":
{
if instanceKey == nil {
log.Fatal("Cannot deduce instance:", instance)
}
if conn, err := net.Dial("tcp", instanceKey.DisplayString()); err == nil {
conn.Close()
} else {
log.Fatale(err)
}
fmt.Println(instanceKey.DisplayString())
}
default:
log.Fatal("Unknown command:", command)
}
}
func (s *TestSuite) TestFailMakeCoMaster(c *C) {
clearTestMaintenance()
_, err := inst.MakeCoMaster(&masterKey)
c.Assert(err, Not(IsNil))
}