func PostAccessTokensEnabled(w http.ResponseWriter, r *http.Request) {
db := context.Get(r, "db").(*sqlx.DB)
tokenID, err := getIdFromPath(w, r)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
at := dal.NewAccessToken(db)
accessTokenRow, err := at.GetByID(nil, tokenID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
data := make(map[string]interface{})
data["enabled"] = !accessTokenRow.Enabled
_, err = at.UpdateById(nil, data, tokenID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/clusters", 301)
}
func PostSavedQueries(w http.ResponseWriter, r *http.Request) {
db := context.Get(r, "db").(*sqlx.DB)
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUser := session.Values["user"].(*rm_dal.UserRow)
accessTokenRow, err := rm_dal.NewAccessToken(db).GetByUserID(nil, currentUser.ID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
savedQuery := r.FormValue("SavedQuery")
_, err = rm_dal.NewSavedQuery(db).CreateOrUpdate(nil, accessTokenRow, savedQuery)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/?q="+savedQuery, 301)
}
func PostAccessTokens(w http.ResponseWriter, r *http.Request) {
db := context.Get(r, "db").(*sqlx.DB)
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUser := session.Values["user"].(*dal.UserRow)
clusterID, err := getIdFromPath(w, r)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
level := r.FormValue("Level")
_, err = dal.NewAccessToken(db).Create(nil, currentUser.ID, clusterID, level)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/clusters", 301)
}
func ApiWSAccessToken(w http.ResponseWriter, r *http.Request) {
accessToken := mux.Vars(r)["id"]
db := context.Get(r, "db").(*sqlx.DB)
// Check if access token exists
accessTokenRow, err := dal.NewAccessToken(db).GetByAccessToken(nil, accessToken)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if accessTokenRow == nil {
err = errors.New("Unrecognized access token")
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// Upgrade connection to full duplex TCP connection
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
wsTraffickers := context.Get(r, "wsTraffickers").(*wstrafficker.WSTraffickers)
wsTrafficker, err := wsTraffickers.SaveConnection(accessToken, conn)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
ticker := time.NewTicker(pingPeriod)
defer func() {
ticker.Stop()
conn.Close()
}()
for {
select {
case message, ok := <-wsTrafficker.Chans.Send:
if !ok {
wsTrafficker.Write(websocket.CloseMessage, []byte{})
wsTraffickers.DeleteConnection(accessToken, wsTrafficker.Hostname)
return
}
if err := wsTrafficker.Write(websocket.TextMessage, message); err != nil {
return
}
case <-ticker.C:
if err := wsTrafficker.Write(websocket.PingMessage, []byte{}); err != nil {
return
}
}
}
}
// MustLoginApi is a middleware that checks /api login.
func MustLoginApi(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
auth := r.Header.Get("Authorization")
if auth == "" {
libhttp.BasicAuthUnauthorized(w, nil)
return
}
accessTokenString, _, ok := libhttp.ParseBasicAuth(auth)
if !ok {
libhttp.BasicAuthUnauthorized(w, nil)
return
}
db := context.Get(r, "db").(*sqlx.DB)
accessTokenRow, err := dal.NewAccessToken(db).GetByAccessToken(nil, accessTokenString)
if err != nil {
libhttp.BasicAuthUnauthorized(w, nil)
return
}
if accessTokenRow == nil {
libhttp.BasicAuthUnauthorized(w, nil)
return
}
if !accessTokenRow.Enabled {
libhttp.BasicAuthUnauthorized(w, nil)
return
}
isAllowed := false
if r.Method == "GET" {
isAllowed = true
} else if accessTokenRow.Level == "write" || accessTokenRow.Level == "execute" {
isAllowed = true
}
if !isAllowed {
libhttp.BasicAuthUnauthorized(w, nil)
return
}
context.Set(r, "accessTokenRow", accessTokenRow)
next.ServeHTTP(w, r)
})
}
func GetClusters(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
db := context.Get(r, "db").(*sqlx.DB)
currentUser := getCurrentUser(w, r)
clusters := context.Get(r, "clusters").([]*dal.ClusterRow)
accessTokens := make(map[int64][]*dal.AccessTokenRow)
for _, cluster := range clusters {
accessTokensSlice, err := dal.NewAccessToken(db).AllAccessTokensByClusterID(nil, cluster.ID)
if err != nil {
libhttp.HandleErrorHTML(w, err, 500)
return
}
accessTokens[cluster.ID] = accessTokensSlice
}
data := struct {
CurrentUser *dal.UserRow
Clusters []*dal.ClusterRow
CurrentClusterJson string
AccessTokens map[int64][]*dal.AccessTokenRow
}{
currentUser,
clusters,
string(context.Get(r, "currentClusterJson").([]byte)),
accessTokens,
}
tmpl, err := template.ParseFiles("templates/dashboard.html.tmpl", "templates/clusters/list.html.tmpl")
if err != nil {
libhttp.HandleErrorHTML(w, err, 500)
return
}
tmpl.Execute(w, data)
}
func PostAccessTokensLevel(w http.ResponseWriter, r *http.Request) {
db := context.Get(r, "db").(*sqlx.DB)
tokenID, err := getIdFromPath(w, r)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
level := r.FormValue("Level")
data := make(map[string]interface{})
data["level"] = level
_, err = dal.NewAccessToken(db).UpdateById(nil, data, tokenID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
http.Redirect(w, r, "/clusters", 301)
}
func GetHosts(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
cookieStore := context.Get(r, "cookieStore").(*sessions.CookieStore)
session, _ := cookieStore.Get(r, "resourcedmaster-session")
currentUserRow, ok := session.Values["user"].(*dal.UserRow)
if !ok {
http.Redirect(w, r, "/logout", 301)
return
}
currentClusterInterface := session.Values["currentCluster"]
if currentClusterInterface == nil {
http.Redirect(w, r, "/", 301)
return
}
currentCluster := currentClusterInterface.(*dal.ClusterRow)
db := context.Get(r, "db").(*sqlx.DB)
query := r.URL.Query().Get("q")
hosts, err := dal.NewHost(db).AllByClusterIDAndQuery(nil, currentCluster.ID, query)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
savedQueries, err := dal.NewSavedQuery(db).AllByClusterID(nil, currentCluster.ID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
accessTokenRow, err := dal.NewAccessToken(db).GetByUserID(nil, currentUserRow.ID)
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
data := struct {
Addr string
CurrentUser *dal.UserRow
AccessToken *dal.AccessTokenRow
Clusters []*dal.ClusterRow
CurrentClusterJson string
Hosts []*dal.HostRow
SavedQueries []*dal.SavedQueryRow
}{
context.Get(r, "addr").(string),
currentUserRow,
accessTokenRow,
context.Get(r, "clusters").([]*dal.ClusterRow),
string(context.Get(r, "currentClusterJson").([]byte)),
hosts,
savedQueries,
}
tmpl, err := template.ParseFiles("templates/dashboard.html.tmpl", "templates/hosts/list.html.tmpl")
if err != nil {
libhttp.HandleErrorJson(w, err)
return
}
tmpl.Execute(w, data)
}
