func updateSchedule(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
return nil, httpapi.NewError("", "Request too large", 413)
}
if err := r.Body.Close(); err != nil {
return nil, errors.New("")
}
s := new(spec.Schedule)
if err := json.Unmarshal(body, &s); err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid Request", 400)
}
vars := mux.Vars(r)
sID, err := strconv.ParseInt(vars["sID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid schedule ID", 400)
}
s.ID = int(sID)
if err := manager.UpdateSchedule(s); err != nil {
return nil, httpapi.NewError(err.Error(), "Could not update schedule", 400)
}
return &httpapi.APIResponse{HTTPCode: 200}, nil
}
func restore(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
return nil, httpapi.NewError("", "Request too large", 413)
}
if err := r.Body.Close(); err != nil {
return nil, errors.New("")
}
restore := new(spec.RestoreRequest)
err = json.Unmarshal(body, &restore)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid restore request", 400)
}
id, err := manager.RunRestore(restore)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Unable to create restore job", 400)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"id": id}, HTTPCode: 200}, nil
}
func newBackupJob(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
return nil, httpapi.NewError("", "Request too large", 413)
}
if err := r.Body.Close(); err != nil {
return nil, errors.New("")
}
backupRequest := new(spec.BackupJobRequest)
if err := json.Unmarshal(body, &backupRequest); err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid Request", 400)
}
if err = manager.VerifySignature(body, r.Header.Get("x-gobl-signature")); err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid Signature", 401)
}
err = manager.NewBackup(*backupRequest)
if err != nil {
if e, ok := err.(*manager.Error); ok {
return nil, httpapi.NewError(e.Source, e.Message, e.Code)
}
return nil, errors.New("")
}
return &httpapi.APIResponse{HTTPCode: 201}, nil
}
func modifyBackup(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
return nil, httpapi.NewError("", "Request too large", 413)
}
if err := r.Body.Close(); err != nil {
return nil, errors.New("")
}
backup := new(spec.BackupDefinition)
err = json.Unmarshal(body, &backup)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid backup definition provided", 400)
}
vars := mux.Vars(r)
bID, err := strconv.ParseInt(vars["backupID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid backup ID", 400)
}
backup.ID = int(bID)
err = manager.ModifyBackup(backup)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Unable to modify backup", 400)
}
return &httpapi.APIResponse{HTTPCode: 200}, nil
}
func finishJob(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
return nil, httpapi.NewError("", "Request too large", 413)
}
if err := r.Body.Close(); err != nil {
return nil, errors.New("")
}
if err = manager.VerifySignature(r.RemoteAddr, body, r.Header.Get("x-gobl-signature")); err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid Signature", 401)
}
vars := mux.Vars(r)
jID, err := strconv.ParseInt(vars["jobID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid job id", 400)
}
var jobUpdate spec.JobUpdateRequest
if err = json.Unmarshal(body, &jobUpdate); err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid request", 400)
}
err = manager.FinishJob(int(jID))
if err != nil {
return nil, httpapi.NewError(err.Error(), "Problem updating Job", 400)
}
return &httpapi.APIResponse{HTTPCode: 200}, nil
}
func deleteBackup(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
bID, err := strconv.ParseInt(vars["backupID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid backup ID", 400)
}
err = manager.DeleteBackup(int(bID))
if err != nil {
return nil, httpapi.NewError(err.Error(), "Could not delete backup", 500)
}
return &httpapi.APIResponse{HTTPCode: 200}, nil
}
func jobStatus(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
id, err := strconv.ParseInt(vars["jobID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid job id", 400)
}
job, err := manager.JobStatus(int(id))
if err != nil {
return nil, httpapi.NewError(err.Error(), "Could not get job status", 400)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"job": job}, HTTPCode: 200}, nil
}
func cancelJob(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
id, err := strconv.ParseInt(vars["jobId"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid job ID", 400)
}
if _, err := manager.Cancel(int(id)); err != nil {
return nil, httpapi.NewError(err.Error(), "Problem Canceling Job", 500)
}
return &httpapi.APIResponse{HTTPCode: 200}, nil
}
func getSchedule(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
sID, err := strconv.ParseInt(vars["sID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid schedule ID", 400)
}
s, err := manager.GetSchedule(int(sID))
if err != nil {
return nil, httpapi.NewError(err.Error(), "Unable to get schedule", 400)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"schedule": s}, HTTPCode: 200}, nil
}
func getAgent(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
aID, err := strconv.ParseInt(vars["agentID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid Agent ID", 400)
}
agent, err := manager.GetAgent(int(aID))
if err != nil {
return nil, httpapi.NewError(err.Error(), "Unable to get agent", 400)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"agent": agent}, HTTPCode: 200}, nil
}
func jobStatus(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
id, err := strconv.ParseInt(vars["jobId"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid job ID", 400)
}
jobStatus, found := manager.JobStatus(int(id))
if !found {
return nil, httpapi.NewError("", "I can't find that job ID", 404)
}
return &httpapi.APIResponse{Data: map[string]interface{}{vars["jobId"]: jobStatus}, HTTPCode: 200}, nil
}
func getBackup(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
bID, err := strconv.ParseInt(vars["backupID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid backup ID", 400)
}
backup, err := manager.GetBackup(int(bID))
if err != nil {
return nil, httpapi.NewError(err.Error(), "Could not read backup", 500)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"backup": backup}, HTTPCode: 200}, nil
}
func runBackup(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
bID, err := strconv.ParseInt(vars["backupID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid backup ID", 400)
}
id, err := manager.RunBackup(int(bID))
if err != nil {
return nil, httpapi.NewError(err.Error(), "Failed to run backup", 400)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"id": id}, HTTPCode: 200}, nil
}
func jobFiles(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
vars := mux.Vars(r)
id, err := strconv.ParseInt(vars["jobID"], 10, 64)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid job id", 400)
}
files, err := manager.JobFiles(vars["path"], int(id))
if err != nil {
return nil, httpapi.NewError(err.Error(), "Could not pull list of job files", 400)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"files": files}, HTTPCode: 200}, nil
}
func testEmail(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
err := manager.SendTestEmail()
if err != nil {
return nil, httpapi.NewError(err.Error(), "Unable to send test email", 400)
}
return &httpapi.APIResponse{HTTPCode: 200}, nil
}
func agentKey(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
key, err := manager.GetKey()
if err != nil {
return nil, httpapi.NewError(err.Error(), "Server Error", 500)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"keyString": key}, HTTPCode: 200}, nil
}
func agentList(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
list, err := manager.Agents()
if err != nil {
return nil, httpapi.NewError(err.Error(), "Could not Read Agents", 500)
}
if list == nil {
list = make([]*spec.Agent, 0)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"agents": list}, HTTPCode: 200}, nil
}
func listBackups(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
list, err := manager.Backups()
if err != nil {
return nil, httpapi.NewError(err.Error(), "Could not read backups", 500)
}
if list == nil {
list = make([]*spec.BackupDefinition, 0)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"backups": list}, HTTPCode: 200}, nil
}
func scheduleList(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
list, err := manager.ScheduleList()
if err != nil {
return nil, httpapi.NewError(err.Error(), "Could not Read Agents", 500)
}
if list == nil {
list = make([]*spec.Schedule, 0)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"stored": list, "active": manager.CronSchedules()}, HTTPCode: 200}, nil
}
func jobQuery(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
jobs, err := manager.QueryJobs(r.URL.Query())
if err != nil {
return nil, httpapi.NewError(err.Error(), "Error with query", 400)
}
if jobs == nil {
jobs = make([]*spec.Job, 0)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"jobs": jobs}, HTTPCode: 200}, nil
}
func addSchedule(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
return nil, httpapi.NewError("", "Request too large", 413)
}
if err := r.Body.Close(); err != nil {
return nil, errors.New("")
}
s := new(spec.Schedule)
if err := json.Unmarshal(body, &s); err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid Request", 400)
}
err = manager.AddSchedule(s)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Unable to add schedule", 400)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"id": s.ID}, HTTPCode: 200}, nil
}
func addBackup(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
return nil, httpapi.NewError("", "Request too large", 413)
}
if err := r.Body.Close(); err != nil {
return nil, errors.New("")
}
backup := new(spec.BackupDefinition)
err = json.Unmarshal(body, &backup)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Invalid backup definition provided", 400)
}
err = manager.AddBackup(backup)
if err != nil {
return nil, httpapi.NewError(err.Error(), "Could not create backup", 400)
}
return &httpapi.APIResponse{Data: map[string]interface{}{"id": backup.ID}, HTTPCode: 201}, nil
}
