// 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
}
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 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
}
// 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 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 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
}
/* Returns a sorted list of all the versions of this cookbook */
func (c *Cookbook) sortedVersions() []*CookbookVersion {
if config.UsingDB() {
return c.sortedCookbookVersionsSQL()
}
sorted := make([]*CookbookVersion, len(c.Versions))
keys := make(VersionStrings, len(c.Versions))
u := 0
for k, cbv := range c.Versions {
keys[u] = k
u++
datastore.ChkNilArray(cbv)
}
sort.Sort(sort.Reverse(keys))
/* populate sorted now */
for i, s := range keys {
/* This shouldn't be able to happen, but somehow it... does? */
if i >= len(sorted) {
break
}
sorted[i] = c.Versions[s]
}
return sorted
}
// 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
}
// DeleteVersion deletes a particular version of a cookbook.
func (c *Cookbook) DeleteVersion(cbVersion string) util.Gerror {
/* Check for existence */
cbv, _ := c.GetVersion(cbVersion)
if cbv == nil {
err := util.Errorf("Version %s of cookbook %s does not exist to be deleted.", cbVersion, c.Name)
err.SetStatus(http.StatusNotFound)
return err
}
fhashes := cbv.fileHashes()
if config.UsingDB() {
err := cbv.deleteCookbookVersionSQL()
if err != nil {
return nil
}
}
c.numVersions = nil
delete(c.Versions, cbVersion)
c.Save()
c.deleteHashes(fhashes)
return 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 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
}
// 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 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
}
// 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 report.
func (r *Report) Delete() error {
if config.UsingDB() {
return r.deleteSQL()
}
ds := datastore.New()
ds.Delete("report", r.RunID)
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 (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
}
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 (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
}
// NumVersions returns the number of versions this cookbook has.
func (c *Cookbook) NumVersions() int {
if config.UsingDB() {
if c.numVersions == nil {
c.numVersions = c.numVersionsSQL()
}
return *c.numVersions
}
return len(c.Versions)
}
// CookbookLister lists all of the cookbooks on the server, along with some
// information like URL, available versions, etc.
func CookbookLister(numResults interface{}) map[string]interface{} {
if config.UsingDB() {
return cookbookListerSQL(numResults)
}
cr := make(map[string]interface{})
for _, cb := range AllCookbooks() {
cr[cb.Name] = cb.InfoHash(numResults)
}
return cr
}
// 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
}
// 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
}