func (*environSuite) TestSetConfigUpdatesConfig(c *gc.C) {
origAttrs := coretesting.Attrs{
"server-name": "http://maas2.testing.invalid",
"maas-oauth": "a:b:c",
"admin-secret": "secret",
}
cfg := getSimpleTestConfig(c, origAttrs)
env, err := maas.NewEnviron(cfg)
c.Check(err, jc.ErrorIsNil)
c.Check(env.Config().Name(), gc.Equals, "testenv")
anotherServer := "http://maas.testing.invalid"
anotherOauth := "c:d:e"
anotherSecret := "secret2"
newAttrs := coretesting.Attrs{
"server-name": anotherServer,
"maas-oauth": anotherOauth,
"admin-secret": anotherSecret,
}
cfg2 := getSimpleTestConfig(c, newAttrs)
errSetConfig := env.SetConfig(cfg2)
c.Check(errSetConfig, gc.IsNil)
c.Check(env.Config().Name(), gc.Equals, "testenv")
authClient, _ := gomaasapi.NewAuthenticatedClient(anotherServer, anotherOauth, maas.APIVersion)
maasClient := gomaasapi.NewMAAS(*authClient)
MAASServer := maas.GetMAASClient(env)
c.Check(MAASServer, gc.DeepEquals, maasClient)
}
func main() {
getParams()
// Create API server endpoint.
authClient, err := gomaasapi.NewAuthenticatedClient(apiURL, apiKey, apiVersion)
checkError(err)
maas := gomaasapi.NewMAAS(*authClient)
// Exercise the API.
ManipulateNodes(maas)
ManipulateFiles(maas)
fmt.Println("All done.")
}
func main() {
flag.Parse()
options := ProcessingOptions{
Preview: *preview,
Verbose: *verbose,
AlwaysRename: *always,
}
// Determine the filter, this can either be specified on the the command
// line as a value or a file reference. If none is specified the default
// will be used
if len(*filterSpec) > 0 {
if (*filterSpec)[0] == '@' {
name := os.ExpandEnv((*filterSpec)[1:])
file, err := os.OpenFile(name, os.O_RDONLY, 0)
checkError(err, "[error] unable to open file '%s' to load the filter : %s", name, err)
decoder := json.NewDecoder(file)
err = decoder.Decode(&options.Filter)
checkError(err, "[error] unable to parse filter configuration from file '%s' : %s", name, err)
} else {
err := json.Unmarshal([]byte(*filterSpec), &options.Filter)
checkError(err, "[error] unable to parse filter specification: '%s' : %s", *filterSpec, err)
}
} else {
err := json.Unmarshal([]byte(defaultFilter), &options.Filter)
checkError(err, "[error] unable to parse default filter specificiation: '%s' : %s", defaultFilter, err)
}
// Determine the mac to name mapping, this can either be specified on the the command
// line as a value or a file reference. If none is specified the default
// will be used
if len(*mappings) > 0 {
if (*mappings)[0] == '@' {
name := os.ExpandEnv((*mappings)[1:])
file, err := os.OpenFile(name, os.O_RDONLY, 0)
checkError(err, "[error] unable to open file '%s' to load the mac name mapping : %s", name, err)
decoder := json.NewDecoder(file)
err = decoder.Decode(&options.Mappings)
checkError(err, "[error] unable to parse filter configuration from file '%s' : %s", name, err)
} else {
err := json.Unmarshal([]byte(*mappings), &options.Mappings)
checkError(err, "[error] unable to parse mac name mapping: '%s' : %s", *mappings, err)
}
} else {
err := json.Unmarshal([]byte(defaultMapping), &options.Mappings)
checkError(err, "[error] unable to parse default mac name mappings: '%s' : %s", defaultMapping, err)
}
// Verify the specified period for queries can be converted into a Go duration
period, err := time.ParseDuration(*queryPeriod)
checkError(err, "[error] unable to parse specified query period duration: '%s': %s", queryPeriod, err)
authClient, err := maas.NewAuthenticatedClient(*maasURL, *apiKey, *apiVersion)
if err != nil {
checkError(err, "[error] Unable to use specified client key, '%s', to authenticate to the MAAS server: %s", *apiKey, err)
}
// Create an object through which we will communicate with MAAS
client := maas.NewMAAS(*authClient)
// This utility essentially polls the MAAS server for node state and
// process the node to the next state. This is done by kicking off the
// process every specified duration. This means that the first processing of
// nodes will have "period" in the future. This is really not the behavior
// we want, we really want, do it now, and then do the next one in "period".
// So, the code does one now.
nodes, _ := fetchNodes(client)
ProcessAll(client, nodes, options)
if !(*preview) {
// Create a ticker and fetch and process the nodes every "period"
ticker := time.NewTicker(period)
for t := range ticker.C {
log.Printf("[info] query server at %s", t)
nodes, _ := fetchNodes(client)
ProcessAll(client, nodes, options)
}
}
}