// AdminStartNode starts a container func AdminStartNode(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(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(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(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } /** server := types.Server{} server, err = admindb.GetServer(dbConn, node.ServerID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } */ var response swarmapi.DockerStartResponse request := &swarmapi.DockerStartRequest{} request.ContainerName = node.Name response, err = swarmapi.DockerStart(request) if err != nil { logit.Error.Println(err.Error()) logit.Error.Println(response.Output) } //logit.Info.Println(response.Output) w.WriteHeader(http.StatusOK) status := types.SimpleStatus{} status.Status = "OK" w.WriteJson(&status) }
// AdminStoppg stops a postgres database on a given container func AdminStoppg(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(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(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 types.Container dbNode, err = admindb.GetContainer(dbConn, ID) if err != nil { logit.Error.Println(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(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } w.WriteHeader(http.StatusOK) status := types.SimpleStatus{} status.Status = "OK" w.WriteJson(&status) }
// GetNode returns the container node definition func GetNode(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(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(err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } ID := r.PathParam("ID") if ID == "" { logit.Error.Println("error node ID required") rest.Error(w, "node ID required", http.StatusBadRequest) return } node, err2 := admindb.GetContainer(dbConn, ID) if node.ID == "" { rest.NotFound(w, r) return } if err2 != nil { logit.Error.Println(err2.Error()) rest.Error(w, err2.Error(), http.StatusBadRequest) return } var currentStatus = "UNKNOWN" request := &swarmapi.DockerInspectRequest{} var inspectInfo swarmapi.DockerInspectResponse request.ContainerName = node.Name inspectInfo, err = swarmapi.DockerInspect(request) if err != nil { logit.Error.Println(err.Error()) currentStatus = CONTAINER_NOT_FOUND } if currentStatus != "CONTAINER NOT FOUND" { var pgport types.Setting pgport, err = admindb.GetSetting(dbConn, "PG-PORT") if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } currentStatus, err = util.FastPing(pgport.Value, node.Name) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } //logit.Info.Println("pinging db finished") } clusternode := new(types.ClusterNode) clusternode.ID = node.ID clusternode.ClusterID = node.ClusterID clusternode.Name = node.Name clusternode.Role = node.Role clusternode.Image = node.Image clusternode.CreateDate = node.CreateDate clusternode.Status = currentStatus clusternode.ProjectID = node.ProjectID clusternode.ProjectName = node.ProjectName clusternode.ClusterName = node.ClusterName clusternode.ServerID = inspectInfo.ServerID clusternode.IPAddress = inspectInfo.IPAddress w.WriteJson(clusternode) }
/* TODO refactor this to share code with DeleteCluster!!!!! */ func DeleteNode(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } defer dbConn.Close() err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-container") if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } ID := r.PathParam("ID") if ID == "" { logit.Error.Println("DeleteNode: error node ID required") rest.Error(w, "node ID required", http.StatusBadRequest) return } //go get the node we intend to delete var dbNode types.Container dbNode, err = admindb.GetContainer(dbConn, ID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var infoResponse swarmapi.DockerInfoResponse infoResponse, err = swarmapi.DockerInfo() if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } servers := make([]types.Server, len(infoResponse.Output)) i := 0 for i = range infoResponse.Output { servers[i].ID = infoResponse.Output[i] servers[i].Name = infoResponse.Output[i] servers[i].IPAddress = infoResponse.Output[i] i++ } var pgdatapath types.Setting pgdatapath, err = admindb.GetSetting(dbConn, "PG-DATA-PATH") if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } err = admindb.DeleteContainer(dbConn, ID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } logit.Info.Println("remove 1") //it is possible that someone can remove a container //outside of us, so we let it pass that we can't remove //it request := &swarmapi.DockerRemoveRequest{} request.ContainerName = dbNode.Name _, err = swarmapi.DockerRemove(request) if err != nil { logit.Error.Println(err.Error()) } logit.Info.Println("remove 2") //send the server a deletevolume command request2 := &cpmserverapi.DiskDeleteRequest{} request2.Path = pgdatapath.Value + "/" + dbNode.Name for _, each := range servers { _, err = cpmserverapi.DiskDeleteClient(each.Name, request2) if err != nil { logit.Error.Println(err.Error()) } } logit.Info.Println("remove 3") //we should not have to delete the DNS entries because //of the dnsbridge, it should remove them when we remove //the containers via the docker api w.WriteHeader(http.StatusOK) status := types.SimpleStatus{} status.Status = "OK" w.WriteJson(&status) }
// TODO func EventJoinCluster(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(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(err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } IDList := r.PathParam("IDList") if IDList == "" { logit.Error.Println("IDList required") rest.Error(w, "IDList required", http.StatusBadRequest) return } else { logit.Info.Println("EventJoinCluster: IDList=[" + IDList + "]") } MasterID := r.PathParam("MasterID") if MasterID == "" { logit.Error.Println("MasterID required") rest.Error(w, "MasterID required", http.StatusBadRequest) return } else { logit.Info.Println("EventJoinCluster: MasterID=[" + MasterID + "]") } ClusterID := r.PathParam("ClusterID") if ClusterID == "" { logit.Error.Println("ClusterID required") rest.Error(w, "node ClusterID required", http.StatusBadRequest) return } else { logit.Info.Println("EventJoinCluster: ClusterID=[" + ClusterID + "]") } var idList = strings.Split(IDList, "_") i := 0 pgpoolCount := 0 origDBNode := types.Container{} for i = range idList { if idList[i] != "" { logit.Info.Println("EventJoinCluster: idList[" + strconv.Itoa(i) + "]=" + idList[i]) origDBNode, err = admindb.GetContainer(dbConn, idList[i]) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } //update the node to be in the cluster origDBNode.ClusterID = ClusterID if origDBNode.Image == "cpm-node" { origDBNode.Role = STANDBY } else { origDBNode.Role = "pgpool" pgpoolCount++ } if pgpoolCount > 1 { logit.Error.Println("EventJoinCluster: more than 1 pgpool is in the cluster") rest.Error(w, "only 1 pgpool is allowed in a cluster", http.StatusBadRequest) return } err = admindb.UpdateContainer(dbConn, origDBNode) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } } i++ } //we use the -1 value to indicate that we are only adding //to an existing cluster, the UI doesn't know who the master //is at this point if MasterID != "-1" { //update the master node origDBNode, err = admindb.GetContainer(dbConn, MasterID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } origDBNode.ClusterID = ClusterID origDBNode.Role = "master" err = admindb.UpdateContainer(dbConn, origDBNode) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } } w.WriteHeader(http.StatusOK) status := types.SimpleStatus{} status.Status = "OK" w.WriteJson(&status) }
// AdminFailover causes a cluster failorver to be performed for a given cluster func AdminFailover(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(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("authorize error " + err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } ID := r.PathParam("ID") if ID == "" { logit.Error.Println("node ID required error") rest.Error(w, "node ID required", http.StatusBadRequest) return } //dbNode is the standby node we are going to fail over and //make the new master in the cluster var dbNode types.Container dbNode, err = admindb.GetContainer(dbConn, ID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } cluster, err := admindb.GetCluster(dbConn, dbNode.ClusterID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var failoverResp cpmcontainerapi.FailoverResponse failoverResp, err = cpmcontainerapi.FailoverClient(dbNode.Name) if err != nil { logit.Error.Println("fail-over error " + err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } logit.Info.Println("AdminFailover: fail-over output " + failoverResp.Output) //update the old master to standalone role oldMaster := types.Container{} oldMaster, err = admindb.GetContainerMaster(dbConn, dbNode.ClusterID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } oldMaster.Role = "standalone" oldMaster.ClusterID = "-1" err = admindb.UpdateContainer(dbConn, oldMaster) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } //update the failover node to master role dbNode.Role = "master" err = admindb.UpdateContainer(dbConn, dbNode) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } //stop pg on the old master //params.IPAddress1 = oldMaster.IPAddress var stopPGResp cpmcontainerapi.StopPGResponse stopPGResp, err = cpmcontainerapi.StopPGClient(oldMaster.Name) if err != nil { logit.Error.Println(err.Error() + stopPGResp.Output) rest.Error(w, err.Error(), http.StatusBadRequest) return } err = configureCluster("SM", dbConn, cluster, false) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } w.WriteHeader(http.StatusOK) status := types.SimpleStatus{} status.Status = "OK" w.WriteJson(&status) return }
// UpdateContainerUser updates a database users preferences on a given container db func UpdateContainerUser(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } defer dbConn.Close() postMsg := types.NodeUser{} err = r.DecodeJsonPayload(&postMsg) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } err = secimpl.Authorize(dbConn, postMsg.Token, "perm-user") if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } if postMsg.ID == "" { logit.Error.Println("UpdateContainerUser: error node ID required") rest.Error(w, "ID required", 400) return } if postMsg.Rolname == "" { logit.Error.Println("UpdateContainerUser: error node Rolname required") rest.Error(w, "Rolname required", 400) return } //create user on the container //get container info var node types.Container node, err = admindb.GetContainer(dbConn, postMsg.ID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } if postMsg.Passwd == "" { } else { //update the password } var credential types.Credential credential, err = admindb.GetUserCredentials(dbConn, &node) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var dbConn2 *sql.DB dbConn2, err = util.GetMonitoringConnection(credential.Host, credential.Username, credential.Port, credential.Database, credential.Password) defer dbConn2.Close() var SUPERUSER = "******" var INHERIT = "INHERIT" var CREATEROLE = "CREATEROLE" var CREATEDB = "CREATEDB" var LOGIN = "******" var REPLICATION = "REPLICATION" logit.Info.Println("Rolsuper is " + strconv.FormatBool(postMsg.Rolsuper)) if !postMsg.Rolsuper { SUPERUSER = "******" } if !postMsg.Rolinherit { INHERIT = "NOINHERIT" } if !postMsg.Rolcreaterole { CREATEROLE = "NOCREATEROLE" } if !postMsg.Rolcreatedb { CREATEDB = "NOCREATEDB" } if !postMsg.Rollogin { LOGIN = "******" } if !postMsg.Rolreplication { REPLICATION = "NOREPLICATION" } query := "alter user " + postMsg.Rolname + " " + SUPERUSER + " " + INHERIT + " " + CREATEROLE + " " + CREATEDB + " " + LOGIN + " " + REPLICATION + " " if postMsg.Passwd != "" { query = query + " PASSWORD '" + postMsg.Passwd + "'" } logit.Info.Println(query) _, err = dbConn2.Query(query) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var userexists = true _, err = admindb.GetContainerUser(dbConn, node.Name, postMsg.Rolname) if err == sql.ErrNoRows { // Handle no rows userexists = false } else if err != nil { // Handle actual error logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } if postMsg.Passwd != "" { //update user's password dbuser := types.ContainerUser{} dbuser.Containername = node.Name dbuser.Passwd = postMsg.Passwd dbuser.Rolname = postMsg.Rolname if userexists { err = admindb.UpdateContainerUser(dbConn, dbuser) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } } } w.WriteHeader(http.StatusOK) status := types.SimpleStatus{} status.Status = "OK" w.WriteJson(&status) }
// GetAllusersForContainer returns a list of all database users on a given db container func GetAllUsersForContainer(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(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(err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } ID := r.PathParam("ID") if ID == "" { rest.Error(w, "ID required", 400) return } //get container info var node types.Container node, err = admindb.GetContainer(dbConn, ID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var credential types.Credential credential, err = admindb.GetUserCredentials(dbConn, &node) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var dbConn2 *sql.DB dbConn2, err = util.GetMonitoringConnection(credential.Host, credential.Username, credential.Port, credential.Database, credential.Password) defer dbConn2.Close() users := make([]types.ContainerUser, 0) //query results var rows *sql.Rows rows, err = dbConn2.Query("select rolname::text, rolsuper::text, rolinherit::text, rolcreaterole::text, rolcreatedb::text, rolcanlogin::text, rolreplication::text from pg_roles order by rolname") if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } defer rows.Close() for rows.Next() { user := types.ContainerUser{} if err = rows.Scan( &user.Rolname, &user.Rolsuper, &user.Rolinherit, &user.Rolcreaterole, &user.Rolcreatedb, &user.Rolcanlogin, &user.Rolreplication, ); err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } user.Containername = node.Name user.ContainerID = node.ID users = append(users, user) } if err = rows.Err(); err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } w.WriteHeader(http.StatusOK) w.WriteJson(&users) }
// AddContainerUser creates a new database user for a given container func AddContainerUser(w rest.ResponseWriter, r *rest.Request) { postMsg := types.NodeUser{} err := r.DecodeJsonPayload(&postMsg) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } var dbConn *sql.DB dbConn, err = util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } defer dbConn.Close() err = secimpl.Authorize(dbConn, postMsg.Token, "perm-user") if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } if postMsg.ID == "" { logit.Error.Println("AddContainerUser: error node ID required") rest.Error(w, "ID required", 400) return } if postMsg.Rolname == "" { logit.Error.Println("AddContainerUser: error node Rolname required") rest.Error(w, "Rolname required", 400) return } if postMsg.Passwd == "" { logit.Error.Println("AddContainerUser: error node Passwd required") rest.Error(w, "Passwd required", 400) return } //create user on the container //get container info node, err := admindb.GetContainer(dbConn, postMsg.ID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var credential types.Credential credential, err = admindb.GetUserCredentials(dbConn, &node) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var dbConn2 *sql.DB dbConn2, err = util.GetMonitoringConnection(credential.Host, credential.Username, credential.Port, credential.Database, credential.Password) defer dbConn2.Close() var SUPERUSER = "" var INHERIT = "" var CREATEROLE = "" var CREATEDB = "" var LOGIN = "" var REPLICATION = "" //logit.Info.Println("Rolsuper is " + strconv.FormatBool(postMsg.Rolsuper)) if postMsg.Rolsuper { SUPERUSER = "******" } if postMsg.Rolinherit { INHERIT = "INHERIT" } if postMsg.Rolcreaterole { CREATEROLE = "CREATEROLE" } if postMsg.Rolcreatedb { CREATEDB = "CREATEDB" } if postMsg.Rollogin { LOGIN = "******" } if postMsg.Rolreplication { REPLICATION = "REPLICATION" } query := "create user " + postMsg.Rolname + " " + SUPERUSER + " " + INHERIT + " " + CREATEROLE + " " + CREATEDB + " " + LOGIN + " " + REPLICATION + " " + "PASSWORD '" + postMsg.Passwd + "'" logit.Info.Println(query) _, err = dbConn2.Query(query) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } //create user in the admin db dbuser := types.ContainerUser{} dbuser.Containername = node.Name dbuser.Passwd = postMsg.Passwd dbuser.Rolname = postMsg.Rolname result, err := admindb.AddContainerUser(dbConn, dbuser) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } logit.Info.Printf("AddContainerUser: new ID %d\n", result) w.WriteHeader(http.StatusOK) status := types.SimpleStatus{} status.Status = "OK" w.WriteJson(&status) }
// GetContainerUser returns a database user for a given container func GetContainerUser(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(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(err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } ContainerID := r.PathParam("ContainerID") if ContainerID == "" { rest.Error(w, "ContainerID required", 400) return } Rolname := r.PathParam("Rolname") if Rolname == "" { rest.Error(w, "Rolname required", 400) return } //get container info node, err := admindb.GetContainer(dbConn, ContainerID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var credential types.Credential credential, err = admindb.GetUserCredentials(dbConn, &node) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var dbConn2 *sql.DB dbConn2, err = util.GetMonitoringConnection(credential.Host, credential.Username, credential.Port, credential.Database, credential.Password) defer dbConn2.Close() query := "select rolname::text, rolsuper::text, rolinherit::text, rolcreaterole::text, rolcreatedb::text, rolcanlogin::text, rolreplication::text from pg_roles where rolname = '" + Rolname + "' order by rolname" logit.Info.Println(query) nodeuser := types.ContainerUser{} err = dbConn2.QueryRow(query).Scan( &nodeuser.Rolname, &nodeuser.Rolsuper, &nodeuser.Rolinherit, &nodeuser.Rolcreaterole, &nodeuser.Rolcreatedb, &nodeuser.Rolcanlogin, &nodeuser.Rolreplication) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } w.WriteJson(&nodeuser) }
// DeleteContainerUser deletes a database user on a given container func DeleteContainerUser(w rest.ResponseWriter, r *rest.Request) { dbConn, err := util.GetConnection(CLUSTERADMIN_DB) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } defer dbConn.Close() err = secimpl.Authorize(dbConn, r.PathParam("Token"), "perm-backup") if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusUnauthorized) return } ContainerID := r.PathParam("ContainerID") if ContainerID == "" { rest.Error(w, "ContainerID required", 400) return } rolname := r.PathParam("Rolname") if rolname == "" { rest.Error(w, "Rolname required", 400) return } //get node info node, err := admindb.GetContainer(dbConn, ContainerID) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var userexists = true _, err = admindb.GetContainerUser(dbConn, node.Name, rolname) if err == sql.ErrNoRows { // Handle no rows userexists = false } else if err != nil { // Handle actual error logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } //only delete if there is a container user if userexists { err = admindb.DeleteContainerUser(dbConn, node.Name, rolname) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), 400) return } } var credential types.Credential credential, err = admindb.GetUserCredentials(dbConn, &node) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } var dbConn2 *sql.DB dbConn2, err = util.GetMonitoringConnection(credential.Host, credential.Username, credential.Port, credential.Database, credential.Password) defer dbConn2.Close() query := "drop role " + rolname logit.Info.Println(query) _, err = dbConn2.Query(query) if err != nil { logit.Error.Println(err.Error()) rest.Error(w, err.Error(), http.StatusBadRequest) return } w.WriteHeader(http.StatusOK) status := types.SimpleStatus{} status.Status = "OK" w.WriteJson(&status) }
func performConfigUpdate(dbConn *sql.DB, ContainerID string) error { logit.Info.Println("performConfigUpdate....") cars, err := GetAllContainerAccessRule(dbConn, ContainerID) if err != nil { logit.Error.Println(err.Error()) return err } container, err := admindb.GetContainer(dbConn, ContainerID) if err != nil { logit.Error.Println("GetNode: " + err.Error()) return err } var currentStatus string //currentStatus, err = GetPGStatus2(dbConn, container.Name, container.Name) var pgport types.Setting pgport, err = admindb.GetSetting(dbConn, "PG-PORT") if err != nil { logit.Error.Println(err.Error()) return err } currentStatus, err = util.FastPing(pgport.Value, container.Name) if err != nil { logit.Error.Println("GetNode:" + err.Error()) return err } if currentStatus != "RUNNING" { logit.Info.Println("performConfigUpdate....starting postgres") if container.Role == "pgpool" { var spgresp cpmcontainerapi.StartPgpoolResponse spgresp, err = cpmcontainerapi.StartPgpoolClient(container.Name) logit.Info.Println("AdminStartpg:" + spgresp.Output) } else { var srep cpmcontainerapi.StartPGResponse srep, err = cpmcontainerapi.StartPGClient(container.Name) logit.Info.Println("AdminStartpg:" + srep.Output) } if err != nil { logit.Error.Println("AdminStartpg:" + err.Error()) return err } } //make template changes here logit.Info.Println("performConfigUpdate....making template changes") templateChange(dbConn, container.Name, cars, container.Role) //restart postgres if container.Role == "pgpool" { logit.Info.Println("performConfigUpdate....stopping pgpool") var stoppoolResp cpmcontainerapi.StopPgpoolResponse stoppoolResp, err = cpmcontainerapi.StopPgpoolClient(container.Name) logit.Info.Println("AdminStoppg:" + stoppoolResp.Output) } else { logit.Info.Println("performConfigUpdate....stopping postgres") var stoppgResp cpmcontainerapi.StopPGResponse stoppgResp, err = cpmcontainerapi.StopPGClient(container.Name) logit.Info.Println("AdminStoppg:" + stoppgResp.Output) } if err != nil { logit.Error.Println("AdminStoppg:" + err.Error()) return err } if container.Role == "pgpool" { logit.Info.Println("performConfigUpdate....starting pgpool") var spgresp cpmcontainerapi.StartPgpoolResponse spgresp, err = cpmcontainerapi.StartPgpoolClient(container.Name) logit.Info.Println("AdminStartpg:" + spgresp.Output) } else { logit.Info.Println("performConfigUpdate....starting postgres") var srep cpmcontainerapi.StartPGResponse srep, err = cpmcontainerapi.StartPGClient(container.Name) logit.Info.Println("AdminStartpg:" + srep.Output) } if err != nil { logit.Error.Println("AdminStartpg:" + err.Error()) return err } return err }