scottk/databunker
1
0
Fork 0
mirror of https://github.com/optim-enterprises-bv/databunker.git synced 2025-10-30 09:32:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

cleanup log events

Browse Source
This commit is contained in:
root
2021-06-02 21:23:02 +00:00
parent e760ef6947
commit 7a4d2c1774
7 changed files with 30 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/bunker.go
View File

@@ -444,6 +444,7 @@ func setupDB(dbPtr *string, masterKeyPtr *string, customRootToken string) (*dbco
//log.Panic("error %s", err.Error())
fmt.Printf("error %s", err.Error())
}
log.Println("Creating default entities: core-send-email-on-login and core-send-sms-on-login");
db.createLegalBasis("core-send-email-on-login", "", "login", "Send email on login",
"Confirm to allow sending access code using 3rd party email gateway", "consent",
"This consent is required to give you our service.", "active", true, true);

6
src/bunker_test.go
View File

@@ -28,7 +28,7 @@ func helpServe0(request *http.Request) ([]byte, error) {
if rr.Code != 200 {
return rr.Body.Bytes(), fmt.Errorf("wrong status: %d", rr.Code)
}
//fmt.Printf("Got: %s\n", rr.Body.Bytes())
//fmt.Printf("Response: %s\n", rr.Body.Bytes())
return rr.Body.Bytes(), nil
}
@@ -37,7 +37,7 @@ func helpServe(request *http.Request) (map[string]interface{}, error) {
rr := httptest.NewRecorder()
router.ServeHTTP(rr, request)
fmt.Printf("[%d] %s%s\n", rr.Code, request.Host, request.URL.Path)
fmt.Printf("Got: %s\n", rr.Body.Bytes())
fmt.Printf("Response: %s\n", rr.Body.Bytes())
var raw map[string]interface{}
if rr.Body.Bytes()[0] == '{' {
json.Unmarshal(rr.Body.Bytes(), &raw)
@@ -53,7 +53,7 @@ func helpServe2(request *http.Request) (map[string]interface{}, error) {
rr := httptest.NewRecorder()
router.ServeHTTP(rr, request)
fmt.Printf("[%d] %s%s\n", rr.Code, request.Host, request.URL.Path)
fmt.Printf("Got: %s\n", rr.Body.Bytes())
fmt.Printf("Response: %s\n", rr.Body.Bytes())
var raw map[string]interface{}
if rr.Body.Bytes()[0] == '{' {
json.Unmarshal(rr.Body.Bytes(), &raw)

9
src/storage/mysql-storage.go
View File

@@ -498,7 +498,6 @@ func (dbobj MySQLDB) getRecordInTableDo(q string, values []interface{}) (bson.M,
defer tx.Rollback()
rows, err := tx.Query(q, values...)
if err == sql.ErrNoRows {
fmt.Println("nothing found")
return nil, nil
} else if err != nil {
return nil, err
@@ -560,13 +559,11 @@ func (dbobj MySQLDB) getRecordInTableDo(q string, values []interface{}) (bson.M,
}
err = rows.Close()
if err == sql.ErrNoRows {
fmt.Println("nothing found2")
return nil, nil
} else if err != nil {
return nil, err
}
if len(recBson) == 0 {
fmt.Println("no result!!!")
return nil, nil
}
tx.Commit()
@@ -802,7 +799,6 @@ func (dbobj MySQLDB) getListDo(q string, values []interface{}) ([]bson.M, error)
defer tx.Rollback()
rows, err := tx.Query(q, values...)
if err == sql.ErrNoRows {
fmt.Println("nothing found")
return nil, nil
} else if err != nil {
return nil, err
@@ -830,7 +826,6 @@ func (dbobj MySQLDB) getListDo(q string, values []interface{}) ([]bson.M, error)
err = rows.Scan(columnPointers...)
if err == sql.ErrNoRows {
fmt.Println("nothing found")
return nil, nil
}
if err != nil {
@@ -857,13 +852,11 @@ func (dbobj MySQLDB) getListDo(q string, values []interface{}) ([]bson.M, error)
}
err = rows.Close()
if err == sql.ErrNoRows {
fmt.Println("nothing found2")
return nil, nil
} else if err != nil {
return nil, err
}
if len(results) == 0 {
fmt.Println("no result!!!")
return nil, nil
}
tx.Commit()
@@ -912,7 +905,7 @@ func (dbobj MySQLDB) execQueries(queries []string) error {
func (dbobj MySQLDB) IndexNewApp(appName string) {
if contains(allTables, appName) == false {
// it is a new app, create an index
fmt.Printf("This is a new app, creating table & index for: %s\n", appName)
log.Printf("This is a new app, creating table & index for: %s\n", appName)
queries := []string{
`CREATE TABLE IF NOT EXISTS ` + appName + ` (`+
`token TINYTEXT,`+

40
src/storage/sqlite-storage.go
View File

@@ -124,7 +124,7 @@ func (dbobj *SQLiteDB) OpenDB(filepath *string) error {
knownApps = append(knownApps, t)
}
tx.Commit()
fmt.Printf("tables: %s\n", knownApps)
log.Printf("List of tables: %s\n", knownApps)
return nil
}
@@ -179,7 +179,7 @@ func (dbobj SQLiteDB) BackupDB(w http.ResponseWriter) {
err := sqlite3dump.DumpDB(dbobj.db, w)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Printf("error in backup: %s", err)
log.Printf("error in backup: %s", err)
}
}
@@ -231,7 +231,7 @@ func (dbobj SQLiteDB) decodeFieldsValues(data interface{}) (string, []interface{
values = append(values, val)
}
default:
fmt.Printf("XXXXXX wrong type: %T\n", t)
log.Printf("XXXXXX wrong type: %T\n", t)
}
return fields, values
}
@@ -258,7 +258,7 @@ func (dbobj SQLiteDB) decodeForCleanup(data interface{}) string {
}
}
default:
fmt.Printf("decodeForCleanup: wrong type: %s\n", t)
log.Printf("decodeForCleanup: wrong type: %s\n", t)
}
return fields
@@ -313,7 +313,7 @@ func (dbobj SQLiteDB) CreateRecordInTable(tbl string, data interface{}) (int, er
}
}
q := "insert into " + tbl + " (" + fields + ") values (" + valuesInQ + ")"
fmt.Printf("q: %s\n", q)
//fmt.Printf("q: %s\n", q)
//fmt.Printf("values: %s\n", values...)
tx, err := dbobj.db.Begin()
if err != nil {
@@ -492,7 +492,7 @@ func (dbobj SQLiteDB) getRecordInTableDo(q string, values []interface{}) (bson.M
defer tx.Rollback()
rows, err := tx.Query(q, values...)
if err == sql.ErrNoRows {
fmt.Println("nothing found")
log.Println("nothing found")
return nil, nil
} else if err != nil {
return nil, err
@@ -520,12 +520,10 @@ func (dbobj SQLiteDB) getRecordInTableDo(q string, values []interface{}) (bson.M
}
err = rows.Scan(columnPointers...)
if err == sql.ErrNoRows {
fmt.Println("returning empty result")
return nil, nil
}
if err != nil {
if strings.Contains(err.Error(), "Rows are closed") {
fmt.Println("returning empty result")
return nil, nil
}
return nil, err
@@ -545,18 +543,16 @@ func (dbobj SQLiteDB) getRecordInTableDo(q string, values []interface{}) (bson.M
case nil:
//fmt.Printf("is nil, not interesting\n")
default:
fmt.Printf("field: %s - %s, unknown: %s - %T\n", colName, columns[i], t, t)
log.Printf("field: %s - %s, unknown: %s - %T\n", colName, columns[i], t, t)
}
}
err = rows.Close()
if err == sql.ErrNoRows {
fmt.Println("nothing found2")
return nil, nil
} else if err != nil {
return nil, err
}
if len(recBson) == 0 {
fmt.Println("no result!!!")
return nil, nil
}
tx.Commit()
@@ -572,7 +568,7 @@ func (dbobj SQLiteDB) DeleteRecord(t Tbl, keyName string, keyValue string) (int6
// DeleteRecordInTable deletes record in database
func (dbobj SQLiteDB) DeleteRecordInTable(table string, keyName string, keyValue string) (int64, error) {
q := "delete from " + table + " WHERE " + dbobj.escapeName(keyName) + "=$1"
fmt.Printf("q: %s\n", q)
log.Printf("q: %s\n", q)
tx, err := dbobj.db.Begin()
if err != nil {
@@ -599,7 +595,7 @@ func (dbobj SQLiteDB) DeleteRecord2(t Tbl, keyName string, keyValue string, keyN
func (dbobj SQLiteDB) deleteRecordInTable2(table string, keyName string, keyValue string, keyName2 string, keyValue2 string) (int64, error) {
q := "delete from " + table + " WHERE " + dbobj.escapeName(keyName) + "=$1 AND " +
dbobj.escapeName(keyName2) + "=$2"
fmt.Printf("q: %s\n", q)
log.Printf("q: %s\n", q)
tx, err := dbobj.db.Begin()
if err != nil {
@@ -654,7 +650,7 @@ func (dbobj SQLiteDB) DeleteExpired0(t Tbl, expt int32) (int64, error) {
table := GetTable(t)
now := int32(time.Now().Unix())
q := fmt.Sprintf("delete from %s WHERE `when`>0 AND `when`<%d", table, now-expt)
fmt.Printf("q: %s\n", q)
log.Printf("q: %s\n", q)
tx, err := dbobj.db.Begin()
if err != nil {
return 0, err
@@ -677,7 +673,7 @@ func (dbobj SQLiteDB) DeleteExpired0(t Tbl, expt int32) (int64, error) {
func (dbobj SQLiteDB) DeleteExpired(t Tbl, keyName string, keyValue string) (int64, error) {
table := GetTable(t)
q := "delete from " + table + " WHERE endtime>0 AND endtime<$1 AND " + dbobj.escapeName(keyName) + "=$2"
fmt.Printf("q: %s\n", q)
log.Printf("q: %s\n", q)
tx, err := dbobj.db.Begin()
if err != nil {
@@ -701,7 +697,7 @@ func (dbobj SQLiteDB) CleanupRecord(t Tbl, keyName string, keyValue string, data
tbl := GetTable(t)
cleanup := dbobj.decodeForCleanup(data)
q := "update " + tbl + " SET " + cleanup + " WHERE " + dbobj.escapeName(keyName) + "=$1"
fmt.Printf("q: %s\n", q)
log.Printf("q: %s\n", q)
tx, err := dbobj.db.Begin()
if err != nil {
@@ -725,7 +721,7 @@ func (dbobj SQLiteDB) GetExpiring(t Tbl, keyName string, keyValue string) ([]bso
now := int32(time.Now().Unix())
q := fmt.Sprintf("select * from %s WHERE endtime>0 AND endtime<%d AND %s=$1",
table, now, dbobj.escapeName(keyName))
fmt.Printf("q: %s\n", q)
//fmt.Printf("q: %s\n", q)
values := make([]interface{}, 0)
values = append(values, keyValue)
return dbobj.getListDo(q, values)
@@ -794,7 +790,7 @@ func (dbobj SQLiteDB) getListDo(q string, values []interface{}) ([]bson.M, error
defer tx.Rollback()
rows, err := tx.Query(q, values...)
if err == sql.ErrNoRows {
fmt.Println("nothing found")
log.Println("nothing found")
return nil, nil
} else if err != nil {
return nil, err
@@ -826,11 +822,9 @@ func (dbobj SQLiteDB) getListDo(q string, values []interface{}) ([]bson.M, error
err = rows.Scan(columnPointers...)
if err == sql.ErrNoRows {
fmt.Println("nothing found")
return nil, nil
}
if err != nil {
fmt.Printf("nothing found: %s\n", err)
return nil, nil
}
for i, colName := range columnNames {
@@ -846,20 +840,18 @@ func (dbobj SQLiteDB) getListDo(q string, values []interface{}) ([]bson.M, error
case nil:
//fmt.Printf("is nil, not interesting\n")
default:
fmt.Printf("field: %s - %s, unknown: %s - %T\n", colName, columns[i], t, t)
log.Printf("field: %s - %s, unknown: %s - %T\n", colName, columns[i], t, t)
}
}
results = append(results, recBson)
}
err = rows.Close()
if err == sql.ErrNoRows {
fmt.Println("nothing found2")
return nil, nil
} else if err != nil {
return nil, err
}
if len(results) == 0 {
fmt.Println("no result!!!")
return nil, nil
}
tx.Commit()
@@ -904,7 +896,7 @@ func (dbobj SQLiteDB) execQueries(queries []string) error {
func (dbobj SQLiteDB) IndexNewApp(appName string) {
if contains(knownApps, appName) == false {
// it is a new app, create an index
fmt.Printf("This is a new app, creating table & index for: %s\n", appName)
log.Printf("This is a new app, creating table & index for: %s\n", appName)
queries := []string{"CREATE TABLE IF NOT EXISTS " + appName + ` (
token STRING,
md5 STRING,

13
src/userapps_db.go
View File

@@ -5,7 +5,7 @@ import (
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"log"
"strings"
jsonpatch "github.com/evanphx/json-patch"
@@ -31,7 +31,7 @@ func (dbobj dbcon) deleteUserApp(userTOKEN string, appName string) {
}
func (dbobj dbcon) createAppRecord(jsonData []byte, userTOKEN string, appName string, event *auditEvent) (string, error) {
fmt.Printf("createAppRecord app is : %s\n", appName)
log.Printf("Going to create app record: %s\n", appName)
encodedStr, err := dbobj.userEncrypt(userTOKEN, jsonData)
if err != nil {
return userTOKEN, err
@@ -94,15 +94,14 @@ func (dbobj dbcon) updateAppRecord(jsonDataPatch []byte, userTOKEN string, appNa
if err != nil {
return userTOKEN, err
}
// merge
fmt.Printf("old json: %s\n", decrypted)
fmt.Printf("json patch: %s\n", jsonDataPatch)
//fmt.Printf("old json: %s\n", decrypted)
//fmt.Printf("json patch: %s\n", jsonDataPatch)
newJSON, err := jsonpatch.MergePatch(decrypted, jsonDataPatch)
if err != nil {
return userTOKEN, err
}
fmt.Printf("result: %s\n", newJSON)
//fmt.Printf("result: %s\n", newJSON)
bdoc := bson.M{}
encoded, err := encrypt(dbobj.masterKey, recordKey, newJSON)
if err != nil {
@@ -117,7 +116,6 @@ func (dbobj dbcon) updateAppRecord(jsonDataPatch []byte, userTOKEN string, appNa
// here I add md5 of the original record to filter
// to make sure this record was not change by other thread
fmt.Println("update user app")
result, err := dbobj.store.UpdateRecordInTable2("app_"+appName, "token", userTOKEN, "md5", sig, &bdoc, nil)
if err != nil {
return userTOKEN, err
@@ -159,7 +157,6 @@ func (dbobj dbcon) listUserApps(userTOKEN string) ([]byte, error) {
}
}
}
fmt.Printf("returning: %s\n", result)
if len(result) == 0 {
return []byte("[]"), nil
}

4
src/utils.go
View File

@@ -341,9 +341,9 @@ func returnError(w http.ResponseWriter, r *http.Request, message string, code in
event.Msg = message
if err != nil {
event.Debug = err.Error()
fmt.Printf("Msg: %s, Error: %s\n", message, err.Error())
log.Printf("Generate error reponse: %s, Error: %s\n", message, err.Error())
} else {
fmt.Printf("Msg: %s\n", message)
log.Printf("Generate error reponse: %s\n", message)
}
}
//http.Error(w, http.StatusText(405), 405)

5
src/xtokens_db.go
View File

@@ -2,7 +2,6 @@ package main
import (
"errors"
"fmt"
"time"
uuid "github.com/hashicorp/go-uuid"
@@ -79,7 +78,7 @@ func (dbobj dbcon) checkUserAuthXToken(xtokenUUID string) (tokenAuthResult, erro
}
xtokenHashed := hashString(dbobj.hash, xtokenUUID)
if len(rootXTOKEN) > 0 && rootXTOKEN == xtokenHashed {
//fmt.Println("It is a root token")
//log.Println("It is a root token")
result.ttype = "root"
result.name = "root"
return result, nil
@@ -89,7 +88,7 @@ func (dbobj dbcon) checkUserAuthXToken(xtokenUUID string) (tokenAuthResult, erro
return result, errors.New("failed to authenticate")
}
tokenType := record["type"].(string)
fmt.Printf("xtoken type: %s\n", tokenType)
//log.Printf("xtoken type: %s\n", tokenType)
if tokenType == "root" {
// we have this admin user
rootXTOKEN = xtokenHashed