// buildCommandFunc executes the "build" command. func buildCommandFunc(c *cli.Context) { var privileged = c.Bool("p") var identity = c.String("i") var deploy = c.Bool("deploy") var publish = c.Bool("publish") var path string var dockerhost = c.String("docker-host") var dockercert = c.String("docker-cert") var dockerkey = c.String("docker-key") // the path is provided as an optional argument that // will otherwise default to $PWD/.drone.yml if len(c.Args()) > 0 { path = c.Args()[0] } switch len(path) { case 0: path, _ = os.Getwd() path = filepath.Join(path, ".drone.yml") default: path = filepath.Clean(path) path, _ = filepath.Abs(path) path = filepath.Join(path, ".drone.yml") } // this configures the default Docker logging levels, // and suffix and prefix values. log.SetPrefix("\033[2m[DRONE] ") log.SetSuffix("\033[0m\n") log.SetOutput(os.Stdout) log.SetPriority(log.LOG_DEBUG) //LOG_NOTICE docker.Logging = false var exit, _ = run(path, identity, dockerhost, dockercert, dockerkey, publish, deploy, privileged) os.Exit(exit) }
func main() { log.SetPriority(log.LOG_NOTICE) // Parses flags. The only flag that can be passed into the // application is the location of the configuration (.toml) file. var conf string flag.StringVar(&conf, "config", "", "") flag.Parse() config.Var(&nodes, "worker-nodes") // Parses config data. The config data can be stored in a config // file (.toml format) or environment variables, or a combo. config.SetPrefix("DRONE_") err := config.Parse(conf) if err != nil { log.Errf("Unable to parse config: %v", err) os.Exit(1) } // Setup the remote services. We need to execute these to register // the remote plugins with the system. // // NOTE: this cannot be done via init() because they need to be // executed after config.Parse bitbucket.Register() github.Register() gitlab.Register() gogs.Register() // setup the database and cancel all pending // commits in the system. db = database.MustConnect(*driver, *datasource) go database.NewCommitstore(db).KillCommits() // Create the worker, director and builders workers = pool.New() worker = director.New() if nodes == nil || len(nodes) == 0 { workers.Allocate(docker.New()) workers.Allocate(docker.New()) } else { for _, node := range nodes { if strings.HasPrefix(node, "unix://") { workers.Allocate(docker.NewHost(node)) } else if *dockercert != "" && *dockerkey != "" { workers.Allocate(docker.NewHostCertFile(node, *dockercert, *dockerkey)) } else { fmt.Println(DockerTLSWarning) workers.Allocate(docker.NewHost(node)) } } } pub = pubsub.NewPubSub() // create handler for static resources // if we have a configured assets folder it takes precedence over the assets // bundled to the binary var assetserve http.Handler if *assets_folder != "" { assetserve = http.FileServer(http.Dir(*assets_folder)) } else { assetserve = http.FileServer(rice.MustFindBox("app").HTTPBox()) } http.Handle("/robots.txt", assetserve) http.Handle("/static/", http.StripPrefix("/static", assetserve)) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { r.URL.Path = "/" assetserve.ServeHTTP(w, r) }) // create the router and add middleware mux := router.New() mux.Use(middleware.Options) mux.Use(ContextMiddleware) mux.Use(middleware.SetHeaders) mux.Use(middleware.SetUser) http.Handle("/api/", mux) // start the http server in either http or https mode, // depending on whether a certificate was provided. if len(*sslcrt) == 0 { panic(http.ListenAndServe(*port, nil)) } else { panic(http.ListenAndServeTLS(*port, *sslcrt, *sslkey, nil)) } }