func (loc *ExecutionLocator) Terminate() error {
	var params rsapi.APIParams
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "terminate")
	if err != nil {
		return err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	return nil
}
POST /api/manager/projects/:project_id/executions/:id/actions/terminate

Terminate an Execution.
package ssm
import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"time"
	"github.com/rightscale/rsc/metadata"
	"github.com/rightscale/rsc/rsapi"
)
const APIVersion = "1.0"
type Href string
func (r *Href) ActionPath(rName, aName string) (*metadata.ActionPath, error) {
	res, ok := GenMetadata[rName]
	if !ok {
		return nil, fmt.Errorf("No resource with name '%s'", rName)
	}
	var action *metadata.Action
	for _, a := range res.Actions {
		if a.Name == aName {
			action = a
			break
		}
	}
	if action == nil {
		return nil, fmt.Errorf("No action with name '%s' on %s", aName, rName)
	}
	vars, err := res.ExtractVariables(string(*r))
	if err != nil {
		return nil, err
	}
	return action.URL(vars)
}
type Execution struct {
	ApiResources            []*Resource            `json:"api_resources,omitempty"`
	AvailableActions        []string               `json:"available_actions,omitempty"`
	AvailableOperations     []*OperationDefinition `json:"available_operations,omitempty"`
	AvailableOperationsInfo []*OperationInfo       `json:"available_operations_info,omitempty"`
	CompilationHref         string                 `json:"compilation_href,omitempty"`
	ConfigurationOptions    []*ConfigurationOption `json:"configuration_options,omitempty"`
	Cost                    *CostStruct            `json:"cost,omitempty"`
	CreatedBy               *User                  `json:"created_by,omitempty"`
	CurrentSchedule         string                 `json:"current_schedule,omitempty"`
	Dependencies            []*CatDependency       `json:"dependencies,omitempty"`
	Deployment              string                 `json:"deployment,omitempty"`
	DeploymentUrl           string                 `json:"deployment_url,omitempty"`
	Description             string                 `json:"description,omitempty"`
	EndsAt                  *time.Time             `json:"ends_at,omitempty"`
	Href                    string                 `json:"href,omitempty"`
	Id                      string                 `json:"id,omitempty"`
	Kind                    string                 `json:"kind,omitempty"`
	LatestNotification      *Notification          `json:"latest_notification,omitempty"`
	LatestNotifications     []*Notification        `json:"latest_notifications,omitempty"`
	LaunchedFrom            *LaunchedFrom          `json:"launched_from,omitempty"`
	LaunchedFromSummary     map[string]interface{} `json:"launched_from_summary,omitempty"`
	Links                   *ExecutionLinks        `json:"links,omitempty"`
	Name                    string                 `json:"name,omitempty"`
	NextAction              *ScheduledAction       `json:"next_action,omitempty"`
	Outputs                 []*Output              `json:"outputs,omitempty"`
	RunningOperations       []*Operation           `json:"running_operations,omitempty"`
	ScheduleRequired        bool                   `json:"schedule_required,omitempty"`
	Scheduled               bool                   `json:"scheduled,omitempty"`
	Schedules               []*Schedule            `json:"schedules,omitempty"`
	Source                  string                 `json:"source,omitempty"`
	Status                  string                 `json:"status,omitempty"`
	Timestamps              *TimestampsStruct      `json:"timestamps,omitempty"`
}
func (r *Execution) Locator(api *API) *ExecutionLocator {
	return api.ExecutionLocator(r.Href)
}
type ExecutionLocator struct {
	Href
	api *API
}
func (api *API) ExecutionLocator(href string) *ExecutionLocator {
	return &ExecutionLocator{Href(href), api}
}
func (loc *ExecutionLocator) Index(options rsapi.APIParams) ([]*Execution, error) {
	var res []*Execution
	var params rsapi.APIParams
	params = rsapi.APIParams{}
	var filterOpt = options["filter"]
	if filterOpt != nil {
		params["filter[]"] = filterOpt
	}
	var idsOpt = options["ids"]
	if idsOpt != nil {
		params["ids[]"] = idsOpt
	}
	var viewOpt = options["view"]
	if viewOpt != nil {
		params["view"] = viewOpt
	}
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "index")
	if err != nil {
		return res, err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return res, err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return res, err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return res, fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	defer resp.Body.Close()
	respBody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return res, err
	}
	err = json.Unmarshal(respBody, &res)
	return res, err
}
func (loc *ExecutionLocator) Show(options rsapi.APIParams) (*Execution, error) {
	var res *Execution
	var params rsapi.APIParams
	params = rsapi.APIParams{}
	var viewOpt = options["view"]
	if viewOpt != nil {
		params["view"] = viewOpt
	}
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "show")
	if err != nil {
		return res, err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return res, err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return res, err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return res, fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	defer resp.Body.Close()
	respBody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return res, err
	}
	err = json.Unmarshal(respBody, &res)
	return res, err
}
func (loc *ExecutionLocator) Create(options rsapi.APIParams) (*ExecutionLocator, error) {
	var res *ExecutionLocator
	var params rsapi.APIParams
	var p rsapi.APIParams
	p = rsapi.APIParams{}
	var applicationHrefOpt = options["application_href"]
	if applicationHrefOpt != nil {
		p["application_href"] = applicationHrefOpt
	}
	var compilationHrefOpt = options["compilation_href"]
	if compilationHrefOpt != nil {
		p["compilation_href"] = compilationHrefOpt
	}
	var compiledCatOpt = options["compiled_cat"]
	if compiledCatOpt != nil {
		p["compiled_cat"] = compiledCatOpt
	}
	var currentScheduleOpt = options["current_schedule"]
	if currentScheduleOpt != nil {
		p["current_schedule"] = currentScheduleOpt
	}
	var deferLaunchOpt = options["defer_launch"]
	if deferLaunchOpt != nil {
		p["defer_launch"] = deferLaunchOpt
	}
	var descriptionOpt = options["description"]
	if descriptionOpt != nil {
		p["description"] = descriptionOpt
	}
	var endsAtOpt = options["ends_at"]
	if endsAtOpt != nil {
		p["ends_at"] = endsAtOpt
	}
	var nameOpt = options["name"]
	if nameOpt != nil {
		p["name"] = nameOpt
	}
	var options_Opt = options["options"]
	if options_Opt != nil {
		p["options"] = options_Opt
	}
	var scheduleRequiredOpt = options["schedule_required"]
	if scheduleRequiredOpt != nil {
		p["schedule_required"] = scheduleRequiredOpt
	}
	var scheduledActionsOpt = options["scheduled_actions"]
	if scheduledActionsOpt != nil {
		p["scheduled_actions"] = scheduledActionsOpt
	}
	var schedulesOpt = options["schedules"]
	if schedulesOpt != nil {
		p["schedules"] = schedulesOpt
	}
	var sourceOpt = options["source"]
	if sourceOpt != nil {
		p["source"] = sourceOpt
	}
	var templateHrefOpt = options["template_href"]
	if templateHrefOpt != nil {
		p["template_href"] = templateHrefOpt
	}
	uri, err := loc.ActionPath("Execution", "create")
	if err != nil {
		return res, err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return res, err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return res, err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return res, fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	location := resp.Header.Get("Location")
	if len(location) == 0 {
		return res, fmt.Errorf("Missing location header in response")
	} else {
		return &ExecutionLocator{Href(location), loc.api}, nil
	}
}
func (loc *ExecutionLocator) Patch(options rsapi.APIParams) error {
	var params rsapi.APIParams
	var p rsapi.APIParams
	p = rsapi.APIParams{}
	var currentScheduleOpt = options["current_schedule"]
	if currentScheduleOpt != nil {
		p["current_schedule"] = currentScheduleOpt
	}
	var endsAtOpt = options["ends_at"]
	if endsAtOpt != nil {
		p["ends_at"] = endsAtOpt
	}
	uri, err := loc.ActionPath("Execution", "patch")
	if err != nil {
		return err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	return nil
}
func (loc *ExecutionLocator) Delete(options rsapi.APIParams) error {
	var params rsapi.APIParams
	params = rsapi.APIParams{}
	var forceOpt = options["force"]
	if forceOpt != nil {
		params["force"] = forceOpt
	}
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "delete")
	if err != nil {
		return err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	return nil
}
func (loc *ExecutionLocator) MultiDelete(ids []string, options rsapi.APIParams) error {
	if len(ids) == 0 {
		return fmt.Errorf("ids is required")
	}
	var params rsapi.APIParams
	params = rsapi.APIParams{
		"ids[]": ids,
	}
	var forceOpt = options["force"]
	if forceOpt != nil {
		params["force"] = forceOpt
	}
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "multi_delete")
	if err != nil {
		return err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	return nil
}
func (loc *ExecutionLocator) Download(apiVersion string) error {
	if apiVersion == "" {
		return fmt.Errorf("apiVersion is required")
	}
	var params rsapi.APIParams
	params = rsapi.APIParams{
		"api_version": apiVersion,
	}
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "download")
	if err != nil {
		return err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	return nil
}
func (loc *ExecutionLocator) Launch() error {
	var params rsapi.APIParams
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "launch")
	if err != nil {
		return err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	return nil
}
func (loc *ExecutionLocator) Start() error {
	var params rsapi.APIParams
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "start")
	if err != nil {
		return err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	return nil
}
func (loc *ExecutionLocator) Stop() error {
	var params rsapi.APIParams
	var p rsapi.APIParams
	uri, err := loc.ActionPath("Execution", "stop")
	if err != nil {
		return err
	}
	req, err := loc.api.BuildHTTPRequest(uri.HTTPMethod, uri.Path, APIVersion, params, p)
	if err != nil {
		return err
	}
	resp, err := loc.api.PerformRequest(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		respBody, _ := ioutil.ReadAll(resp.Body)
		sr := string(respBody)
		if sr != "" {
			sr = ": " + sr
		}
		return fmt.Errorf("invalid response %s%s", resp.Status, sr)
	}
	return nil
}