func NewBuilder(podRoot string, podUUID *types.UUID) (*Builder, error) {
pod, err := stage1commontypes.LoadPod(podRoot, podUUID)
if err != nil {
logs.WithError(err).Fatal("Failed to load pod")
}
if len(pod.Manifest.Apps) != 1 {
logs.Fatal("dgr builder support only 1 application")
}
fields := data.WithField("aci", manifestApp(pod).Name)
aciPath, ok := manifestApp(pod).App.Environment.Get(common.EnvAciPath)
if !ok || aciPath == "" {
return nil, errs.WithF(fields, "Builder image require "+common.EnvAciPath+" environment variable")
}
aciTarget, ok := manifestApp(pod).App.Environment.Get(common.EnvAciTarget)
if !ok || aciPath == "" {
return nil, errs.WithF(fields, "Builder image require "+common.EnvAciTarget+" environment variable")
}
return &Builder{
fields: fields,
aciHomePath: aciPath,
aciTargetPath: aciTarget,
pod: pod,
stage1Rootfs: rktcommon.Stage1RootfsPath(pod.Root),
stage2Rootfs: filepath.Join(rktcommon.AppPath(pod.Root, manifestApp(pod).Name), "rootfs"),
}, nil
}
func main() {
rand.Seed(time.Now().UTC().UnixNano())
sigQuitThreadDump()
var logLevel string
var version bool
var oneshot bool
rootCmd := &cobra.Command{
Use: "synapse config.yml",
PersistentPreRun: func(cmd *cobra.Command, args []string) {
if version {
fmt.Println("Synapse")
fmt.Println("Version :", Version)
fmt.Println("Build Time :", BuildTime)
os.Exit(0)
}
if logLevel != "" {
level, err := logs.ParseLevel(logLevel)
if err != nil {
logs.WithField("value", logLevel).Fatal("Unknown log level")
}
logs.SetLevel(level)
}
},
Run: func(cmd *cobra.Command, args []string) {
if len(args) != 1 {
logs.Fatal("Synapse require a configuration file as argument")
}
synapse, err := LoadConfig(args[0])
if err != nil {
logs.WithE(err).Fatal("Cannot start, failed to load configuration")
}
if err := synapse.Init(Version, BuildTime, logLevel != ""); err != nil {
logs.WithE(err).Fatal("Failed to init synapse")
}
if err := synapse.Start(oneshot); err != nil {
logs.WithE(err).Fatal("Failed to start synapse")
}
waitForSignal()
synapse.Stop()
},
}
rootCmd.PersistentFlags().StringVarP(&logLevel, "log-level", "L", "", "Set log level")
rootCmd.PersistentFlags().BoolVarP(&version, "version", "V", false, "Display version")
//rootCmd.PersistentFlags().BoolVarP(&oneshot, "oneshot", "O", false, "run watchers/router only once and exit")
if err := rootCmd.Execute(); err != nil {
logs.WithE(err).Fatal("Failed to process args")
}
}
func main() {
rand.Seed(time.Now().UTC().UnixNano())
sigQuitThreadDump()
var logLevel string
var version bool
rootCmd := &cobra.Command{
Use: "nerve config.yml",
PersistentPreRun: func(cmd *cobra.Command, args []string) {
if version {
fmt.Println("Nerve")
fmt.Println("Version :", Version)
fmt.Println("Build Time :", BuildTime)
os.Exit(0)
}
if logLevel != "" {
level, err := logs.ParseLevel(logLevel)
if err != nil {
logs.WithField("value", logLevel).Fatal("Unknown log level")
}
logs.SetLevel(level)
}
},
Run: func(cmd *cobra.Command, args []string) {
if len(args) != 1 {
logs.Fatal("Nerve require a configuration file as argument")
}
nerve, err := LoadConfig(args[0])
if err != nil {
logs.WithE(err).Fatal("Cannot start, failed to load configuration")
}
if err := nerve.Init(Version, BuildTime, logLevel != ""); err != nil {
logs.WithE(err).Fatal("Failed to init nerve")
}
startStatus := make(chan error)
go nerve.Start(startStatus)
if status := <-startStatus; status != nil {
logs.WithE(status).Fatal("Failed to start nerve")
}
waitForSignal()
nerve.Stop()
},
}
rootCmd.PersistentFlags().StringVarP(&logLevel, "log-level", "L", "", "Set log level")
rootCmd.PersistentFlags().BoolVarP(&version, "version", "V", false, "Display version")
if err := rootCmd.Execute(); err != nil {
logs.WithE(err).Fatal("Failed to process args")
}
}
func main() {
logs.GetDefaultLog().(*erlog.ErlogLogger).Appenders[0].(*erlog.ErlogWriterAppender).Out = os.Stdout
if os.Getuid() != 0 {
println("dgr needs to be run as root")
os.Exit(1)
}
if !SupportsOverlay() {
logs.Fatal("Overlay filesystem is required")
}
Execute()
}
func prepareServiceCommands(service *work.Service) *cobra.Command {
var ttl string
serviceCmd := &cobra.Command{
Use: service.Name,
Short: "run command for " + service.Name + " on env " + service.GetEnv().GetName(),
}
generateCmd := &cobra.Command{
Use: "generate",
Short: "generate units for " + service.Name + " on env " + service.GetEnv().GetName(),
Long: `generate units using remote resolved or local pod/aci manifests`,
Run: func(cmd *cobra.Command, args []string) {
if err := service.Generate(); err != nil {
logs.WithE(err).Fatal("Generate failed")
}
},
}
checkCmd := &cobra.Command{
Use: "check [manifest...]",
Short: "Check units for " + service.Name + " on env " + service.GetEnv().GetName(),
Run: func(cmd *cobra.Command, args []string) {
if err := service.Check(); err != nil {
logs.WithE(err).Fatal("Check failed")
}
},
}
diffCmd := &cobra.Command{
Use: "diff [manifest...]",
Short: "diff units for " + service.Name + " on env " + service.GetEnv().GetName(),
Run: func(cmd *cobra.Command, args []string) {
service.Diff()
},
}
lockCmd := &cobra.Command{
Use: "lock [message...]",
Short: "lock " + service.Name + " on env " + service.GetEnv().GetName(),
Long: `Add a lock to the service in etcd to prevent somebody else to do modification actions on this service/units.` +
`lock is ignored if set by the current user`,
Run: func(cmd *cobra.Command, args []string) {
if len(args) == 0 {
logs.Fatal("Please add a message to describe lock")
}
message := strings.Join(args, " ")
ttl, err := time.ParseDuration(ttl)
if err != nil {
logs.WithError(err).Fatal("Wrong value for ttl")
}
service.Lock("service/lock", ttl, message)
},
}
unlockCmd := &cobra.Command{
Use: "unlock",
Short: "unlock " + service.Name + " on env " + service.GetEnv().GetName(),
Run: func(cmd *cobra.Command, args []string) {
service.Unlock("service/unlock")
},
}
listCmd := &cobra.Command{
Use: "list-units",
Short: "list-units on " + service.Name + " on env " + service.GetEnv().GetName(),
Run: func(cmd *cobra.Command, args []string) {
service.FleetListUnits("service/unlock")
},
}
updateCmd := &cobra.Command{
Use: "update",
Short: "update " + service.Name + " on env " + service.GetEnv().GetName(),
Run: func(cmd *cobra.Command, args []string) {
err := service.Update()
if err != nil {
os.Exit(1)
}
},
}
lockCmd.Flags().StringVarP(&ttl, "duration", "t", "1h", "lock duration")
updateCmd.Flags().BoolVarP(&work.BuildFlags.All, "all", "a", false, "process all units, even up to date")
updateCmd.Flags().BoolVarP(&work.BuildFlags.Yes, "yes", "y", false, "process units without asking")
serviceCmd.AddCommand(generateCmd, lockCmd, unlockCmd, updateCmd, checkCmd, diffCmd, listCmd)
// var units []string
// hystrix.Go("list_units", func() error {
// units = service.ListUnits()
// return nil
// }, func(err error) error {
// entry := service.GetLog()
// entry.WithError(err).Warn("Cannot list units. Some command may be missing")
// return nil
// })
for _, unitName := range service.ListUnits() {
unit := service.LoadUnit(unitName)
serviceCmd.AddCommand(prepareUnitCommands(unit))
}
return serviceCmd
}