Example #1
0
func main() {

	app := cli.NewApp()
	app.Name = "hookserve"
	app.Usage = "A small little application that listens for commit / push webhook events from github and runs a specified command\n\n"
	app.Usage += "EXAMPLE:\n"
	app.Usage += "   hookserve --secret=whiskey --port=8888 echo  #Echo back the information provided\n"
	app.Usage += "   hookserve logger -t PushEvent #log the push event to the system log (/var/log/message)"
	app.Version = "1.0"
	app.Author = "Patrick Hayes"
	app.Email = "*****@*****.**"

	app.Flags = []cli.Flag{
		cli.IntFlag{
			Name:  "port, p",
			Value: 80,
			Usage: "port on which to listen for github webhooks",
		},
		cli.StringFlag{
			Name:  "secret, s",
			Value: "",
			Usage: "Secret for HMAC verification. If not provided no HMAC verification will be done and all valid requests will be processed",
		},
		cli.BoolFlag{
			Name:  "tags, t",
			Usage: "Also execute the command when a tag is pushed",
		},
	}

	app.Action = func(c *cli.Context) {
		server := hookserve.NewServer()
		server.Port = c.Int("port")
		server.Secret = c.String("secret")
		server.IgnoreTags = !c.Bool("tags")
		server.GoListenAndServe()

		for commit := range server.Events {
			if args := c.Args(); len(args) != 0 {
				root := args[0]
				rest := append(args[1:], commit.Owner, commit.Repo, commit.Branch, commit.Commit)
				cmd := exec.Command(root, rest...)
				cmd.Stdout = os.Stdout
				cmd.Stderr = os.Stderr
				cmd.Run()
			} else {
				fmt.Println(commit.Owner + " " + commit.Repo + " " + commit.Branch + " " + commit.Commit)
			}
		}
	}

	app.Run(os.Args)
}
Example #2
0
func ServeHook(port int, secret string) {
	server := hookserve.NewServer()
	server.Port = port
	server.Secret = secret

	go func() {
		log.Print("Starting hook even listener")
		for event := range server.Events {
			log.Print(event.Owner + " " + event.Repo + " " + event.Branch + " " + event.Commit)
			if event.Branch == "master" {
				PublishBlog()
			}
		}
	}()

	log.Printf("Starting hook server on port %d", server.Port)
	server.ListenAndServe()
}
Example #3
0
func main() {
	var err error
	if pushPort, err = strconv.Atoi(os.Getenv("PUSH_PORT")); err != nil {
		log.Fatal("Env PUSH_PORT must be integer")
	}

	pushNotifHTTPPath = os.Getenv("PUSH_HTTP_PATH")
	if pushNotifHTTPPath == "" {
		log.Fatal("Env PUSH_HTTP_PATH must be present")
	}

	pushGithubSecret = os.Getenv("PUSH_GITHUB_SECRET")

	projectDir = os.Getenv("PUSH_PROJECT_DIR")
	if projectDir == "" {
		log.Fatal("Env PUSH_PROJECT_DIR must be present")
	}

	server := hookserve.NewServer()
	server.Port = pushPort
	server.Path = pushNotifHTTPPath
	server.Secret = pushGithubSecret
	server.GoListenAndServe()

	cliExecuter := cliRunner{os.Stderr}

	fmt.Printf("Starting server...\nExpecting push notification on :%d%s\nProject path %s\n", pushPort, pushNotifHTTPPath, projectDir)

	for {
		select {
		case event := <-server.Events:
			err := pull(event, &cliExecuter)
			if err != nil {
				log.Fatal(err)
			}

			err = build(&cliExecuter)
			if err != nil {
				log.Fatal(err)
			}
		}
	}
}
Example #4
0
File: main.go Project: thinkhike/ci
func main() {
	// Create a new map.
	mymap = cmap.New()

	log.Println(os.Getenv("GH_TOKEN"))
	server := hookserve.NewServer()
	server.Port = 8120
	server.Secret = "absolutesecret"
	server.GoListenAndServe()
	fmt.Printf("Listening on %d\n", server.Port)
	for {
		select {
		case commit := <-server.Events:
			fmt.Println("Got: ", commit.Owner, commit.Repo, commit.Branch, commit.Commit)
			go func() { build(&commit) }()
		default:
			time.Sleep(100)
			//fmt.Println("No activity...")
		}
	}
}
Example #5
0
File: main.go Project: alxp/deadci
func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())

	InitConfig()
	InitDB()
	InitANSI2HTML()
	glog.Info("starting main thread.")
	// Set up HTTP paths
	githubreceive := hookserve.NewServer()
	if Config.Github.Enabled {
		githubreceive.Secret = Config.Github.Secret
		http.Handle("/postreceive", githubreceive)
		fmt.Println("Github webhook URL: http://" + Config.Host + ":" + strconv.Itoa(Config.Port) + "/postreceive")
	}
	http.HandleFunc("/", handleUI)

	// Listen and serve HTTP
	go func() {
		fmt.Println("Listening on port " + strconv.Itoa(Config.Port))
		err := http.ListenAndServe(":"+strconv.Itoa(Config.Port), nil)
		if err != nil {
			log.Fatal("ListenAndServe: ", err)
		}
	}()

	// Launch workers for running jobs
	// We have a number of workers equal to the number of cores
	for i := 1; i <= runtime.NumCPU(); i++ {
		go func() {
			for {
				event, err := PopEvent()
				if err != nil {
					log.Println(err)
				} else if event != nil {
					err = event.Report()
					if err != nil {
						// If we can't update the status on the source-control system, then just log it and continue
						event.Log = append(event.Log, []byte(err.Error()+"\n")...)
						event.Update()
						log.Println(err)
					}
					status, err := event.Run()
					err = event.Finalize(status, err)
					if err != nil {
						log.Println(err)
					}
				}

				// Wait 100 ms then check again
				time.Sleep(100 * time.Millisecond)

				// If we are shutting down, stop processing
				if InShutdown {
					return
				}
			}
		}()
	}

	// Handle a sigint to gracefully shutdown
	sigint := make(chan os.Signal, 1)
	signal.Notify(sigint, syscall.SIGINT)
	go func() {
		for _ = range sigint {
			log.Println("Got shutdown signal. Will shutdown when actively running jobs are finished. To shutdown immidaitely, use sigquit.")
			InShutdown = true
			// Wait until we have no running jobs then shut down.
			for {
				numEvents, err := NumEvent("running")
				if err != nil {
					log.Fatal(err)
				}
				if numEvents == 0 {
					log.Println("Shutting down")
					os.Exit(0)
				} else {
					// Wait 100 ms then check again
					time.Sleep(100 * time.Millisecond)
				}
			}
		}
	}()

	// Handle a sigquit to shut down immidiately
	sigquit := make(chan os.Signal, 1)
	signal.Notify(sigquit, syscall.SIGQUIT)
	go func() {
		for _ = range sigquit {
			log.Println("Got quit signal. Shutting down immidaitely. To shutdown gracefully, use sigint.")
			os.Exit(1)
		}
	}()

	// Add new events to the queue as they come in
	for commit := range githubreceive.Events {
		// Only run tets on pull-requests if there is new code to test
		if commit.Type == "pull_request" && (commit.Action != "synchronize" && commit.Action != "opened") {
			continue
		}

		event := Event{
			Event:  commit,
			Domain: "github.com", // For now we only support github
			Status: StatusPending,
			Time:   time.Now(),
		}

		// First check to see if the event already exists, and if it is reque it if it's not running
		checkEvent, err := GetEvent(event.Domain, event.Owner, event.Repo, event.Branch, event.Commit)
		if err != nil {
			log.Println(err)
		}
		if checkEvent != nil {
			// It's an old event, requeue it if we can
			if checkEvent.Status != StatusRunning {
				checkEvent.Status = StatusPending
				err = checkEvent.Update()
				if err != nil {
					log.Println(err)
				}
				err = checkEvent.Report()
				if err != nil {
					log.Println(err)
				}
			}
		} else {
			// It's a new event, insert it anew
			err = event.Insert()
			if err != nil {
				log.Println(err)
			}
			err = event.Report()
			if err != nil {
				log.Println(err)
			}
		}
	}
}