// Get gets a client from the data store.
func Get(clientname string) (*Client, util.Gerror) {
var client *Client
var err error
if config.UsingDB() {
client, err = getClientSQL(clientname)
if err != nil {
var gerr util.Gerror
if err != sql.ErrNoRows {
gerr = util.Errorf(err.Error())
gerr.SetStatus(http.StatusInternalServerError)
} else {
gerr = util.Errorf("Client %s not found", clientname)
gerr.SetStatus(http.StatusNotFound)
}
return nil, gerr
}
} else {
ds := datastore.New()
c, found := ds.Get("client", clientname)
if !found {
gerr := util.Errorf("Client %s not found", clientname)
gerr.SetStatus(http.StatusNotFound)
return nil, gerr
}
if c != nil {
client = c.(*Client)
}
}
return client, nil
}
// Get a node.
func Get(nodeName string) (*Node, error) {
var node *Node
var found bool
if config.UsingDB() {
var err error
node, err = getSQL(nodeName)
if err != nil {
if err == sql.ErrNoRows {
found = false
} else {
return nil, err
}
} else {
found = true
}
} else {
ds := datastore.New()
var n interface{}
n, found = ds.Get("node", nodeName)
if n != nil {
node = n.(*Node)
}
}
if !found {
err := fmt.Errorf("node '%s' not found", nodeName)
return nil, err
}
return node, nil
}
// New creates a new environment, returning an error if the environment already
// exists or you try to create an environment named "_default".
func New(name string) (*ChefEnvironment, util.Gerror) {
if !util.ValidateEnvName(name) {
err := util.Errorf("Field 'name' invalid")
err.SetStatus(http.StatusBadRequest)
return nil, err
}
var found bool
if config.UsingDB() {
var eerr error
found, eerr = checkForEnvironmentSQL(datastore.Dbh, name)
if eerr != nil {
err := util.CastErr(eerr)
err.SetStatus(http.StatusInternalServerError)
return nil, err
}
} else {
ds := datastore.New()
_, found = ds.Get("env", name)
}
if found || name == "_default" {
err := util.Errorf("Environment already exists")
return nil, err
}
env := &ChefEnvironment{
Name: name,
ChefType: "environment",
JSONClass: "Chef::Environment",
Default: map[string]interface{}{},
Override: map[string]interface{}{},
CookbookVersions: map[string]string{},
}
return env, nil
}
func handleSignals() {
c := make(chan os.Signal, 1)
// SIGTERM is not exactly portable, but Go has a fake signal for it
// with Windows so it being there should theoretically not break it
// running on windows
signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
// if we receive a SIGINT or SIGTERM, do cleanup here.
go func() {
for sig := range c {
if sig == os.Interrupt || sig == syscall.SIGTERM {
logger.Infof("cleaning up...")
if config.Config.FreezeData {
if config.Config.DataStoreFile != "" {
ds := datastore.New()
if err := ds.Save(config.Config.DataStoreFile); err != nil {
logger.Errorf(err.Error())
}
}
if err := indexer.SaveIndex(config.Config.IndexFile); err != nil {
logger.Errorf(err.Error())
}
}
if config.UsingDB() {
datastore.Dbh.Close()
}
os.Exit(0)
} else if sig == syscall.SIGHUP {
logger.Infof("Reloading configuration...")
config.ParseConfigOptions()
}
}
}()
}
// New creates a new report.
func New(runID string, nodeName string) (*Report, util.Gerror) {
var found bool
if config.UsingDB() {
var err error
found, err = checkForReportSQL(datastore.Dbh, runID)
if err != nil {
gerr := util.CastErr(err)
gerr.SetStatus(http.StatusInternalServerError)
return nil, gerr
}
} else {
ds := datastore.New()
_, found = ds.Get("report", runID)
}
if found {
err := util.Errorf("Report already exists")
err.SetStatus(http.StatusConflict)
return nil, err
}
if u := uuid.Parse(runID); u == nil {
err := util.Errorf("run id was not a valid uuid")
err.SetStatus(http.StatusBadRequest)
return nil, err
}
report := &Report{
RunID: runID,
NodeName: nodeName,
Status: "started",
}
return report, nil
}
// Get a role.
func Get(roleName string) (*Role, error) {
var role *Role
var found bool
if config.UsingDB() {
var err error
role, err = getSQL(roleName)
if err != nil {
if err == sql.ErrNoRows {
found = false
} else {
return nil, err
}
} else {
found = true
}
} else {
ds := datastore.New()
var r interface{}
r, found = ds.Get("role", roleName)
if r != nil {
role = r.(*Role)
}
}
if !found {
err := fmt.Errorf("Cannot load role %s", roleName)
return nil, err
}
return role, nil
}
// Save a file store item.
func (f *FileStore) Save() error {
if config.Config.UseMySQL {
err := f.saveMySQL()
if err != nil {
return err
}
} else if config.Config.UsePostgreSQL {
err := f.savePostgreSQL()
if err != nil {
return nil
}
} else {
ds := datastore.New()
ds.Set("filestore", f.Chksum, f)
}
if config.Config.LocalFstoreDir != "" {
fp, err := os.Create(path.Join(config.Config.LocalFstoreDir, f.Chksum))
if err != nil {
return err
}
defer fp.Close()
_, err = fp.Write(*f.Data)
if err != nil {
return err
}
return fp.Close()
}
return nil
}
// Get a sandbox.
func Get(sandboxID string) (*Sandbox, error) {
var sandbox *Sandbox
var found bool
if config.UsingDB() {
var err error
sandbox, err = getSQL(sandboxID)
if err != nil {
if err == sql.ErrNoRows {
found = false
} else {
return nil, err
}
} else {
found = true
}
} else {
ds := datastore.New()
var s interface{}
s, found = ds.Get("sandbox", sandboxID)
if s != nil {
sandbox = s.(*Sandbox)
}
}
if !found {
err := fmt.Errorf("Sandbox %s not found", sandboxID)
return nil, err
}
return sandbox, nil
}
// New creates a new cookbook.
func New(name string) (*Cookbook, util.Gerror) {
var found bool
if !util.ValidateEnvName(name) {
err := util.Errorf("Invalid cookbook name '%s' using regex: 'Malformed cookbook name. Must only contain A-Z, a-z, 0-9, _ or -'.", name)
return nil, err
}
if config.UsingDB() {
var cerr error
found, cerr = checkForCookbookSQL(datastore.Dbh, name)
if cerr != nil {
err := util.CastErr(cerr)
err.SetStatus(http.StatusInternalServerError)
return nil, err
}
} else {
ds := datastore.New()
_, found = ds.Get("cookbook", name)
}
if found {
err := util.Errorf("Cookbook %s already exists", name)
err.SetStatus(http.StatusConflict)
}
cookbook := &Cookbook{
Name: name,
Versions: make(map[string]*CookbookVersion),
}
return cookbook, nil
}
// Get a user.
func Get(name string) (*User, util.Gerror) {
var user *User
if config.UsingDB() {
var err error
user, err = getUserSQL(name)
if err != nil {
var gerr util.Gerror
if err != sql.ErrNoRows {
gerr = util.Errorf(err.Error())
gerr.SetStatus(http.StatusInternalServerError)
} else {
gerr = util.Errorf("Client %s not found", name)
gerr.SetStatus(http.StatusNotFound)
}
return nil, gerr
}
} else {
ds := datastore.New()
u, found := ds.Get("user", name)
if !found {
err := util.Errorf("User %s not found", name)
return nil, err
}
if u != nil {
user = u.(*User)
}
}
return user, nil
}
// Get a report.
func Get(runID string) (*Report, util.Gerror) {
var report *Report
var found bool
if config.UsingDB() {
var err error
report, err = getReportSQL(runID)
if err != nil {
if err == sql.ErrNoRows {
found = false
} else {
gerr := util.CastErr(err)
gerr.SetStatus(http.StatusInternalServerError)
return nil, gerr
}
} else {
found = true
}
} else {
ds := datastore.New()
var r interface{}
r, found = ds.Get("report", runID)
if r != nil {
report = r.(*Report)
}
}
if !found {
err := util.Errorf("Report %s not found", runID)
err.SetStatus(http.StatusNotFound)
return nil, err
}
return report, nil
}
// Get a particular event by its id.
func Get(id int) (*LogInfo, error) {
var le *LogInfo
if config.UsingDB() {
var err error
le, err = getLogEventSQL(id)
if err != nil {
if err == sql.ErrNoRows {
err = fmt.Errorf("Couldn't find log event with id %d", id)
}
return nil, err
}
} else {
ds := datastore.New()
c, err := ds.GetLogInfo(id)
if err != nil {
return nil, err
}
if c != nil {
le = c.(*LogInfo)
le.ID = id
}
}
return le, nil
}
// PurgeLogInfos removes all logged events before the given id.
func PurgeLogInfos(id int) (int64, error) {
if config.UsingDB() {
return purgeSQL(id)
}
ds := datastore.New()
return ds.PurgeLogInfoBefore(id)
}
// Get a data bag.
func Get(dbName string) (*DataBag, util.Gerror) {
var dataBag *DataBag
var err error
if config.UsingDB() {
dataBag, err = getDataBagSQL(dbName)
if err != nil {
var gerr util.Gerror
if err == sql.ErrNoRows {
gerr = util.Errorf("Cannot load data bag %s", dbName)
gerr.SetStatus(http.StatusNotFound)
} else {
gerr = util.Errorf(err.Error())
gerr.SetStatus(http.StatusInternalServerError)
}
return nil, gerr
}
} else {
ds := datastore.New()
d, found := ds.Get("data_bag", dbName)
if !found {
err := util.Errorf("Cannot load data bag %s", dbName)
err.SetStatus(http.StatusNotFound)
return nil, err
}
if d != nil {
dataBag = d.(*DataBag)
for _, v := range dataBag.DataBagItems {
z := datastore.WalkMapForNil(v.RawData)
v.RawData = z.(map[string]interface{})
}
}
}
return dataBag, nil
}
// New creates an empty data bag, and kicks off adding it to the index.
func New(name string) (*DataBag, util.Gerror) {
var found bool
var err util.Gerror
if err = validateDataBagName(name, false); err != nil {
return nil, err
}
if config.UsingDB() {
var cerr error
found, cerr = checkForDataBagSQL(datastore.Dbh, name)
if cerr != nil {
err = util.Errorf(cerr.Error())
err.SetStatus(http.StatusInternalServerError)
return nil, err
}
} else {
ds := datastore.New()
_, found = ds.Get("data_bag", name)
}
if found {
err = util.Errorf("Data bag %s already exists", name)
err.SetStatus(http.StatusConflict)
return nil, err
}
dbiMap := make(map[string]*DataBagItem)
dataBag := &DataBag{
Name: name,
DataBagItems: dbiMap,
}
indexer.CreateNewCollection(name)
return dataBag, nil
}
// Get the file with this checksum.
func Get(chksum string) (*FileStore, error) {
var filestore *FileStore
var found bool
if config.UsingDB() {
var err error
filestore, err = getSQL(chksum)
if err != nil {
if err == sql.ErrNoRows {
found = false
} else {
return nil, err
}
} else {
found = true
}
} else {
ds := datastore.New()
var f interface{}
f, found = ds.Get("filestore", chksum)
if f != nil {
filestore = f.(*FileStore)
}
}
if !found {
err := fmt.Errorf("File with checksum %s not found", chksum)
return nil, err
}
if config.Config.LocalFstoreDir != "" {
if err := filestore.loadData(); err != nil {
return nil, err
}
}
return filestore, nil
}
func chkInMemClient(name string) error {
var err error
ds := datastore.New()
if _, found := ds.Get("clients", name); found {
err = fmt.Errorf("a client named %s was found that would conflict with this user", name)
}
return err
}
// AllShoveyIDs returns all shovey run ids.
func AllShoveyIDs() ([]string, util.Gerror) {
if config.UsingDB() {
return allShoveyIDsSQL()
}
ds := datastore.New()
list := ds.GetList("shovey")
return list, nil
}
// Delete a logged event.
func (le *LogInfo) Delete() error {
if config.UsingDB() {
return le.deleteSQL()
}
ds := datastore.New()
ds.DeleteLogInfo(le.ID)
return nil
}
// Delete a coookbook.
func (c *Cookbook) Delete() error {
if config.UsingDB() {
return c.deleteCookbookSQL()
}
ds := datastore.New()
ds.Delete("cookbook", c.Name)
return nil
}
func (sr *ShoveyRun) save() util.Gerror {
if config.UsingDB() {
return sr.saveSQL()
}
ds := datastore.New()
ds.Set("shovey_run", sr.ShoveyUUID+sr.NodeName, sr)
return nil
}
func (s *Shovey) importSave() error {
if config.UsingDB() {
return s.importSaveSQL()
}
ds := datastore.New()
ds.Set("shovey", s.RunID, s)
return nil
}
func (n *Node) deleteStatuses() error {
if config.UsingDB() {
err := fmt.Errorf("not needed in SQL mode - foreign keys handle deleting node statuses")
return err
}
ds := datastore.New()
return ds.DeleteNodeStatus(n.Name)
}
// GetList gets a list of all cookbooks on this server.
func GetList() []string {
if config.UsingDB() {
return getCookbookListSQL()
}
ds := datastore.New()
cbList := ds.GetList("cookbook")
return cbList
}
// Delete a report.
func (r *Report) Delete() error {
if config.UsingDB() {
return r.deleteSQL()
}
ds := datastore.New()
ds.Delete("report", r.RunID)
return nil
}
func (srs *ShoveyRunStream) importSave() error {
if config.UsingDB() {
return srs.importSaveSQL()
}
ds := datastore.New()
skey := fmt.Sprintf("%s_%s_%s_%d", srs.ShoveyUUID, srs.NodeName, srs.OutputType, srs.Seq)
ds.Set("shovey_run_stream", skey, srs)
return nil
}
// GetList returns a list of users.
func GetList() []string {
var userList []string
if config.UsingDB() {
userList = getListSQL()
} else {
ds := datastore.New()
userList = ds.GetList("user")
}
return userList
}
// GetList gets a list of files that have been uploaded.
func GetList() []string {
var fileList []string
if config.UsingDB() {
fileList = getListSQL()
} else {
ds := datastore.New()
fileList = ds.GetList("filestore")
}
return fileList
}
// GetList returns a list of UUIDs of reports on the system.
func GetList() []string {
var reportList []string
if config.UsingDB() {
reportList = getListSQL()
} else {
ds := datastore.New()
reportList = ds.GetList("report")
}
return reportList
}
// GetList gets a list of the nodes on this server.
func GetList() []string {
var nodeList []string
if config.UsingDB() {
nodeList = getListSQL()
} else {
ds := datastore.New()
nodeList = ds.GetList("node")
}
return nodeList
}