state.go

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

/*
 * Copyright 2018 Zachary Schneider
 */

package zpm

import (
	"path/filepath"
	"strings"
	"time"

	"github.com/asdine/storm/q"

	"github.com/asdine/storm"
	"github.com/fezz-io/zps/action"
	bolt "go.etcd.io/bbolt"
)

type State struct {
	Path         string
	Frozen       *StateFrozen
	Packages     *StatePackages
	Objects      *StateObjects
	Templates    *StateTemplates
	Transactions *StateTransactions
}

type StateFrozen struct {
	getDb func() (*storm.DB, error)
}

type StatePackages struct {
	getDb func() (*storm.DB, error)
}

type StateObjects struct {
	getDb func() (*storm.DB, error)
}

type StateTemplates struct {
	getDb func() (*storm.DB, error)
}

type StateTransactions struct {
	getDb func() (*storm.DB, error)
}

type PkgEntry struct {
	Name     string `storm:"id"`
	Manifest []byte
}

type FrozenEntry struct {
	PkgId string `storm:"id"`
}

type FsEntry struct {
	Key  string `storm:"id"`
	Path string `storm:"index"`
	Pkg  string `storm:"index"`
	Type string `storm:"index"`
}

type TemplateEntry struct {
	Id   string `storm:"id"`
	Pkg  string `storm:"index"`
	Name string

	Source string
	Output string

	Owner string
	Group string
	Mode  string
}

type TransactionEntry struct {
	Key       string `storm:"id"`
	Id        string `storm:"index"`
	PkgId     string
	Operation string
	Date      *time.Time `storm:"index"`
}

func NewState(path string) *State {
	state := &State{Path: path}
	state.Frozen = &StateFrozen{}
	state.Frozen.getDb = state.getDb

	state.Packages = &StatePackages{}
	state.Packages.getDb = state.getDb

	state.Objects = &StateObjects{}
	state.Objects.getDb = state.getDb

	state.Templates = &StateTemplates{}
	state.Templates.getDb = state.getDb

	state.Transactions = &StateTransactions{}
	state.Transactions.getDb = state.getDb

	return state
}

func NewFsEntry(path string, pkg string, typ string) *FsEntry {
	fs := &FsEntry{Path: path, Pkg: pkg, Type: typ}
	fs.Key = strings.Join([]string{path, pkg}, "\x00")

	return fs
}

func NewTransactionEntry(id string, pkgId string, operation string, date *time.Time) *TransactionEntry {
	ts := &TransactionEntry{Id: id, PkgId: pkgId, Operation: operation, Date: date}
	ts.Key = strings.Join([]string{id, pkgId}, "\x00")

	return ts
}

func (s *State) getDb() (*storm.DB, error) {
	db, err := storm.Open(filepath.Join(s.Path, "image.db"), storm.BoltOptions(0600, &bolt.Options{Timeout: 10 * time.Second}))
	if err != nil {
		return nil, err
	}

	return db, nil
}

func (s *StatePackages) All() ([]*action.Manifest, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entries []*PkgEntry
	var packages []*action.Manifest

	err = db.All(&entries)

	for _, pkg := range entries {
		manifest := action.NewManifest()
		err := manifest.Load(string(pkg.Manifest))
		if err != nil {
			return nil, err
		}

		packages = append(packages, manifest)
	}

	return packages, nil
}

func (s *StatePackages) Get(name string) (*action.Manifest, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entry PkgEntry
	pkg := action.NewManifest()

	err = db.One("Name", name, &entry)
	if err != nil {
		if err == storm.ErrNotFound {
			return nil, nil
		}

		return nil, err
	}

	err = pkg.Load(string(entry.Manifest))
	if err != nil {
		return nil, err
	}

	return pkg, err
}

func (s *StatePackages) Del(name string) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	err = db.DeleteStruct(&PkgEntry{Name: name})

	return err
}

func (s *StatePackages) Put(name string, pkg *action.Manifest) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	entry := &PkgEntry{name, []byte(pkg.ToJson())}

	err = db.Save(entry)
	return err
}

func (s *StateObjects) All() ([]*FsEntry, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entries []*FsEntry

	err = db.All(&entries)

	return entries, nil
}

func (s *StateObjects) Get(path string) ([]*FsEntry, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entries []*FsEntry

	err = db.Find("Path", path, &entries)

	return entries, nil
}

func (s *StateObjects) Del(pkg string) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	query := db.Select(q.Eq("Pkg", pkg))
	err = query.Delete(&FsEntry{})

	return err
}

func (s *StateObjects) Put(path string, pkg string, typ string) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	err = db.Save(NewFsEntry(path, pkg, typ))

	return err
}

func (s *StateTemplates) All() ([]*TemplateEntry, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entries []*TemplateEntry

	err = db.All(&entries)

	return entries, nil
}

func (s *StateTemplates) Get(pkg string) ([]*action.Template, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entries []*TemplateEntry

	err = db.Find("Pkg", pkg, &entries)
	if err != nil {
		if err == storm.ErrNotFound {
			return nil, nil
		}

		return nil, err
	}

	var templates []*action.Template

	for _, tpl := range entries {
		templates = append(
			templates, &action.Template{
				Name:   tpl.Name,
				Source: tpl.Source,
				Output: tpl.Output,
				Owner:  tpl.Owner,
				Group:  tpl.Group,
				Mode:   tpl.Mode,
			})
	}

	return templates, nil
}

func (s *StateTemplates) Del(pkg string) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	query := db.Select(q.Eq("Pkg", pkg))
	err = query.Delete(&TemplateEntry{})

	return err
}

func (s *StateTemplates) Put(pkg string, tpl *action.Template) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	err = db.Save(&TemplateEntry{
		Id:     pkg + ":" + tpl.Name,
		Pkg:    pkg,
		Name:   tpl.Name,
		Source: tpl.Source,
		Output: tpl.Output,
		Owner:  tpl.Owner,
		Group:  tpl.Group,
		Mode:   tpl.Mode,
	})

	return err
}

func (s *StateTransactions) All() ([]*TransactionEntry, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entries []*TransactionEntry

	err = db.AllByIndex("Date", &entries)

	return entries, nil
}

func (s *StateTransactions) Get(id string) ([]*TransactionEntry, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entries []*TransactionEntry

	err = db.Find("Id", id, &entries)

	return entries, nil
}

func (s *StateTransactions) Put(id string, pkgId string, operation string, date *time.Time) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	err = db.Save(NewTransactionEntry(id, pkgId, operation, date))

	return err
}

func (s *StateFrozen) All() ([]*FrozenEntry, error) {
	db, err := s.getDb()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	var entries []*FrozenEntry

	err = db.All(&entries)

	return entries, nil
}

func (s *StateFrozen) Del(pkgId string) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	err = db.DeleteStruct(&FrozenEntry{pkgId})

	return err
}

func (s *StateFrozen) Put(pkgId string) error {
	db, err := s.getDb()
	if err != nil {
		return err
	}
	defer db.Close()

	err = db.Save(&FrozenEntry{pkgId})

	return err
}