func JobAdd(store datastore.DataStore, w http.ResponseWriter, r *http.Request) {
body, err := ioutil.ReadAll(r.Body)
if err != nil {
fmt.Printf("Error: %s\n", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
var obj model.Job
err = json.Unmarshal(body, &obj)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
return
}
if obj.ID != 0 {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("Error: You cannot pass an ID"))
return
}
created, err := store.SaveJob(&obj)
if !created || err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
return
}
w.WriteHeader(http.StatusCreated)
}
func JobDelete(store datastore.DataStore, w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
id, err := strconv.Atoi(vars["id"])
if err != nil {
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
w.WriteHeader(http.StatusBadRequest)
return
}
obj, err := store.Job(int64(id))
if obj.ID == 0 || err != nil {
w.WriteHeader(http.StatusNotFound)
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
return
}
deleted, err := store.DeleteJob(&obj)
if !deleted || err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
return
}
w.WriteHeader(http.StatusOK)
}
func BackupIndex(store datastore.DataStore, w http.ResponseWriter, r *http.Request) {
jobs, err := store.Backups()
if err != nil {
panic(err)
}
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(jobs); err != nil {
panic(err)
}
}
func JobUpdate(store datastore.DataStore, w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
fmt.Printf("Error: %s\n", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
id, err := strconv.Atoi(vars["id"])
if err != nil {
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
w.WriteHeader(http.StatusBadRequest)
return
}
obj, err := store.Job(int64(id))
if obj.ID == 0 || err != nil {
w.WriteHeader(http.StatusNotFound)
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
return
}
oldid := obj.ID
err = json.Unmarshal(body, &obj)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
return
}
if obj.ID != oldid {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("Error: You cannot change an ID"))
return
}
_, err = store.SaveJob(&obj)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(fmt.Sprintf("Error: %s", err)))
return
}
w.WriteHeader(http.StatusOK)
}
func testJobs(s datastore.DataStore, t *testing.T) {
// Test only valid RemoteIDs are accepted
j := model.Job{JobName: "foo", RemoteID: 0}
created, err := s.SaveJob(&j)
assert.NotNil(t, err)
r := model.Remote{Driver: "ssh", Location: "foo"}
created, err = s.SaveRemote(&r)
r2 := model.Remote{Driver: "ssh", Location: "bar"}
created, err = s.SaveRemote(&r2)
j = model.Job{JobName: "foo", RemoteID: r.ID}
created, err = s.SaveJob(&j)
assert.Equal(t, true, created)
assert.Nil(t, err)
j2, err := s.Job(j.ID)
assert.Nil(t, err)
assert.Equal(t, j.JobName, j2.JobName)
assert.Equal(t, j.ID, j2.ID)
j2.JobName = "bar"
created, err = s.SaveJob(&j2)
assert.Equal(t, false, created)
assert.Nil(t, err)
jslice, err := s.Jobs()
assert.Nil(t, err)
assert.Equal(t, 1, len(jslice))
assert.Equal(t, j2.JobName, jslice[0].JobName)
assert.Equal(t, j2.ID, jslice[0].ID)
jslice, err = s.JobsForRemote(&r)
assert.Nil(t, err)
assert.Equal(t, 1, len(jslice))
jslice, err = s.JobsForRemote(&r2)
assert.Nil(t, err)
assert.Equal(t, 0, len(jslice))
s.DeleteJob(&j2)
jslice, err = s.Jobs()
assert.Nil(t, err)
assert.Equal(t, 0, len(jslice))
_, err = s.Job(j.ID)
assert.NotNil(t, err)
s.DeleteRemote(&r)
s.DeleteRemote(&r2)
}
func testRemotes(s datastore.DataStore, t *testing.T) {
r := model.Remote{Driver: "ssh", Location: "foo"}
created, err := s.SaveRemote(&r)
assert.Equal(t, true, created)
assert.Nil(t, err)
r2, err := s.Remote(r.ID)
assert.Nil(t, err)
assert.Equal(t, r.Location, r2.Location)
assert.Equal(t, r.ID, r2.ID)
r2.Location = "bar"
created, err = s.SaveRemote(&r2)
assert.Equal(t, false, created)
assert.Nil(t, err)
rslice, err := s.Remotes()
assert.Nil(t, err)
assert.Equal(t, 1, len(rslice))
assert.Equal(t, r2.Location, rslice[0].Location)
assert.Equal(t, r2.ID, rslice[0].ID)
s.DeleteRemote(&r2)
rslice, err = s.Remotes()
assert.Nil(t, err)
assert.Equal(t, 0, len(rslice))
_, err = s.Remote(r.ID)
assert.NotNil(t, err)
}
func testDeleteCascade(s datastore.DataStore, t *testing.T) {
r := model.Remote{Driver: "ssh", Location: "foo"}
created, err := s.SaveRemote(&r)
assert.Equal(t, true, created)
assert.Nil(t, err)
j := model.Job{JobName: "foo", RemoteID: r.ID}
created, err = s.SaveJob(&j)
assert.Equal(t, true, created)
assert.Nil(t, err)
b := model.Backup{Result: model.BackupCompleted, JobID: j.ID}
created, err = s.SaveBackup(&b)
assert.Equal(t, true, created)
assert.Nil(t, err)
jslice, err := s.Jobs()
assert.Nil(t, err)
assert.Equal(t, 1, len(jslice))
bslice, err := s.Backups()
assert.Nil(t, err)
assert.Equal(t, 1, len(bslice))
s.DeleteRemote(&r)
jslice, err = s.Jobs()
assert.Nil(t, err)
assert.Equal(t, 0, len(jslice))
bslice, err = s.Backups()
assert.Nil(t, err)
assert.Equal(t, 0, len(bslice))
}
func testBackups(s datastore.DataStore, t *testing.T) {
// Test only valid JobIDs are accepted
b := model.Backup{Result: model.BackupCompleted, JobID: 0}
created, err := s.SaveBackup(&b)
assert.NotNil(t, err)
r := model.Remote{Driver: "ssh", Location: "foo"}
created, err = s.SaveRemote(&r)
j := model.Job{RemoteID: r.ID}
created, err = s.SaveJob(&j)
j2 := model.Job{RemoteID: r.ID}
created, err = s.SaveJob(&j2)
b = model.Backup{Result: model.BackupCompleted, JobID: j.ID}
created, err = s.SaveBackup(&b)
assert.Equal(t, true, created)
assert.Nil(t, err)
b2, err := s.Backup(b.ID)
assert.Nil(t, err)
assert.Equal(t, b.Result, b2.Result)
assert.Equal(t, b.ID, b2.ID)
b2.Result = model.BackupFailed
created, err = s.SaveBackup(&b2)
assert.Equal(t, false, created)
assert.Nil(t, err)
bslice, err := s.Backups()
assert.Nil(t, err)
assert.Equal(t, 1, len(bslice))
assert.Equal(t, b2.Result, bslice[0].Result)
assert.Equal(t, b2.ID, bslice[0].ID)
bslice, err = s.BackupsForJob(&j)
assert.Nil(t, err)
assert.Equal(t, 1, len(bslice))
bslice, err = s.BackupsForJob(&j2)
assert.Nil(t, err)
assert.Equal(t, 0, len(bslice))
s.DeleteBackup(&b2)
bslice, err = s.Backups()
assert.Nil(t, err)
assert.Equal(t, 0, len(bslice))
_, err = s.Backup(b.ID)
assert.NotNil(t, err)
s.DeleteRemote(&r)
}
