func renderHTML(w http.ResponseWriter, r *http.Request, task types.EremeticTask, taskID string) {
var err error
var tpl *template.Template
data := make(map[string]interface{})
funcMap := template.FuncMap{
"ToLower": strings.ToLower,
}
if task == (types.EremeticTask{}) {
tpl, err = template.ParseFiles("templates/error_404.html")
data["TaskID"] = taskID
} else {
tpl, err = template.New("task.html").Funcs(funcMap).ParseFiles("templates/task.html")
data = makeMap(task)
}
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())
return
}
err = tpl.Execute(w, data)
}
// NotifyCallback handles posting a JSON back to the URI given with the task.
func NotifyCallback(task *types.EremeticTask) {
if len(task.CallbackURI) == 0 {
return
}
cbData := callbackData{
Time: task.Status[len(task.Status)-1].Time,
Status: task.Status[len(task.Status)-1].Status,
TaskID: task.ID,
}
body, err := json.Marshal(cbData)
if err != nil {
log.Errorf("Unable to create message for task %s, target uri %s", task.ID, task.CallbackURI)
return
}
go func() {
_, err = http.Post(task.CallbackURI, "application/json", bytes.NewBuffer(body))
if err != nil {
log.Error(err.Error())
} else {
log.Debugf("Sent callback to %s", task.CallbackURI)
}
}()
}
func renderHTML(w http.ResponseWriter, r *http.Request, task types.EremeticTask, taskID string) {
var templateFile string
data := make(map[string]interface{})
funcMap := template.FuncMap{
"ToLower": strings.ToLower,
"FormatTime": formatter.FormatTime,
}
if reflect.DeepEqual(task, (types.EremeticTask{})) {
templateFile = "error_404.html"
data["TaskID"] = taskID
} else {
templateFile = "task.html"
data = makeMap(task)
}
source, _ := assets.Asset(fmt.Sprintf("templates/%s", templateFile))
tpl, err := template.New(templateFile).Funcs(funcMap).Parse(string(source))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())
return
}
err = tpl.Execute(w, data)
}
func main() {
if len(os.Args) == 2 && os.Args[1] == "--version" {
fmt.Println(Version)
os.Exit(0)
}
readConfig()
setupLogging()
setupMetrics()
defer database.Close()
bind := fmt.Sprintf("%s:%d", viper.GetString("address"), viper.GetInt("port"))
// Catch interrupt
go func() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, os.Kill)
s := <-c
if s != os.Interrupt && s != os.Kill {
return
}
log.Info("Eremetic is shutting down")
os.Exit(0)
}()
sched := scheduler.Create()
router := routes.Create(sched)
log.Infof("listening to %s", bind)
go scheduler.Run(sched)
err := http.ListenAndServe(bind, router)
if err != nil {
log.Error(err.Error())
os.Exit(1)
}
}
func notFound(w http.ResponseWriter, r *http.Request) {
if strings.Contains(r.Header.Get("Accept"), "text/html") {
tpl, err := template.ParseFiles("templates/error_404.html")
if err == nil {
tpl.Execute(w, nil)
return
}
log.Error(err.Error())
}
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusNotFound)
json.NewEncoder(w).Encode(nil)
}
func indexHandler(w http.ResponseWriter, r *http.Request) {
if strings.Contains(r.Header.Get("Accept"), "text/html") {
src, _ := assets.Asset("templates/index.html")
tpl, err := template.New("index").Parse(string(src))
if err == nil {
tpl.Execute(w, nil)
return
}
log.Error(err.Error())
}
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusNoContent)
json.NewEncoder(w).Encode(nil)
}
func (s *eremeticScheduler) ScheduleTask(request types.Request) (string, error) {
log.Debugf(
"Adding task running on %s to queue",
request.DockerImage)
request.Name = fmt.Sprintf("Eremetic task %d", nextID(s))
task, err := createEremeticTask(request)
if err != nil {
log.Error(err.Error())
return "", err
}
TasksCreated.Inc()
QueueSize.Inc()
database.PutTask(&task)
s.tasks <- task.ID
return task.ID, nil
}
func (sched *MockScheduler) Error(d sched.SchedulerDriver, msg string) {
log.Error(msg)
sched.Called()
}