cm16

package
v5.0.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 21, 2016 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// APIName is used by rsc to display the command line help.
	APIName = "RightScale CM API 1.6"
)
View Source 
const APIVersion = "1.6"

API Version

Variables

View Source 
var GenMetadata = map[string]*metadata.Resource{
	"Account": &metadata.Resource{
		Name: "Account",
		Description: `        Resources in RightScale generally belong to accounts. Users can have
        any number of accounts, but when performing an action, a user is
        operating under a particular account.`,
		Identifier: "application/vnd.rightscale.account",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/accounts",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/accounts`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/accounts/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/accounts/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
	},
	"Cloud": &metadata.Resource{
		Name: "Cloud",
		Description: `        Clouds provide remote resources for things like storage and compute.
        You must have registered a cloud within your account in order to use
        it.`,
		Identifier: "application/vnd.rightscale.cloud",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/clouds`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
	},
	"Datacenter": &metadata.Resource{
		Name: "Datacenter",
		Description: `        Datacenters are cloud resources that give you the ability to place
        resources in isolated locations. A carefully designed system placed in
        multiple datacenters can provide fault tolerance when one datacenter
        has a problem.`,
		Identifier: "application/vnd.rightscale.datacenter",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/datacenters",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/datacenters`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/datacenters",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/datacenters`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/datacenters/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/datacenters/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/datacenters/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/datacenters/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud where the Datacenter exists",
		},
	},
	"Deployment": &metadata.Resource{
		Name: "Deployment",
		Description: `        Deployments provide a way to group resources that logically belong
        together.`,
		Identifier: "application/vnd.rightscale.deployment",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `          List all Deployments in an Account.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/deployments",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/deployments`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "ids",
						Description: `Comma separated list of Deployment IDs`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
					},
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full", "link"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "ids",
						Description: `Comma separated list of Deployment IDs`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
					},
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full", "link"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `Show a single Deployment`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/deployments/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/deployments/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: ``,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full", "link"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: ``,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full", "link"},
					},
				},
			},
		},
		Links: map[string]string{
			"account": "Link to the Account where the Deployment exists",
		},
	},
	"Image": &metadata.Resource{
		Name: "Image",
		Description: `        Images define the initial Operating System and root disk contents
        for new instances.`,
		Identifier: "application/vnd.rightscale.image",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `Lists all Images for the given Cloud.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/images",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/images`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name: "filter",
						Description: `              Filter images by attribute. A filter takes the form <attribute><operator><value>.
              <operator> can be either "=" or "!=". <value> can be comma-separated list of values to
              express multiple possible values. For example, "image_type=machine,ramdisk" finds all
              images that have "machine" and "ramdisk" types. Multiple filters must be concatenated with an
              ampersand (&). For example, "image_type=machine&visibility=private" finds all images with
              type "machine" and visibility "private". All special characters in the filter must be
              URL encoded.`,
						Type:      "string",
						Location:  metadata.QueryParam,
						Mandatory: false,
						NonBlank:  false,
					},
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name: "filter",
						Description: `              Filter images by attribute. A filter takes the form <attribute><operator><value>.
              <operator> can be either "=" or "!=". <value> can be comma-separated list of values to
              express multiple possible values. For example, "image_type=machine,ramdisk" finds all
              images that have "machine" and "ramdisk" types. Multiple filters must be concatenated with an
              ampersand (&). For example, "image_type=machine&visibility=private" finds all images with
              type "machine" and visibility "private". All special characters in the filter must be
              URL encoded.`,
						Type:      "string",
						Location:  metadata.QueryParam,
						Mandatory: false,
						NonBlank:  false,
					},
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/images/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/images/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/images/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/images/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud where the Image exists",
		},
	},
	"Instance": &metadata.Resource{
		Name: "Instance",
		Description: `        Instances represent an entity that is runnable in the cloud.
        An instance of type "next" is a container of information that expresses
        how to configure a future instance when we decide to launch or start
        it. A "next" instance generally only exists in the RightScale realm,
        and usually doesn't have any corresponding representation existing in
        the cloud. However, if an instance is not of type "next", it will
        generally represent an existing running (or provisioned) virtual
        machine existing in the cloud.`,
		Identifier: "application/vnd.rightscale.instance",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `          List all Instances in an account.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/instances",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/instances`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/instances",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/instances`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name: "filter",
						Description: `              Filter instances by attribute. A filter takes the form <attribute><operator><value>.
              <operator> can be either "=" or "!=". <value> can be comma-separated list of values to
              express multiple possible values. For example, "state=booting,operational" finds all
              instances that are in "booting" or "operational" state. Percentage (%) wildcard character
              can be used to perform partial string match if supported by the filter. For example,
              "name=%test%" finds all instances with name containing the word "test",
              "name=test%" finds all instances with name beginning with "test", and "name=%test" finds
              all instances with name ending with "test". Multiple filters must be concatenated with an
              ampersand (&). For example, "name=test&state=operational" finds all instances with
              name "test" and are in "operational" state. All special characters in the filter must be
              URL encoded.`,
						Type:      "string",
						Location:  metadata.QueryParam,
						Mandatory: false,
						NonBlank:  false,
					},
					&metadata.ActionParam{
						Name:        "ids",
						Description: `Comma separated list of Instance RsIds`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
					},
					&metadata.ActionParam{
						Name:        "limit",
						Description: `The maximum number of resources to return for this index`,
						Type:        "int",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
					},
					&metadata.ActionParam{
						Name:        "view",
						Description: ``,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full", "tiny", "link"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name: "filter",
						Description: `              Filter instances by attribute. A filter takes the form <attribute><operator><value>.
              <operator> can be either "=" or "!=". <value> can be comma-separated list of values to
              express multiple possible values. For example, "state=booting,operational" finds all
              instances that are in "booting" or "operational" state. Percentage (%) wildcard character
              can be used to perform partial string match if supported by the filter. For example,
              "name=%test%" finds all instances with name containing the word "test",
              "name=test%" finds all instances with name beginning with "test", and "name=%test" finds
              all instances with name ending with "test". Multiple filters must be concatenated with an
              ampersand (&). For example, "name=test&state=operational" finds all instances with
              name "test" and are in "operational" state. All special characters in the filter must be
              URL encoded.`,
						Type:      "string",
						Location:  metadata.QueryParam,
						Mandatory: false,
						NonBlank:  false,
					},
					&metadata.ActionParam{
						Name:        "ids",
						Description: `Comma separated list of Instance RsIds`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
					},
					&metadata.ActionParam{
						Name:        "limit",
						Description: `The maximum number of resources to return for this index`,
						Type:        "int",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
					},
					&metadata.ActionParam{
						Name:        "view",
						Description: ``,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full", "tiny", "link"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/instances/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/instances/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/instances/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/instances/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full", "tiny"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full", "tiny"},
					},
				},
			},
		},
		Links: map[string]string{
			"account":                    "Link to the Account where the Instance exist",
			"cloud":                      "Link to the Cloud where the Instance exist",
			"computed_image":             "Link to the computed Image for the Instance",
			"computed_multi_cloud_image": "Link to the computed MultiCloudImage for the Instance",
			"datacenter":                 "Link to the Datacenter where the Instance exist",
			"deployment":                 "Link to the Deployment where the Instance exists",
			"image":                      "Link to the Image used by the Instance",
			"incarnator":                 "Incarnator of the Instance if there is one",
			"instance_type":              "Link to the InstanceType of the Instance",
			"multi_cloud_image":          "Link to the MultiCloudImage used by the Instance",
			"security_groups":            "Link to the collection of SecurityGroups associated with the Instance",
			"ssh_key":                    "Link to the SshKey used by the Instance",
			"subnets":                    "Link to the collection of Subnets associated with the Instance",
		},
	},
	"InstanceType": &metadata.Resource{
		Name: "InstanceType",
		Description: `        An InstanceType represents a basic hardware configuration for an
        Instance.
        Combining all possible configurations of hardware into a smaller,
        well-known set of options makes instances easier to manage, and allows
        better allocation efficiency into physical hosts.`,
		Identifier: "application/vnd.rightscale.instance_type",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/instance_types",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/instance_types`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/instance_types",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/instance_types`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/instance_types/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/instance_types/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/instance_types/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/instance_types/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud supporting the InstanceType",
		},
	},
	"IpAddress": &metadata.Resource{
		Name: "IpAddress",
		Description: `        An IpAddress provides an abstraction for IPv4 addresses bindable to
        Instance resources running in a Cloud.`,
		Identifier: "application/vnd.rightscale.ip_address",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/ip_addresses",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/ip_addresses`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/ip_addresses",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/ip_addresses`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/ip_addresses/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/ip_addresses/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/ip_addresses/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/ip_addresses/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud where the IpAddress exists",
		},
	},
	"IpAddressBinding": &metadata.Resource{
		Name: "IpAddressBinding",
		Description: `        An IpAddressBinding represents an abstraction for binding an IpAddress
        to an instance. The IpAddress is bound immediately for a current
        instance, or on launch for a next instance.`,
		Identifier: "application/vnd.rightscale.ip_address_binding",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/ip_address_bindings",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/ip_address_bindings`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/ip_address_bindings",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/ip_address_bindings`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/ip_address_bindings/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/ip_address_bindings/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/ip_address_bindings/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/ip_address_bindings/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud":      "Link to the Cloud where the IpAddressBinding exists",
			"instance":   "Link to the Instance to which the IpAddressBinding is associated",
			"ip_address": "Link to the IpAddress associated with the IpAddressBinding",
		},
	},
	"MultiCloudImage": &metadata.Resource{
		Name: "MultiCloudImage",
		Description: `        A MultiCloudImage is a RightScale component that functions as a pointer
        to machine images in specific clouds (e.g. AWS US-East, Rackspace).
        Each ServerTemplate can reference many MultiCloudImages that define
        which image should be used when a server is launched in a particular
        cloud.`,
		Identifier: "application/vnd.rightscale.multi_cloud_image",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/multi_cloud_images",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/multi_cloud_images`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/multi_cloud_images/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/multi_cloud_images/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
	},
	"Network": &metadata.Resource{
		Name:        "Network",
		Description: `        A Network is a logical grouping of network devices.`,
		Identifier:  "application/vnd.rightscale.network",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/networks",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/networks`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/networks/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/networks/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud where the Network exists",
		},
	},
	"NetworkInterface": &metadata.Resource{
		Name: "NetworkInterface",
		Description: `        Just like their physical counterparts, NetworkInterfaces join other
        resources to a network.`,
		Identifier: "application/vnd.rightscale.network_interface",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/network_interfaces",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/network_interfaces`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/network_interfaces/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/network_interfaces/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud where the NetworkInterface exists",
		},
	},
	"NetworkInterfaceAttachment": &metadata.Resource{
		Name: "NetworkInterfaceAttachment",
		Description: `        NetworkInterfaceAttachments represent an attachment between a
        NetworkInterface and another resource.`,
		Identifier: "application/vnd.rightscale.network_interface_attachment",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/network_interface_attachments",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/network_interface_attachments`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/network_interface_attachments/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/network_interface_attachments/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud where the NetworkInterfaceAttachment exists",
		},
	},
	"SecurityGroup": &metadata.Resource{
		Name: "SecurityGroup",
		Description: `        Security Groups represent network security profiles that contain lists
        of firewall rules for different ports and source IP addresses, as well
        as trust relationships between security groups.`,
		Identifier: "application/vnd.rightscale.security_group",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/security_groups",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/security_groups`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/security_groups",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/security_groups`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/instances/%s/security_groups",
						Variables:  []string{"cloud_id", "instance_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/instances/([^/]+)/security_groups`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/security_groups/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/security_groups/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/security_groups/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/security_groups/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud where the SecurityGroup exists",
		},
	},
	"Server": &metadata.Resource{
		Name: "Server",
		Description: `        Servers represent the notion of a server/machine from RightScale's
        perspective. A Server, does not always have a corresponding VM running
        or provisioned in a cloud. Some clouds use the word "servers" to refer
        to created VMs. These allocated VMs are not called Servers in the
        RightScale API, they are called Instances.
        A Server always has a next_instance association, which will define the
        configuration to apply to a new instance when the server is launched or
        started (starting servers is not yet supported through this API). Once
        a Server is launched/started, a current_instance relationship will
        exist.  Accessing the current_instance of a server results in immediate
        runtime modification of this running server. Changes to the
        next_instance association prepares the configuration for the next
        instance launch/start (therefore they have no effect until such
        operation is performed).`,
		Identifier: "application/vnd.rightscale.server",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/servers",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/servers`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/servers/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/servers/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full"},
					},
				},
			},
		},
		Links: map[string]string{
			"account":          "The Account to which the Server belongs",
			"cloud":            "The Cloud where new instances of the Server will be created",
			"current_instance": "Link to the current Instance of the Server",
			"next_instance":    "Link to the next Instance of the Server",
		},
	},
	"ServerArray": &metadata.Resource{
		Name: "ServerArray",
		Description: `        A server array represents a logical group of instances and allows to
        resize(grow/shrink) that group based on certain elasticity parameters.
        A server array just like a server always has a next_instance
        association, which will define the configuration to apply when a new
        instance is launched. But unlike a server which has a current_instance
        relationship, the server array has a current_instances relationship
        that gives the information about all the running instances in the
        array.  Changes to the next_instance association prepares the
        configuration for the next instance that is to be launched in the array
        and will therefore not affect any of the currently running instances.`,
		Identifier: "application/vnd.rightscale.server_array",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/server_arrays",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/server_arrays`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/server_arrays/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/server_arrays/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "extended", "full"},
					},
				},
			},
		},
		Links: map[string]string{
			"account":           "Link to the Account where the ServerArray exists",
			"cloud":             "Link to the Cloud where the ServerArray exists",
			"current_instances": "Link to the current Instance of the ServerArray",
			"next_instance":     "Link to the next Instance of the ServerArray",
		},
	},
	"ServerTemplate": &metadata.Resource{
		Name: "ServerTemplate",
		Description: `        ServerTemplates allow you to pre-configure servers by starting from a
        base image and adding scripts that run during the boot, operational,
        and shutdown phases. A ServerTemplate is a description of how a new
        instance will be configured when it is provisioned by your cloud
        provider.
        All revisions of a ServerTemplate belong to a ServerTemplate lineage
        that is exposed by the "lineage" attribute. (NOTE: This attribute is
        merely a string to locate all revisions of a ServerTemplate and NOT a
        working URL)`,
		Identifier: "application/vnd.rightscale.server_template",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/server_templates",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/server_templates`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "embedded"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "embedded"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/server_templates/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/server_templates/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "embedded"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default", "embedded"},
					},
				},
			},
		},
	},
	"SshKey": &metadata.Resource{
		Name:        "SshKey",
		Description: `        Ssh Keys represent a created SSH Key that exists in the cloud.`,
		Identifier:  "application/vnd.rightscale.ssh_key",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/ssh_keys",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/ssh_keys`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/ssh_keys",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/ssh_keys`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/ssh_keys/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/ssh_keys/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/ssh_keys/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/ssh_keys/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
	},
	"Subnet": &metadata.Resource{
		Name: "Subnet",
		Description: `        A Subnet is a logical grouping of network devices. An Instance can have
        many Subnets.`,
		Identifier: "application/vnd.rightscale.subnet",
		Actions: []*metadata.Action{
			&metadata.Action{
				Name:        "index",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/subnets",
						Variables:  []string{},
						Regexp:     regexp.MustCompile(`/api/subnets`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/subnets",
						Variables:  []string{"cloud_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/subnets`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/instances/%s/subnets",
						Variables:  []string{"cloud_id", "instance_id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/instances/([^/]+)/subnets`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},

			&metadata.Action{
				Name:        "show",
				Description: `      Currently not implemented.`,
				PathPatterns: []*metadata.PathPattern{
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/subnets/%s",
						Variables:  []string{"id"},
						Regexp:     regexp.MustCompile(`/api/subnets/([^/]+)`),
					},
					&metadata.PathPattern{
						HTTPMethod: "GET",
						Pattern:    "/api/clouds/%s/subnets/%s",
						Variables:  []string{"cloud_id", "id"},
						Regexp:     regexp.MustCompile(`/api/clouds/([^/]+)/subnets/([^/]+)`),
					},
				},
				CommandFlags: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
				APIParams: []*metadata.ActionParam{
					&metadata.ActionParam{
						Name:        "view",
						Description: `The view to use to render this resource`,
						Type:        "string",
						Location:    metadata.QueryParam,
						Mandatory:   false,
						NonBlank:    false,
						ValidValues: []string{"default"},
					},
				},
			},
		},
		Links: map[string]string{
			"cloud": "Link to the Cloud where the Subnet exists",
		},
	},
}

Consists of a map of resource name to resource metadata.

Functions

func RegisterCommands 

func RegisterCommands(registrar *rsapi.Registrar)

RegisterCommands registers all the commands with the kinpin application.

Types

type API 

type API struct {
	*rsapi.API
}

API 1.6 client Just a vanilla RightScale API client.

func FromCommandLine 

func FromCommandLine(cmdLine *cmd.CommandLine) (*API, error)

FromCommandLine builds a client from the command line.

func New 

func New(host string, auth rsapi.Authenticator) *API

New returns a API 1.6 client. It makes a test request to API 1.5 and returns an error if authentication fails. host may be blank in which case client attempts to resolve it using auth.

func NewRL10 

func NewRL10() (*API, error)

NewRL10 returns a API 1.6 client that uses the information stored in /var/run/rightlink/secret to do auth and configure the host. The client behaves identically to the new returned by New in all other regards.

func (*API) AccountLocator 

func (api *API) AccountLocator(href string) *AccountLocator

AccountLocator builds a locator from the given href.

func (*API) BuildRequest 

func (a *API) BuildRequest(resource, action, href string, params rsapi.APIParams) (*http.Request, error)

BuildRequest builds a HTTP request from a resource name and href and an action name and parameters. It is intended for generic clients that need to consume APIs in a generic maner. The method builds an HTTP request that can be fed to PerformRequest.

func (*API) CloudLocator 

func (api *API) CloudLocator(href string) *CloudLocator

CloudLocator builds a locator from the given href.

func (*API) DatacenterLocator 

func (api *API) DatacenterLocator(href string) *DatacenterLocator

DatacenterLocator builds a locator from the given href.

func (*API) DeploymentLocator 

func (api *API) DeploymentLocator(href string) *DeploymentLocator

DeploymentLocator builds a locator from the given href.

func (*API) ImageLocator 

func (api *API) ImageLocator(href string) *ImageLocator

ImageLocator builds a locator from the given href.

func (*API) InstanceLocator 

func (api *API) InstanceLocator(href string) *InstanceLocator

InstanceLocator builds a locator from the given href.

func (*API) InstanceTypeLocator 

func (api *API) InstanceTypeLocator(href string) *InstanceTypeLocator

InstanceTypeLocator builds a locator from the given href.

func (*API) IpAddressBindingLocator 

func (api *API) IpAddressBindingLocator(href string) *IpAddressBindingLocator

IpAddressBindingLocator builds a locator from the given href.

func (*API) IpAddressLocator 

func (api *API) IpAddressLocator(href string) *IpAddressLocator

IpAddressLocator builds a locator from the given href.

func (*API) MultiCloudImageLocator 

func (api *API) MultiCloudImageLocator(href string) *MultiCloudImageLocator

MultiCloudImageLocator builds a locator from the given href.

func (*API) NetworkInterfaceAttachmentLocator 

func (api *API) NetworkInterfaceAttachmentLocator(href string) *NetworkInterfaceAttachmentLocator

NetworkInterfaceAttachmentLocator builds a locator from the given href.

func (*API) NetworkInterfaceLocator 

func (api *API) NetworkInterfaceLocator(href string) *NetworkInterfaceLocator

NetworkInterfaceLocator builds a locator from the given href.

func (*API) NetworkLocator 

func (api *API) NetworkLocator(href string) *NetworkLocator

NetworkLocator builds a locator from the given href.

func (*API) RunCommand 

func (a *API) RunCommand(cmd string) (*http.Response, error)

RunCommand parses and runs the command with the given name.

func (*API) SecurityGroupLocator 

func (api *API) SecurityGroupLocator(href string) *SecurityGroupLocator

SecurityGroupLocator builds a locator from the given href.

func (*API) ServerArrayLocator 

func (api *API) ServerArrayLocator(href string) *ServerArrayLocator

ServerArrayLocator builds a locator from the given href.

func (*API) ServerLocator 

func (api *API) ServerLocator(href string) *ServerLocator

ServerLocator builds a locator from the given href.

func (*API) ServerTemplateLocator 

func (api *API) ServerTemplateLocator(href string) *ServerTemplateLocator

ServerTemplateLocator builds a locator from the given href.

func (*API) ShowAPIActions 

func (a *API) ShowAPIActions(cmd string) error

ShowAPIActions displays the command hrefs.

func (*API) ShowCommandHelp 

func (a *API) ShowCommandHelp(cmd string) error

ShowCommandHelp displays help for the given command.

func (*API) SshKeyLocator 

func (api *API) SshKeyLocator(href string) *SshKeyLocator

SshKeyLocator builds a locator from the given href.

func (*API) SubnetLocator 

func (api *API) SubnetLocator(href string) *SubnetLocator

SubnetLocator builds a locator from the given href.

type Account 

type Account struct {
	Href string `json:"href,omitempty"`
	Id   int    `json:"id,omitempty"`
	Kind string `json:"kind,omitempty"`
	Name string `json:"name,omitempty"`
}

Resources in RightScale generally belong to accounts. Users can have any number of accounts, but when performing an action, a user is operating under a particular account.

func (*Account) Locator 

func (r *Account) Locator(api *API) *AccountLocator

Locator returns a locator for the given resource

type AccountLocator 

type AccountLocator struct {
	Href
	// contains filtered or unexported fields
}

AccountLocator exposes the Account resource actions.

func (*AccountLocator) Index 

func (loc *AccountLocator) Index(options rsapi.APIParams) error

GET /api/accounts

Currently not implemented.

func (*AccountLocator) Show 

func (loc *AccountLocator) Show(options rsapi.APIParams) error

GET /api/accounts/:id

Currently not implemented.

type AccountParam 

type AccountParam struct {
	Href string `json:"href,omitempty"`
	Id   int    `json:"id,omitempty"`
	Kind string `json:"kind,omitempty"`
	Name string `json:"name,omitempty"`
}

type Cloud 

type Cloud struct {
	CloudType   string `json:"cloud_type,omitempty"`
	Description string `json:"description,omitempty"`
	Href        string `json:"href,omitempty"`
	Id          int    `json:"id,omitempty"`
	Kind        string `json:"kind,omitempty"`
	Name        string `json:"name,omitempty"`
}

Clouds provide remote resources for things like storage and compute. You must have registered a cloud within your account in order to use it.

func (*Cloud) Locator 

func (r *Cloud) Locator(api *API) *CloudLocator

Locator returns a locator for the given resource

type CloudLocator 

type CloudLocator struct {
	Href
	// contains filtered or unexported fields
}

CloudLocator exposes the Cloud resource actions.

func (*CloudLocator) Index 

func (loc *CloudLocator) Index(options rsapi.APIParams) error

GET /api/clouds

Currently not implemented.

func (*CloudLocator) Show 

func (loc *CloudLocator) Show(options rsapi.APIParams) error

GET /api/clouds/:id

Currently not implemented.

type CloudParam 

type CloudParam struct {
	CloudType   string `json:"cloud_type,omitempty"`
	Description string `json:"description,omitempty"`
	Href        string `json:"href,omitempty"`
	Id          int    `json:"id,omitempty"`
	Kind        string `json:"kind,omitempty"`
	Name        string `json:"name,omitempty"`
}

type Datacenter 

type Datacenter struct {
	Description string           `json:"description,omitempty"`
	Href        string           `json:"href,omitempty"`
	Id          string           `json:"id,omitempty"`
	Kind        string           `json:"kind,omitempty"`
	LegacyId    int              `json:"legacy_id,omitempty"`
	Links       *DatacenterLinks `json:"links,omitempty"`
	Name        string           `json:"name,omitempty"`
}

Datacenters are cloud resources that give you the ability to place resources in isolated locations. A carefully designed system placed in multiple datacenters can provide fault tolerance when one datacenter has a problem.

func (*Datacenter) Locator 

func (r *Datacenter) Locator(api *API) *DatacenterLocator

Locator returns a locator for the given resource 

type DatacenterLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type DatacenterLocator 

type DatacenterLocator struct {
	Href
	// contains filtered or unexported fields
}

DatacenterLocator exposes the Datacenter resource actions.

func (*DatacenterLocator) Index 

func (loc *DatacenterLocator) Index(options rsapi.APIParams) error

GET /api/datacenters GET /api/clouds/:cloud_id/datacenters

Currently not implemented.

func (*DatacenterLocator) Show 

func (loc *DatacenterLocator) Show(options rsapi.APIParams) error

GET /api/datacenters/:id GET /api/clouds/:cloud_id/datacenters/:id

Currently not implemented.

type DatacenterParam 

type DatacenterParam struct {
	Description string           `json:"description,omitempty"`
	Href        string           `json:"href,omitempty"`
	Id          string           `json:"id,omitempty"`
	Kind        string           `json:"kind,omitempty"`
	LegacyId    int              `json:"legacy_id,omitempty"`
	Links       *DatacenterLinks `json:"links,omitempty"`
	Name        string           `json:"name,omitempty"`
}

type Deployment 

type Deployment struct {
	Description  string           `json:"description,omitempty"`
	Href         string           `json:"href,omitempty"`
	Id           int              `json:"id,omitempty"`
	Instances    []*Instance      `json:"instances,omitempty"`
	Kind         string           `json:"kind,omitempty"`
	Links        *DeploymentLinks `json:"links,omitempty"`
	Locked       bool             `json:"locked,omitempty"`
	Name         string           `json:"name,omitempty"`
	ServerArrays []*ServerArray   `json:"server_arrays,omitempty"`
	Servers      []*Server        `json:"servers,omitempty"`
	Tags         []string         `json:"tags,omitempty"`
}

Deployments provide a way to group resources that logically belong together.

func (*Deployment) Locator 

func (r *Deployment) Locator(api *API) *DeploymentLocator

Locator returns a locator for the given resource 

type DeploymentLinks struct {
	Account *AccountParam `json:"account,omitempty"`
}

type DeploymentLocator 

type DeploymentLocator struct {
	Href
	// contains filtered or unexported fields
}

DeploymentLocator exposes the Deployment resource actions.

func (*DeploymentLocator) Index 

func (loc *DeploymentLocator) Index(options rsapi.APIParams) ([]*Deployment, error)

GET /api/deployments

List all Deployments in an Account.

func (*DeploymentLocator) Show 

func (loc *DeploymentLocator) Show(options rsapi.APIParams) (*Deployment, error)

GET /api/deployments/:id

Show a single Deployment

type DeploymentParam 

type DeploymentParam struct {
	Description  string              `json:"description,omitempty"`
	Href         string              `json:"href,omitempty"`
	Id           int                 `json:"id,omitempty"`
	Instances    []*InstanceParam    `json:"instances,omitempty"`
	Kind         string              `json:"kind,omitempty"`
	Links        *DeploymentLinks    `json:"links,omitempty"`
	Locked       bool                `json:"locked,omitempty"`
	Name         string              `json:"name,omitempty"`
	ServerArrays []*ServerArrayParam `json:"server_arrays,omitempty"`
	Servers      []*ServerParam      `json:"servers,omitempty"`
	Tags         []string            `json:"tags,omitempty"`
}

type Href 

type Href string

An Href contains the relative path to a resource or resource collection, e.g. "/api/servers/123" or "/api/servers".

func (*Href) ActionPath 

func (r *Href) ActionPath(rName, aName string) (*metadata.ActionPath, error)

ActionPath computes the path to the given resource action. For example given the href "/api/servers/123" calling ActionPath with resource "servers" and action "clone" returns the path "/api/servers/123/clone" and verb POST. The algorithm consists of extracting the variables from the href by looking up a matching pattern from the resource metadata. The variables are then substituted in the action path. If there are more than one pattern that match the href then the algorithm picks the one that can substitute the most variables.

type Image 

type Image struct {
	CpuArchitecture    string      `json:"cpu_architecture,omitempty"`
	Description        string      `json:"description,omitempty"`
	Href               string      `json:"href,omitempty"`
	Id                 string      `json:"id,omitempty"`
	ImageType          string      `json:"image_type,omitempty"`
	InheritedSource    string      `json:"inherited_source,omitempty"`
	Kind               string      `json:"kind,omitempty"`
	LegacyId           int         `json:"legacy_id,omitempty"`
	Links              *ImageLinks `json:"links,omitempty"`
	Name               string      `json:"name,omitempty"`
	OsPlatform         string      `json:"os_platform,omitempty"`
	ResourceUid        string      `json:"resource_uid,omitempty"`
	RootDeviceStorage  string      `json:"root_device_storage,omitempty"`
	VirtualizationType string      `json:"virtualization_type,omitempty"`
	Visibility         string      `json:"visibility,omitempty"`
}

Images define the initial Operating System and root disk contents for new instances.

func (*Image) Locator 

func (r *Image) Locator(api *API) *ImageLocator

Locator returns a locator for the given resource 

type ImageLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type ImageLocator 

type ImageLocator struct {
	Href
	// contains filtered or unexported fields
}

ImageLocator exposes the Image resource actions.

func (*ImageLocator) Index 

func (loc *ImageLocator) Index(options rsapi.APIParams) ([]*Image, error)

GET /api/clouds/:cloud_id/images

Lists all Images for the given Cloud.

func (*ImageLocator) Show 

func (loc *ImageLocator) Show(options rsapi.APIParams) error

GET /api/images/:id GET /api/clouds/:cloud_id/images/:id

Currently not implemented.

type ImageParam 

type ImageParam struct {
	CpuArchitecture    string      `json:"cpu_architecture,omitempty"`
	Description        string      `json:"description,omitempty"`
	Href               string      `json:"href,omitempty"`
	Id                 string      `json:"id,omitempty"`
	ImageType          string      `json:"image_type,omitempty"`
	InheritedSource    string      `json:"inherited_source,omitempty"`
	Kind               string      `json:"kind,omitempty"`
	LegacyId           int         `json:"legacy_id,omitempty"`
	Links              *ImageLinks `json:"links,omitempty"`
	Name               string      `json:"name,omitempty"`
	OsPlatform         string      `json:"os_platform,omitempty"`
	ResourceUid        string      `json:"resource_uid,omitempty"`
	RootDeviceStorage  string      `json:"root_device_storage,omitempty"`
	VirtualizationType string      `json:"virtualization_type,omitempty"`
	Visibility         string      `json:"visibility,omitempty"`
}

type Incarnator 

type Incarnator struct {
	Href  string `json:"href,omitempty"`
	Id    int    `json:"id,omitempty"`
	Kind  string `json:"kind,omitempty"`
	Name  string `json:"name,omitempty"`
	State string `json:"state,omitempty"`
}

type Instance 

type Instance struct {
	Actions            []string                 `json:"actions,omitempty"`
	Description        string                   `json:"description,omitempty"`
	Href               string                   `json:"href,omitempty"`
	Id                 string                   `json:"id,omitempty"`
	IpAddresses        []*IpAddress             `json:"ip_addresses,omitempty"`
	IsNext             bool                     `json:"is_next,omitempty"`
	Kind               string                   `json:"kind,omitempty"`
	LegacyId           int                      `json:"legacy_id,omitempty"`
	Links              *InstanceLinks           `json:"links,omitempty"`
	Locked             bool                     `json:"locked,omitempty"`
	MonitoringId       string                   `json:"monitoring_id,omitempty"`
	MonitoringServer   string                   `json:"monitoring_server,omitempty"`
	MonitoringToken    string                   `json:"monitoring_token,omitempty"`
	Name               string                   `json:"name,omitempty"`
	Networks           []*Network               `json:"networks,omitempty"`
	OsPlatform         string                   `json:"os_platform,omitempty"`
	PrivateDnsNames    []string                 `json:"private_dns_names,omitempty"`
	PrivateIpAddresses []string                 `json:"private_ip_addresses,omitempty"`
	PublicDnsNames     []string                 `json:"public_dns_names,omitempty"`
	PublicIpAddresses  []string                 `json:"public_ip_addresses,omitempty"`
	ResourceUid        string                   `json:"resource_uid,omitempty"`
	SecurityGroups     *SecurityGroupCollection `json:"security_groups,omitempty"`
	ServerTemplate     *ServerTemplate          `json:"server_template,omitempty"`
	SshHost            string                   `json:"ssh_host,omitempty"`
	State              string                   `json:"state,omitempty"`
	Subnets            *SubnetCollection        `json:"subnets,omitempty"`
	Tags               []string                 `json:"tags,omitempty"`
	Timestamps         *TimestampsStruct        `json:"timestamps,omitempty"`
}

Instances represent an entity that is runnable in the cloud. An instance of type "next" is a container of information that expresses how to configure a future instance when we decide to launch or start it. A "next" instance generally only exists in the RightScale realm, and usually doesn't have any corresponding representation existing in the cloud. However, if an instance is not of type "next", it will generally represent an existing running (or provisioned) virtual machine existing in the cloud.

func (*Instance) Locator 

func (r *Instance) Locator(api *API) *InstanceLocator

Locator returns a locator for the given resource 

type InstanceLinks struct {
	Account                 *AccountParam            `json:"account,omitempty"`
	Cloud                   *CloudParam              `json:"cloud,omitempty"`
	ComputedImage           *ImageParam              `json:"computed_image,omitempty"`
	ComputedMultiCloudImage *MultiCloudImageParam    `json:"computed_multi_cloud_image,omitempty"`
	Datacenter              *DatacenterParam         `json:"datacenter,omitempty"`
	Deployment              *DeploymentParam         `json:"deployment,omitempty"`
	Image                   *ImageParam              `json:"image,omitempty"`
	Incarnator              *Incarnator              `json:"incarnator,omitempty"`
	InstanceType            *InstanceTypeParam       `json:"instance_type,omitempty"`
	MultiCloudImage         *MultiCloudImageParam    `json:"multi_cloud_image,omitempty"`
	SecurityGroups          *SecurityGroupCollection `json:"security_groups,omitempty"`
	SshKey                  *SshKeyParam             `json:"ssh_key,omitempty"`
	Subnets                 *SubnetCollection        `json:"subnets,omitempty"`
}

type InstanceLocator 

type InstanceLocator struct {
	Href
	// contains filtered or unexported fields
}

InstanceLocator exposes the Instance resource actions.

func (*InstanceLocator) Index 

func (loc *InstanceLocator) Index(options rsapi.APIParams) ([]*Instance, error)

GET /api/instances GET /api/clouds/:cloud_id/instances

List all Instances in an account.

func (*InstanceLocator) Show 

func (loc *InstanceLocator) Show(options rsapi.APIParams) error

GET /api/instances/:id GET /api/clouds/:cloud_id/instances/:id

Currently not implemented.

type InstanceParam 

type InstanceParam struct {
	Actions            []string                   `json:"actions,omitempty"`
	Description        string                     `json:"description,omitempty"`
	Href               string                     `json:"href,omitempty"`
	Id                 string                     `json:"id,omitempty"`
	IpAddresses        []*IpAddressParam          `json:"ip_addresses,omitempty"`
	IsNext             bool                       `json:"is_next,omitempty"`
	Kind               string                     `json:"kind,omitempty"`
	LegacyId           int                        `json:"legacy_id,omitempty"`
	Links              *InstanceLinks             `json:"links,omitempty"`
	Locked             bool                       `json:"locked,omitempty"`
	MonitoringId       string                     `json:"monitoring_id,omitempty"`
	MonitoringServer   string                     `json:"monitoring_server,omitempty"`
	MonitoringToken    string                     `json:"monitoring_token,omitempty"`
	Name               string                     `json:"name,omitempty"`
	Networks           []*NetworkParam            `json:"networks,omitempty"`
	OsPlatform         string                     `json:"os_platform,omitempty"`
	PrivateDnsNames    []string                   `json:"private_dns_names,omitempty"`
	PrivateIpAddresses []string                   `json:"private_ip_addresses,omitempty"`
	PublicDnsNames     []string                   `json:"public_dns_names,omitempty"`
	PublicIpAddresses  []string                   `json:"public_ip_addresses,omitempty"`
	ResourceUid        string                     `json:"resource_uid,omitempty"`
	SecurityGroups     *SecurityGroupCollection   `json:"security_groups,omitempty"`
	ServerTemplate     *ServerTemplateParam       `json:"server_template,omitempty"`
	SshHost            string                     `json:"ssh_host,omitempty"`
	State              string                     `json:"state,omitempty"`
	Subnets            *SubnetCollection          `json:"subnets,omitempty"`
	Tags               []string                   `json:"tags,omitempty"`
	Timestamps         *InstancesTimestampsStruct `json:"timestamps,omitempty"`
}

type InstanceSummaryStruct 

type InstanceSummaryStruct struct {
	HealthyCount       int `json:"healthy_count,omitempty"`
	NotTerminatedCount int `json:"not_terminated_count,omitempty"`
	TotalCount         int `json:"total_count,omitempty"`
	UnhealthyCount     int `json:"unhealthy_count,omitempty"`
}

type InstanceType 

type InstanceType struct {
	CpuCount    int                `json:"cpu_count,omitempty"`
	CpuSpeed    string             `json:"cpu_speed,omitempty"`
	Description string             `json:"description,omitempty"`
	Href        string             `json:"href,omitempty"`
	Id          string             `json:"id,omitempty"`
	Kind        string             `json:"kind,omitempty"`
	LegacyId    int                `json:"legacy_id,omitempty"`
	Links       *InstanceTypeLinks `json:"links,omitempty"`
	Memory      string             `json:"memory,omitempty"`
	Name        string             `json:"name,omitempty"`
}

An InstanceType represents a basic hardware configuration for an Instance. Combining all possible configurations of hardware into a smaller, well-known set of options makes instances easier to manage, and allows better allocation efficiency into physical hosts.

func (*InstanceType) Locator 

func (r *InstanceType) Locator(api *API) *InstanceTypeLocator

Locator returns a locator for the given resource 

type InstanceTypeLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type InstanceTypeLocator 

type InstanceTypeLocator struct {
	Href
	// contains filtered or unexported fields
}

InstanceTypeLocator exposes the InstanceType resource actions.

func (*InstanceTypeLocator) Index 

func (loc *InstanceTypeLocator) Index(options rsapi.APIParams) error

GET /api/instance_types GET /api/clouds/:cloud_id/instance_types

Currently not implemented.

func (*InstanceTypeLocator) Show 

func (loc *InstanceTypeLocator) Show(options rsapi.APIParams) error

GET /api/instance_types/:id GET /api/clouds/:cloud_id/instance_types/:id

Currently not implemented.

type InstanceTypeParam 

type InstanceTypeParam struct {
	CpuCount    int                `json:"cpu_count,omitempty"`
	CpuSpeed    string             `json:"cpu_speed,omitempty"`
	Description string             `json:"description,omitempty"`
	Href        string             `json:"href,omitempty"`
	Id          string             `json:"id,omitempty"`
	Kind        string             `json:"kind,omitempty"`
	LegacyId    int                `json:"legacy_id,omitempty"`
	Links       *InstanceTypeLinks `json:"links,omitempty"`
	Memory      string             `json:"memory,omitempty"`
	Name        string             `json:"name,omitempty"`
}

type InstancesLinksDeploymentServerArraysInstanceSummaryStruct 

type InstancesLinksDeploymentServerArraysInstanceSummaryStruct struct {
	HealthyCount       int `json:"healthy_count,omitempty"`
	NotTerminatedCount int `json:"not_terminated_count,omitempty"`
	TotalCount         int `json:"total_count,omitempty"`
	UnhealthyCount     int `json:"unhealthy_count,omitempty"`
}

type InstancesTimestampsStruct 

type InstancesTimestampsStruct struct {
	BootedAt      *time.Time `json:"booted_at,omitempty"`
	CreatedAt     *time.Time `json:"created_at,omitempty"`
	OperationalAt *time.Time `json:"operational_at,omitempty"`
	PendingAt     *time.Time `json:"pending_at,omitempty"`
	StrandedAt    *time.Time `json:"stranded_at,omitempty"`
	TerminatedAt  *time.Time `json:"terminated_at,omitempty"`
	UpdatedAt     *time.Time `json:"updated_at,omitempty"`
}

type IpAddress 

type IpAddress struct {
	Address  string          `json:"address,omitempty"`
	Href     string          `json:"href,omitempty"`
	Id       string          `json:"id,omitempty"`
	Kind     string          `json:"kind,omitempty"`
	LegacyId int             `json:"legacy_id,omitempty"`
	Links    *IpAddressLinks `json:"links,omitempty"`
	Name     string          `json:"name,omitempty"`
}

An IpAddress provides an abstraction for IPv4 addresses bindable to Instance resources running in a Cloud.

func (*IpAddress) Locator 

func (r *IpAddress) Locator(api *API) *IpAddressLocator

Locator returns a locator for the given resource

type IpAddressBinding 

type IpAddressBinding struct {
	Href        string                 `json:"href,omitempty"`
	Id          string                 `json:"id,omitempty"`
	Kind        string                 `json:"kind,omitempty"`
	LegacyId    int                    `json:"legacy_id,omitempty"`
	Links       *IpAddressBindingLinks `json:"links,omitempty"`
	PrivatePort int                    `json:"private_port,omitempty"`
	Protocol    string                 `json:"protocol,omitempty"`
	PublicPort  int                    `json:"public_port,omitempty"`
}

An IpAddressBinding represents an abstraction for binding an IpAddress to an instance. The IpAddress is bound immediately for a current instance, or on launch for a next instance.

func (*IpAddressBinding) Locator 

func (r *IpAddressBinding) Locator(api *API) *IpAddressBindingLocator

Locator returns a locator for the given resource 

type IpAddressBindingLinks struct {
	Cloud     *CloudParam     `json:"cloud,omitempty"`
	Instance  *InstanceParam  `json:"instance,omitempty"`
	IpAddress *IpAddressParam `json:"ip_address,omitempty"`
}

type IpAddressBindingLocator 

type IpAddressBindingLocator struct {
	Href
	// contains filtered or unexported fields
}

IpAddressBindingLocator exposes the IpAddressBinding resource actions.

func (*IpAddressBindingLocator) Index 

func (loc *IpAddressBindingLocator) Index(options rsapi.APIParams) error

GET /api/ip_address_bindings GET /api/clouds/:cloud_id/ip_address_bindings

Currently not implemented.

func (*IpAddressBindingLocator) Show 

func (loc *IpAddressBindingLocator) Show(options rsapi.APIParams) error

GET /api/ip_address_bindings/:id GET /api/clouds/:cloud_id/ip_address_bindings/:id

Currently not implemented. 

type IpAddressLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type IpAddressLocator 

type IpAddressLocator struct {
	Href
	// contains filtered or unexported fields
}

IpAddressLocator exposes the IpAddress resource actions.

func (*IpAddressLocator) Index 

func (loc *IpAddressLocator) Index(options rsapi.APIParams) error

GET /api/ip_addresses GET /api/clouds/:cloud_id/ip_addresses

Currently not implemented.

func (*IpAddressLocator) Show 

func (loc *IpAddressLocator) Show(options rsapi.APIParams) error

GET /api/ip_addresses/:id GET /api/clouds/:cloud_id/ip_addresses/:id

Currently not implemented.

type IpAddressParam 

type IpAddressParam struct {
	Address  string          `json:"address,omitempty"`
	Href     string          `json:"href,omitempty"`
	Id       string          `json:"id,omitempty"`
	Kind     string          `json:"kind,omitempty"`
	LegacyId int             `json:"legacy_id,omitempty"`
	Links    *IpAddressLinks `json:"links,omitempty"`
	Name     string          `json:"name,omitempty"`
}

type MultiCloudImage 

type MultiCloudImage struct {
	Description     string `json:"description,omitempty"`
	Href            string `json:"href,omitempty"`
	Id              int    `json:"id,omitempty"`
	InheritedSource string `json:"inherited_source,omitempty"`
	Kind            string `json:"kind,omitempty"`
	Name            string `json:"name,omitempty"`
	Version         int    `json:"version,omitempty"`
}

A MultiCloudImage is a RightScale component that functions as a pointer to machine images in specific clouds (e.g. AWS US-East, Rackspace). Each ServerTemplate can reference many MultiCloudImages that define which image should be used when a server is launched in a particular cloud.

func (*MultiCloudImage) Locator 

func (r *MultiCloudImage) Locator(api *API) *MultiCloudImageLocator

Locator returns a locator for the given resource

type MultiCloudImageLocator 

type MultiCloudImageLocator struct {
	Href
	// contains filtered or unexported fields
}

MultiCloudImageLocator exposes the MultiCloudImage resource actions.

func (*MultiCloudImageLocator) Index 

func (loc *MultiCloudImageLocator) Index(options rsapi.APIParams) error

GET /api/multi_cloud_images

Currently not implemented.

func (*MultiCloudImageLocator) Show 

func (loc *MultiCloudImageLocator) Show(options rsapi.APIParams) error

GET /api/multi_cloud_images/:id

Currently not implemented.

type MultiCloudImageParam 

type MultiCloudImageParam struct {
	Description     string `json:"description,omitempty"`
	Href            string `json:"href,omitempty"`
	Id              int    `json:"id,omitempty"`
	InheritedSource string `json:"inherited_source,omitempty"`
	Kind            string `json:"kind,omitempty"`
	Name            string `json:"name,omitempty"`
	Version         int    `json:"version,omitempty"`
}

type Network 

type Network struct {
	Description string        `json:"description,omitempty"`
	Href        string        `json:"href,omitempty"`
	Id          string        `json:"id,omitempty"`
	Kind        string        `json:"kind,omitempty"`
	LegacyId    int           `json:"legacy_id,omitempty"`
	Links       *NetworkLinks `json:"links,omitempty"`
	Name        string        `json:"name,omitempty"`
}

A Network is a logical grouping of network devices.

func (*Network) Locator 

func (r *Network) Locator(api *API) *NetworkLocator

Locator returns a locator for the given resource

type NetworkInterface 

type NetworkInterface struct {
	Description string                 `json:"description,omitempty"`
	Href        string                 `json:"href,omitempty"`
	Id          string                 `json:"id,omitempty"`
	Kind        string                 `json:"kind,omitempty"`
	Links       *NetworkInterfaceLinks `json:"links,omitempty"`
}

Just like their physical counterparts, NetworkInterfaces join other resources to a network.

func (*NetworkInterface) Locator 

func (r *NetworkInterface) Locator(api *API) *NetworkInterfaceLocator

Locator returns a locator for the given resource

type NetworkInterfaceAttachment 

type NetworkInterfaceAttachment struct {
	Href  string                           `json:"href,omitempty"`
	Id    string                           `json:"id,omitempty"`
	Kind  string                           `json:"kind,omitempty"`
	Links *NetworkInterfaceAttachmentLinks `json:"links,omitempty"`
}

NetworkInterfaceAttachments represent an attachment between a NetworkInterface and another resource.

func (*NetworkInterfaceAttachment) Locator 

func (r *NetworkInterfaceAttachment) Locator(api *API) *NetworkInterfaceAttachmentLocator

Locator returns a locator for the given resource 

type NetworkInterfaceAttachmentLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type NetworkInterfaceAttachmentLocator 

type NetworkInterfaceAttachmentLocator struct {
	Href
	// contains filtered or unexported fields
}

NetworkInterfaceAttachmentLocator exposes the NetworkInterfaceAttachment resource actions.

func (*NetworkInterfaceAttachmentLocator) Index 

func (loc *NetworkInterfaceAttachmentLocator) Index(options rsapi.APIParams) error

GET /api/network_interface_attachments

Currently not implemented.

func (*NetworkInterfaceAttachmentLocator) Show 

func (loc *NetworkInterfaceAttachmentLocator) Show(options rsapi.APIParams) error

GET /api/network_interface_attachments/:id

Currently not implemented. 

type NetworkInterfaceLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type NetworkInterfaceLocator 

type NetworkInterfaceLocator struct {
	Href
	// contains filtered or unexported fields
}

NetworkInterfaceLocator exposes the NetworkInterface resource actions.

func (*NetworkInterfaceLocator) Index 

func (loc *NetworkInterfaceLocator) Index(options rsapi.APIParams) error

GET /api/network_interfaces

Currently not implemented.

func (*NetworkInterfaceLocator) Show 

func (loc *NetworkInterfaceLocator) Show(options rsapi.APIParams) error

GET /api/network_interfaces/:id

Currently not implemented. 

type NetworkLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type NetworkLocator 

type NetworkLocator struct {
	Href
	// contains filtered or unexported fields
}

NetworkLocator exposes the Network resource actions.

func (*NetworkLocator) Index 

func (loc *NetworkLocator) Index(options rsapi.APIParams) error

GET /api/networks

Currently not implemented.

func (*NetworkLocator) Show 

func (loc *NetworkLocator) Show(options rsapi.APIParams) error

GET /api/networks/:id

Currently not implemented.

type NetworkParam 

type NetworkParam struct {
	Description string        `json:"description,omitempty"`
	Href        string        `json:"href,omitempty"`
	Id          string        `json:"id,omitempty"`
	Kind        string        `json:"kind,omitempty"`
	LegacyId    int           `json:"legacy_id,omitempty"`
	Links       *NetworkLinks `json:"links,omitempty"`
	Name        string        `json:"name,omitempty"`
}

type SecurityGroup 

type SecurityGroup struct {
	Description string              `json:"description,omitempty"`
	Href        string              `json:"href,omitempty"`
	Id          string              `json:"id,omitempty"`
	Kind        string              `json:"kind,omitempty"`
	LegacyId    int                 `json:"legacy_id,omitempty"`
	Links       *SecurityGroupLinks `json:"links,omitempty"`
	Name        string              `json:"name,omitempty"`
}

Security Groups represent network security profiles that contain lists of firewall rules for different ports and source IP addresses, as well as trust relationships between security groups.

func (*SecurityGroup) Locator 

func (r *SecurityGroup) Locator(api *API) *SecurityGroupLocator

Locator returns a locator for the given resource

type SecurityGroupCollection 

type SecurityGroupCollection struct {
	Count int    `json:"count,omitempty"`
	Href  string `json:"href,omitempty"`
}
type SecurityGroupLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type SecurityGroupLocator 

type SecurityGroupLocator struct {
	Href
	// contains filtered or unexported fields
}

SecurityGroupLocator exposes the SecurityGroup resource actions.

func (*SecurityGroupLocator) Index 

func (loc *SecurityGroupLocator) Index(options rsapi.APIParams) error

GET /api/security_groups GET /api/clouds/:cloud_id/security_groups GET /api/clouds/:cloud_id/instances/:instance_id/security_groups

Currently not implemented.

func (*SecurityGroupLocator) Show 

func (loc *SecurityGroupLocator) Show(options rsapi.APIParams) error

GET /api/security_groups/:id GET /api/clouds/:cloud_id/security_groups/:id

Currently not implemented.

type Server 

type Server struct {
	Actions         []string     `json:"actions,omitempty"`
	CurrentInstance *Instance    `json:"current_instance,omitempty"`
	Description     string       `json:"description,omitempty"`
	Href            string       `json:"href,omitempty"`
	Id              int          `json:"id,omitempty"`
	Instance        *Instance    `json:"instance,omitempty"`
	Kind            string       `json:"kind,omitempty"`
	Links           *ServerLinks `json:"links,omitempty"`
	Name            string       `json:"name,omitempty"`
	NextInstance    *Instance    `json:"next_instance,omitempty"`
	Tags            []string     `json:"tags,omitempty"`
}

Servers represent the notion of a server/machine from RightScale's perspective. A Server, does not always have a corresponding VM running or provisioned in a cloud. Some clouds use the word "servers" to refer to created VMs. These allocated VMs are not called Servers in the RightScale API, they are called Instances. A Server always has a next_instance association, which will define the configuration to apply to a new instance when the server is launched or started (starting servers is not yet supported through this API). Once a Server is launched/started, a current_instance relationship will exist. Accessing the current_instance of a server results in immediate runtime modification of this running server. Changes to the next_instance association prepares the configuration for the next instance launch/start (therefore they have no effect until such operation is performed).

func (*Server) Locator 

func (r *Server) Locator(api *API) *ServerLocator

Locator returns a locator for the given resource

type ServerArray 

type ServerArray struct {
	Actions         []string               `json:"actions,omitempty"`
	Description     string                 `json:"description,omitempty"`
	Href            string                 `json:"href,omitempty"`
	Id              int                    `json:"id,omitempty"`
	InstanceSummary *InstanceSummaryStruct `json:"instance_summary,omitempty"`
	Kind            string                 `json:"kind,omitempty"`
	Links           *ServerArrayLinks      `json:"links,omitempty"`
	Name            string                 `json:"name,omitempty"`
	NextInstance    *Instance              `json:"next_instance,omitempty"`
	State           string                 `json:"state,omitempty"`
	Tags            []string               `json:"tags,omitempty"`
}

A server array represents a logical group of instances and allows to resize(grow/shrink) that group based on certain elasticity parameters. A server array just like a server always has a next_instance association, which will define the configuration to apply when a new instance is launched. But unlike a server which has a current_instance relationship, the server array has a current_instances relationship that gives the information about all the running instances in the array. Changes to the next_instance association prepares the configuration for the next instance that is to be launched in the array and will therefore not affect any of the currently running instances.

func (*ServerArray) Locator 

func (r *ServerArray) Locator(api *API) *ServerArrayLocator

Locator returns a locator for the given resource 

type ServerArrayLinks struct {
	Account          *AccountParam    `json:"account,omitempty"`
	Cloud            *CloudParam      `json:"cloud,omitempty"`
	CurrentInstances []*InstanceParam `json:"current_instances,omitempty"`
	NextInstance     *InstanceParam   `json:"next_instance,omitempty"`
}

type ServerArrayLocator 

type ServerArrayLocator struct {
	Href
	// contains filtered or unexported fields
}

ServerArrayLocator exposes the ServerArray resource actions.

func (*ServerArrayLocator) Index 

func (loc *ServerArrayLocator) Index(options rsapi.APIParams) error

GET /api/server_arrays

Currently not implemented.

func (*ServerArrayLocator) Show 

func (loc *ServerArrayLocator) Show(options rsapi.APIParams) error

GET /api/server_arrays/:id

Currently not implemented.

type ServerArrayParam 

type ServerArrayParam struct {
	Actions         []string                                                   `json:"actions,omitempty"`
	Description     string                                                     `json:"description,omitempty"`
	Href            string                                                     `json:"href,omitempty"`
	Id              int                                                        `json:"id,omitempty"`
	InstanceSummary *InstancesLinksDeploymentServerArraysInstanceSummaryStruct `json:"instance_summary,omitempty"`
	Kind            string                                                     `json:"kind,omitempty"`
	Links           *ServerArrayLinks                                          `json:"links,omitempty"`
	Name            string                                                     `json:"name,omitempty"`
	NextInstance    *InstanceParam                                             `json:"next_instance,omitempty"`
	State           string                                                     `json:"state,omitempty"`
	Tags            []string                                                   `json:"tags,omitempty"`
}
type ServerLinks struct {
	Account         *AccountParam  `json:"account,omitempty"`
	Cloud           *CloudParam    `json:"cloud,omitempty"`
	CurrentInstance *InstanceParam `json:"current_instance,omitempty"`
	NextInstance    *InstanceParam `json:"next_instance,omitempty"`
}

type ServerLocator 

type ServerLocator struct {
	Href
	// contains filtered or unexported fields
}

ServerLocator exposes the Server resource actions.

func (*ServerLocator) Index 

func (loc *ServerLocator) Index(options rsapi.APIParams) error

GET /api/servers

Currently not implemented.

func (*ServerLocator) Show 

func (loc *ServerLocator) Show(options rsapi.APIParams) error

GET /api/servers/:id

Currently not implemented.

type ServerParam 

type ServerParam struct {
	Actions         []string       `json:"actions,omitempty"`
	CurrentInstance *InstanceParam `json:"current_instance,omitempty"`
	Description     string         `json:"description,omitempty"`
	Href            string         `json:"href,omitempty"`
	Id              int            `json:"id,omitempty"`
	Instance        *InstanceParam `json:"instance,omitempty"`
	Kind            string         `json:"kind,omitempty"`
	Links           *ServerLinks   `json:"links,omitempty"`
	Name            string         `json:"name,omitempty"`
	NextInstance    *InstanceParam `json:"next_instance,omitempty"`
	Tags            []string       `json:"tags,omitempty"`
}

type ServerTemplate 

type ServerTemplate struct {
	Description string `json:"description,omitempty"`
	Href        string `json:"href,omitempty"`
	Id          int    `json:"id,omitempty"`
	Kind        string `json:"kind,omitempty"`
	Name        string `json:"name,omitempty"`
	Version     int    `json:"version,omitempty"`
}

ServerTemplates allow you to pre-configure servers by starting from a base image and adding scripts that run during the boot, operational, and shutdown phases. A ServerTemplate is a description of how a new instance will be configured when it is provisioned by your cloud provider. All revisions of a ServerTemplate belong to a ServerTemplate lineage that is exposed by the "lineage" attribute. (NOTE: This attribute is merely a string to locate all revisions of a ServerTemplate and NOT a working URL)

func (*ServerTemplate) Locator 

func (r *ServerTemplate) Locator(api *API) *ServerTemplateLocator

Locator returns a locator for the given resource

type ServerTemplateLocator 

type ServerTemplateLocator struct {
	Href
	// contains filtered or unexported fields
}

ServerTemplateLocator exposes the ServerTemplate resource actions.

func (*ServerTemplateLocator) Index 

func (loc *ServerTemplateLocator) Index(options rsapi.APIParams) error

GET /api/server_templates

Currently not implemented.

func (*ServerTemplateLocator) Show 

func (loc *ServerTemplateLocator) Show(options rsapi.APIParams) error

GET /api/server_templates/:id

Currently not implemented.

type ServerTemplateParam 

type ServerTemplateParam struct {
	Description string `json:"description,omitempty"`
	Href        string `json:"href,omitempty"`
	Id          int    `json:"id,omitempty"`
	Kind        string `json:"kind,omitempty"`
	Name        string `json:"name,omitempty"`
	Version     int    `json:"version,omitempty"`
}

type SshKey 

type SshKey struct {
	Fingerprint string `json:"fingerprint,omitempty"`
	Href        string `json:"href,omitempty"`
	Id          string `json:"id,omitempty"`
	Kind        string `json:"kind,omitempty"`
	LegacyId    int    `json:"legacy_id,omitempty"`
	ResourceUid string `json:"resource_uid,omitempty"`
}

Ssh Keys represent a created SSH Key that exists in the cloud.

func (*SshKey) Locator 

func (r *SshKey) Locator(api *API) *SshKeyLocator

Locator returns a locator for the given resource

type SshKeyLocator 

type SshKeyLocator struct {
	Href
	// contains filtered or unexported fields
}

SshKeyLocator exposes the SshKey resource actions.

func (*SshKeyLocator) Index 

func (loc *SshKeyLocator) Index(options rsapi.APIParams) error

GET /api/ssh_keys GET /api/clouds/:cloud_id/ssh_keys

Currently not implemented.

func (*SshKeyLocator) Show 

func (loc *SshKeyLocator) Show(options rsapi.APIParams) error

GET /api/ssh_keys/:id GET /api/clouds/:cloud_id/ssh_keys/:id

Currently not implemented.

type SshKeyParam 

type SshKeyParam struct {
	Fingerprint string `json:"fingerprint,omitempty"`
	Href        string `json:"href,omitempty"`
	Id          string `json:"id,omitempty"`
	Kind        string `json:"kind,omitempty"`
	LegacyId    int    `json:"legacy_id,omitempty"`
	ResourceUid string `json:"resource_uid,omitempty"`
}

type Subnet 

type Subnet struct {
	Description string       `json:"description,omitempty"`
	Href        string       `json:"href,omitempty"`
	Id          string       `json:"id,omitempty"`
	Kind        string       `json:"kind,omitempty"`
	LegacyId    int          `json:"legacy_id,omitempty"`
	Links       *SubnetLinks `json:"links,omitempty"`
	Name        string       `json:"name,omitempty"`
}

A Subnet is a logical grouping of network devices. An Instance can have many Subnets.

func (*Subnet) Locator 

func (r *Subnet) Locator(api *API) *SubnetLocator

Locator returns a locator for the given resource

type SubnetCollection 

type SubnetCollection struct {
	Count int    `json:"count,omitempty"`
	Href  string `json:"href,omitempty"`
}
type SubnetLinks struct {
	Cloud *CloudParam `json:"cloud,omitempty"`
}

type SubnetLocator 

type SubnetLocator struct {
	Href
	// contains filtered or unexported fields
}

SubnetLocator exposes the Subnet resource actions.

func (*SubnetLocator) Index 

func (loc *SubnetLocator) Index(options rsapi.APIParams) error

GET /api/subnets GET /api/clouds/:cloud_id/subnets GET /api/clouds/:cloud_id/instances/:instance_id/subnets

Currently not implemented.

func (*SubnetLocator) Show 

func (loc *SubnetLocator) Show(options rsapi.APIParams) error

GET /api/subnets/:id GET /api/clouds/:cloud_id/subnets/:id

Currently not implemented.

type TimestampsStruct 

type TimestampsStruct struct {
	BootedAt      *time.Time `json:"booted_at,omitempty"`
	CreatedAt     *time.Time `json:"created_at,omitempty"`
	OperationalAt *time.Time `json:"operational_at,omitempty"`
	PendingAt     *time.Time `json:"pending_at,omitempty"`
	StrandedAt    *time.Time `json:"stranded_at,omitempty"`
	TerminatedAt  *time.Time `json:"terminated_at,omitempty"`
	UpdatedAt     *time.Time `json:"updated_at,omitempty"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.