func GetUser(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetUser: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
logit.Error.Println("GetUser: error User ID required")
rest.Error(w, "User ID required", http.StatusBadRequest)
return
}
status := SimpleStatus{}
status.Status = "OK"
w.WriteHeader(http.StatusOK)
w.WriteJson(&status)
}
func GetHealthCheck(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection("clusteradmin")
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
var results []collect.HealthCheck
results, err = collect.GetHealthCheck(dbConn)
if err != nil {
logit.Error.Println(err.Error())
w.WriteJson(&results)
return
}
w.WriteJson(&results)
}
func GetServer(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetServer: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
logit.Info.Println("in GetServer with ID=" + ID)
results, err := admindb.GetServer(dbConn, ID)
if err != nil {
logit.Error.Println("GetServer:" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
server := Server{results.ID, results.Name, results.IPAddress,
results.DockerBridgeIP, results.PGDataPath, results.ServerClass, results.CreateDate}
logit.Info.Println("GetServer: results=" + results.ID)
w.WriteJson(&server)
}
func RulesGetAll(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("RulesGetAll: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
rules, err := GetAllRules(dbConn)
if err != nil {
logit.Error.Println("RulesGetAll:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusOK)
w.WriteJson(&rules)
}
func Login(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
ID := r.PathParam("ID")
PSW := r.PathParam("PSW")
if ID == "" || PSW == "" {
logit.Error.Println("Login: ID or PSW not supplied")
rest.Error(w, "ID or PSW not supplied", http.StatusBadRequest)
}
logit.Info.Println("Login: called")
tokenContents, err := secimpl.Login(dbConn, ID, PSW)
if err != nil {
logit.Error.Println("Login: error secimpl call" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
//w.WriteHeader(http.StatusOK)
token := LoginToken{tokenContents}
logit.Info.Println("sending back token " + token.Contents)
w.WriteJson(&token)
}
func GetAllUsers(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetAllUsers: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
usersList, err := secimpl.GetAllUsers(dbConn)
if err != nil {
logit.Error.Println("GetAllUsers: error " + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
for i := range usersList {
logit.Info.Println("GetAllUsers: secimpl.GetAllUsers userName=" + usersList[i].Name)
}
w.WriteHeader(http.StatusOK)
w.WriteJson(&usersList)
}
func DeleteServer(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-server")
if err != nil {
logit.Error.Println("DeleteServer: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
logit.Error.Println("DeleteServer: error server id required")
rest.Error(w, "Server ID required", http.StatusBadRequest)
return
}
err = admindb.DeleteServer(dbConn, ID)
if err != nil {
logit.Error.Println("DeleteServer: " + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
}
w.WriteHeader(http.StatusOK)
}
func DeleteRole(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-user")
if err != nil {
logit.Error.Println("GetAllRoles: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
if r.PathParam("ID") == "" {
logit.Error.Println("DeleteRole: error ID required")
rest.Error(w, "ID required", http.StatusBadRequest)
return
}
err = secimpl.DeleteRole(dbConn, r.PathParam("ID"))
if err != nil {
logit.Error.Println("DeleteRole: error secimpl call" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
status := SimpleStatus{}
status.Status = "OK"
w.WriteJson(&status)
}
func GetSchedule(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetSchedule: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
rest.Error(w, "ID required", 400)
return
}
result, err := backup.GetSchedule(dbConn, ID)
if err != nil {
logit.Error.Println("GetNode: " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
w.WriteJson(result)
}
func GetCluster(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetCluster: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
results, err := admindb.GetCluster(dbConn, ID)
if err != nil {
logit.Error.Println("GetCluster:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
}
cluster := Cluster{results.ID, results.ProjectID, results.Name, results.ClusterType,
results.Status, results.CreateDate, "", results.Containers}
logit.Info.Println("GetCluser:db call results=" + results.ID)
w.WriteJson(&cluster)
}
func GetRole(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetRole: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
Name := r.PathParam("Name")
if Name == "" {
logit.Error.Println("GetRole: error Name required")
rest.Error(w, "Name required", http.StatusBadRequest)
return
}
var role sec.Role
role, err = secimpl.GetRole(dbConn, Name)
if err != nil {
logit.Error.Println("GetRole: error secimpl call" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.WriteJson(&role)
}
func ContainerLoadTest(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("ContainerLoadTest: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
rest.Error(w, "ID required", http.StatusBadRequest)
return
}
Writes := r.PathParam("Writes")
if Writes == "" {
rest.Error(w, "Writes required", http.StatusBadRequest)
return
}
var writes int
writes, err = strconv.Atoi(Writes)
if err != nil {
logit.Error.Println("ContainerLoadTest:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
node, err := admindb.GetContainer(dbConn, ID)
if err != nil {
logit.Error.Println("ContainerLoadTest:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
var host = node.Name
if KubeEnv {
host = node.Name + "-db"
}
results, err2 := loadtest(dbConn, node.Name, host, writes)
if err2 != nil {
logit.Error.Println("ContainerLoadTest:" + err2.Error())
rest.Error(w, err2.Error(), http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusOK)
w.WriteJson(&results)
}
func Logout(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
token := r.PathParam("Token")
if token == "" {
logit.Error.Println("Logout: Token not supplied")
rest.Error(w, "Token not supplied", http.StatusBadRequest)
}
err = secimpl.Logout(dbConn, token)
if err != nil {
logit.Error.Println("Logout: error secimpl call" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
status := SimpleStatus{}
status.Status = "OK"
w.WriteJson(&status)
}
func ContainerAccessRuleGetAll(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("ContainerRulesGetAll: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ContainerID := r.PathParam("ID")
if ContainerID == "" {
rest.Error(w, "ID required", http.StatusBadRequest)
return
}
cars, err := GetAllContainerAccessRule(dbConn, ContainerID)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusOK)
w.WriteJson(&cars)
}
func GetStatus(w rest.ResponseWriter, r *rest.Request) {
Token := r.PathParam("Token")
if Token == "" {
rest.Error(w, "Token required", 400)
return
}
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, Token, "perm-read")
if err != nil {
logit.Error.Println("GetStatus: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
rest.Error(w, "ID required", 400)
return
}
stat, err := backup.GetStatus(dbConn, ID)
if err != nil {
logit.Error.Println("GetStatus: " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
w.WriteHeader(http.StatusOK)
w.WriteJson(stat)
}
func GetProject(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetProject: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
logit.Error.Println("GetProject: error Project ID required")
rest.Error(w, "Project ID required", http.StatusBadRequest)
return
}
results, err := admindb.GetProject(dbConn, ID)
if err != nil {
logit.Error.Println("GetProject:" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
project := Project{results.ID, results.Name, results.Desc, results.UpdateDate, "", results.Containers, results.Clusters}
w.WriteJson(&project)
}
func MonitorContainerControldata(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("MonitorContainerControldata: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
rest.Error(w, "ID required", http.StatusBadRequest)
return
}
node, err := admindb.GetContainer(dbConn, ID)
if err != nil {
logit.Error.Println("MonitorContainerControldata:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
settings := make([]PostgresControldata, 0)
//send the container a pg_controldata command
var cdout cpmcontainerapi.ControldataResponse
cdout, err = cpmcontainerapi.ControldataClient(node.Name)
if err != nil {
logit.Error.Println("MonitorContainerControldata:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
logit.Info.Println(cdout.Output)
lines := strings.Split(cdout.Output, "\n")
//fmt.Println(len(lines))
for i := range lines {
//fmt.Println(len(lines[i]))
if len(lines[i]) > 1 {
setting := PostgresControldata{}
columns := strings.Split(lines[i], ":")
setting.Name = strings.TrimSpace(columns[0])
setting.Value = strings.TrimSpace(columns[1])
//fmt.Println("name=[" + strings.TrimSpace(columns[0]) + "] value=[" + strings.TrimSpace(columns[1]) + "]")
settings = append(settings, setting)
}
}
w.WriteHeader(http.StatusOK)
w.WriteJson(&settings)
}
func LoadSchedules() error {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
return err
}
defer dbConn.Close()
logit.Info.Println("LoadSchedules called")
var schedules []BackupSchedule
schedules, err = GetSchedules(dbConn)
if err != nil {
logit.Error.Println("LoadSchedules error " + err.Error())
return err
}
if CRONInstance != nil {
logit.Info.Println("stopping current cron instance...")
CRONInstance.Stop()
}
//kill off the old cron, garbage collect it
CRONInstance = nil
//create a new cron
logit.Info.Println("creating cron instance...")
CRONInstance = cron.New()
var cronexp string
for i := 0; i < len(schedules); i++ {
cronexp = getCron(schedules[i])
logit.Info.Println("would have loaded schedule..." + cronexp)
if schedules[i].Enabled == "YES" {
logit.Info.Println("schedule " + schedules[i].ID + " was enabled so adding it")
x := DefaultJob{}
x.request = BackupRequest{}
x.request.ScheduleID = schedules[i].ID
x.request.ServerID = schedules[i].ServerID
x.request.ServerName = schedules[i].ServerName
x.request.ServerIP = schedules[i].ServerIP
x.request.ContainerName = schedules[i].ContainerName
x.request.ProfileName = schedules[i].ProfileName
CRONInstance.AddJob(cronexp, x)
} else {
logit.Info.Println("schedule " + schedules[i].ID + " NOT enabled so dropping it")
}
}
logit.Info.Println("starting new CRONInstance")
CRONInstance.Start()
return err
}
//we use AddServer for both updating and inserting based on the ID passed in
func AddServer(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-server")
if err != nil {
logit.Error.Println("AddServer: authorize token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
CreateDate := ""
server := Server{r.PathParam("ID"), r.PathParam("Name"), r.PathParam("IPAddress"), r.PathParam("DockerBridgeIP"), r.PathParam("PGDataPath"), r.PathParam("ServerClass"), CreateDate}
server.IPAddress = strings.Replace(server.IPAddress, "_", ".", -1)
server.DockerBridgeIP = strings.Replace(server.DockerBridgeIP, "_", ".", -1)
server.PGDataPath = strings.Replace(server.PGDataPath, "_", "/", -1)
if server.Name == "" {
logit.Error.Println("AddServer: error server name required")
rest.Error(w, "server name required", http.StatusBadRequest)
return
}
if server.IPAddress == "" {
logit.Error.Println("AddServer: error ipaddress required")
rest.Error(w, "server IPAddress required", http.StatusBadRequest)
return
}
if server.PGDataPath == "" {
logit.Error.Println("AddServer: error pgdatapath required")
rest.Error(w, "server PGDataPath required", http.StatusBadRequest)
return
}
dbserver := admindb.Server{server.ID, server.Name, server.IPAddress,
server.DockerBridgeIP, server.PGDataPath, server.ServerClass, CreateDate, ""}
if dbserver.ID == "0" {
strid, err := admindb.InsertServer(dbConn, dbserver)
newid := strconv.Itoa(strid)
if err != nil {
logit.Error.Println("AddServer:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
server.ID = newid
} else {
admindb.UpdateServer(dbConn, dbserver)
}
w.WriteHeader(http.StatusOK)
w.WriteJson(&server)
}
func ChangePassword(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
logit.Info.Println("ChangePassword: in ChangePassword")
changePass := ChgPassword{}
err = r.DecodeJsonPayload(&changePass)
if err != nil {
logit.Error.Println("ChangePassword: error in decode" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = secimpl.Authorize(dbConn, changePass.Token, "perm-read")
if err != nil {
logit.Error.Println("ChangePassword: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
var sameUser bool
sameUser, err = secimpl.CompareUserToToken(dbConn, changePass.Username, changePass.Token)
if err != nil {
logit.Error.Println("ChangePassword: compare UserToToken error " + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
//enforce perm-user if the username is not the same as the token's
//username (e.g. bob tries to change larry's password)
if !sameUser {
err = secimpl.Authorize(dbConn, changePass.Token, "perm-user")
if err != nil {
logit.Error.Println("ChangePassword: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
}
err = secimpl.ChangePassword(dbConn, changePass.Username, changePass.Password)
if err != nil {
logit.Error.Println("ChangePassword: error secimpl call" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
status := SimpleStatus{}
status.Status = "OK"
w.WriteJson(&status)
}
func AdminStoppg(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-cluster")
if err != nil {
logit.Error.Println("AdminStoppg: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
logit.Info.Println("AdminStoppg:called")
ID := r.PathParam("ID")
if ID == "" {
logit.Error.Println("AdminStoppg:ID not found error")
rest.Error(w, "node ID required", http.StatusBadRequest)
return
}
var dbNode admindb.Container
dbNode, err = admindb.GetContainer(dbConn, ID)
if err != nil {
logit.Error.Println("AdminStartpg: " + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
logit.Info.Println("AdminStoppg: in stop with dbnode")
if dbNode.Role == "pgpool" {
var stoppoolResp cpmcontainerapi.StopPgpoolResponse
stoppoolResp, err = cpmcontainerapi.StopPgpoolClient(dbNode.Name)
logit.Info.Println("AdminStoppg:" + stoppoolResp.Output)
} else {
var stoppgResp cpmcontainerapi.StopPGResponse
stoppgResp, err = cpmcontainerapi.StopPGClient(dbNode.Name)
logit.Info.Println("AdminStoppg:" + stoppgResp.Output)
}
if err != nil {
logit.Error.Println("AdminStoppg:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
//give the UI a chance to see the stop
time.Sleep(3000 * time.Millisecond)
w.WriteHeader(http.StatusOK)
status := SimpleStatus{}
status.Status = "OK"
w.WriteJson(&status)
}
//this is the func that implements the cron Job interface
func (t DefaultJob) Run() {
logit.Info.Println("running ScheduleID:" + t.request.ScheduleID)
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
}
defer dbConn.Close()
ProvisionBackupJob(dbConn, &t.request)
}
func AdminStartNode(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("AdminStartNode: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
logit.Error.Println("AdminStartNode: error ID required")
rest.Error(w, "ID required", http.StatusBadRequest)
return
}
node, err := admindb.GetContainer(dbConn, ID)
if err != nil {
logit.Error.Println("AdminStartNode:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
server := admindb.Server{}
server, err = admindb.GetServer(dbConn, node.ServerID)
if err != nil {
logit.Error.Println("AdminStartNode:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
var url = "http://" + server.IPAddress + ":10001"
var response cpmserverapi.DockerStartResponse
request := &cpmserverapi.DockerStartRequest{}
request.ContainerName = node.Name
response, err = cpmserverapi.DockerStartClient(url, request)
if err != nil {
logit.Error.Println("AdminStartNode: error when trying to start container " + err.Error())
}
logit.Info.Println(response.Output)
w.WriteHeader(http.StatusOK)
status := SimpleStatus{}
status.Status = "OK"
w.WriteJson(&status)
}
//we use POST for both updating and inserting based on the ID passed in
func PostCluster(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
logit.Info.Println("PostCluster: in PostCluster")
cluster := Cluster{}
err = r.DecodeJsonPayload(&cluster)
if err != nil {
logit.Error.Println("PostCluster: error in decode" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = secimpl.Authorize(dbConn, cluster.Token, "perm-cluster")
if err != nil {
logit.Error.Println("PostCluster: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
if cluster.Name == "" {
logit.Error.Println("PostCluster: error in Name")
rest.Error(w, "cluster name required", http.StatusBadRequest)
return
}
logit.Info.Println("PostCluster: have ID=" + cluster.ID + " Name=" + cluster.Name + " type=" + cluster.ClusterType + " status=" + cluster.Status)
dbcluster := admindb.Cluster{cluster.ID, cluster.ProjectID, cluster.Name, cluster.ClusterType, cluster.Status, "", cluster.Containers}
if cluster.ID == "" {
strid, err := admindb.InsertCluster(dbConn, dbcluster)
newid := strconv.Itoa(strid)
if err != nil {
logit.Error.Println("PostCluster:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
cluster.ID = newid
} else {
logit.Info.Println("PostCluster: about to call UpdateCluster")
err2 := admindb.UpdateCluster(dbConn, dbcluster)
if err2 != nil {
logit.Error.Println("PostCluster: error in UpdateCluster " + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
w.WriteJson(&cluster)
}
func UpdateProject(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
logit.Info.Println("UpdateProject: in UpdateProject")
project := Project{}
err = r.DecodeJsonPayload(&project)
if err != nil {
logit.Error.Println("UpdateProject: error in decode" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
logit.Info.Println("UpdateProject: ID=" + project.ID)
logit.Info.Println("UpdateProject: Name=" + project.Name)
logit.Info.Println("UpdateProject: Desc=" + project.Desc)
logit.Info.Println("UpdateProject: token=" + project.Token)
err = secimpl.Authorize(dbConn, project.Token, "perm-container")
if err != nil {
logit.Error.Println("UpdateProject: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
dbproject := admindb.Project{
ID: project.ID,
Name: project.Name,
Desc: project.Desc,
UpdateDate: project.UpdateDate,
Containers: project.Containers,
Clusters: project.Clusters}
err = admindb.UpdateProject(dbConn, dbproject)
if err != nil {
logit.Error.Println("UpdateProject: error secimpl call" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
status := SimpleStatus{}
status.Status = "OK"
w.WriteJson(&status)
}
func RulesUpdate(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
logit.Info.Println("RulesUpdate: in RulesUpdate")
rule := Rule{}
err = r.DecodeJsonPayload(&rule)
if err != nil {
logit.Error.Println("RulesUpdate: error in decode" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = secimpl.Authorize(dbConn, rule.Token, "perm-container")
if err != nil {
logit.Error.Println("RulesUpdate: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
if rule.ID == "" {
logit.Error.Println("RulesUpdate: error in ID")
rest.Error(w, "rule ID required", http.StatusBadRequest)
return
}
if rule.Name == "" {
logit.Error.Println("RulesUpdate: error in Name")
rest.Error(w, "rule name required", http.StatusBadRequest)
return
}
err = UpdateRule(dbConn, rule)
if err != nil {
logit.Error.Println("RulesUpdate: error " + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
status := SimpleStatus{}
status.Status = "OK"
w.WriteHeader(http.StatusOK)
w.WriteJson(&status)
}
func GetAllNodesForCluster(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetAllForCluster: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ClusterID := r.PathParam("ClusterID")
if ClusterID == "" {
logit.Error.Println("GetAllNodesForCluster: node ClusterID required")
rest.Error(w, "node ClusterID required", http.StatusBadRequest)
return
}
results, err := admindb.GetAllContainersForCluster(dbConn, ClusterID)
if err != nil {
logit.Error.Println("GetAllNodesForCluster:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
}
nodes := make([]ClusterNode, len(results))
i := 0
for i = range results {
nodes[i].ID = results[i].ID
nodes[i].Name = results[i].Name
nodes[i].ClusterID = results[i].ClusterID
nodes[i].ServerID = results[i].ServerID
nodes[i].Role = results[i].Role
nodes[i].Image = results[i].Image
nodes[i].CreateDate = results[i].CreateDate
nodes[i].ProjectID = results[i].ProjectID
nodes[i].ProjectName = results[i].ProjectName
nodes[i].ServerName = results[i].ServerName
nodes[i].ClusterName = results[i].ClusterName
//nodes[i].Status = "UNKNOWN"
i++
}
w.WriteJson(&nodes)
}
func BadgerGenerate(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("BadgerGenerate: authorize error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
ID := r.PathParam("ID")
if ID == "" {
rest.Error(w, "ID required", http.StatusBadRequest)
return
}
container, err := admindb.GetContainer(dbConn, ID)
if err != nil {
logit.Error.Println("BadgerGenerate:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
var host = container.Name
if KubeEnv {
host = container.Name + "-db"
}
//send the container a pg_controldata command
var cdout cpmcontainerapi.BadgerGenerateResponse
cdout, err = cpmcontainerapi.BadgerGenerateClient(host)
if err != nil {
logit.Error.Println("BadgerGenerate:" + err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
logit.Info.Println(cdout.Output)
w.WriteHeader(http.StatusOK)
w.WriteJson(&cdout)
}
func GetBackupNodes(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
rest.Error(w, err.Error(), 400)
return
}
err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-read")
if err != nil {
logit.Error.Println("GetAllNodes: validate token error " + err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
results, err2 := admindb.GetAllContainers(dbConn)
if err2 != nil {
logit.Error.Println("GetAllNodes: " + err2.Error())
rest.Error(w, err2.Error(), 400)
}
i := 0
//nodes := make([]ClusterNode, found)
nodes := []ClusterNode{}
for i = range results {
if results[i].Role == "unassigned" ||
results[i].Role == "master" {
n := ClusterNode{}
n.ID = results[i].ID
n.Name = results[i].Name
n.ClusterID = results[i].ClusterID
n.ServerID = results[i].ServerID
n.Role = results[i].Role
n.Image = results[i].Image
n.CreateDate = results[i].CreateDate
n.ProjectName = results[i].ProjectName
n.ServerName = results[i].ServerName
n.Status = "UNKNOWN"
nodes = append(nodes, n)
}
i++
}
w.WriteJson(&nodes)
}
//called by backup jobs as they execute
func (t *Command) AddStatus(status *BackupStatus, reply *Command) error {
logit.Info.Println("AddStatus called")
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println("BackupNow: error " + err.Error())
return err
}
defer dbConn.Close()
var id string
id, err = AddStatus(dbConn, *status)
if err != nil {
logit.Error.Println("AddStatus error " + err.Error())
}
reply.Output = id
return err
}