Struct aws_manager::ec2::Manager

pub struct Manager { /* private fields */ }

Implements AWS EC2 manager.

Implementations

impl Manager

pub fn new(shared_config: &AwsSdkConfig) -> Self

pub fn client(&self) -> Client

pub async fn create_key_pair(&self, key_name: &str, key_path: &str) -> Result<()>

Creates an AWS EC2 key-pair and saves the private key to disk. It overwrites “key_path” file with the newly created key.

pub async fn delete_key_pair(&self, key_name: &str) -> Result<()>

Deletes the AWS EC2 key-pair.

pub async fn describe_volumes(
    &self,
    filters: Option<Vec<Filter>>
) -> Result<Vec<Volume>>

Describes the EBS volumes by filters. ref. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVolumes.html

Examples found in repository

src/ec2/mod.rs (lines 180-183)

    pub async fn poll_volume_state(
        &self,
        ebs_volume_id: String,
        desired_state: VolumeState,
        timeout: Duration,
        interval: Duration,
    ) -> Result<Option<Volume>> {
        let start = Instant::now();
        let mut cnt: u128 = 0;
        loop {
            let elapsed = start.elapsed();
            if elapsed.gt(&timeout) {
                break;
            }

            let itv = {
                if cnt == 0 {
                    // first poll with no wait
                    Duration::from_secs(1)
                } else {
                    interval
                }
            };
            sleep(itv).await;

            let volumes = self
                .describe_volumes(Some(vec![Filter::builder()
                    .set_name(Some(String::from("volume-id")))
                    .set_values(Some(vec![ebs_volume_id.clone()]))
                    .build()]))
                .await?;
            if volumes.is_empty() {
                if desired_state.eq(&VolumeState::Deleted) {
                    log::info!("volume already deleted");
                    return Ok(None);
                }

                log::warn!("no volume found");
                continue;
            }
            if volumes.len() != 1 {
                log::warn!("unexpected {} volumes found", volumes.len());
                continue;
            }
            let volume = volumes[0].clone();

            let current_state = {
                if let Some(v) = volume.state() {
                    v.clone()
                } else {
                    VolumeState::from("not found")
                }
            };
            log::info!(
                "poll (current volume state {:?}, elapsed {:?})",
                current_state,
                elapsed
            );

            if current_state.eq(&desired_state) {
                return Ok(Some(volume));
            }

            cnt += 1;
        }

        Err(Other {
            message: format!(
                "failed to poll volume state for '{}' in time",
                ebs_volume_id
            ),
            is_retryable: true,
        })
    }

    /// Describes the attached volume by the volume Id and EBS device name.
    /// The "local_ec2_instance_id" is only set to bypass extra EC2 metadata
    /// service API calls.
    /// The region used for API call is inherited from the EC2 client SDK.
    ///
    /// e.g.,
    ///
    /// aws ec2 describe-volumes \
    /// --region ${AWS::Region} \
    /// --filters \
    ///   Name=attachment.instance-id,Values=$INSTANCE_ID \
    ///   Name=attachment.device,Values=/dev/xvdb \
    /// --query Volumes[].Attachments[].State \
    /// --output text
    ///
    /// ref. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVolumes.html
    /// ref. https://github.com/ava-labs/avalanche-ops/blob/fcbac87a219a8d3d6d3c38a1663fe1dafe78e04e/bin/avalancheup-aws/cfn-templates/asg_amd64_ubuntu.yaml#L397-L409
    ///
    pub async fn describe_local_volumes(
        &self,
        ebs_volume_id: Option<String>,
        ebs_device_name: String,
        local_ec2_instance_id: Option<String>,
    ) -> Result<Vec<Volume>> {
        let mut filters: Vec<Filter> = vec![];

        if let Some(v) = ebs_volume_id {
            log::info!("filtering volumes via volume Id {}", v);
            filters.push(
                Filter::builder()
                    .set_name(Some(String::from("volume-id")))
                    .set_values(Some(vec![v]))
                    .build(),
            );
        }

        let device = if ebs_device_name.starts_with("/dev/") {
            ebs_device_name
        } else {
            format!("/dev/{}", ebs_device_name.clone()).to_string()
        };
        log::info!("filtering volumes via EBS device name {}", device);
        filters.push(
            Filter::builder()
                .set_name(Some(String::from("attachment.device")))
                .set_values(Some(vec![device]))
                .build(),
        );

        let ec2_instance_id = if let Some(v) = local_ec2_instance_id {
            v
        } else {
            metadata::fetch_instance_id().await?
        };
        log::info!("filtering volumes via instance Id {}", ec2_instance_id);
        filters.push(
            Filter::builder()
                .set_name(Some(String::from("attachment.instance-id")))
                .set_values(Some(vec![ec2_instance_id]))
                .build(),
        );

        self.describe_volumes(Some(filters)).await
    }

pub async fn poll_volume_state(
    &self,
    ebs_volume_id: String,
    desired_state: VolumeState,
    timeout: Duration,
    interval: Duration
) -> Result<Option<Volume>>

Polls the EBS volume by its state.

pub async fn describe_local_volumes(
    &self,
    ebs_volume_id: Option<String>,
    ebs_device_name: String,
    local_ec2_instance_id: Option<String>
) -> Result<Vec<Volume>>

Describes the attached volume by the volume Id and EBS device name. The “local_ec2_instance_id” is only set to bypass extra EC2 metadata service API calls. The region used for API call is inherited from the EC2 client SDK.

e.g.,

aws ec2 describe-volumes
–region ${AWS::Region}
–filters
Name=attachment.instance-id,Values=$INSTANCE_ID
Name=attachment.device,Values=/dev/xvdb
–query Volumes[].Attachments[].State
–output text

ref. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVolumes.html ref. https://github.com/ava-labs/avalanche-ops/blob/fcbac87a219a8d3d6d3c38a1663fe1dafe78e04e/bin/avalancheup-aws/cfn-templates/asg_amd64_ubuntu.yaml#L397-L409

Examples found in repository

src/ec2/mod.rs (lines 324-328)

    pub async fn poll_local_volume_by_attachment_state(
        &self,
        ebs_volume_id: Option<String>,
        ebs_device_name: String,
        desired_attachment_state: VolumeAttachmentState,
        timeout: Duration,
        interval: Duration,
    ) -> Result<Volume> {
        let local_ec2_instance_id = metadata::fetch_instance_id().await?;
        let start = Instant::now();
        let mut cnt: u128 = 0;
        loop {
            let elapsed = start.elapsed();
            if elapsed.gt(&timeout) {
                break;
            }

            let itv = {
                if cnt == 0 {
                    // first poll with no wait
                    Duration::from_secs(1)
                } else {
                    interval
                }
            };
            sleep(itv).await;

            let volumes = self
                .describe_local_volumes(
                    ebs_volume_id.clone(),
                    ebs_device_name.clone(),
                    Some(local_ec2_instance_id.clone()),
                )
                .await?;
            if volumes.is_empty() {
                log::warn!("no volume found");
                continue;
            }
            if volumes.len() != 1 {
                log::warn!("unexpected {} volumes found", volumes.len());
                continue;
            }
            let volume = volumes[0].clone();
            if volume.attachments().is_none() {
                log::warn!("no attachment found");
                continue;
            }
            let attachments = volume.attachments().unwrap();
            if attachments.is_empty() {
                log::warn!("no attachment found");
                continue;
            }
            if attachments.len() != 1 {
                log::warn!("unexpected attachment found {}", attachments.len());
                continue;
            }
            let current_attachment_state = attachments[0].state().unwrap();
            log::info!(
                "poll (current volume attachment state {:?}, elapsed {:?})",
                current_attachment_state,
                elapsed
            );

            if current_attachment_state.eq(&desired_attachment_state) {
                return Ok(volume);
            }

            cnt += 1;
        }

        Err(Other {
            message: format!(
                "failed to poll volume attachment state for '{}' in time",
                local_ec2_instance_id
            ),
            is_retryable: true,
        })
    }

pub async fn poll_local_volume_by_attachment_state(
    &self,
    ebs_volume_id: Option<String>,
    ebs_device_name: String,
    desired_attachment_state: VolumeAttachmentState,
    timeout: Duration,
    interval: Duration
) -> Result<Volume>

Polls the EBS volume attachment state. For instance, the “device_name” can be either “/dev/xvdb” or “xvdb” (for the secondary volume).

pub async fn fetch_tags(&self, instance_id: Arc<String>) -> Result<Vec<Tag>>

Fetches all tags for the specified instance.

“If a single piece of data must be accessible from more than one task concurrently, then it must be shared using synchronization primitives such as Arc.” ref. https://tokio.rs/tokio/tutorial/spawning

pub async fn list_asg(&self, asg_name: &str) -> Result<Vec<Droplet>>

Lists instances by the Auto Scaling Groups name.

pub async fn allocate_eip(&self, kind_tag: &str, id_tag: &str) -> Result<Eip>

Allocates an EIP and returns the allocation Id and the public Ip. ref. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateAddress.html

pub async fn associate_eip(
    &self,
    allocation_id: &str,
    instance_id: &str
) -> Result<String>

Associates the elastic Ip with an EC2 instance. ref. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateAddress.html

pub async fn describe_eips_by_instance_id(
    &self,
    instance_id: &str
) -> Result<Vec<Address>>

Describes the elastic IP addresses with the instance Id. ref. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html

pub async fn describe_eips_by_tags(
    &self,
    tags: HashMap<String, String>
) -> Result<Vec<Address>>

Describes the elastic IP addresses with the tags. ref. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html

pub async fn poll_eip_by_describe_addresses(
    &self,
    association_id: &str,
    instance_id: &str,
    timeout: Duration,
    interval: Duration
) -> Result<Vec<Address>>

Polls the elastic Ip for its describe address state, until the elastic Ip becomes attached to the instance. ref. https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html

Trait Implementations

impl Clone for Manager

fn clone(&self) -> Manager

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Manager

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.