File Coverage

blib/lib/MHA/AWS.pm

Criterion	Covered	Total	%
statement	24	96	25.0
branch	0	26	0.0
condition	0	9	0.0
subroutine	8	18	44.4
pod	0	8	0.0
total	32	157	20.3

package MHA::AWS;

use 5.008001;
use strict;
use warnings;
use Log::Minimal;
use AWS::CLIWrapper;
use Time::HiRes qw/ sleep /;
use Scalar::Util qw/ blessed /;
use Moo;

our $VERSION             = "0.05";
our $API_APPLIED_TIMEOUT = 120;
our $CHECK_INTERVAL      = 5;

has host             => ( is => "rw" );
has orig_master_host => ( is => "rw" );
has new_master_host  => ( is => "rw" );
has attachment_id    => ( is => "rw" );
has vip              => ( is => "rw" );
has ssh_user         => ( is => "rw" );
has instance_ids     => ( is => "rw", default => sub { +{} } );
has interface_id     => ( is => "rw" );
has failover_method  => ( is => "rw", required => 1 );
has route_table_id   => ( is => "rw" );
has aws => (
    is      => "rw",
    default => sub {
        AWS::CLIWrapper->new();
    },
);
has current_attached_instance_id => ( is => "rw" );

sub _init_eni {
    my $self = shift;
    my $res;
    $res = $self->ec2("describe-network-interfaces", {
        network_interface_ids => $self->interface_id,
    });
    my $interface = $res->{NetworkInterfaces}->[0];
    unless ($interface) {
        critf "Can't find network interface: %s", $self->interface_id;
        die;
    }

    $self->attachment_id( $interface->{Attachment}->{AttachmentId} );
    $self->current_attached_instance_id( $interface->{Attachment}->{InstanceId} );
    $self->vip( $interface->{PrivateIpAddress} );
}

sub _init_route_table {
    my $self = shift;
    my $res;
    my $destination_cidr_block = sprintf("%s/32", $self->vip);
    $res = $self->ec2("describe-route-tables", {
        route_table_id => $self->route_table_id,
    });
    if ( !$res->{RouteTables}->[0] ) {
        critf "Can't find route_table: %s", $self->route_table_id;
        die;
    }
    for my $route (@{ $res->{RouteTables}->[0]->{Routes} }) {
        if ($route->{DestinationCidrBlock} eq $destination_cidr_block) {
            $self->current_attached_instance_id($route->{InstanceId});
            return 1;
        }
    }
}

sub init {
    my $self = shift;

    if ($self->failover_method eq "eni") {
        $self->_init_eni;
    }
    else {
        $self->_init_route_table;
    }

    # create mapping table (hostname => instance-id) from tags
    my $res = $self->ec2("describe-tags");
    for my $tag (@{ $res->{Tags} }) {
        if ($tag->{ResourceType} eq "instance" && $tag->{Key} eq "Name") {
            $self->instance_ids->{ $tag->{Value} } = $tag->{ResourceId};
        }
    }

    if ( $self->new_master_host && !$self->new_master_instance_id ) {
        critf "Can't detect new_master_instance_id. abort";
        die;
    }
    if ( $self->orig_master_host && !$self->orig_master_instance_id ) {
        critf "Can't detect orig_master_instance_id. abort";
        die;
    }
}

sub ec2 {
    my $self = shift;
    my ($command, $args) = @_;
    infof "aws ec2 %s %s", $command, defined($args) ? ddf $args : "";
    my $res = $self->aws->ec2($command, $args);
    if ($res) {
        debugf "result: %s", ddf $res;
    }
    else {
        critf "failed";
        die;
    }
    $res;
}

sub ping {
    my $self    = shift;
    my $ip_addr = shift;
    system(qw/ timeout 3 ping -c 1 -t 3 /, $ip_addr) == 0 ? 1 : 0;
}

sub host_instance_id {
    my $self = shift;
    $self->instance_ids->{ $self->host };
}

sub new_master_instance_id {
    my $self = shift;
    $self->instance_ids->{ $self->new_master_host };
}

sub orig_master_instance_id {
    my $self = shift;
    $self->instance_ids->{ $self->orig_master_host };
}

sub dispatch {
    my $self    = shift;
    my $command = shift;
    if ( my $method = $self->can("_command_${command}") ) {
        infof "Invoke command: %s::%s", ref $self, $command;
        my $success = $method->($self);
        if ($success) {
            infof "Complete!";
        }
        else {
            infof "Failed!";
            die;
        }
    }
    else {
        critf("Unknown command: %s", $command);
        die;
    }
}

sub info {
    my $self = shift;
    my $info = {};
    for my $key (sort keys %$self) {
        next if Scalar::Util::blessed($self->{$key});
        $info->{$key} = $self->{$key};
    }
    $info;
}

1;
__END__