Documentation
¶
Overview ¶
This is a Go client for Opscode's Chef.
Obviously many of the unit tests require a functioning Chef installation in order to verify the results of API requests. Edit the `TEST_CONFIG.json` file with the appropriate endpoints and information, and run `go test -v`.
This project has no external dependencies other than the Go standard library.
Like most every other Golang project, this projects documentation can be found on godoc at http://godoc.org/github.com/marpaia/chef-golang
The following is an example of a simple Go tool that displays a small amount of information about a few different pieces of a Chef infrastructure:
package main import ( "fmt" "github.com/marpaia/chef-golang" "os" ) var findNode = "neo4j.example.org" var findCookbook = "neo4j" var findRole = "Neo4j" func main() { c, err := chef.Connect() if err != nil { fmt.Println("Error:", err) os.Exit(1) } c.SSLNoVerify = true // Print detailed information about a specific node node, ok, err := c.GetNode(findNode) if err != nil { fmt.Println("Error:", err) os.Exit(1) } if !ok { fmt.Println("\nCouldn't find that node!") } else { for i := 0; i < 80; i++ { fmt.Print("=") } fmt.Println("\nSystem info:", node.Name, "\n") fmt.Println(" [+] IP Address:", node.Info.IPAddress) fmt.Println(" [+] MAC Address:", node.Info.MACAddress) fmt.Println(" [+] Operating System:", node.Info.Platform) fmt.Println("\n [+] Filesystem Info") for partition, info := range node.Info.Filesystem { if info.PercentUsed != "" { fmt.Println(" - ", partition, "is", info.PercentUsed, "utilized") } } fmt.Println("\n [+] Roles") for _, role := range node.Info.Roles { fmt.Println(" - ", role) } fmt.Println() for i := 0; i < 80; i++ { fmt.Print("=") } } // Print detailed information about a specific cookbook cookbook, ok, err := c.GetCookbook(findCookbook) if err != nil { fmt.Println("Error:", err) os.Exit(1) } if !ok { fmt.Println("\nCouldn't find that cookbook!") } else { fmt.Println("\n\nCookbook info:", findCookbook) for _, version := range cookbook.Versions { currentVersion, ok, err := c.GetCookbookVersion(findCookbook, version.Version) if err != nil { fmt.Println("Error:", err) os.Exit(1) } if ok { if len(currentVersion.Files) > 0 { fmt.Println("\n [+]", findCookbook, currentVersion.Version, "Cookbook Files") for _, cookbookFile := range currentVersion.Files { fmt.Println(" - ", cookbookFile.Name) } } } } fmt.Println() for i := 0; i < 80; i++ { fmt.Print("=") } } // Print detailed information about a specific role role, ok, err := c.GetRole(findRole) if err != nil { fmt.Println("Error:", err) } if !ok { fmt.Println("\nCouldn't find that role!") } else { fmt.Println("\n\nRole information:", role.Name) fmt.Println("\n[+] Runlist") for _, recipe := range role.RunList { fmt.Println(" - ", recipe) } } }
Which will output something like this:
================================================================================ System info: neo4j.example.org [+] IP Address: 10.100.1.2 [+] MAC Address: AA:BB:CC:DD:EE:FF [+] Operating System: centos [+] Filesystem Info - /dev/vda is 46% utilized - tmpfs is 1% utilized [+] Roles - Base - Neo4j ================================================================================ Cookbook info: neo4j [+] neo4j 0.1.6 Cookbook Files - neo4j-server.properties - neo4j-service - neo4j-wrapper.conf [+] neo4j 0.1.5 Cookbook Files - neo4j-service - neo4j-wrapper.conf [+] neo4j 0.1.4 Cookbook Files - neo4j-service [+] neo4j 0.1.3 Cookbook Files - neo4j-service [+] neo4j 0.1.2 Cookbook Files - neo4j-service ================================================================================ Role information: Neo4j [+] Runlist - recipe[yum] - recipe[ldap] - recipe[system] - recipe[neo4j::server] - recipe[neo4j::web-ui]
Index ¶
- type Chef
- func (chef *Chef) Delete(endpoint string, params map[string]string) (*http.Response, error)
- func (chef *Chef) Get(endpoint string) (*http.Response, error)
- func (chef *Chef) GetClient(name string) (*Client, bool, error)
- func (chef *Chef) GetClients() (map[string]string, error)
- func (chef *Chef) GetCookbook(name string) (*Cookbook, bool, error)
- func (chef *Chef) GetCookbookVersion(name, version string) (*CookbookVersion, bool, error)
- func (chef *Chef) GetCookbooks() (map[string]*Cookbook, error)
- func (chef *Chef) GetData() (map[string]string, error)
- func (chef *Chef) GetDataByName(name string) (map[string]string, bool, error)
- func (chef *Chef) GetEnvironment(name string) (*Environment, bool, error)
- func (chef *Chef) GetEnvironmentCookbook(env, cb string) (*Cookbook, bool, error)
- func (chef *Chef) GetEnvironmentCookbooks(name string) (map[string]*Cookbook, error)
- func (chef *Chef) GetEnvironmentNodes(name string) (map[string]string, error)
- func (chef *Chef) GetEnvironmentRecipes(name string) ([]string, error)
- func (chef *Chef) GetEnvironmentRole(env, rol string) (map[string][]string, bool, error)
- func (chef *Chef) GetEnvironments() (map[string]string, error)
- func (chef *Chef) GetNode(name string) (*Node, bool, error)
- func (chef *Chef) GetNodes() (map[string]string, error)
- func (chef *Chef) GetPrincipal(name string) (map[string]string, bool, error)
- func (chef *Chef) GetRole(name string) (*Role, bool, error)
- func (chef *Chef) GetRoles() (map[string]string, error)
- func (chef *Chef) GetSearchIndexes() (map[string]string, error)
- func (chef *Chef) GetUsers() (map[string]string, error)
- func (chef *Chef) GetWithParams(endpoint string, params map[string]string) (*http.Response, error)
- func (chef *Chef) NewSearchQuery(index, query string) *SearchParams
- func (chef *Chef) Post(endpoint string, params map[string]string, body io.Reader) (*http.Response, error)
- func (chef *Chef) Put(endpoint string, params map[string]string) (*http.Response, error)
- func (chef *Chef) Search(index, query string) (*SearchResults, error)
- func (chef *Chef) SearchWithParams(index, query string, params map[string]interface{}) (*SearchResults, error)
- type Client
- type Cookbook
- type CookbookItem
- type CookbookVersion
- type Environment
- type Node
- type Role
- type SearchParams
- type SearchResults
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Chef ¶
type Chef struct { Host string Url string Port string Version string Key *rsa.PrivateKey UserId string SSLNoVerify bool Organization string }
Chef is the type that contains all of the relevant information about a Chef server connection
func Connect ¶
Connect looks for knife/chef configuration files and gather connection info automagically
func ConnectBuilder ¶
Given the appropriate connection parameters, ConnectChef returns a pointer to a Chef type so that you can call request methods on it
func (*Chef) Delete ¶
Delete makes an authenticated DELETE request to the Chef server for the supplied endpoint
func (*Chef) Get ¶
Get makes an authenticated HTTP request to the Chef server for the supplied endpoint
func (*Chef) GetClient ¶
GetClient accept a string representing the client name and returns a Client type which illustrates various information about the client. It also returns a bool indicating whether or not the client was found and an error indicating if the request failed or not.
Note that if the request is successful but no such client existed, the error return value will be nil but the bool will be false.
Usage:
client, ok, err := chef.GetClient("clientname") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that client!") } else { // do what you please with the "client" variable which is of the // *Chef.Client type fmt.Printf("%#v\n", client) }
func (*Chef) GetClients ¶
chef.GetClients returns a map of client name's to client REST urls as well as an error indicating if the request was successful or not.
Usage:
clients, err := chef.GetClients() if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "clients" variable which is map of client // names to client REST urls for client := range clients { fmt.Println("Client:", client) }
func (*Chef) GetCookbook ¶
chef.GetCookbook returns a pointer to the chef.Cookbook type for a given string that represents a cookbook name. It also returns a bool indicating whether or not the client was found and an error indicating if the request failed or not.
Note that if the request is successful but no such client existed, the error return value will be nil but the bool will be false.
Usage:
cookbook, ok, err := chef.GetCookbook("apache") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that cookbook!") } else { // do what you please with the "cookbook" variable which is of the // *Chef.Cookbook type fmt.Printf("%#v\n", cookbook) }
func (*Chef) GetCookbookVersion ¶
func (chef *Chef) GetCookbookVersion(name, version string) (*CookbookVersion, bool, error)
chef.GetCookbookVersion returns a pointer to the chef.CookbookVersion type for a given string that represents a cookbook version. It also returns a bool indicating whether or not the client was found and an error indicating if the request failed or not.
Note that if the request is successful but no such client existed, the error return value will be nil but the bool will be false.
Usage:
cookbook, ok, err := chef.GetCookbookVersion("apache", "1.0.0") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that cookbook version!") } else { // do what you please with the "cookbook" variable which is of the // *Chef.CookbookVersion type fmt.Printf("%#v\n", cookbook) }
func (*Chef) GetCookbooks ¶
chef.GetCookbooks returns a map of cookbook names to a pointer to the chef.Cookbook type as well as an error indicating if the request was successful or not.
Usgae:
cookbooks, err := chef.GetCookbooks() if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "cookbooks" variable which is a map of // cookbook names to chef.Cookbook types for name, cookbook := range cookbooks { fmt.Println(name, cookbook.Version[0]) }
func (*Chef) GetData ¶
chef.GetData returns a map of databag names to their related REST URL endpoint as well as an error indicating if the request was successful or not
Usage:
data, err := chef.GetData() if err != nil { fmt.Println(err) os.Exit(1) } for d := range data { fmt.Println(d) }
func (*Chef) GetDataByName ¶
chef.GetDataByName accept a string which represents the name of a specific databag and returns a map of information about that databag, a bool indicating whether or not the databag was found and an error indicating if the request failed or not.
Note that if the request is successful but no such data item existed, the error return value will be nil but the bool will be false
Usage:
data, ok, err := chef.GetDataByName("apache") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that databag!") } else { // do what you please with the "data" variable which is of the // map[string]string type fmt.Println(data) }
func (*Chef) GetEnvironment ¶
func (chef *Chef) GetEnvironment(name string) (*Environment, bool, error)
chef.GetEnvironment accepts a string which represents the name of a Chef environment and returns a chef.Environment type representing that environment as well as a bool indicating whether or not the environment was found and an error indicating if the request failed or not.
Note that if the request is successful but no such client existed, the error return value will be nil but the bool will be false.
Usage:
environment, ok, err := chef.GetEnvironment("production") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that environment!") } else { // do what you please with the "environment" variable which is of the // *Chef.Environment type fmt.Printf("%#v\n", environment) }
func (*Chef) GetEnvironmentCookbook ¶
chef.GetEnvironmentCookbook accepts a string which represents the name of a Chef environment as well as a string which represent the name of a cookbook and returns a *Chef.Cookbook type, a bool indicating whether or not the cookbook was found in the given environment as well as an error indicating whether or not the request failed.
Usage:
cookbook, ok, err := chef.GetEnvironmentCookbook("production", "apache") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that cookbook!") } else { // do what you please with the "cookbook" variable which is of the // *Chef.Cookbook type fmt.Printf("%#v\n", cookbook) }
func (*Chef) GetEnvironmentCookbooks ¶
chef.GetEnvironmentCookbooks accepts a string which represents the name of a Chef environment and returns a map of cookbook names to a *Chef.Cookbook type as well as an error indicating whether or not the request failed.
Usage:
cookbooks, err := chef.GetEnvironmentCookbooks("production") if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "cookbooks" variable which is a map of // cookbook names to chef.Cookbook types for name, cookbook := range cookbooks { fmt.Println(name, cookbook.Version[0]) }
func (*Chef) GetEnvironmentNodes ¶
chef.GetEnvironmentNodes accepts a string which represents the name of a Chef environment as well as a string which represent the name of a node and returns a map of node names to their corresponding RESTful URL, a bool indicating whether or not the cookbook was found in the given environment as well as an error indicating whether or not the request failed.
Usage:
nodes, err := chef.GetEnvironmentNodes("production") if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "nodes" variable which is a map of // node names to their corresponding RESTful URL for node := range nodes { fmt.Println(node) }
func (*Chef) GetEnvironmentRecipes ¶
chef.GetEnvironmentRecipes accepts a string which represents the name of a Chef environment and returns a slice of recipe names as well as an error indicating whether or not the request failed.
Usage:
recipes, err := chef.GetEnvironmentRecipes("production") if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "recipes" variable which is a slice of // recipe names for recipe := range recipes { fmt.Println(recipe) }
func (*Chef) GetEnvironmentRole ¶
chef.GetEnvironmentRole accepts a string which represents the name of a Chef environment as well as a string which represent the name of a role and returns a map of strings (which represent a role attribute like a runlist) to a slice of strings which represents the relevant information with regards to that attribute, a bool indicating whether or not the role was found in the given environment as well as an error indicating whether or not the request failed.
Usage:
role, ok, err := chef.GetEnvironmentRole("production", "base") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that role!") } else { // do what you please with the "role" variable fmt.Println(role) }
func (*Chef) GetEnvironments ¶
chef.GetEnvironments returns a map of environment names to the environment's RESTful URL as well as an error indicating if the request was successful or not.
Usage:
environments, err := chef.GetEnvironments() if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "environments" variable which is a map of // environment names to environment URLs for environment := range environments { fmt.Println(environment) }
func (*Chef) GetNode ¶
chef.GetNode accepts a string which represents the name of a Chef role and returns a chef.Environment type representing that role as well as a bool indicating whether or not the role was found and an error indicating if the request failed or not.
Note that if the request is successful but no such client existed, the error return value will be nil but the bool will be false.
Usage:
node, ok, err := chef.GetNode("neo4j.example.com") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that node!") } else { // do what you please with the "node" variable which is of the // *Chef.Node type fmt.Printf("%#v\n", node) }
func (*Chef) GetNodes ¶
chef.GetNodes returns a map of nodes names to the nodes's RESTful URL as well as an error indicating if the request was successful or not.
Usage:
nodes, err := chef.GetNodes() if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "node" variable which is a map of // node names to node URLs for node := range nodes { fmt.Println(node) }
func (*Chef) GetPrincipal ¶
chef.GetPrincipal returns a map of principal item names to their corresponding RESTful url. It also returns a bool indicating whether or not the client was found and an error indicating if the request failed or not.
Note that if the request is successful but no such client existed, the error return value will be nil but the bool will be false.
Usage:
principal, ok, err := chef.GetCookbookPrincipal("neo4j.example.org") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that principal!") } else { // do what you please with the "principal" variable which is of the // map[string]string type fmt.Println(principal) }
func (*Chef) GetRole ¶
chef.GetRole returns a pointer to the chef.Role type for a given string that represents a role name. It also returns a bool indicating whether or not the client was found and an error indicating if the request failed or not.
Note that if the request is successful but no such client existed, the error return value will be nil but the bool will be false.
Usage:
role, ok, err := chef.GetRole("neo4j") if err != nil { fmt.Println(err) os.Exit(1) } if !ok { fmt.Println("Couldn't find that role!") } else { // do what you please with the "role" variable which is of the // *Chef.Role fmt.Printf("%#v\n", role) }
func (*Chef) GetRoles ¶
chef.GetRoles returns a map of role names to a string which represents the role's RESTful URL as well as an error indicating if the request was successful or not.
Usgae:
roles, err := chef.GetRoles() if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "roles" variable which is a map of // role names to their RESTful URLs for role := range roles { fmt.Println(role) }
func (*Chef) GetSearchIndexes ¶
chef.GetSearchIndexes returns a map of search indexes to the indexes RESTful URL as well as an error indicating if the request was successful or not.
Usage:
indexes, err := chef.GetSearchIndexes() if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "indexes" variable which is a map of // index names to index URLs for index := range indexes { fmt.Println(index) }
func (*Chef) GetUsers ¶
chef.GetUsers returns a map of user names to the users RESTful URL as well as an error indicating if the request was successful or not.
Usage:
users, err := chef.GetUsers() if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "user" variable which is a map of // user names to user URLs for user := range users { fmt.Println(user) }
func (*Chef) GetWithParams ¶
GetWithParams makes an authenticated HTTP request to the Chef server for the supplied endpoint and also includes GET query string parameters
func (*Chef) NewSearchQuery ¶
func (chef *Chef) NewSearchQuery(index, query string) *SearchParams
chef.NewSearchQuery accepts an index and a query and returns a struct which represents the appropriate search parameters. This is mostly just used by the chef.Search method, but you can call it yourself if you'd like some more control over your parameters
func (*Chef) Post ¶
func (chef *Chef) Post(endpoint string, params map[string]string, body io.Reader) (*http.Response, error)
Post post to the chef api
func (*Chef) Put ¶
Put makes an authenticated PUT request to the Chef server for the supplied endpoint
func (*Chef) Search ¶
func (chef *Chef) Search(index, query string) (*SearchResults, error)
chef.Search accepts an index and a query and returns a *Chef.Search results type as well as an error indicating if the request was successful or not
Usage:
results, err := chef.Search("nodes", "hostname:memcached*") if err != nil { fmt.Println(err) os.Exit(1) } // do what you please with the "results" variable which is of the type // *Chef.SearchResults fmt.Println(results)
func (*Chef) SearchWithParams ¶
func (chef *Chef) SearchWithParams(index, query string, params map[string]interface{}) (*SearchResults, error)
chef.SearchWithParams is similar to chef.Search, but you can define additional Chef search parameters
type Client ¶
type Client struct { Name string `json:"name"` Admin bool `json:"admin"` JSONClass string `json:"json_class"` ChefType string `json:"chef_type"` ClientName string `json:"clientname"` Org string `json:"orgname"` Validator bool `json:"validator"` Certificate string `json:"certificate"` PublicKey string `json:"public_key"` }
chef.Client defines the relevant parameters of a Chef client. This includes it's name, whether or not it's an admin, etc.
type Cookbook ¶
type Cookbook struct { Url string `json:"url"` Versions []struct { Url string `json:"url"` Version string `json:"version"` } `json:"versions"` }
chef.Cookbook defines the relevant parameters of a Chef cookbook. This includes the RESTful URL of a cookbook and a slice of all of the cookbooks versions. The versions each have two attributes: Url, which represents the RESTful URL of the cookbook version and Version, which represents the version number (identifier) of the cookbook version
type CookbookItem ¶
type CookbookItem struct { Name string `json:"name"` Path string `json:"path"` Checksum string `json:"checksum"` Specificity string `json:"specificity"` Url string `json:"url"` }
chef.CookbookItem defines the relevant parameters of various items that are found in a chef Cookbook such as the name, checksum, etc. This type is embedded in the chef.CookVersion type to reduce code repetition.
type CookbookVersion ¶
type CookbookVersion struct { Files []struct { CookbookItem } `json:"files"` Definitions []struct { CookbookItem } `json:"definitions"` Libraries []struct { CookbookItem } `json:"libraries"` Attributes []struct { CookbookItem } `json:"attributes"` Recipes []struct { CookbookItem } `json:"recipes"` Providers []struct { CookbookItem } `json:"providers"` Resources []struct { CookbookItem } `json:"resources"` Templates []struct { CookbookItem } `json:"templates"` RootFiles []struct { CookbookItem } `json:"root_file"` Metadata struct { Name string `json:"name"` Description string `json:"description"` LongDescription string `json:"long_description"` Maintainer string `json:"maintainer"` MaintainerEmail string `json:"maintainer_email"` License string `json:"license"` Providing map[string]string `json:"providing"` Dependencies map[string]string `json:"dependencies"` } `json:"metadata"` Name string `json:"cookbook_name"` Version string `json:"version"` FullName string `json:"name"` Frozen bool `json:"frozen?"` ChefType string `json:"chef_type"` JSONClass string `json:"json_class"` }
chef.CookbookVersion defines the relevant parameters of a specific Chef cookbook version. This includes, but is not limited to, information about recipes, files, etc, various pieces of metadata about the cookbook at that point in time, such as the name of the cookbook, the description, the license, etc.
type Environment ¶
type Environment struct { Name string `json:"name"` Description string `json:"description"` CookbookVersions map[string]string `json:"cookbook_versions"` JSONClass string `json:"json_class"` ChefType string `json:"chef_type"` DefaultAttributes map[string]interface{} `json:"default_attributes"` OverrideAttributes map[string]interface{} `json:"override_attributes"` }
chef.Environment dinfes the relevant parameters of a Chef environment. This includes the name of the environment, the description strings, etc.
type Node ¶
type Node struct { Name string `json:"name"` Environment string `json:"chef_environment"` JSONClass string `json:"json_class"` RunList []string `json:"run_list"` ChefType string `json:"chef_type"` Info struct { Languages map[string]map[string]string `json:"languages"` Kernel struct { Name string `json:"name"` Release string `json:"release"` Version string `json:"version"` Machine string `json:"machine"` Modules map[string]map[string]string `json:"modules"` } `json:"kernel"` OS string `json:"os"` OSVersion string `json:"os_version"` Hostname string `json:"hostname"` FQDN string `json:"fqdn"` Domain string `json:"domain"` Network struct { Interfaces map[string]struct { Type string `json:"type"` Number string `json:"number"` Encapsulation string `json:"encapsulation"` Addresses map[string]struct { Family string `json:"family"` Broadcast string `json:"broadcast"` Netmast string `json:"netmast"` } `json:"addresses"` Flags []string `json:"flags"` MTU string `json:"mtu"` Arp map[string]string `json:"arp"` } `json:"interfaces"` } `json:"network"` IPAddress string `json:"ipaddress"` MACAddress string `json:"macaddress"` ChefPackages map[string]map[string]string `json:"chef_packages"` Keys map[string]map[string]string `json:"keys"` Platform string `json:"platform"` PlatformVersion string `json:"platform_version"` CPU map[string]interface{} `json:"cpu"` Filesystem map[string]struct { KBSize string `json:"ks_size"` KBUsed string `json:"ks_used"` KBavailable string `json:"ks_available"` PercentUsed string `json:"percent_used"` Mount string `json:"mount"` FSType string `json:"fs_type"` MountOptions []string `json:"mount_options"` } `json:"filesystem"` Memory map[string]interface{} `json:"memory"` UptimeSeconds int `json:"uptime_seconds"` Uptime string `json:"uptime"` IdletimeSeconds int `json:"idletime_seconds"` Idletime string `json:"idletime"` BlockDevice map[string]interface{} `json:"block_device"` Datacenter map[string]interface{} `json:"datacenter"` Ipmi struct { Address string `json:"address"` MacAddress string `json:"mac_address"` } `json:"ipmi"` Recipes []string `json:"recipes"` Roles []string `json:"roles"` } `json:"automatic"` Normal map[string]interface{} `json:"normal"` Default map[string]interface{} `json:"default"` }
chef.Node represents the relevant parameters of a Chef node
type Role ¶
type Role struct { Name string `json:"name"` ChefType string `json:"chef_type"` JSONClass string `json:"json_class"` DefaultAttributes map[string]interface{} `json:"default_attributes"` OverrideAttributes map[string]interface{} `json:"override_attributes"` RunList []string `json:"run_list"` }
chef.Role represents the relevant attributes of a Chef role
type SearchParams ¶
type SearchParams struct { Index string Query string Sort string Rows int Start int // contains filtered or unexported fields }
chef.SearchParams represents the necessary parameters of a Chef search query
func (*SearchParams) Execute ¶
func (search *SearchParams) Execute() (*SearchResults, error)
chef.Execute is a method on the chef.SearchParams type that executes a given search that has a given set of paramters. This is mostly used by the chef.Search method, but you can call it yourself if you'd like some more control over your parameters
type SearchResults ¶
type SearchResults struct { Total int `json:"total"` Start int `json:"start"` Rows []interface{} `json:"rows"` }
chef.SearchResults represents the results of a Chef search query