view release on metacpan or  search on metacpan

lib/AWS/Networks.pm  view on Meta::CPAN

package AWS::Networks;
  use Moose;
  use JSON;
  use HTTP::Tiny;
  use DateTime;

  our $VERSION = '0.01';

  has url => (
    is => 'ro', 
    isa => 'Str|Undef', 
    default => 'https://ip-ranges.amazonaws.com/ip-ranges.json'
  );

  has netinfo => (
    is => 'ro',
    isa => 'HashRef',
    default => sub {
      my $self = shift;
      die "Can't get some properties from derived results" if (not $self->url);
      my $response = HTTP::Tiny->new->get($self->url);
      die "Error downloading URL" unless ($response->{ success });
      return decode_json($response->{ content });
    },
    lazy => 1,
  );

  has sync_token => (
    is => 'ro',
    isa => 'DateTime',
    default => sub {
      return DateTime->from_epoch( epoch => shift->netinfo->{ syncToken } );
    },
    lazy => 1,
  );

  has networks => (
    is => 'ro',
    isa => 'ArrayRef',
    default => sub {
      return shift->netinfo->{ prefixes };
    },
    lazy => 1,
  );

  has regions => (
    is => 'ro',
    isa => 'ArrayRef',
    default => sub {
      my ($self) = @_;
      my $regions = {};
      map { $regions->{ $_->{ region } } = 1 } @{ $self->networks };
      return [ keys %$regions ];
    },
    lazy => 1,
  );

  sub by_region {
    my ($self, $region) = @_;
    return AWS::Networks->new(
      url => undef,
      sync_token => $self->sync_token,
      networks => [ grep { $_->{ region } eq $region } @{ $self->networks }  ]
    );
  }

  has services => (
    is => 'ro',
    isa => 'ArrayRef',
    default => sub {
      my ($self) = @_;
      my $services = {};
      map { $services->{ $_->{ service } } = 1 } @{ $self->networks };
      return [ keys %$services ];
    },
    lazy => 1,
  );

  sub by_service {
    my ($self, $service) = @_;
    return AWS::Networks->new(
      url => undef,
      sync_token => $self->sync_token,
      networks => [ grep { $_->{ service } eq $service } @{ $self->networks }  ]
    );
  }

  has cidrs => (
    is => 'ro',
    isa => 'ArrayRef',
    default => sub {
      my ($self) = @_;
      return [ map { $_->{ ip_prefix } } @{ $self->networks } ];
    },
    lazy => 1,
  );

1;

#################### main pod documentation begin ###################

=head1 NAME

AWS::Networks - Parse and query official AWS network ranges

=head1 SYNOPSIS

  use AWS::Networks;

  my $nets = AWS::Networks->new();

  say $nets->sync_token->iso8601;

  foreach my $cidr (@{ $nets->cidrs }){
    say $cidr
  }

=head1 DESCRIPTION

This module parses the official public IP network information published by Amazon Web Services at https://ip-ranges.amazonaws.com/ip-ranges.json

Please read and understand the information can be found at http://docs.aws.amazon.com/general/latest/gr/aws-ip-ranges.html to make sense of the data retured by this module.

=head1 USAGE

Instance an object, and use it to filter information of interest to you with the attributes and methods provided.

=head1 METHODS

=head2 new([ url => 'http....' ])

Standard Moose constructor. Can specify a custom URL to download a document that follows the same schema

=head2 url

Returns the URL from which the information was retrieved. Returns undef on filtered datasets

=head2 sync_token

Returns a DateTime object created from the current timestamp of the syncToken reported from the service

=head2 networks

Returns an ArrayRef with HashRefs following the following structure: 

{ ip_prefix => '0.0.0.0/0', region => '...', service => '...' } 

The keys and values in the HashRefs are the ones returned by the Network service

service can be one of: AMAZON | EC2 | CLOUDFRONT | ROUTE53 | ROUTE53_HEALTHCHECKS, but expect
new values to appear