func main()

in main.go [84:190]
85 lines of code
15 McCabe index (conditional complexity)

func main() {
	vidispine_url_str := os.Getenv("VIDISPINE_URL")
	vidispine_user := os.Getenv("VIDISPINE_USER")
	vidispine_passwd := os.Getenv("VIDISPINE_PASSWORD")
	callback_uri_str := os.Getenv("CALLBACK_BASE")
	rabbitmq_uri_str := os.Getenv("RABBITMQ_URI")
	exchangeName := os.Getenv("RABBITMQ_EXCHANGE")

	if vidispine_url_str == "" || vidispine_user == "" || vidispine_passwd == "" {
		log.Fatal("Please set VIDISPINE_URL, VIDISPINE_USER and VIDISPINE_PASSWORD in the environment")
	}

	if callback_uri_str == "" {
		log.Fatal("Please set CALLBACK_BASE in the environment")
	}

	if rabbitmq_uri_str == "" {
		log.Fatal("Please set RABBITMQ_URI in the environment")
	}

	if exchangeName == "" {
		log.Fatal("Please set RABBITMQ_EXCHANGE in the environment")
	}

	vidispine_url, url_parse_err := url.Parse(vidispine_url_str)
	if url_parse_err != nil {
		log.Fatal("VIDISPINE_URL is not valid: ", url_parse_err)
	}

	callback_url, url_parse_err := url.Parse(callback_uri_str)
	if url_parse_err != nil {
		log.Fatal("CALLBACK_BASE is not valid: ", url_parse_err)
	}

	rmq, rmqErr := amqp.Dial(rabbitmq_uri_str)
	if rmqErr != nil {
		log.Fatal("Could not connect to rabbitmq: ", rmqErr)
	}

	conn := &mocks.AmqpConnectionShim{
		Connection: rmq,
	}

	/*
		ensure that rabbitmq connection is terminated cleanly even if program exits uncleanly
	*/
	defer func() {
		if r := recover(); r != nil {
			log.Print("WARNING main Program is existing due to panic")
			if rmq != nil && !rmq.IsClosed() {
				log.Print("INFO main Shutting down broker connection")
				closeErr := rmq.Close()
				if closeErr != nil {
					log.Print("ERROR main Could not shut down broker connection but terminating anyway ", closeErr)
				}
			}
			os.Exit(0xFF)
		}
	}()

	/*
		ensure that rabbiqmq connection is terminated cleanly if we receive termination signal
	*/
	handleSignals(conn)

	requestor := vidispine.NewVSRequestor(*vidispine_url, vidispine_user, vidispine_passwd)

	setUpNotifications(vidispine_url, requestor, callback_url)

	setUpExchange(rmq, exchangeName)
	amqpPool := sender.NewAmqpConnectionPool(conn)

	jobMessageHandler := VidispineMessageHandler{
		ConnectionPool: amqpPool,
		ExchangeName:   exchangeName,
		ChannelTimeout: 45 * time.Second,
	}
	itemMessageHandler := VidispineItemMessageHandler{
		ConnectionPool: amqpPool,
		ExchangeName:   exchangeName,
		ChannelTimeout: 45 * time.Second,
	}
	metaMessageHandler := VidispineMetadataMessageHandler{
		ConnectionPool: amqpPool,
		ExchangeName:   exchangeName,
		ChannelTimeout: 45 * time.Second,
	}
	shapeMessageHandler := VidispineShapeMessageHandler{
		ConnectionPool: amqpPool,
		ExchangeName:   exchangeName,
		ChannelTimeout: 45 * time.Second,
	}
	healthcheckHandler := HealthcheckHandler{}

	log.Printf("Callback URL path is %s", callback_url.Path)
	http.Handle(callback_url.Path+"/job", jobMessageHandler)
	http.Handle(callback_url.Path+"/item/metadata", metaMessageHandler)
	http.Handle(callback_url.Path+"/item", itemMessageHandler)
	http.Handle(callback_url.Path+"/item/shape", shapeMessageHandler)
	http.Handle("/healthcheck", healthcheckHandler)

	log.Printf("Starting up on port 8080...")
	startServeErr := http.ListenAndServe(":8080", nil)
	if startServeErr != nil {
		log.Fatal(startServeErr)
	}
}