124 lines
3.3 KiB
Go
124 lines
3.3 KiB
Go
package filestore
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io/ioutil"
|
|
"os"
|
|
"path"
|
|
|
|
"github.com/influxdata/chronograf"
|
|
)
|
|
|
|
// AppExt is the the file extension searched for in the directory for layout files
|
|
const AppExt = ".json"
|
|
|
|
// Verify apps (layouts) implements layoutsStore interface.
|
|
var _ chronograf.LayoutsStore = (*Apps)(nil)
|
|
|
|
// Apps are canned JSON layouts. Implements LayoutsStore.
|
|
type Apps struct {
|
|
Dir string // Dir is the directory contained the pre-canned applications.
|
|
Load func(string) (chronograf.Layout, error) // Load loads string name and return a Layout
|
|
ReadDir func(dirname string) ([]os.FileInfo, error) // ReadDir reads the directory named by dirname and returns a list of directory entries sorted by filename.
|
|
IDs chronograf.ID // IDs generate unique ids for new application layouts
|
|
Logger chronograf.Logger
|
|
}
|
|
|
|
// NewApps constructs a layout store wrapping a file system directory
|
|
func NewApps(dir string, ids chronograf.ID, logger chronograf.Logger) chronograf.LayoutsStore {
|
|
return &Apps{
|
|
Dir: dir,
|
|
Load: loadFile,
|
|
ReadDir: ioutil.ReadDir,
|
|
IDs: ids,
|
|
Logger: logger,
|
|
}
|
|
}
|
|
|
|
func loadFile(name string) (chronograf.Layout, error) {
|
|
octets, err := ioutil.ReadFile(name)
|
|
if err != nil {
|
|
return chronograf.Layout{}, chronograf.ErrLayoutNotFound
|
|
}
|
|
|
|
var layout chronograf.Layout
|
|
if err = json.Unmarshal(octets, &layout); err != nil {
|
|
return chronograf.Layout{}, chronograf.ErrLayoutInvalid
|
|
}
|
|
|
|
return layout, nil
|
|
}
|
|
|
|
// All returns all layouts from the directory
|
|
func (a *Apps) All(ctx context.Context) ([]chronograf.Layout, error) {
|
|
files, err := a.ReadDir(a.Dir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
layouts := []chronograf.Layout{}
|
|
for _, file := range files {
|
|
if path.Ext(file.Name()) != AppExt {
|
|
continue
|
|
}
|
|
if layout, err := a.Load(path.Join(a.Dir, file.Name())); err != nil {
|
|
continue // We want to load all files we can.
|
|
} else {
|
|
layouts = append(layouts, layout)
|
|
}
|
|
}
|
|
return layouts, nil
|
|
}
|
|
|
|
// Get returns an app file from the layout directory
|
|
func (a *Apps) Get(ctx context.Context, ID string) (chronograf.Layout, error) {
|
|
l, file, err := a.idToFile(ID)
|
|
if err != nil {
|
|
return chronograf.Layout{}, err
|
|
}
|
|
|
|
if err != nil {
|
|
if err == chronograf.ErrLayoutNotFound {
|
|
a.Logger.
|
|
WithField("component", "apps").
|
|
WithField("name", file).
|
|
Error("Unable to read file")
|
|
} else if err == chronograf.ErrLayoutInvalid {
|
|
a.Logger.
|
|
WithField("component", "apps").
|
|
WithField("name", file).
|
|
Error("File is not a layout")
|
|
}
|
|
return chronograf.Layout{}, err
|
|
}
|
|
return l, nil
|
|
}
|
|
|
|
// idToFile takes an id and finds the associated filename
|
|
func (a *Apps) idToFile(ID string) (chronograf.Layout, string, error) {
|
|
// Because the entire layout information is not known at this point, we need
|
|
// to try to find the name of the file through matching the ID in the layout
|
|
// content with the ID passed.
|
|
files, err := a.ReadDir(a.Dir)
|
|
if err != nil {
|
|
return chronograf.Layout{}, "", err
|
|
}
|
|
|
|
for _, f := range files {
|
|
if path.Ext(f.Name()) != AppExt {
|
|
continue
|
|
}
|
|
file := path.Join(a.Dir, f.Name())
|
|
layout, err := a.Load(file)
|
|
if err != nil {
|
|
return chronograf.Layout{}, "", err
|
|
}
|
|
if layout.ID == ID {
|
|
return layout, file, nil
|
|
}
|
|
}
|
|
|
|
return chronograf.Layout{}, "", chronograf.ErrLayoutNotFound
|
|
}
|