func (*ManifoldsSuite) TestMigrationGuardsUsed(c *gc.C) {
exempt := set.NewStrings(
"agent",
"api-caller",
"api-config-watcher",
"log-forwarder",
"state",
"state-config-watcher",
"termination-signal-handler",
"unconverted-state-workers",
"migration-fortress",
"migration-inactive-flag",
"migration-minion",
"upgrade-check-flag",
"upgrade-check-gate",
"upgrade-steps-flag",
"upgrade-steps-gate",
"upgrade-steps-runner",
"upgrader",
)
manifolds := machine.Manifolds(machine.ManifoldsConfig{})
for name, manifold := range manifolds {
c.Logf(name)
if !exempt.Contains(name) {
checkContains(c, manifold.Inputs, "migration-fortress")
checkContains(c, manifold.Inputs, "migration-inactive-flag")
}
}
}
func (*ManifoldsSuite) TestUpgradesBlockMigration(c *gc.C) {
manifolds := machine.Manifolds(machine.ManifoldsConfig{})
manifold, ok := manifolds["migration-fortress"]
c.Assert(ok, jc.IsTrue)
checkContains(c, manifold.Inputs, "upgrade-check-flag")
checkContains(c, manifold.Inputs, "upgrade-steps-flag")
}
func (*ManifoldsSuite) TestStartFuncs(c *gc.C) {
manifolds := machine.Manifolds(machine.ManifoldsConfig{
Agent: fakeAgent{},
})
for name, manifold := range manifolds {
c.Logf("checking %q manifold", name)
c.Check(manifold.Start, gc.NotNil)
}
}
func (*ManifoldsSuite) TestUpgradeGates(c *gc.C) {
upgradeStepsLock := gate.NewLock()
upgradeCheckLock := gate.NewLock()
manifolds := machine.Manifolds(machine.ManifoldsConfig{
UpgradeStepsLock: upgradeStepsLock,
UpgradeCheckLock: upgradeCheckLock,
})
assertGate(c, manifolds["upgrade-steps-gate"], upgradeStepsLock)
assertGate(c, manifolds["upgrade-check-gate"], upgradeCheckLock)
}
func (*ManifoldsSuite) TestManifoldNames(c *gc.C) {
manifolds := machine.Manifolds(machine.ManifoldsConfig{})
keys := make([]string, 0, len(manifolds))
for k := range manifolds {
keys = append(keys, k)
}
sort.Strings(keys)
expectedKeys := []string{
"agent",
"api-address-updater",
"api-caller",
"api-config-watcher",
"disk-manager",
"host-key-reporter",
"log-forwarder",
"log-sender",
"logging-config-updater",
"machine-action-runner",
"machiner",
"mgo-txn-resumer",
"migration-fortress",
"migration-minion",
"migration-inactive-flag",
"proxy-config-updater",
"reboot-executor",
"serving-info-setter",
"ssh-authkeys-updater",
"ssh-identity-writer",
"state",
"state-config-watcher",
"storage-provisioner",
"termination-signal-handler",
"tools-version-checker",
"unconverted-api-workers",
"unconverted-state-workers",
"unit-agent-deployer",
"upgrade-check-flag",
"upgrade-check-gate",
"upgrade-steps-flag",
"upgrade-steps-gate",
"upgrade-steps-runner",
"upgrader",
}
c.Assert(keys, jc.SameContents, expectedKeys)
}
func (*ManifoldsSuite) TestUpgradeGuardsUsed(c *gc.C) {
exempt := set.NewStrings(
"agent",
"api-caller",
"api-config-watcher",
"state",
"state-config-watcher",
"termination-signal-handler",
"unconverted-state-workers",
"upgrade-check-flag",
"upgrade-check-gate",
"upgrade-steps-flag",
"upgrade-steps-gate",
"upgrade-steps-runner",
"upgrader",
)
manifolds := machine.Manifolds(machine.ManifoldsConfig{})
keys := make([]string, 0, len(manifolds))
for key := range manifolds {
if !exempt.Contains(key) {
keys = append(keys, key)
}
}
for _, key := range keys {
c.Logf("checking %s...", key)
var sawCheck, sawSteps bool
for _, name := range manifolds[key].Inputs {
if name == "upgrade-check-flag" {
sawCheck = true
}
if name == "upgrade-steps-flag" {
sawSteps = true
}
}
c.Check(sawSteps, jc.IsTrue)
c.Check(sawCheck, jc.IsTrue)
}
}
func (s *ManifoldsSuite) TestManifoldNames(c *gc.C) {
manifolds := machine.Manifolds(machine.ManifoldsConfig{})
keys := make([]string, 0, len(manifolds))
for k := range manifolds {
keys = append(keys, k)
}
sort.Strings(keys)
expectedKeys := []string{
"agent",
"api-address-updater",
"api-caller",
"apiworkers",
"authenticationworker",
"deployer",
"disk-manager",
"identity-file-writer",
"log-sender",
"logging-config-updater",
"machine-actions",
"machiner",
"proxy-config-updater",
"reboot",
"resumer",
"serving-info-setter",
"state",
"state-config-watcher",
"stateworkers",
"storage-provisioner-machine",
"termination",
"tools-version-checker",
"upgrade-check-gate",
"upgrade-steps-gate",
"upgrader",
"upgradesteps",
"upgradewaiter",
}
c.Assert(keys, jc.SameContents, expectedKeys)
}
func (s *ManifoldsSuite) TestManifoldNames(c *gc.C) {
manifolds := machine.Manifolds(machine.ManifoldsConfig{})
keys := make([]string, 0, len(manifolds))
for k := range manifolds {
keys = append(keys, k)
}
expectedKeys := []string{
"agent",
"termination",
"api-caller",
"upgrade-steps-gate",
"upgrade-check-gate",
"upgrader",
"upgradesteps",
"upgradewaiter",
"uninstaller",
"serving-info-setter",
"apiworkers",
"reboot",
"logging-config-updater",
}
c.Assert(keys, jc.SameContents, expectedKeys)
}
func (a *MachineAgent) makeEngineCreator(previousAgentVersion version.Number) func() (worker.Worker, error) {
return func() (worker.Worker, error) {
config := dependency.EngineConfig{
IsFatal: cmdutil.IsFatal,
WorstError: cmdutil.MoreImportantError,
ErrorDelay: 3 * time.Second,
BounceDelay: 10 * time.Millisecond,
}
engine, err := dependency.NewEngine(config)
if err != nil {
return nil, err
}
manifolds := machine.Manifolds(machine.ManifoldsConfig{
PreviousAgentVersion: previousAgentVersion,
Agent: agent.APIHostPortsSetter{Agent: a},
RootDir: a.rootDir,
AgentConfigChanged: a.configChangedVal,
UpgradeStepsLock: a.upgradeComplete,
UpgradeCheckLock: a.initialUpgradeCheckComplete,
OpenState: a.initState,
OpenStateForUpgrade: a.openStateForUpgrade,
StartStateWorkers: a.startStateWorkers,
StartAPIWorkers: a.startAPIWorkers,
PreUpgradeSteps: upgrades.PreUpgradeSteps,
LogSource: a.bufferedLogs,
NewDeployContext: newDeployContext,
Clock: clock.WallClock,
})
if err := dependency.Install(engine, manifolds); err != nil {
if err := worker.Stop(engine); err != nil {
logger.Errorf("while stopping engine with bad manifolds: %v", err)
}
return nil, err
}
return engine, nil
}
}