func main() {
kingpin.Version(version.VERSION)
kingpin.Parse()
manifest, err := pods.ManifestFromURI(*manifestURI)
if err != nil {
log.Fatalf("%s", err)
}
// /data/pods/hooks/<event>/<id>
// if the event is the empty string (global hook), then that path segment
// will be cleaned out
pod := pods.NewPod(manifest.ID(), pods.PodPath(filepath.Join(*podRoot, "hooks", *hookType), manifest.ID()))
err = pod.Install(manifest)
if err != nil {
log.Fatalf("Could not install manifest %s: %s", manifest.ID(), err)
}
// hooks write their current manifest manually since it's normally done at
// launch time
_, err = pod.WriteCurrentManifest(manifest)
if err != nil {
log.Fatalf("Could not write current manifest for %s: %s", manifest.ID(), err)
}
err = hooks.InstallHookScripts(*hookRoot, pod, manifest, logging.DefaultLogger)
if err != nil {
log.Fatalf("Could not write hook scripts: %s", err)
}
}
func main() {
kingpin.Version(version.VERSION)
kingpin.Parse()
manifest, err := pods.ManifestFromURI(*manifestURI)
if err != nil {
log.Fatalf("%s", err)
}
pod := pods.NewPod(manifest.ID(), pods.PodPath(*podRoot, manifest.ID()))
err = pod.Install(manifest)
if err != nil {
log.Fatalf("Could not install manifest %s: %s", manifest.ID(), err)
}
success, err := pod.Launch(manifest)
if err != nil {
log.Fatalf("Could not launch manifest %s: %s", manifest.ID(), err)
}
if !success {
log.Fatalln("Unsuccessful launch of one or more things in the manifest")
}
}
func main() {
kingpin.CommandLine.Name = "p2-replicate"
kingpin.CommandLine.Help = `p2-replicate uses the replication package to schedule deployment of a pod across multiple nodes. See the replication package's README and godoc for more information.
Example invocation: p2-replicate --min-nodes 2 helloworld.yaml aws{1,2,3}.example.com
This will take the pod whose manifest is located at helloworld.yaml and
deploy it to the three nodes aws1.example.com, aws2.example.com, and
aws3.example.com
Because of --min-nodes 2, the replicator will ensure that at least two healthy
nodes remain up at all times, according to p2's health checks.
`
kingpin.Version(version.VERSION)
_, opts := flags.ParseWithConsulOptions()
client := kp.NewConsulClient(opts)
store := kp.NewConsulStore(client)
healthChecker := checker.NewConsulHealthChecker(client)
manifest, err := pods.ManifestFromURI(*manifestUri)
if err != nil {
log.Fatalf("%s", err)
}
logger := logging.NewLogger(logrus.Fields{
"pod": manifest.ID(),
})
logger.Logger.Formatter = &logrus.TextFormatter{
DisableTimestamp: false,
FullTimestamp: true,
TimestampFormat: "15:04:05.000",
}
// create a lock with a meaningful name and set up a renewal loop for it
thisHost, err := os.Hostname()
if err != nil {
log.Fatalf("Could not retrieve hostname: %s", err)
}
thisUser, err := user.Current()
if err != nil {
log.Fatalf("Could not retrieve user: %s", err)
}
lockMessage := fmt.Sprintf("%q from %q at %q", thisUser.Username, thisHost, time.Now())
repl, err := replication.NewReplicator(
manifest,
logger,
*hosts,
len(*hosts)-*minNodes,
store,
healthChecker,
health.HealthState(*threshold),
lockMessage,
)
if err != nil {
log.Fatalf("Could not initialize replicator: %s", err)
}
replication, errCh, err := repl.InitializeReplication(*overrideLock)
if err != nil {
log.Fatalf("Unable to initialize replication: %s", err)
}
// auto-drain this channel
go func() {
for range errCh {
}
}()
go func() {
// clear lock immediately on ctrl-C
signals := make(chan os.Signal, 1)
signal.Notify(signals, os.Interrupt)
<-signals
replication.Cancel()
os.Exit(1)
}()
replication.Enact()
}
