go-oracle-cloud: github.com/juju/go-oracle-cloud/response Index | Files

package response

import "github.com/juju/go-oracle-cloud/response"

Index

Package Files

account.go acl.go backup.go backupconfiguration.go imagelist.go imagelistentry.go instance.go instanceconsole.go ipaddressassociation.go ipaddressprefixset.go ipaddressreservation.go ipassociation.go ipnetwork.go ipnetworkexchange.go ipreservation.go orchestration.go rebootinstancerequest.go route.go secapplication.go secassociation.go seciplist.go seclist.go secrule.go securityprotocol.go securityrule.go shape.go ssh.go storageattachment.go storageproperty.go storagesnapshot.go storagevolume.go virtualnic.go virtualnicset.go vpnendpoint.go

type Account Uses

type Account struct {
    Credentials      map[string]string `json:"credentials,omitempty"`
    Description      string            `json:"description,omitempty"`
    Accounttype      string            `json:"accounttype,omitempty"`
    Name             string            `json:"name"`
    Uri              string            `json:"uri"`
    Objectproperties map[string]string `json:"objectproperties,omitempty"`
}

type Acl Uses

type Acl struct {
    // Name is the name of the ACL
    Name string `json:"name"`

    // Description of the ACL.
    Description string `json:"description,omitempty"`
    // EnableFlag enables or disables the ACL.
    // Set to true by default.
    // Set to false when the ACL is disable.
    EnableFlag bool `json:"enableFlag"`

    // Tags strings that you can use to tag the ACL.
    Tags []string `json:"tags,omitempty"`

    // Uri is the Unified Resource Identifier
    Uri string `json:"uri"`
}

Acl an access control list (ACL) is a collection of security rules that can be applied to a vNICset. You can use ACLs to control the traffic between instances. ACLs determine whether a packet can be forwarded to or from a vNIC, based on the criteria specified in its security rules. When you create a security rule, you specify the ACL that it belongs to. ACLs apply to vNICsets. Each vNICset can reference multiple ACLs and each ACL can be referenced in multiple vNICsets. When an ACL is referenced in a vNICset, every security rule that belongs to the ACL applies to every vNIC that is specified in the vNICset. The default ACL allows traffic to all virtual NICs in an IP network.

type AllAccounts Uses

type AllAccounts struct {
    Result []Account `json:"result,omitempty"`
}

AllAccounts list of all accounts in the oracle cloud

type AllAcls Uses

type AllAcls struct {
    Result []Acl `json:"result,omitempty"`
}

AllAcls holds all acls inside of the account

type AllBackups Uses

type AllBackups struct {
    Result []Backup `json:"result"`
}

type AllImageLists Uses

type AllImageLists struct {
    Result []ImageList `json:"result,omitempty"`
}

AllImageLists contains a slice of all lists of images in the oracle cloud account

type AllInstanceNames Uses

type AllInstanceNames struct {
    Result []string `json:"result"`
}

AllInstanceNames a slice of all instance names in the oracle cloud account

type AllInstances Uses

type AllInstances struct {
    Result []Instance `json:"result"`
}

AllInstances a slice of all instances in the oracle cloud account

type AllIpAddressAssociations Uses

type AllIpAddressAssociations struct {
    // Result is the hole resutl of the AllIpAddressAssociation call
    Result []IpAddressAssociation `json:"result,omitempty"`
}

AllIpAddressAssociations holds a slice of all the ip address associations in the oracle account

type AllIpAddressPrefixSets Uses

type AllIpAddressPrefixSets struct {
    // Result internal ip address prefix sets slice
    Result []IpAddressPrefixSet `json:"result,omitempty"`
}

AllIpAddressPrefixSets holds all ip address prefix sets in the oracle cloud account

type AllIpAddressReservations Uses

type AllIpAddressReservations struct {
    // Result of all ip address reservations
    Result []IpAddressReservation `json:"result,omitempty"`
}

AllIpAddressReservations is holds a slice of all ip address reservations inside the oracle cloud account

type AllIpAssociations Uses

type AllIpAssociations struct {
    Result []IpAssociation `json:"result,omitempty"`
}

AllIpAssociations holds all ip association in the oracle account

type AllIpNetworkExchanges Uses

type AllIpNetworkExchanges struct {
    // Result slice of all the ip networks exchanges
    Result []IpNetworkExchange `json:"result, omitempty"`
}

AllIpNetworkExchanges is holds all internal ip network exchanges from a cloud account

type AllIpNetworks Uses

type AllIpNetworks struct {
    Result []IpNetwork `json:"result,omitempty"`
}

AllIpNetworks holds a slice of all ip networks in the oracle cloud account

type AllIpReservations Uses

type AllIpReservations struct {
    Result []IpReservation `json:"result,omitmepty"`
}

AllIpReservations holds all ip reservation in the oracle cloud account

type AllOrchestrations Uses

type AllOrchestrations struct {
    Result []Orchestration `json:"result,omitmepty"`
}

AllOrchestrations a holds a slice of all orchestrations of a oracle cloud account

type AllRebootInstanceRequests Uses

type AllRebootInstanceRequests struct {
    Result []RebootInstanceRequest `json:"result,omitempty"`
}

AllRebootInstanceRequests all reboot instance requests that are inside the oracle cloud account

type AllRoutes Uses

type AllRoutes struct {
    // Result holds a slice of all routes
    Result []Route `json:"result,omitempty"`
}

AllRoutes contains all declared routes found in the oracle cloud account

type AllSSH Uses

type AllSSH struct {
    Result []SSH `json:"result"`
}

AllSSH represents all the ssh keys stored in the oracle cloud account

type AllSSHNames Uses

type AllSSHNames struct {
    Result []string `json:"result"`
}

type AllSecApplications Uses

type AllSecApplications struct {
    Result []SecApplication `json:"result,omitempty"`
}

type AllSecAssociations Uses

type AllSecAssociations struct {
    Result []SecAssociation `json:"result,omitempty"`
}

AllSecAssociations is a list of all seurity association in the oracle cloud account

type AllSecIpLists Uses

type AllSecIpLists struct {
    Result []SecIpList `json:"result,omitempty"`
}

AllSecIpLists holds all the secure ip list entries from a given account

type AllSecLists Uses

type AllSecLists struct {
    Result []SecList `json:"result,omitempty"`
}

AllSecLists type that is filled with all the security list that are in the account declared

type AllSecRules Uses

type AllSecRules struct {
    Result []SecRule `json:"result,omitempty"`
}

AllSecRules contains a slice of all security rules in the oracle cloud account

type AllSecurityProtocols Uses

type AllSecurityProtocols struct {
    Result []SecurityProtocol `json:"result,omitempty"`
}

type AllSecurityRules Uses

type AllSecurityRules struct {
    Result []SecurityRule `json:"result,omitempty"`
}

type AllShapes Uses

type AllShapes struct {
    Result []Shape `json:"result"`
}

AllShapes has a slice of all declared shapes in the oracle api

type AllStorageAttachments Uses

type AllStorageAttachments struct {
    Result []StorageAttachment `json:"result,omitempty"`
}

type AllStorageProperties Uses

type AllStorageProperties struct {
    Result []StorageProperty `json:"result,omitempty"`
}

AllStorageProperties

type AllStorageSnapshots Uses

type AllStorageSnapshots struct {
    Result []StorageSnapshot `json:"result,omitempty"`
}

type AllStorageVolumes Uses

type AllStorageVolumes struct {
    Result []StorageVolume `json:"result,omitempty"`
}

type AllVirtualNics Uses

type AllVirtualNics struct {
    Result []VirtualNic `json:"result"`
}

AllVirtualNics type returned by AllVirtualNic() holding all the vnc inside the oracle cloud account

type AllVnicSets Uses

type AllVnicSets struct {
    // Result is a slice of all vnic sets
    Result []VnicSet `json:"result,omitempty"`
}

AllVnicSets type for holding all virtual nic sets in the oracle cloud account

type AllVpnEndpoints Uses

type AllVpnEndpoints struct {
    Result []VpnEndpoint `json:"result,omitmepty"`
}

type Attributes Uses

type Attributes struct {
    Dns                   map[string]string  `json:"dns"`
    Network               map[string]Network `json:"network"`
    Nimbula_orchestration string             `json:"nimbula_orchestration"`
    Sshkeys               []string           `json:"sshkeys"`
    Userdata              interface{}        `json:"userdata"`
}

Attributes holds a map of attributes that is returned from the instance response This attributes can have user data scripts or any other key, value passed to be executed when the instance will start, inits

type AttributesEntry Uses

type AttributesEntry struct {
    // User-defined parameters, in JSON format,
    // that can be passed to an instance of this machine
    // image when it is launched.
    Userdata map[string]interface{} `json:"userdata,omitempty"`

    MinimumDiskSize string `json:"minimumdisksize,omitempty"`
    DefaultShape    string `json:"defaultshape,omitempty"`
    SupportedShapes string `json:"supportedShapes,omitempty"`
}

type AttributesOrchestration Uses

type AttributesOrchestration struct {
    Userdata              map[string]string `json:"userdata,omitempty"`
    Nimbula_orchestration string            `json:"nimbula_orchestration,omitempty"`
}

type Backup Uses

type Backup struct {

    // BackupConfigurationName is the name of the backup configuration
    BackupConfigurationName string `json:"backupConfigurationName"`

    // Bootable is the volume this Backup is associated with a bootable volume
    Bootable bool `json:"bootable"`

    // Description is the description of the Backup
    Description *string `json:"description,omitempty"`

    // detailedErrorMessage is a human readable detailed error message
    DetailedErrorMessage *string `json:"detailedErrorMessage,omitempty"`

    // ErrorMessage is a human readable error message
    ErrorMessage *string `json:"errorMessage,omitempty"`

    // Name is the name of the backup
    Name string `json:"name"`

    //RunAsUser is any actions on this model will be performed as this user
    RunAsUser string `json:"runAsUser"`

    // Shared ss the volume this Backup is associated with a shared volume
    Shared bool `json:"shared"`

    // SnapshotSize is the size of the snapshot
    SnapshotSize *string `json:"snapshotSize"`

    // SnapshotUri is the snapshot created by this Backup
    SnapshotUri *string `json:"snapshotUri"`

    // State of this resource.
    // Allowed Values:
    // common.Submitted,
    // common.Inprogress,
    // common.Completed,
    // common.Failed,
    // common.Canceling,
    // common.Canceled,
    // common.Timeout,
    // common.DeleteSubmitted,
    // common.Deleting,
    // common.Deleted,
    State common.BackupState `json:"state"`

    // TagID used to tag other cloud resources
    TagID string `json:"tagId"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    // VolumeUri is the Backup that was created from
    VolumeUri string `json:"volumeUri"`
}

Backup allows you to create a backup right away using a specified backup configuration. You can also view scheduled backups and their status, or delete a specified backup and the corresponding snapshot.

type BackupConfiguration Uses

type BackupConfiguration struct {
    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri,omitempty"`

    // RunAsUser represents any actions on this
    // model will be performed as this user.
    RunAsUser string `json:"runAsUser,omitempty"`

    // Name is the name of the backup configuration
    Name string `json:"name"`

    // Enabled flag for:
    // when true, backups will automatically
    // be generated based on the interval.
    Enabled bool `json:"enabled,omitempty"`

    // BackupRetentionCount represents how many backups to retain
    BackupRetentionCount uint32 `json:"backupRetentionCount,omitempty"`

    // Scheduled time for next backup execution
    NextScheduledRun string `json:"nextScheduledRun,omitempty"`

    // Interval represents the interval in the backup configuration.
    // There are two kinds of Intervals. Each Interval has its own JSON format.
    // Your Interval field should look like one of the following:
    //
    // "interval":{
    //   "Hourly":{
    //     "hourlyInterval":2
    //	 }
    // }
    //
    //
    // {"DailyWeekly":
    // 	{
    //	  "daysOfWeek":["MONDAY"],
    //	  "timeOfDay":"03:15",
    // 	  "userTimeZone":"America/Los_Angeles"
    //  }
    // }
    // Days of the week is any day of the week
    // fully capitalized (MONDAY, TUESDAY, etc).
    // The user time zone is any IANA user timezone.
    //For example user time zones see List of IANA time zones.
    //
    //
    // But for the caller of this api can use one of the types provided
    // in the common package
    // common.Interval
    // common.DailyWeekly
    //
    // If you want to be sure what are you passing is correcly and checked
    // use this function from the common package instead
    // common.NewInterval
    // common.NewDailyWeekly
    //
    Interval common.Interval `json:"Interval"`

    // VolumeUri is the complete URI of the storage
    // volume that you want to backup.
    VolumeUri string `json:"volumeUri"`

    // Description of this Backup Configuration
    Description string `json:"description,omitempty"`

    // TagId is the ID used to tag other cloud resources
    TagId string `json:"tagId,omitempty"`
}

BackupConfiguration you can schedule backups to be taken automatically at defined intervals. Scheduling a backup creates a snapshot of the specified storage volume and the snapshot is stored in the associated Oracle Storage Cloud Service instance.

type DirectoryNames Uses

type DirectoryNames struct {
    Result []string `json:"result,omitempty"`
}

DirectoryNames are names of all the accounts in the specified container.

type Dns Uses

type Dns struct {
    Domain      string `json:"domain"`
    Hostname    string `json:"hostname"`
    Vcable_eth0 string `json:"nimbula_vcable-eth0"`
}

type Hypervisor Uses

type Hypervisor struct {
    Mode string `json:"mode"`
}

type ImageList Uses

type ImageList struct {
    // Default is the image list entry to be used,
    // by default, when launching instances
    // using this image list.
    // If you don't specify this value, it is set to 1.
    Default int `json:"default"`

    // Description is a description of this image list.
    Description *string `json:"description,omitempty"`

    // Entries represents each machine image in an
    // image list is identified by an image list entry.
    Entries []ImageListEntry `json:"entries,omitempty"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    // Name is the name of the imagelist
    Name string `json:"name"`
}

An image list is a collection of Oracle Compute Cloud Service machine images. Each machine image in an image list is identified by a unique entry number. When you create an instance, by using a launch plan for example, you must specify the image list that contains the machine image you want to use.

type ImageListEntry Uses

type ImageListEntry struct {

    // User-defined parameters, in JSON format,
    // that can be passed to an instance of this machine
    // image when it is launched.
    // This field can be used, for example, to specify the location
    // of a database server and login details.
    // Instance metadata, including user-defined data
    // is available at http://192.0.0.192/ within an instance.
    Attributes AttributesEntry `json:"attributes,omitempty"`

    // Imagelist is the name of the imagelist.
    Imagelist string `json:"imagelist"`

    // Version number of these machineImages in the imagelist.
    Version int `json:"version"`

    // Machineimages represetns a slice of machine images.
    Machineimages []string `json:"machineimages"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

ImageListEntry represents the metadata of a machine image list

type ImageListEntryAdd Uses

type ImageListEntryAdd struct {
    Attributes    interface{} `json:"attributes,omitempty"`
    Imagelist     ImageList   `json:"Imagelist"`
    Version       int         `json:"version"`
    Machineimages []string    `json:"machineimages"`
    Uri           string      `json:"uri"`
}

ImageListEntryAdd custom response returned from CreateImageListEntryAdd This is used instead of ImageListEntry beacause the api is inconsistent

type Info Uses

type Info struct {
    Errors map[string]string `json:"errors,omitempty"`
}

type Instance Uses

type Instance struct {
    Domain                          string               `json:"domain"`
    Placement_requirements          []string             `json:"placement_requirements"`
    Ip                              string               `json:"ip"`
    Fingerprint                     string               `json:"fingerprint,omitempty"`
    Site                            string               `json:"site,omitempty"`
    Last_state_change_time          interface{}          `json:"last_state_change_time,omitempty"`
    Error_exception                 interface{}          `json:"error_exception,omitempty"`
    Cluster                         interface{}          `json:"cluster,omitempty"`
    Shape                           string               `json:"shape"`
    Start_requested                 bool                 `json:"start_requested"`
    Vethernets                      interface{}          `json:"vethernets,omitempty"`
    Imagelist                       string               `json:"imagelist,omitempty"`
    Image_format                    string               `json:"image_format"`
    Cluster_uri                     interface{}          `json:"cluster_uri,omitempty"`
    Relationships                   []string             `json:"relationships,omitempty"`
    Target_node                     interface{}          `json:"target_node,omitempty"`
    Availability_domain             interface{}          `json:"availability_domain,omitempty"`
    Networking                      common.Networking    `json:"networking"`
    Seclist_associations            interface{}          `json:"seclist_associations,omitempty"`
    Hostname                        string               `json:"hostname"`
    State                           common.InstanceState `json:"state"`
    Disk_attach                     string               `json:"disk_attach,omitempty"`
    Label                           string               `json:"label,omitempty"`
    Priority                        string               `json:"priority"`
    Platform                        string               `json:"platform"`
    Quota_reservation               interface{}          `json:"quota_reservation,omitempty"`
    Suspend_file                    interface{}          `json:"suspend_file,omitempty"`
    Node                            interface{}          `json:"node,omitempty"`
    Resource_requirements           ResourceRequirments  `json:"resource_requirements"`
    Virtio                          interface{}          `json:"virtio,omitempty"`
    Vnc                             string               `json:"vnc,omitempty"`
    Desired_state                   common.InstanceState `json:"desired_state"`
    Storage_attachments             []Storage            `json:"storage_attachments,omitempty"`
    Start_time                      string               `json:"start_time"`
    Storage_attachment_associations []interface{}        `json:"storage_attachment_associations,omitempty"`
    Quota                           string               `json:"quota"`
    Vnc_key                         interface{}          `json:"vnc_key,omitempty"`
    Numerical_priority              uint64               `json:"numerical_priority"`
    Suspend_requested               bool                 `json:"suspend_requested"`
    Entry                           int                  `json:"entry"`
    Error_reason                    string               `json:"error_reason,omitempty"`
    Nat_associations                interface{}          `json:"nat_associations,omitempty"`
    SSHKeys                         []string             `json:"sshkeys,omitemtpy"`
    Tags                            []string             `json:"tags,omitempty"`
    Resolvers                       interface{}          `json:"resolvers,omitempty"`
    Metrics                         interface{}          `json:"metrics,omitempty"`
    Account                         string               `json:"account"`
    Node_uuid                       interface{}          `json:"node_uuid,omitempty"`
    Name                            string               `json:"name"`
    Vcable_id                       common.VcableID      `json:"vcable_id,omitempty"`
    Higgs                           interface{}          `json:"higgs,omitempty"`
    Hypervisor                      Hypervisor           `json:"hypervisor"`
    Uri                             string               `json:"uri"`
    Console                         interface{}          `json:"console,omitempty"`
    Reverse_dns                     bool                 `json:"reverse_dns"`
    Launch_context                  string               `json:"launch_context"`
    Delete_requested                interface{}          `json:"delete_requested,omitempty"`
    Tracking_id                     interface{}          `json:"tracking_id,omitempty"`
    Hypervisor_type                 interface{}          `json:"hypervisor_type,omitempty"`
    Attributes                      Attributes           `json:"attributes"`
    Boot_order                      []int                `json:"boot_order,omitempty"`
    Last_seen                       interface{}          `json:"last_seen,omitempty"`
}

Instance represents an Oracle Compute Cloud Service instance is a virtual machine running a specific operating system and with CPU and memory resources that you specify.

type InstanceConsole Uses

type InstanceConsole struct {

    // Timestamp is the time when the console output was created.
    Timestamp string `json:"timestamp"`

    // Output is the serial console output of the instance.
    Output string `json:"output"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    // Name is the name of the instance for
    // which the console output is displayed.
    Name string `json:"name"`
}

InstanceConsole you can use the console output of an instance to diagnose failures that occurred while booting the instance. The instanceconsole object is created when an instance is launched, and it is destroyed when the instance is deleted.

type InstancesOrchestration Uses

type InstancesOrchestration struct {
    Hostname string `json:"hostname,omitempty"`

    // Networking information of the instance
    Networking common.Networking `json:"networking,omitempty"`

    // Name of the instance
    Name string `json:"name,omitempty"`

    // Boot_order is the number in what order the instance is booting
    Boot_order []int `json:"boot_order,omitempty"`

    Ip  string `json:"ip,omitempty"`

    Start_time string `json:"start_time,omitempty"`

    // Storage_attachments list of storages that the instnaces has
    Storage_attachments []StorageOrhcestration `json:"storage_attachments,omitmepty"`

    // Uri of the instnace
    Uri *string `json:"uri,omitempty"`

    // Label is the label of the instance
    Label string `json:"label,omitempty"`

    // Shape is the shape of the instnace
    Shape string `json:"shape,omitempty"`

    State common.InstanceState `json:"state,omitempty"`

    // Attributes list of orchestration attributes
    Attributes AttributesOrchestration `json:"attributes,omitmepty"`

    // Imagelist is the image from what was created
    Imagelist string `json:"imagelist,omitempty"`

    // SSHKeys of the instance
    SSHkeys []string `json:"sshkeys,omitmepty"`

    // Tags are a list of tags, aliases for the instance
    Tags []string `json:"tags,omitmepty"`
}

InstancesOrchestration holds information for an instances inside the orchestration object

type IpAddressAssociation Uses

type IpAddressAssociation struct {
    // Name is the name of the ip address association
    Name string `json:"name"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    // Description is the description of the object.
    Description string `json:"description,omitempty"`

    // Tags associated with the object.
    Tags []string `json:"tags,omitempty"`

    //Vnic represents the multipart name of the virtual
    // NIC associated with this NAT IP reservation
    Vnic string `json:"vnic"`

    // IpAddressReservation is the NAT IP address reservation
    IpAddressReservation string `json:"ipAddressReservation"`
}

IpAddressAssociation IP address association to associate an IP address reservation

type IpAddressPrefixSet Uses

type IpAddressPrefixSet struct {

    // Description is a description of the ip address prefix set
    Description *string `json:"description,omitmepty"`

    IpAddressPrefixes []string `json:"ipAddressPrefixes"`

    // Name is the name of the ip address prefix set
    Name string `json:"name"`

    // Tags is strings that you can use to tag the IP address prefix set.
    Tags []string `json:"tags,omitempty"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

IpAddressPrefixSet is an IP address prefix set lists IPv4 addresses in the CIDR address prefix format. After creating an IP address prefix set, you can specify it as a source or destination for permitted traffic while creating a security rule. See Add a Security Rule.

type IpAddressReservation Uses

type IpAddressReservation struct {

    // Description is the description of the ip address reservation
    Description *string `json:"description,omitmepty"`

    // IpAddressPool is the IP address pool from which you want
    // to reserve an IP address. Enter one of the following:
    // * /oracle/public/public-ippool: When you attach an IP address
    // from this pool to an instance, you enable
    // access between the public Internet and the instance.
    // * /oracle/public/cloud-ippool: When you attach
    // an IP address from this pool to an instance, the instance
    // can communicate privately (that is, without traffic going over
    // the public Internet) with other Oracle Cloud services, such as the
    IpAddressPool common.IPPool `json:"ipAddressPool,omitempty"`

    // IpAddress reserved NAT IPv4 address from the IP address pool
    IpAddress string `json:"ipAddress,omitempty"`

    // Name is the name of the ip address reservation
    Name string `json:"name"`

    // Tags is the strings that you can use to tag the IP address reservation.
    Tags []string `json:"tags,omitempty"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

IpAddressReservation is when you associate an instance with an IP network, you can specify a public IP address to be associated with the instance. An IP address reservation allows you to reserve a public IP address from a specified IP pool. After creating an IP address reservation, you can associate the public IP address with a vNIC on an instance by creating an IP address association.

type IpAssociation Uses

type IpAssociation struct {

    // Account is  the default account
    // for your identity domain.
    Account string `json:"account"`

    // Ip is the public IP address which is
    // attached to an Oracle Compute Cloud Service
    // instance that requires access to or from the Internet.
    Ip  string `json:"ip"`

    // Name is the name of the ip association
    Name string `json:"name"`

    //To associate a temporary IP address from the pool,
    // specify ippool:/oracle/public/ippool.
    // To associate a persistent IP address, specify // ipreservation:ipreservation_name, where ipreservation_name
    // is three-part name of an existing IP reservation in the // /Compute-identity_domain/user/object_name format. For more
    // information about how to create an IP reservation,
    // see CreateIpReservation.
    Parentpool common.IPPool `json:"parentpool"`

    // Reservation is the  ip reservation object in the format name
    Reservation string `json:"reservation"`

    // Uri is the uniform Resource Identifier
    Uri string `json:"uri"`

    // Vcable is the vcable it of the instance that
    // is associated with the ip reservation.
    Vcable common.VcableID `json:"vcable"`
}

IpAssociation is a link between an IP reservation and the vcable of an instance. A vcable is an attachment point to a specific network interface of an instance. A vcable is created automatically when an instance is created and is deleted when the instance is deleted.

type IpNetwork Uses

type IpNetwork struct {

    // Description of the object.
    Description *string `json:"description,omitempty"`

    // IpAddressPrefix is the size of the IP subnet.
    // It is a range of IPv4 addresses assigned in the
    // virtual network, in CIDR address prefix format.
    // While specifying the IP address prefix take care
    // of the following points:
    //
    // * These IP addresses aren't part of the common
    // pool of Oracle-provided IP addresses used by the shared network.
    //
    // * There's no conflict with the range of IP addresses used in another
    // IP network, the IP addresses used your on-premises network,
    // or with the range of private IP addresses used in the shared network.
    // If IP networks with overlapping IP subnets are linked to an IP exchange,
    // packets going to and from those IP networks are dropped.
    //
    // * The upper limit of the CIDR block size for an IP network is /16.
    //
    // Note: The first IP address of any IP network is reserved for
    // the default gateway, the DHCP server, and the
    // DNS server of that IP network.
    IpAddressPrefix string `json:"ipAddressPrefix"`

    // IpNetworkExchange is the IP network exchange to which the IP network belongs.
    // You can add an IP network to only one IP network exchange,
    // but an IP network exchange can include multiple IP networks.
    // An IP network exchange enables access between IP networks that
    // have non-overlapping addresses, so that instances on these
    // networks can exchange packets with each other without NAT.
    IpNetworkExchange *string `json:"ipNetworkExchange,omitempty"`

    // Name object names can contain only alphanumeric, underscore (_),
    // dash (-), and period (.) characters. Object names are case-sensitive.
    Name string `json:"name"`

    // PublicNaptEnabledFlag if true, enable public internet access using NAPT for VNICs without any public IP reservation.
    PublicNaptEnabledFlag bool `json:"publicNaptEnabledFlag"`

    // Tags associated with the object.
    Tags []string `json:"tags,omitempty"`

    // Uniform Resource Identifier
    Uri string `json:"uri"`
}

IpNetwork is an ip network that allows you to define an IP subnet in your account. The size of the IP subnet and the set IP addresses in the subnet are determined by the IP address prefix that you specify while creating the IP network. These IP addresses aren't part of the common pool of Oracle-provided IP addresses used by the shared network. When you add an instance to an IP network, the instance is assigned an IP address in that subnet. You can assign IP addresses to instances either statically or dynamically, depending on your business needs. So you have complete control over the IP addresses assigned to your instances

type IpNetworkExchange Uses

type IpNetworkExchange struct {

    // Description is the description of the ip network exchange
    Description *string `json:"description,omitempty"`

    // Name si the name of the ip network exchange
    Name string `json:"name"`

    // Tags associated with the object.
    Tags []string `json:"tags,omitempty"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

IpNetworkExchange is nn IP network exchange can include multiple IP networks, but an IP network can be added to only one IP network exchange.

type IpReservation Uses

type IpReservation struct {
    // Account is  the default account
    // for your identity domain.
    Account string `json:"account"`

    // Ip is an IP reservation is a public IP address
    // that you can attach to an Oracle Compute Cloud
    // Service instance that requires
    //  access to or from the Internet.
    Ip  string `json:"ip"`

    // Name is the name of the ip reservation
    Name string `json:"name"`

    // Parentpool is a pool of public IP addresses
    Parentpool common.IPPool `json:"parentpool"`

    // Permanent flag is true and indicates that the IP reservation
    // has a persistent public IP address.
    // You can associate either a temporary or a persistent
    // public IP address with an instance when
    // you create the instance.
    // Temporary public IP addresses are assigned
    // dynamically from a pool of public IP addresses.
    // When you associate a temporary public IP address with an instance,
    // if the instance is restarted or is deleted and created again later,
    // its public IP address might change.
    Permanent bool `json:"permanent"`

    // Quota is Not used
    Quota *string `json:"quota,omitempty"`

    // Tags is a comma-separated list of strings
    // which helps you to identify IP reservation.
    Tags []string `json:"tags,omitempty"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    // Used flag when is true indicates that the IP reservation
    //  is associated with an instance.
    Used bool `json:"used"`
}

IpReservation is an IP reservation is the allocation of a public IP address from an IP address pool. After creating an IP reservation, you can associate it with an instance by using an IP association, to enable access between the Internet and the instance.

type LaunchPlan Uses

type LaunchPlan struct {
    Relationships []string   `json:"relationships,omitempty"`
    Instances     []Instance `json:"instances"`
}

type Network Uses

type Network struct {
    // The MAC address of the interface, in hexadecimal format
    // This can contains ipv4 addresses also
    Address []string `json:"address"`

    Dhcp_options []string `json:"dhcp_options,omitempty"`

    // Id you want to associate a static private
    // IP address with the instance, specify
    // an available IP address from the IP
    // address range of the specified ipnetwork.
    Id  string `json:"id"`

    // Model is the type of network
    // interface card (NIC).
    // The only allowed value is e1000.
    Model string `json:"model"`

    Vethernet string `json:"vethernet"`

    Vethernet_id string `json:"vethernet_id"`

    Vethernet_type string `josn:"vethernet_type"`

    Instance string `json:"instance,omitmepty"`

    Ipassociations []string `json:"ipassociations,omitempty"`

    Ipattachment string `json:"ipattachment"`

    // Ipnetwork is the name of the IP network
    // that you want to add the instance to
    Ipnetwork string `json:"ipnetwork"`

    // Nnic is the virtual nic
    Vnic string `json:"vnic"`

    // Vnicsets are names of the vNICsets
    // that you want to add this interface to
    Vnicsets []string `json:"vnicsets"`
}

type OType Uses

type OType string

OType represents the orchestration type

const (
    // Instance is the instance orchestration type
    OInstance OType = "Instance"
    // Storage is the storage orchestration type
    OStorage OType = "Storage"
    // Master is the master orchestration type
    OMaster OType = "Master"
)

type Object Uses

type Object struct {
    // Info is the aditional information about the orchestration object
    Info Info `json:"info,omitempty"`

    //
    // Intances is generally populated when we are dealing with an
    // instance orchestration
    //
    // Instances instances that are attached to this orchestration
    Instances []InstancesOrchestration `json:"instances,omitempty"`

    // Status is the status of the orchestration
    Status string `json:"status,omitempty"`

    // Name is the name of the object
    Name string `json:"name,omitempty"`

    // Status_timestamp is the status when the object was created
    Status_timestamp string `json:"status_timestamp,omitmepty"`

    // Uri is the endpoint uri that the object is located
    Uri *string `json:"uri,omitempty"`

    //
    //
    // Below these fields are populated when we are dealing with an
    // storage orchestration
    //
    //
    // Managed flag true if the storage is managed
    Managed bool `json:"managed,omitempty"`

    // Snapshot_account is the account name that the snapshot was created from
    Snapshot_account *string `json:"snapshot_account,omitempty"`

    // Machineimage_name is the name of the machine image
    // that the storage was/will bot from
    Machineimage_name string `json:"machineimage_name,omitempty"`

    // Snapshot_id is the snapshot id
    Snapshot_id *string `json:"snapshot_id,omitempty"`

    // Imagelist is the image list that the storage was created from
    Imagelist string `json:"imagelist,omitempty"`

    // Writecache flag true if the write cache is enabled on the storage
    Writecache bool `json:"writecache,omitempty"`

    // Size is the storage size in the cloud
    Size uint64 `json:"size,string"`

    // Platform is the platform storage could be linux,windows, etc.
    Platform string `json:"platform"`

    // Readonly flag true if the storage is read only and does not permit
    // write operation on
    Readonly bool `json:"readonly"`

    // Storage_pool is the storage endpoint pool that the storage
    // belongs to
    Storage_pool string `json:"storage_pool,omitempty"`

    // Shared flag true if the storage is shared across multiple instances
    Shared bool `json:"shared,omitempty"`

    // Description is the description of the object
    Description string `json:"description,omitempty"`

    // Tags are the tags, aliases of the object
    Tags []string `json:"tags,omitempty"`

    // Quota this field is not used
    Quota *string `json:"quota,omitempty"`

    // Properties of the storage obejct
    Properties []string `json:"properties,omitempty"`

    // Account is the account name of the object that has been created from
    Account string `json:"account"`

    // Bootable flag represents that the instance can boot from the storage
    Bootable bool `json:"bootable,omitempty"`

    // Hypervisor is the hypervisor name used in the object orchestration
    Hypervisor *string `json:"hypervisor,omitempty"`

    // Imagelist_entry is the index entry of the image that is used
    // in the storage obejct
    Imagelist_entry int `json:"imagelist_entry,omitempty"`

    // Snapshot is the snapshot name of the storage
    Snapshot *string `json:"snapshot,omitempty"`
}

Objects

type Oplan Uses

type Oplan struct {

    // Status is the most recent status.
    Status string `json:"status"`

    // Info dictionary for the oplan.
    Info Info `json:"info,omitempty"`

    // Obj_type type of the object.
    Obj_type string `json:"obj_type"`

    // Ha_policy indicates that description is not available
    Ha_policy string `json:"ha_policy,omitempty"`

    // Label is the description of this object plan.
    Label string `json:"label"`

    // Objects list of object dictionaries
    // or object names.
    Objects []Object `json:"objects"`

    // Status_timestamp Timestamp of the most-recent status change.
    Status_timestamp string `json:"status_timestamp,omitempty"`
}

Oplan is an object plan, or oplan, a top-level orchestration attribute

type Orchestration Uses

type Orchestration struct {

    // Relationships holds a slice of relationships that holds every
    // relationship between the objects
    Relationships []Relationship `json:"relationships,omitempty"`

    // Status shows the current status of the orchestration.
    Status string `json:"status"`

    // Account shows the default account for your identity domain.
    Account string `json:"account"`

    // Description is the description of this orchestration plan
    Description string `json:"description,omitempty"`

    // Schedule for an orchestration consists
    // of the start and stop dates and times.
    Schedule Schedule `json:"schedule"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri,omitempty"`

    // List of oplans. An object plan, or oplan,
    // is a top-level orchestration attribute.
    Oplans []Oplan `json:"oplans"`

    // Info the nested parameter errors shows which object
    // in the orchestration has encountered an error.
    // Empty if there are no errors.
    Info Info `json:"info,omitempty"`

    // User is the user of the orchestration
    User string `json:"user"`

    // Status_timestamp this information is generally displayed
    // at the end of the orchestration JSON.
    // It indicates the time that the current view of the
    // orchestration was generated. This information shows only when
    // the orchestration is running.
    Status_timestamp string `json:"status_timestamp"`

    // Name is the name of the orchestration
    Name string `json:"name"`
}

Orchestration is an orchestration defines the attributes and interdependencies of a collection of compute, networking, and storage resources in Oracle Compute Cloud Service. You can use orchestrations to automate the provisioning and lifecycle operations of an entire virtual compute topology. After creating an orchestration (in a JSON-formatted file) and adding it to Oracle Compute Cloud Service, you can trigger the creation and removal all the resources defined in the orchestration with a single step. An orchestration contains one or more object plans (oplans). The attributes that you can specify in an oplan vary depending on the object type (obj_type). For detailed information about the object types that you can create by using orchestrations and the attributes for each object type, see Attributes in Orchestrations in Using Oracle Compute Cloud Service (IaaS).

func (Orchestration) OrchestrationType Uses

func (o Orchestration) OrchestrationType() OType

OrchestrationType returns the type of response orchestration we are dealing with

type RebootInstanceRequest Uses

type RebootInstanceRequest struct {
    // Name is the name of the reboot instance request
    Name string `json:"name"`

    // Hard is true if the we are  performing a hard reset
    Hard bool `json:"hard"`

    //Creation_time represents the timestamp of request creation.
    Creation_time string `json:"creation_time"`

    // Error_reason a description of the reason this request entered error state.
    Error_reason string `json:"error_reason,omitempty"`

    // Instance is multipart name of
    // the instance that you want to reboot.
    Instance string `json:"instance"`

    // State is the state of the request.
    State string `json:"state"`

    Instance_id string `json:"instance_id,omitempty"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    Request_id string `json:"request_id,omitempty"`
}

RebootInstanceRequest you can reboot a running instance by creating a rebootinstancerequest object.

type Relationship Uses

type Relationship struct {

    // ToOplan to witch orchestration plan should
    // be the orchestration in a relationship
    ToOplan string `json:"to_oplan,omitempty"`

    // Oplan orchestration plan
    Oplan string `json:"oplan,omitempty"`

    // The type of relationship that this orchestration
    // has with the other one in the ToOplan field
    Type string `json:"type,omitempty"`
}

Relationship type that will describe the relationship between objects

type ResourceRequirments Uses

type ResourceRequirments struct {
    Compressed_size   uint64  `json:"compressed_size"`
    Is_root_ssd       bool    `json:"is_root_ssd"`
    Ram               uint64  `json:"ram"`
    Cpus              float64 `json:"cpus"`
    Root_disk_size    uint64  `json:"root_disk_size"`
    Io                uint64  `json:"io"`
    Decompressed_size uint64  `json:"decompressed_size"`
    Gpus              uint64  `json:"gpus"`
    Ssd_data_size     uint64  `json:"ssd_data_size"`
}

type Route Uses

type Route struct {

    // Specify common.AdminDistanceZero or common.AdminDistranceOne,
    // or common.AdminDistranceTwo,
    // as the route's administrative distance.
    // If you do not specify a value, the
    // default value is common.AdminDistanceZero,
    // The same prefix can be used in multiple routes.
    // In this case, packets are routed over all the matching routes with
    // the lowest administrative distance. In the case multiple routes with
    // the same lowest administrative distance match,
    // routing occurs over all these routes using ECMP.
    AdminDistance common.AdminDistance `json:"adminDistance,omitempty"`

    // Description is the description of the route
    Description string `json:"description,omitempty,omitempty"`

    // IpAddressPrefix is the IPv4 address prefix, in CIDR format,
    // of the external network (external to the vNIC set)
    // from which you want to route traffic.
    IpAddressPrefix string `json:"ipAddressPrefix"`

    // Name is the name of the route
    Name string `json:"name"`

    // NextHopVnicSet is the name of the virtual NIC set to route matching
    // packets to. Routed flows are load-balanced among all
    // the virtual NICs in the virtual NIC set.
    NextHopVnicSet string `json:"nextHopVnicSet"`

    // Tags associated with the object.
    Tags []string `json:"tags,omitempty"`

    // Uri si the Uniform Resource Identifier
    Uri string `json:"uri"`
}

Route is after creating IP networks and adding instances to the networks, you can specify connections between different networks by creating routes and IP network exchanges. Route specifies the IP address of the destination as well as a vNICset which provides the next hop for routing packets. Using routes to enable traffic between subnets allows you to specify multiple routes to each IP network. Using vNICsets in routes also provides egress load balancing and high availability.

type SSH Uses

type SSH struct {
    Enabled bool   `json:"enabled"`
    Uri     string `json:"uri"`
    Key     string `json:"key"`
    Name    string `json:"name"`
}

SSH is the ssh key that the instance is using To connect to an instance using SSH, you must associate it with one or more SSH public keys. You must first generate the required SSH key pairs, by using a tool such as ssh-keygen, and then upload the public keys to Oracle Compute Cloud Service. You can add, delete, update, and view SSH public keys

type Schedule Uses

type Schedule struct {
    //Start_time when the orchestration will start
    Start_time *string `json:"start_time,omitempty"`

    // Stop_time when the orchestration will stop
    Stop_time *string `json:"stop_time,omitempty"`
}

Schedule for an orchestration consists of the start and stop dates and times

type SecApplication Uses

type SecApplication struct {

    // Description is a description of the security application.
    Description string `json:"description,omitempty"`

    // Dport is the TCP or UDP destination port number.
    // You can also specify a port range, such as 5900-5999 for TCP.
    // If you specify tcp or udp as the protocol, then the dport
    // parameter is required; otherwise, it is optional.
    // This parameter isn't relevant to the icmp protocol.
    // Note: This request fails if the range-end is lower than the range-start.
    // For example, if you specify the port range as 5000-4000.
    Dport string `json:"dport,omitempty"`

    // Icmpcode is the ICMP code.
    // This parameter is relevant only if you specify
    // icmp as the protocol. You can specify one of the following values:
    //
    // common.IcmpCodeNetwork
    // common.IcmpCodeHost
    // common.IcmpCodeProtocol
    // common.IcmpPort
    // common.IcmpCodeDf
    // common.IcmpCodeAdmin
    //
    // If you specify icmp as the protocol and don't
    // specify icmptype or icmpcode, then all ICMP packets are matched.
    Icmpcode common.IcmpCode `json:"icmpcode,omitempty"`

    // Icmptype
    // The ICMP type. This parameter is relevant only if you specify icmp
    // as the protocol. You can specify one of the following values:
    //
    // common.IcmpTypeEcho
    // common.IcmpTypeReply
    // common.IcmpTypeTTL
    // common.IcmpTraceroute
    // common.IcmpUnreachable
    // If you specify icmp as the protocol and
    // don't specify icmptype or icmpcode, then all ICMP packets are matched.
    Icmptype common.IcmpType `json:"icmptype,omitempty"`

    // Name is the name of the secure application
    Name string `json:"name"`

    // Protocol is the protocol to use.
    // The value that you specify can be either a text representation of
    // a protocol or any unsigned 8-bit assigned protocol number
    // in the range 0-254. See Assigned Internet Protocol Numbers.
    // For example, you can specify either tcp or the number 6.
    // The following text representations are allowed:
    // tcp, udp, icmp, igmp, ipip, rdp, esp, ah, gre, icmpv6, ospf, pim, sctp, mplsip, all.
    // To specify all protocols, set this to all.
    Protocol common.Protocol

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    // Not in the documentation, but the API returns Value1 which holds the port range start
    // Should coincide with Dport if only one port is opened
    Value1 int `json:"value1"`

    // Not in the documentation, but the API returns Value2 which holds the port range end
    // If only one port is opened, this value will hold the value -1. If multiple ports are
    // opened, this value will hold the second element (delimited by - ) from Dport
    Value2 int `json:"value2"`

    // Not in the documentation. No idea what this is. My crystal ball is broken.
    Id  string `json:"id"`
}

func (*SecApplication) PortProtocolPair Uses

func (s *SecApplication) PortProtocolPair() string

func (*SecApplication) String Uses

func (s *SecApplication) String() string

type SecAssociation Uses

type SecAssociation struct {
    // Name is the name of the secure
    // association
    Name string `json:"name"`

    // Seclist is the security list that
    // you want to associate with the instance.
    Seclist string `json:"seclist"`

    // Vcable of the instance that you want to
    // associate with the security list.
    Vcable common.VcableID `json:"vcable"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

SecAssociation is a security association, a relationship between a security list and the vcable of an instance. The vcable is an attachment point to a specific network interface of an instance. The vcable enables dynamic association/disassociation of its instance with security lists. You can associate up to eight security lists with a given vcable. This limit includes security lists specified in the instance configuration (for example, in a launch plan) as well as new security associations added after creating instances. Note that when a security list is deleted, all the security associations involving that security list are also deleted.

type SecIpList Uses

type SecIpList struct {

    // Description is a description of the security IP list.
    Description *string `json:"description,omitempty"`

    // Name is the name of the secure ip list
    Name string `json:"name"`

    // A comma-separated list of the subnets
    // (in CIDR format) or IPv4 addresses for
    // which you want to create this security IP list.
    // For example, to create a security
    // IP list containing the IP addresses
    // 203.0.113.1 and 203.0.113.2, enter one of the following:
    // 203.0.113.0/30
    // 203.0.113.1, 203.0.113.2
    Secipentries []string `json:"secipentries"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    // the group id of the secure ip list
    Group_id string `json:"group_id"`

    // the id of the secure ip list
    Id  string `json:"id"`
}

SecIpList a security IP list is a set of IP addresses or subnets external to the instances you create in Oracle Compute Cloud Service. These lists can then be used as a source when you define security rules. Note that, a security IP list named /oracle/public/public-internet is predefined in Oracle Compute Cloud Service. You can use this security IP list as the source in a security rule to permit traffic from any host on the Internet.

type SecList Uses

type SecList struct {

    // Account shows the default account for your identity domain.
    Account string `json:"account"`

    // A description of the security list.
    Description string `json:"description,omitempty"`

    // Name of the secure list
    Name string `json:"name"`

    // The policy for outbound traffic from the security list.
    // You can specify one of the following values:
    // - deny: Packets are dropped. No response is sent.
    // - reject: Packets are dropped, but a response is sent.
    // - permit(default): Packets are allowed.
    Outbound_cidr_policy common.SecRuleAction `json:"outbound_cidr_policy"`

    // The policy for inbound traffic to the security list.
    // You can specify one of the following values:
    // - deny(default): Packets are dropped. No response is sent.
    // - reject: Packets are dropped, but a response is sent.
    // - permit: Packets are allowed. This policy effectively turns off the firewall for all instances in this security list.
    Policy common.SecRuleAction `json:"policy"`

    // uniform Resource Identifier
    Uri string `json:"uri"`
}

SecList a security list is a group of one or more instances that you can specify as the destination or source in a security rule. Instances within a security list can communicate fully with one another on all ports. When you attach an instance to a security list, the inbound and outbound policies defined in the security list are applicable to that instance. All instances within a security list can communicate fully with one another on all protocols and ports. While creating an instance, if you do not attach it to any security list, the instance gets attached automatically to the predefined /Compute-identity_domain/default/default security list, which has the inbound policy set to DENY and the outbound policy set to PERMIT.

type SecRule Uses

type SecRule struct {

    // Action is the security rule
    Action common.SecRuleAction `json:"action"`

    // Application is the application securiy name
    Application string `json:"application"`

    // Description is the description of the security rule
    Description string `json:"description,omitempty"`

    // Disabled flag indicates whether the security rule
    // is enabled (set to false) or disabled (true).
    // The default setting is false
    Disabled bool `json:"disabled"`

    // Dst_is_ip name of the destination
    // security list or security IP list
    // You cannot specify any of the security
    // IP lists in the /oracle/public container
    // as a destination in a secrule.
    Dst_is_ip string `json:"dst_is_ip"`

    //  Dst_list
    // Note: You can specify a security IP list
    // as the destination in a secrule,
    // provided src_list is a security list that
    // has DENY as its outbound policy.
    // You cannot specify any of the security
    // IP lists in the /oracle/public container
    // as a destination in a secrule.
    Dst_list string `json:"dst_list"`

    // Name is the
    Name string `json:"name"`

    // Is the id of the sec rule
    Id  string `json:"id"`

    Src_is_ip string `json:"src_is_ip"`

    // Src_list name of the source security list or security IP list
    // You must use the prefix seclist:
    // or seciplist: to identify the list type
    Src_list string `json:"src_list"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

SecRule is a security rule defines network access over a specified protocol between instances in two security lists, or from a set of external hosts (an IP list) to instances in a security list Security rules tie the security list, security IP list, and security application entities together.

type SecurityProtocol Uses

type SecurityProtocol struct {

    // Description is a description of the security protocol
    Description string `json:"description,omitempty"`

    // DstPortSet enter a list of port numbers or port range strings.
    // Traffic is enabled by a security rule when a packet's destination
    // port matches the ports specified here.
    // For TCP, SCTP, and UDP, each port is a destination transport port,
    // between 0 and 65535, inclusive. For ICMP,
    // each port is an ICMP type, between 0 and 255, inclusive.
    // If no destination ports are specified, all destination ports or
    // ICMP types are allowed.
    DstPortSet []string `json:"dstPortSet"`

    // IpProtocol the protocol used in the data portion of the IP datagram.
    // Specify one of the permitted values or enter a number in the range 0–254
    // to represent the protocol that you want to specify. See Assigned Internet
    // Protocol Numbers. Permitted values are: tcp, udp, icmp, igmp, ipip,
    // rdp, esp, ah, gre, icmpv6, ospf, pim, sctp, mplsip, all.
    // Traffic is enabled by a security rule when the protocol in the packet
    // matches the protocol specified here. If no protocol is specified,
    // all protocols are allowed.
    IpProtocol common.Protocol `json:"ipProtocol"`

    // Name is the name of the security protocol
    Name string `json:"name"`

    // SrcPortSet is a list of port numbers or port range strings.
    // Traffic is enabled by a security rule when a packet's source port
    // matches the ports specified here.
    // For TCP, SCTP, and UDP, each port is a source transport port,
    // between 0 and 65535, inclusive. For ICMP, each port is an ICMP type,
    // between 0 and 255, inclusive.
    // If no source ports are specified, all source ports or ICMP
    // types are allowed.
    SrcPortSet []string `json:"srcPortSet"`

    // Tags is strings that you can use to tag the security protocol.
    Tags []string

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

SecurityProtocol is a security protocol allows you to specify a transport protocol and the source and destination ports to be used with the specified protocol. It is used for matching packets in a security rule. When you create a security rule, the protocols and ports of the specified security protocols are used to determine the type of traffic that is permitted by that security rule. If you don't specify protocols and ports in a security protocol, traffic is permitted over all protocols and ports. You can specify a security protocol in multiple security rules. So if you have a protocol that you want to use in a number of security rules, you don't have to create the protocol multiple times.

type SecurityRule Uses

type SecurityRule struct {
    // Acl is the name of the acl that contains this rule
    Acl string `json:"acl"`

    // Description is the description of the object
    Description string `json:"description,omitempty"`

    // DstIpAddressPrefixSets list of IP address prefix set names
    // to match the packet's destination IP address.
    DstIpAddressPrefixSets []string `json:"dstIpAddressPrefixSets"`

    // DstVnicSet the name of virtual NIC set containing the
    // packet's destination virtual NIC.
    DstVnicSet string `json:"dstVnicSet"`

    // EnabledFlag false indicated that the security rule is disabled
    EnabledFlag bool `json:"enabledFlag"`

    // FlowDirection is the direction of the flow;
    // Can be "egress" or "ingress".
    FlowDirection common.FlowDirection `json:"flowDirection"`

    // Name is the name of the security rule
    Name string `json:"name"`

    // SecProtocols is the list of security protocol object
    // names to match the packet's protocol and port.
    SecProtocols []string `json:"secProtocols"`

    // SrcIpAddressPrefixSets list of multipart names of
    // IP address prefix set to match the packet's source IP address.
    SrcIpAddressPrefixSets []string `json:"srcIpAddressPrefixSets"`

    // SrcVnicSet is the name of virtual NIC set containing
    // the packet's source virtual NIC.
    SrcVnicSet string `json:"srcVnicSet"`

    // Tags associated with the object.
    Tags []string `json:"tags,omitempty"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

SecurityRule is a security rule permits traffic from a specified source or to a specified destination. You must specify the direction of a security rule - either ingress or egress. In addition, you can specify the source or destination of permitted traffic, and the security protocol and port used to send or receive packets. Each of the parameters that you specify in a security rule provides a criterion that the type of traffic permitted by that rule must match. Only packets that match all of the specified criteria are permitted. If you don't specify match criteria in the security rule, all traffic in the specified direction is permitted. The primary function of security rules is to help identify the type of traffic to be allowed in the IP network.

type Shape Uses

type Shape struct {
    // Limits the rate of IO for NDS storage volumes.
    Nds_iops_limit uint64 `json:"nds_iops_limit"`

    // Number of megabytes of memory allocated to instances of this shape.
    Ram uint64 `json:"ram"`

    // Store the root disk image on SSD storage.
    Is_root_ssd bool `json:"is_root_ssd,omitempty"`

    // Size of the local SSD data disk in bytes.
    Ssd_data_size uint64 `json:"ssd_data_size,omitmepty"`

    // Number of gpu devices allocated to instances of this shape
    Gpus uint64 `json:"gpus,omitempty"`

    // Number of CPUs or partial CPUs allocated to instances of this shape.
    Cpus float64 `json:"cpus"`

    // Uniform Resource Identifier of the shape
    Uri string `json:"uri"`

    // Size of the root disk in bytes.
    Root_disk_size uint64 `json:"root_disk_size"`

    // IO share allocated to instances of this shape.
    Io  uint64 `json:"io"`

    // Name of this shape.
    Name string `json:"name"`
}

A shape is a resource profile that specifies the number of OCPUs and the amount of memory to be allocated to an instance in Oracle Compute Cloud Service. The shape determines the type of disk drive that your instance uses. If you select a general purpose or high-memory shape, a hard-disk drive is used. If you select a high-I/O shape, an NVM Express solid-state drive is used. High-I/O shapes also determine the size of the root disk.

type Storage Uses

type Storage struct {
    Index               uint64 `json:"index"`
    Storage_volume_name string `json:"storage_volume_name"`
    Name                string `json:"name"`
}

type StorageAttachment Uses

type StorageAttachment struct {

    // Account shows the default account for your identity domain
    Account *string `json:"account,omitempty"`

    // Hypervisor type to which this volume was attached to
    Hypervisor *string `json:"hypervisor,omitempty"`

    // Index number for the volume.
    // The allowed range is 1-10.
    // The index determines the device name by which the
    // volume is exposed to the instance. Index 0 is allocated
    // to the temporary boot disk, /dev/xvda An attachment with
    // index 1 is exposed to the instance as /dev/xvdb,
    // an attachment with index 2 is exposed as /dev/xvdc, and so on
    Index common.Index `json:"index"`

    // Instance_name multipart name of the instance
    // to which you want to attach the volume
    Instance_name string `json:"instance_name"`

    // Storage_volume_name is the name of the storage volume
    Storage_volume_name string `json:"storage_volume_name"`

    Name string `json:"name"`

    // Readonly when set to true, it indicates
    // that the volume is a read-only storage volume
    Readonly bool `json:"readonly"`

    // State specifies one of the following states of the storage attachment:
    // common.StateAttaching: The storage attachment is in
    // the process of attaching to the instance.
    // common.StateAttached: The storage attachment is
    // attached to the instance
    // common.StateDetaching: The storage attachment is
    // in the process of detaching from the instance
    // common.stateUnavailable: The storage attachment is unavailable
    // common.StateUnknown: The state of the storage attachment is not known
    State common.StateStorage `json:"state"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

StorageAttachment is a storage attachment is an association between a storage volume and an instance. You can associate a volume to only one instance at a time. You can detach a volume from an instance by deleting the relevant storage attachment

type StorageOrhcestration Uses

type StorageOrhcestration struct {
    Volume string `json:"volume,omitempty"`
    Index  int    `json:"index,omitempty"`
}

type StorageProperty Uses

type StorageProperty struct {

    // Description of this property.
    Description string `json:"description,omitempty"`
    // Name is the storage property name
    // one of the following storage properties:
    // oracle/public/storage/default
    // oracle/public/storage/latency
    Name string `json:"name"`

    Uri string `json:"uri"`
}

StorageProperty are storage properties used to describe the characteristics of storage pools and are used to determine volume placement within a pool when a volume is created. You must specify a storage property while creating a storage volume. For storage volumes that require low latency and high IOPS, such as for storing database files, select the /oracle/public/storage/latency storage property. For all other storage volumes, select /oracle/public/storage/default.

type StorageSnapshot Uses

type StorageSnapshot struct {

    // Account to use for snapshots
    Account *string `json:"account,omitempty"`

    // Description is the description of the storage
    // snapshot
    Description string `json:"description,omitempty"`

    // Machineimage_name is the name of the machine
    // image that's used in the boot volume
    // from which this snapshot is taken
    Machineimage_name *string `json:"machineimage_name,omitempty"`

    // Name is the name of the snapshot
    Name string `json:"name"`

    // Property that describes:
    // If you don't specify a value, a remote snapshot is created.
    // Remote snapshots aren't stored in the
    // same location as the original storage volume. Instead,
    // they are reduced and stored in the associated Oracle
    // Storage Cloud Service instance. Remote snapshots are useful
    // if your domain spans multiple sites.
    // With remote snapshots, you can create a snapshot in one
    // site, then switch to another site and create a copy of the
    // storage volume on that site. However, creating a
    // remote snapshot and restoring a storage volume from a remote
    // snapshot can take quite a long time depending on the size
    // of the storage volume, as data is written to and from
    // the Oracle Storage Cloud Service instance.
    // Specify /oracle/private/storage/snapshot/collocated to
    // create a collocated snapshot. Colocated snapshots
    // are stored in the same physical location as the
    // original storage volume and each snapshot uses the
    // same amount of storage as the original volume.
    // Colocated snapshots and volumes from colocated snapshots can
    // be created very quickly. Colocated snapshots are useful
    // for quickly cloning storage volumes within a site.
    // However, you can't restore volumes across sites using colocated snapshots
    Property string `json:"property"`

    // Size is the size of the storage snapshot in bytes
    Size uint64 `json:"size, string"`

    // Snapshot_id is a unique id for this snapshot
    // auto-generated by the server
    Snapshot_id string `json:"snapshot_id"`

    // Snapshot_timestamp is the timestamp of the storage snapshot,
    // generated by storage server. The snapshot will contain
    // data written to the original volume before this time
    Snapshot_timestamp *string `json:"snapshot_timestamp,omitempty"`

    // Start_timestamp is the timestamp when the operation is started
    Start_timestamp string `json:"start_timestamp"`

    // Status is the current status of the storage snapshot
    Status string `json:"status"`

    // Status_details indicates details about the latest
    // state of the storage volume snapshot.
    Status_detail string `json:"status_detail"`

    // Status_timestamp indicates the time that the current view of
    // the storage volume snapshot was generated.
    Status_timestamp string `json:"status_timestamp"`

    // Tags are strings that describe the
    // storage snapshot and help you identify it
    Tags []string `json:"tags,omitempty"`

    // Volume is the volume name you wish to create
    // the snapshot
    Volume string `json:"volume"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

type StorageVolume Uses

type StorageVolume struct {

    // Account is the the default account for your identity domain
    Account string `json:"account"`

    // Bootable is a a boolean field that indicates whether
    // the storage volume can be used as the boot
    // disk for an instance.
    // If you set the value to true, then you must
    // specify values for the following parameters imagelist
    // The machine image that you want to extract
    // on to the storage volume that you're creating.
    // imagelist_entry field (optional)
    // for the version of the image list entry
    // that you want to extract. The default value is 1.
    Bootable bool `json:"bootable"`

    // Description is the description of the
    // storage volume
    Description *string `json:"description"`

    // Hypervisor is the hypervisor that this volume is compatible with
    Hypervisor *string `json:"hypervisor"`

    // Imagelist is the name of machineimage
    // to extract onto this volume when created.<Paste>
    Imagelist string `json:"imagelist"`

    // Imagelist_entry is a pecific imagelist entry version to extract.
    Imagelist_entry int `json:"imagelist_entry"`

    // Machineimage_name three-part name of the machine image.
    // This information is available if the volume
    // is a bootable storage volume
    Machineimage_name string `json:"machineimage_name"`

    // Managed flag indicating that all volumes are managed volumes.
    // Default value is true.
    Managed bool `json:"managed"`

    // Name is the name of the storage volume
    Name string `json:"name"`

    // Platform is the OS platform this volume is compatible with
    Platform string `json:"platform"`

    // Properties contains the storage-pool properties
    // For storage volumes that require low latency and high IOPS,
    // such as for storing database files, specify common.LatencyPool
    // For all other storage volumes, specify common.DefaultPool
    Properties []common.StoragePool `json:"properties"`

    // Quota field not used
    Quota *string `json:"quota,omitempty"`

    // Readonly boolean field indicating whether this volume
    // can be attached as readonly. If set to False the
    // volume will be attached as read-write
    Readonly bool `json:"readonly"`

    // Shared not used
    Shared bool `json:"shared"`

    // Size is the the size of this storage volume.
    // Use one of the following abbreviations for the unit of measurement:
    // B or b for bytes
    // K or k for kilobytes
    // M or m for megabytes
    // G or g for gigabytes
    // T or t for terabytes
    // For example, to create a volume of size 10 gigabytes,
    // you can specify 10G, or 10240M, or 10485760K, and so on.
    // The allowed range is from 1 GB to 2 TB, in increments of 1 GB.
    // If you are creating a bootable storage volume, ensure
    // that the size of the storage volume is greater
    // than the size of the machine image that you want
    // to extract on to the storage volume.
    // If you are creating this storage volume from a storage snapshot,
    // ensure that the size of the storage volume that you create
    // is greater than the size of the storage snapshot.
    Size int `json:",string"`

    // Snapshot multipart name of the storage volume snapshot if
    // this storage volume is a clone.
    Snapshot *string `json:"snapshot"`

    // Snapshot_account of the parent snapshot
    // from which the storage volume is restored
    Snapshot_account string `json:"snapshot_account"`

    // Snapshot_id is the dd of the parent snapshot
    // from which the storage volume is restored or cloned
    Snapshot_id string `json:"snapshot_id"`

    // Status it the current state of the storage volume
    Status common.VolumeState `json:"status"`

    // Status_details details about the latest state of the storage volume.
    Status_detail string `json:"status_detail"`

    // Status_timestamp indicates the time that the current
    // view of the storage volume was generated
    Status_timestamp string `json:"status_timestamp"`

    // Storage_pool is the storage
    // pool from which this volume is allocated
    Storage_pool string `json:"storage_pool"`

    // Tags are strings that you can use to tag the storage volume.
    Tags []string `json:"tags,omitempty"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    // Writecache not used
    Writecache bool `json:"writecache"`
}

StorageVolueme is a storage volume is virtual disk drive that provides block storage for Oracle Compute Cloud Service instances.

type Userdata Uses

type Userdata map[string]interface{}

Userdata key value pair In order to read elements from it you should use the build in function for this type StringValue

func (Userdata) StringValue Uses

func (u Userdata) StringValue(key string) string

StringValue returns a string from a given key in the userdata

type VirtualNic Uses

type VirtualNic struct {

    // Name is the name of the vnc
    Name string `json:"name"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`

    //Description is the description of the object.
    Description *string `json:"description,omitempty"`

    // Tags associated with the object.
    Tags []string `json:"tags"`

    // MacAddress holds the MAC address of this VNIC.
    MacAddress string `json:"macAddress"`

    //TransitFlag is True if the VNIC is of type "transit".
    TransitFlag bool `json:"transitFlag"`
}

VirtualNic A Virtual NIC, or vNIC, is a virtual network interface card that enables an instance to be associated

with a network. Instances created after mid-September 2016 using

Oracle-provided images support eight vNICs, enabling each instance to be associated with up to eight networks. Virtual NIC is created when you launch an instance using an orchestration and in the network attributes

you specify the IP network or shared network that each vNIC of an instance

should be associated with. For more information, see Instance Attributes in Using Oracle Compute Cloud Service (IaaS).

type VnicSet Uses

type VnicSet struct {

    // AppliedAcls is a list of ACLs applied to the VNICs in the set.
    AppliedAcls []string `json:"appliedAcls,omitempty"`

    // Description of the object
    Description *string `json:"description,omitempty"`

    // Name is the name of the vnic set
    Name string `json:"name"`

    // Tags associated with the object.
    Tags []string `json:"tags"`

    // List of VNICs associated with this VNIC set
    Vnics []string `json:"vnics"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

VnicSet is a A Virtual NIC Set, or vNICset, is a collection of one or more vNICs. You must specify a vNICset when you create a route. When a vNICset containing multiple vNICs is used in a route, Equal Cost Multipath (ECMP) anycast routing is implemented. Traffic routed by that route is load balanced across all the vNICs in the vNICset. Using vNICsets with multiple vNICs also ensures high availability for traffic across the specified vNICs

type VpnEndpoint Uses

type VpnEndpoint struct {
    // Customer_vpn_gateway specify the IP address of the
    // VPN gateway in your data center through which
    // you want to connect to the Oracle Cloud VPN gateway.
    // Your gateway device must support route-based VPN
    // and IKE (Internet Key Exchange) configuration
    // using pre-shared keys.
    Customer_vpn_gateway string `json:"customer_vpn_gateway"`

    // Enabled flag, enables the VPN endpoint.
    // To start a VPN connection, set to true.
    // A connection is established immediately, if possible.
    // If you do not specify this option, the VPN
    // endpoint is disabled and the
    // connection is not established
    Enabled bool `json:"enabled"`

    // Name is the name of the vpn endpoint resource
    Name string `json:"name"`

    // Psk is the pre-shared VPN key. Enter the pre-shared key.
    // This must be the same key that you provided
    // when you requested the service. This secret key
    // is shared between your network gateway and the
    // Oracle Cloud network for authentication.
    // Specify the full path and name of the text file
    // that contains the pre-shared key. Ensure
    // that the permission level of the text file is
    // set to 400. The pre-shared VPN key must not
    // exceed 256 characters.
    Psk string `json:"psk"`

    // Reachable_routes is a list of routes (CIDR prefixes)
    // that are reachable through this VPN tunnel.
    // You can specify a maximum of 20 IP subnet addresses.
    // Specify IPv4 addresses in dot-decimal
    // notation with or without mask.
    Reachable_routes []string `json:"reachable_routes"`

    // Status is the current status of the VPN tunnel.
    Status string `json:"status"`

    // Status_desc describes the current status of the VPN tunnel.
    Status_desc string `json:"status_desc"`

    // Uri is the Uniform Resource Identifier
    Uri string `json:"uri"`
}

Package response imports 2 packages (graph) and is imported by 14 packages. Updated 2017-04-27. Refresh now. Tools for package owners.