func main() {
flag.Parse()
name := getNameArgument()
switch *action {
case "types":
git := getGitRegistry()
types, err := git.List()
if err != nil {
log.Fatalf("Cannot list %v err")
}
log.Printf("Types:")
for _, t := range types {
log.Printf("%s:%s", t.Name, t.Version)
downloadURL, err := git.GetURL(t)
if err != nil {
log.Printf("Failed to get download URL for type %s:%s", t.Name, t.Version)
}
log.Printf("\tdownload URL: %s", downloadURL)
}
case "expand":
backend := expander.NewExpander(*binary)
template := loadTemplate(name)
output, err := backend.ExpandTemplate(template)
if err != nil {
log.Fatalf("cannot expand %s: %s\n", name, err)
}
fmt.Println(output)
case "deploy":
callService("deployments", "POST", name, readTemplate(name))
case "list":
callService("deployments", "GET", name, nil)
case "get":
path := fmt.Sprintf("deployments/%s", name)
callService(path, "GET", name, nil)
case "delete":
path := fmt.Sprintf("deployments/%s", name)
callService(path, "DELETE", name, nil)
case "update":
path := fmt.Sprintf("deployments/%s", name)
callService(path, "PUT", name, readTemplate(name))
case "listtypes":
callService("types", "GET", name, nil)
case "listtypeinstances":
path := fmt.Sprintf("types/%s/instances", url.QueryEscape(name))
callService(path, "GET", name, nil)
}
}
func main() {
flag.Parse()
backend := expander.NewExpander(*expansionBinary)
wrapper := service.NewService(service.NewExpansionHandler(backend))
address := fmt.Sprintf(":%d", *port)
container := restful.DefaultContainer
server := &http.Server{
Addr: address,
Handler: container,
}
wrapper.Register(container)
log.Printf("Version: %s", version.DeploymentManagerVersion)
log.Printf("Listening on %s...", address)
log.Fatal(server.ListenAndServe())
}
func TestServiceWrapper(t *testing.T) {
backend := expander.NewExpander("../expansion/expansion.py")
wrapper := NewService(NewExpansionHandler(backend))
container := restful.NewContainer()
container.ServeMux = http.NewServeMux()
wrapper.Register(container)
handlerTester := util.NewHandlerTester(container)
for _, swtc := range ServiceWrapperTestCases {
reader := GetTemplateReader(t, swtc.Description, inputFileName)
w, err := handlerTester(swtc.HTTPMethod, swtc.ServiceURLPath, swtc.ContentType, reader)
if err != nil {
t.Errorf("error in test case '%s': %s\n", swtc.Description, err)
}
if w.Code != http.StatusOK {
if w.Code != swtc.StatusCode {
message := fmt.Sprintf("test returned code:%d, status: %s", w.Code, w.Body.String())
t.Errorf("error in test case '%s': %s\n", swtc.Description, message)
}
} else {
if swtc.StatusCode != http.StatusOK {
t.Errorf("expected error did not occur in test case '%s': want: %d have: %d\n",
swtc.Description, swtc.StatusCode, w.Code)
}
body := w.Body.Bytes()
actualResponse := &expander.ExpansionResponse{}
if err := json.Unmarshal(body, actualResponse); err != nil {
t.Errorf("error in test case '%s': %s\n", swtc.Description, err)
}
actualResult, err := actualResponse.Unmarshal()
if err != nil {
t.Errorf("error in test case '%s': %s\n", swtc.Description, err)
}
expectedOutput := GetOutputString(t, swtc.Description)
expectedResult := expandOutputOrDie(t, expectedOutput, swtc.Description)
if !reflect.DeepEqual(expectedResult, actualResult) {
message := fmt.Sprintf("want: %s\nhave: %s\n",
util.ToYAMLOrError(expectedResult), util.ToYAMLOrError(actualResult))
t.Errorf("error in test case '%s':\n%s\n", swtc.Description, message)
}
}
}
}
func main() {
flag.Parse()
args := flag.Args()
if len(args) < 1 {
fmt.Fprintln(os.Stderr, "No command supplied")
usage()
}
if *stdin {
fmt.Printf("reading from stdin is not yet implemented")
os.Exit(0)
}
command := args[0]
switch command {
case "templates":
git := getGitRegistry()
templates, err := git.List()
if err != nil {
log.Fatalf("Cannot list %v", err)
}
fmt.Printf("Templates:\n")
for _, t := range templates {
fmt.Printf("%s:%s\n", t.Name, t.Version)
downloadURL, err := git.GetURL(t)
if err != nil {
log.Printf("Failed to get download URL for template %s:%s", t.Name, t.Version)
}
fmt.Printf("\tdownload URL: %s\n", downloadURL)
}
case "describe":
fmt.Printf("the describe feature is not yet implemented")
case "expand":
backend := expander.NewExpander(*binary)
template := loadTemplate(args)
output, err := backend.ExpandTemplate(template)
if err != nil {
log.Fatalf("cannot expand %s: %s\n", template.Name, err)
}
fmt.Println(output)
case "deploy":
template := loadTemplate(args)
action := fmt.Sprintf("deploy configuration named %s", template.Name)
callService("deployments", "POST", action, marshalTemplate(template))
case "list":
callService("deployments", "GET", "list deployments", nil)
case "get":
if len(args) < 2 {
fmt.Fprintln(os.Stderr, "No deployment name supplied")
usage()
}
path := fmt.Sprintf("deployments/%s", args[1])
action := fmt.Sprintf("get deployment named %s", args[1])
callService(path, "GET", action, nil)
case "delete":
if len(args) < 2 {
fmt.Fprintln(os.Stderr, "No deployment name supplied")
usage()
}
path := fmt.Sprintf("deployments/%s", args[1])
action := fmt.Sprintf("delete deployment named %s", args[1])
callService(path, "DELETE", action, nil)
case "update":
template := loadTemplate(args)
path := fmt.Sprintf("deployments/%s", template.Name)
action := fmt.Sprintf("delete deployment named %s", template.Name)
callService(path, "PUT", action, marshalTemplate(template))
case "deployed-types":
callService("types", "GET", "list deployed types", nil)
case "deployed-instances":
if len(args) < 2 {
fmt.Fprintln(os.Stderr, "No type name supplied")
usage()
}
path := fmt.Sprintf("types/%s/instances", url.QueryEscape(args[1]))
action := fmt.Sprintf("list deployed instances of type %s", args[1])
callService(path, "GET", action, nil)
default:
usage()
}
}
