// WaitForSnapShotReady waits for snapshot ready
func (client *Client) WaitForSnapShotReady(regionId common.Region, snapshotId string, timeout int) error {
if timeout <= 0 {
timeout = SnapshotDefaultTimeout
}
for {
args := DescribeSnapshotsArgs{
RegionId: regionId,
SnapshotIds: []string{snapshotId},
}
snapshots, _, err := client.DescribeSnapshots(&args)
if err != nil {
return err
}
if snapshots == nil || len(snapshots) == 0 {
return common.GetClientErrorFromString("Not found")
}
if snapshots[0].Progress == "100%" {
break
}
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
}
return nil
}
// WaitForDisk waits for disk to given status
func (client *Client) WaitForDisk(regionId common.Region, diskId string, status DiskStatus, timeout int) error {
if timeout <= 0 {
timeout = DefaultTimeout
}
args := DescribeDisksArgs{
RegionId: regionId,
DiskIds: []string{diskId},
}
for {
disks, _, err := client.DescribeDisks(&args)
if err != nil {
return err
}
if disks == nil || len(disks) == 0 {
return common.GetClientErrorFromString("Not found")
}
if disks[0].Status == status {
break
}
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
}
return nil
}
//Wait Image ready
func (client *Client) WaitForImageReady(regionId common.Region, imageId string, timeout int) error {
if timeout <= 0 {
timeout = ImageDefaultTimeout
}
for {
args := DescribeImagesArgs{
RegionId: regionId,
ImageId: imageId,
Status: ImageStatusCreating,
}
images, _, err := client.DescribeImages(&args)
if err != nil {
return err
}
if images == nil || len(images) == 0 {
args.Status = ImageStatusAvailable
images, _, er := client.DescribeImages(&args)
if er == nil && len(images) == 1 {
break
} else {
return common.GetClientErrorFromString("Not found")
}
}
if images[0].Progress == "100%" {
break
}
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
}
return nil
}
// WaitForVSwitchAvailable waits for VSwitch to given status
func (client *Client) WaitForVSwitchAvailable(vpcId string, vswitchId string, timeout int) error {
if timeout <= 0 {
timeout = DefaultTimeout
}
args := DescribeVSwitchesArgs{
VpcId: vpcId,
VSwitchId: vswitchId,
}
for {
vswitches, _, err := client.DescribeVSwitches(&args)
if err != nil {
return err
}
if len(vswitches) == 0 {
return common.GetClientErrorFromString("Not found")
}
if vswitches[0].Status == VSwitchStatusAvailable {
break
}
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
}
return nil
}
// WaitForVSwitchAvailable waits for VSwitch to given status
func (client *Client) WaitForEip(regionId common.Region, allocationId string, status EipStatus, timeout int) error {
if timeout <= 0 {
timeout = DefaultTimeout
}
args := DescribeEipAddressesArgs{
RegionId: regionId,
AllocationId: allocationId,
}
for {
eips, _, err := client.DescribeEipAddresses(&args)
if err != nil {
return err
}
if len(eips) == 0 {
return common.GetClientErrorFromString("Not found")
}
if eips[0].Status == status {
break
}
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
}
return nil
}
// WaitForListener waits for listener to given status
func (client *Client) WaitForListener(loadBalancerId string, port int, listenerType ListenerType) (status ListenerStatus, err error) {
timeout := DefaultTimeout
args := &CommonLoadBalancerListenerArgs{
LoadBalancerId: loadBalancerId,
ListenerPort: port,
}
method := fmt.Sprintf("DescribeLoadBalancer%sListenerAttribute", listenerType)
response := &DescribeLoadBalancerListenerAttributeResponse{}
for {
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return response.Status, common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
//Sleep first to ensure the previous request is sent
err = client.Invoke(method, args, response)
if err != nil {
return "", err
}
if response.Status == Running || response.Status == Stopped {
break
}
}
return response.Status, nil
}
// WaitForAllRouteEntriesAvailable waits for all route entries to Available status
func (client *Client) WaitForAllRouteEntriesAvailable(vrouterId string, routeTableId string, timeout int) error {
if timeout <= 0 {
timeout = DefaultTimeout
}
args := DescribeRouteTablesArgs{
VRouterId: vrouterId,
RouteTableId: routeTableId,
}
for {
routeTables, _, err := client.DescribeRouteTables(&args)
if err != nil {
return err
}
sucess := true
loop:
for _, routeTable := range routeTables {
for _, routeEntry := range routeTable.RouteEntrys.RouteEntry {
if routeEntry.Status != RouteEntryStatusAvailable {
sucess = false
break loop
}
}
}
if sucess {
break
}
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
}
return nil
}
// WaitForInstance waits for instance to given status
func (client *Client) WaitForVpcAvailable(regionId common.Region, vpcId string, timeout int) error {
if timeout <= 0 {
timeout = DefaultTimeout
}
args := DescribeVpcsArgs{
RegionId: regionId,
VpcId: vpcId,
}
for {
vpcs, _, err := client.DescribeVpcs(&args)
if err != nil {
return err
}
if len(vpcs) > 0 && vpcs[0].Status == VpcStatusAvailable {
break
}
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
}
return nil
}
// WaitForInstance waits for instance to given status
func (client *Client) WaitForInstance(instanceId string, status InstanceStatus, timeout int) error {
if timeout <= 0 {
timeout = InstanceDefaultTimeout
}
for {
instance, err := client.DescribeInstanceAttribute(instanceId)
if err != nil {
return err
}
if instance.Status == status {
//TODO
//Sleep one more time for timing issues
time.Sleep(DefaultWaitForInterval * time.Second)
break
}
timeout = timeout - DefaultWaitForInterval
if timeout <= 0 {
return common.GetClientErrorFromString("Timeout")
}
time.Sleep(DefaultWaitForInterval * time.Second)
}
return nil
}