ston1th/gowiki
0
0
Fork 0
Code Issues 2 Releases Activity

major changes

Browse source
This commit is contained in:
ston1th 2018-02-07 21:41:54 +01:00
commit 2b56832843
83 changed files with 7760 additions and 1244 deletions
Download patch file Download diff file Expand all files Collapse all files

156
userdb.go
View file

@ -12,10 +12,10 @@ import (
)
type User struct {
Username string
Password string
Admin bool
Locked int
Username string `json:"username"`
Password string `json:"password"`
Admin bool `json"admin"`
Locked int `json:"locked"`
}
func validatePassword(pw string) (b []byte) {
@ -30,65 +30,69 @@ func validatePassword(pw string) (b []byte) {
}
const (
userTable = "user"
bcryptCost = 13
dbFile = "gowiki.db"
defUser = "admin"
defPassword = "gowiki"
userTable = "user"
snippetTable = "snippet"
bcryptCost = 13
)
var (
ErrNotFound = errors.New("db: key not found")
ErrExists = errors.New("db: key already exists")
errUserNotExists = dbErr("user does not exist")
errUserExists = dbErr("user already exist")
)
func dbErr(i interface{}) error {
return fmt.Errorf("db: %s", i)
}
type BoltStore struct {
Marshaler
db *bolt.DB
}
func NewBoltStore(file string) (*BoltStore, error) {
db, err := bolt.Open(file, 0666, nil)
func NewBoltStore() (bs *BoltStore, err error) {
db, err := bolt.Open(dbFile, 0666, nil)
if err != nil {
return nil, err
return
}
if err = db.Update(func(tx *bolt.Tx) error {
if _, err := tx.CreateBucketIfNotExists([]byte([]byte(userTable))); err != nil {
if _, err := tx.CreateBucketIfNotExists([]byte(userTable)); err != nil {
return err
}
if _, err := tx.CreateBucketIfNotExists([]byte(snippetTable)); err != nil {
return err
}
return nil
}); err != nil {
return nil, err
return
}
bs = &BoltStore{NewGOB(), db}
if !bs.UserExists(defUser) {
err = bs.CreateUser(defUser, defPassword, true)
if err != nil {
return
}
}
bs := &BoltStore{NewGOB(), db}
bs.UnlockUser(defUser)
return bs, nil
return
}
func (bs *BoltStore) Close() error {
return bs.db.Close()
}
func (bs *BoltStore) GetUsers() (us []User, err error) {
err = bs.db.View(func(tx *bolt.Tx) error {
return tx.Bucket([]byte(userTable)).ForEach(func(k, v []byte) error {
u := new(User)
if err := bs.Unmarshal(v, u); err != nil {
return err
}
u.Password = ""
us = append(us, *u)
return nil
})
})
func (bs *BoltStore) GetUsers() (users []User, err error) {
users, err = bs.DumpUsers()
for i := range users {
users[i].Password = ""
}
return
}
func (bs *BoltStore) GetUserWithoutPassword(username string) (u User, err error) {
err = bs.db.View(func(tx *bolt.Tx) error {
v := tx.Bucket([]byte(userTable)).Get([]byte(username))
if v == nil {
return ErrNotFound
}
return bs.Unmarshal(v, &u)
})
u, err = bs.GetUser(username)
u.Password = ""
return
}
@ -97,7 +101,7 @@ func (bs *BoltStore) GetUser(username string) (u User, err error) {
err = bs.db.View(func(tx *bolt.Tx) error {
v := tx.Bucket([]byte(userTable)).Get([]byte(username))
if v == nil {
return ErrNotFound
return errUserNotExists
}
return bs.Unmarshal(v, &u)
})
@ -106,29 +110,71 @@ func (bs *BoltStore) GetUser(username string) (u User, err error) {
func (bs *BoltStore) UserIsAdmin(username string) (admin bool) {
bs.db.View(func(tx *bolt.Tx) error {
u, err := bs.GetUser(username)
if err != nil {
return err
}
u, _ := bs.GetUser(username)
admin = u.Admin
return nil
})
return
}
func (bs *BoltStore) UserExists(username string) (exists bool) {
bs.db.View(func(tx *bolt.Tx) error {
exists = tx.Bucket([]byte(userTable)).Get([]byte(username)) != nil
func (bs *BoltStore) UserExists(username string) error {
return bs.db.View(func(tx *bolt.Tx) error {
if tx.Bucket([]byte(userTable)).Get([]byte(username)) == nil {
return errUserNotExists
}
return nil
})
}
func (bs *BoltStore) DumpUsers() (users []User, err error) {
var buf [][]byte
err = bs.db.View(func(tx *bolt.Tx) error {
return tx.Bucket([]byte(userTable)).ForEach(func(k, v []byte) error {
buf = append(buf, copyBuf(v))
return nil
})
})
if err != nil {
return
}
for _, b := range buf {
u := new(User)
if err = bs.Unmarshal(b, u); err != nil {
return
}
users = append(users, *u)
}
return
}
func (bs *BoltStore) CreateUser(username, password string, admin bool) error {
func (bs *BoltStore) RestoreUsers(users []User) error {
return bs.db.Update(func(tx *bolt.Tx) error {
if bs.UserExists(username) {
return ErrExists
b := tx.Bucket([]byte(userTable))
err := b.ForEach(func(k, v []byte) error {
return b.Delete(k)
})
if err != nil {
return err
}
for _, u := range users {
v, err := bs.Marshal(u)
if err != nil {
return err
}
err = b.Put([]byte(u.Username), v)
if err != nil {
return err
}
}
return nil
})
}
func (bs *BoltStore) CreateUser(username, password string, admin bool) error {
if err := bs.UserExists(username); err == nil {
return errUserExists
}
return bs.db.Update(func(tx *bolt.Tx) error {
hash, err := bcrypt.GenerateFromPassword(validatePassword(password), bcryptCost)
v, err := bs.Marshal(&User{
Username: username,
@ -247,11 +293,11 @@ func (bs *BoltStore) DeleteUser(username string) error {
if username == defUser {
return errors.New("user '" + defUser + "' cannot be deleted")
}
if err := bs.UserExists(username); err != nil {
return err
}
return bs.db.Update(func(tx *bolt.Tx) error {
if bs.UserExists(username) {
return tx.Bucket([]byte(userTable)).Delete([]byte(username))
}
return ErrNotFound
return tx.Bucket([]byte(userTable)).Delete([]byte(username))
})
}
@ -266,13 +312,11 @@ func NewGOB() Marshaler {
return gobMarshaler{}
}
func (gobMarshaler) Marshal(v interface{}) ([]byte, error) {
b := new(bytes.Buffer)
err := gob.NewEncoder(b).Encode(v)
if err != nil {
return nil, err
}
return b.Bytes(), nil
func (gobMarshaler) Marshal(v interface{}) (b []byte, err error) {
buf := new(bytes.Buffer)
err = gob.NewEncoder(buf).Encode(v)
b = buf.Bytes()
return
}
func (gobMarshaler) Unmarshal(data []byte, v interface{}) error {