160 lines
3.3 KiB
Go
160 lines
3.3 KiB
Go
package datastore
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
|
|
"git.dayanhub.com/sagi/envoid/internal/common"
|
|
"git.dayanhub.com/sagi/envoid/internal/errors"
|
|
"git.dayanhub.com/sagi/envoid/internal/types"
|
|
"git.dayanhub.com/sagi/envoid/internal/variables"
|
|
_ "github.com/glebarez/go-sqlite"
|
|
)
|
|
|
|
type db struct {
|
|
con *sql.DB
|
|
}
|
|
|
|
func newDB() (*db, error) {
|
|
con, err := sql.Open("sqlite", variables.DBFileName)
|
|
if err != nil {
|
|
fmt.Printf("%v\n", err)
|
|
|
|
return nil, err
|
|
}
|
|
|
|
return &db{
|
|
con: con,
|
|
}, nil
|
|
}
|
|
|
|
func (d *db) close() error {
|
|
return d.con.Close()
|
|
}
|
|
|
|
func (d *db) createTableIfNotExists(tableName string) error {
|
|
q := "CREATE TABLE IF NOT EXISTS " + tableName +
|
|
" (key TEXT PRIMARY KEY NOT NULL,value BLOB NOT NULL,encrypted BOOL NOT NULL);"
|
|
|
|
_, err := d.con.Exec(q)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (d *db) listTables() ([]string, error) {
|
|
tables := []string{}
|
|
q := "SELECT name FROM sqlite_schema WHERE type ='table' AND name NOT LIKE 'sqlite_%' AND name LIKE ?"
|
|
|
|
rows, err := d.con.Query(q, variables.DBTablePrefix+"_%%")
|
|
if err != nil || rows.Err() != nil {
|
|
return tables, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
var table string
|
|
|
|
if err := rows.Scan(&table); err != nil {
|
|
return tables, err
|
|
}
|
|
|
|
tables = append(tables, tableNameToEnvName(table))
|
|
}
|
|
|
|
return tables, nil
|
|
}
|
|
|
|
func (d *db) copyContentFromTo(tableNameTarget string, tableNameDest string) error {
|
|
_, err := d.con.Exec(
|
|
fmt.Sprintf("INSERT INTO %s (key, value, encrypted) SELECT * FROM %s",
|
|
tableNameDest, tableNameTarget),
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (d *db) deleteTable(tableName string) error {
|
|
_, err := d.con.Exec("DROP TABLE IF EXISTS " + tableName)
|
|
|
|
return err
|
|
}
|
|
|
|
func (d *db) getVar(tableName string, key string) (*types.EnvVar, error) {
|
|
q := "SELECT * FROM " + tableName + " WHERE key=?"
|
|
row := d.con.QueryRow(q, key)
|
|
envVar := &types.EnvVar{}
|
|
|
|
err := row.Scan(&envVar.Key, &envVar.Value, &envVar.Encrypted)
|
|
if err != nil {
|
|
return envVar, errors.NewNoKeyFoundError(key)
|
|
}
|
|
|
|
return envVar, nil
|
|
}
|
|
|
|
func (d *db) getAll(tableName string) ([]*types.EnvVar, error) {
|
|
entries := []*types.EnvVar{}
|
|
|
|
rows, err := d.con.Query("SELECT * FROM " + tableName)
|
|
if err != nil || rows.Err() != nil {
|
|
return entries, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
for rows.Next() {
|
|
key := ""
|
|
value := ""
|
|
enc := common.BoolP(false)
|
|
|
|
err := rows.Scan(&key, &value, enc)
|
|
if err != nil {
|
|
return entries, err
|
|
}
|
|
|
|
e := &types.EnvVar{
|
|
Key: key,
|
|
Value: value,
|
|
Encrypted: *enc,
|
|
}
|
|
entries = append(entries, e)
|
|
}
|
|
|
|
return entries, nil
|
|
}
|
|
|
|
func (d *db) setVar(tableName string, key string, value string, encrypted bool) error {
|
|
q := "INSERT INTO " +
|
|
tableName +
|
|
" (key,value,encrypted) values (?,?,?) ON CONFLICT (key) DO UPDATE SET value=?, encrypted=?"
|
|
|
|
_, err := d.con.Exec(q, key, value, encrypted, value, encrypted)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
|
|
return errors.NewSecretExsistsError(key)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (d *db) rmVar(tableName string, key string) {
|
|
q := "DELETE FROM " + tableName + " WHERE key = ?"
|
|
_, _ = d.con.Exec(q, key)
|
|
}
|
|
|
|
func envNameToTableName(envName string) string {
|
|
envSanke := common.StrToSnakeCase(envName)
|
|
|
|
return fmt.Sprintf("%s_%s", variables.DBTablePrefix, envSanke)
|
|
}
|
|
|
|
func tableNameToEnvName(tableName string) string {
|
|
// remove '<prefix>_'
|
|
return tableName[len(variables.DBTablePrefix)+1:]
|
|
}
|