Net-Amazon-EC2-0.36000755000766000024 013260744456 13532 5ustar00mallenstaff000000000000LICENSE100644000766000024 4364713260744456 14656 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36This software is copyright (c) 2018 by Mark Allen. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. Terms of the Perl programming language system itself a) the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version, or b) the "Artistic License" --- The GNU General Public License, Version 1, February 1989 --- This software is Copyright (c) 2018 by Mark Allen. This is free software, licensed under: The GNU General Public License, Version 1, February 1989 GNU GENERAL PUBLIC LICENSE Version 1, February 1989 Copyright (C) 1989 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The license agreements of most software companies try to keep users at the mercy of those companies. By contrast, our General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. The General Public License applies to the Free Software Foundation's software and to any other program whose authors commit to using it. You can use it for your programs, too. When we speak of free software, we are referring to freedom, not price. Specifically, the General Public License is designed to make sure that you have the freedom to give away or sell copies of free software, that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of a such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any work containing the Program or a portion of it, either verbatim or with modifications. Each licensee is addressed as "you". 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this General Public License and to the absence of any warranty; and give any other recipients of the Program a copy of this General Public License along with the Program. You may charge a fee for the physical act of transferring a copy. 2. You may modify your copy or copies of the Program or any portion of it, and copy and distribute such modifications under the terms of Paragraph 1 above, provided that you also do the following: a) cause the modified files to carry prominent notices stating that you changed the files and the date of any change; and b) cause the whole of any work that you distribute or publish, that in whole or in part contains the Program or any part thereof, either with or without modifications, to be licensed at no charge to all third parties under the terms of this General Public License (except that you may choose to grant warranty protection to some or all third parties, at your option). c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the simplest and most usual way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this General Public License. d) You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. Mere aggregation of another independent work with the Program (or its derivative) on a volume of a storage or distribution medium does not bring the other work under the scope of these terms. 3. You may copy and distribute the Program (or a portion or derivative of it, under Paragraph 2) in object code or executable form under the terms of Paragraphs 1 and 2 above provided that you also do one of the following: a) accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Paragraphs 1 and 2 above; or, b) accompany it with a written offer, valid for at least three years, to give any third party free (except for a nominal charge for the cost of distribution) a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Paragraphs 1 and 2 above; or, c) accompany it with the information you received as to where the corresponding source code may be obtained. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form alone.) Source code for a work means the preferred form of the work for making modifications to it. For an executable file, complete source code means all the source code for all modules it contains; but, as a special exception, it need not include source code for modules which are standard libraries that accompany the operating system on which the executable file runs, or for standard header files or definitions files that accompany that operating system. 4. You may not copy, modify, sublicense, distribute or transfer the Program except as expressly provided under this General Public License. Any attempt otherwise to copy, modify, sublicense, distribute or transfer the Program is void, and will automatically terminate your rights to use the Program under this License. However, parties who have received copies, or rights to use copies, from you under this General Public License will not have their licenses terminated so long as such parties remain in full compliance. 5. By copying, distributing or modifying the Program (or any work based on the Program) you indicate your acceptance of this license to do so, and all its terms and conditions. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. 7. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of the license which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the license, you may choose any version ever published by the Free Software Foundation. 8. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to humanity, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19xx name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (a program to direct compilers to make passes at assemblers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice That's all there is to it! --- The Artistic License 1.0 --- This software is Copyright (c) 2018 by Mark Allen. This is free software, licensed under: The Artistic License 1.0 The Artistic License Preamble The intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications. Definitions: - "Package" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification. - "Standard Version" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder. - "Copyright Holder" is whoever is named in the copyright or copyrights for the package. - "You" is you, if you're thinking about copying or distributing this Package. - "Reasonable copying fee" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.) - "Freely Available" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it. 1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers. 2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version. 3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following: a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as ftp.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package. b) use the modified Package only within your corporation or organization. c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version. d) make other distribution arrangements with the Copyright Holder. 4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following: a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version. b) accompany the distribution with the machine-readable source of the Package with your modifications. c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version. d) make other distribution arrangements with the Copyright Holder. 5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own. 6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package. 7. C or perl subroutines supplied by you and linked into this Package shall not be considered part of this Package. 8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission. 9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End dist.ini100644000766000024 70113260744456 15235 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36name = Net-Amazon-EC2 version = 0.36 author = Mark Allen license = Perl_5 copyright_holder = Mark Allen [@Filter] bundle = @Basic remove = Readme [MetaJSON] [AutoMetaResources] bugtracker.rt = 1 repository.github = user:mrallen1;lcdist:net-amazon-ec2 homepage = https://metacpan.org/dist/%{dist} [ReadmeFromPod] [ReadmeAnyFromPod] type = markdown filename = README.md location = root [PkgVersion] [AutoPrereqs] META.yml100644000766000024 177113260744456 15072 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36--- abstract: 'Perl interface to the Amazon Elastic Compute Cloud (EC2) environment.' author: - 'Mark Allen ' build_requires: Test::Exception: '0' Test::More: '0' blib: '0' configure_requires: ExtUtils::MakeMaker: '0' dynamic_config: 0 generated_by: 'Dist::Zilla version 6.010, CPAN::Meta::Converter version 2.150010' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: Net-Amazon-EC2 requires: Carp: '0' Data::Dumper: '0' Digest::SHA: '0' Encode: '0' LWP::Protocol::https: '0' LWP::UserAgent: '0' MIME::Base64: '0' Moose: '0' POSIX: '0' Params::Validate: '0' URI: '0' URI::Escape: '0' XML::Simple: '0' overload: '0' strict: '0' resources: bugtracker: https://rt.cpan.org/Public/Dist/Display.html?Name=Net-Amazon-EC2 homepage: https://metacpan.org/dist/Net-Amazon-EC2 repository: git://github.com/mrallen1/net-amazon-ec2.git version: '0.36' x_serialization_backend: 'YAML::Tiny version 1.70' MANIFEST100644000766000024 430713260744456 14750 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36# This file was automatically generated by Dist::Zilla::Plugin::Manifest v6.010. Changelog LICENSE MANIFEST META.json META.yml Makefile.PL dist.ini lib/Net/Amazon/EC2.pm lib/Net/Amazon/EC2/Attachment.pm lib/Net/Amazon/EC2/AvailabilityZone.pm lib/Net/Amazon/EC2/AvailabilityZoneMessage.pm lib/Net/Amazon/EC2/BlockDeviceMapping.pm lib/Net/Amazon/EC2/BundleInstanceResponse.pm lib/Net/Amazon/EC2/ConfirmProductInstanceResponse.pm lib/Net/Amazon/EC2/ConsoleOutput.pm lib/Net/Amazon/EC2/CreateVolumePermission.pm lib/Net/Amazon/EC2/DescribeAddress.pm lib/Net/Amazon/EC2/DescribeImageAttribute.pm lib/Net/Amazon/EC2/DescribeImagesResponse.pm lib/Net/Amazon/EC2/DescribeInstanceAttributeResponse.pm lib/Net/Amazon/EC2/DescribeKeyPairsResponse.pm lib/Net/Amazon/EC2/DescribeSubnetResponse.pm lib/Net/Amazon/EC2/DescribeTags.pm lib/Net/Amazon/EC2/Details.pm lib/Net/Amazon/EC2/EbsBlockDevice.pm lib/Net/Amazon/EC2/EbsInstanceBlockDeviceMapping.pm lib/Net/Amazon/EC2/Error.pm lib/Net/Amazon/EC2/Errors.pm lib/Net/Amazon/EC2/Events.pm lib/Net/Amazon/EC2/GroupSet.pm lib/Net/Amazon/EC2/InstanceBlockDeviceMapping.pm lib/Net/Amazon/EC2/InstancePassword.pm lib/Net/Amazon/EC2/InstanceState.pm lib/Net/Amazon/EC2/InstanceStateChange.pm lib/Net/Amazon/EC2/InstanceStatus.pm lib/Net/Amazon/EC2/InstanceStatuses.pm lib/Net/Amazon/EC2/IpPermission.pm lib/Net/Amazon/EC2/IpRange.pm lib/Net/Amazon/EC2/KeyPair.pm lib/Net/Amazon/EC2/LaunchPermission.pm lib/Net/Amazon/EC2/LaunchPermissionOperation.pm lib/Net/Amazon/EC2/MonitoredInstance.pm lib/Net/Amazon/EC2/NetworkInterfaceSet.pm lib/Net/Amazon/EC2/PlacementResponse.pm lib/Net/Amazon/EC2/ProductCode.pm lib/Net/Amazon/EC2/ProductInstanceResponse.pm lib/Net/Amazon/EC2/Region.pm lib/Net/Amazon/EC2/ReservationInfo.pm lib/Net/Amazon/EC2/ReservedInstance.pm lib/Net/Amazon/EC2/ReservedInstanceOffering.pm lib/Net/Amazon/EC2/RunningInstances.pm lib/Net/Amazon/EC2/SecurityGroup.pm lib/Net/Amazon/EC2/Snapshot.pm lib/Net/Amazon/EC2/SnapshotAttribute.pm lib/Net/Amazon/EC2/StateReason.pm lib/Net/Amazon/EC2/SystemStatus.pm lib/Net/Amazon/EC2/TagSet.pm lib/Net/Amazon/EC2/UserData.pm lib/Net/Amazon/EC2/UserIdGroupPair.pm lib/Net/Amazon/EC2/Volume.pm t/00_use.t t/01_init.t t/02_live.t t/03_failing_calls.t t/04_live_v4.t Changelog100644000766000024 1502413260744456 15447 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.360.36 2018-04-03 Support connecting to China regions if appropriate in the base URL 0.35 2017-12-29 Fix authentication errors using IAM security tokens provided by instance metadata in signature v4 authentication. Switch to using dzil for release packaging. 0.34 2017-12-28 Mark Allen Fix packaging errors 0.33 2017-12-18 Maik Hentsche Fix stateReason for empty hash (GH#54) 0.32 2017-03-06 Stephen Day DRY code. Fix whitespace. (GH#47) Brett Estrade Fix POD for run_instance parameters (GH#48) Maik Hentsche Add AllInstances boolean to describe_instances (GH#53) Mark Allen Make signature version 4 the default (GH#52) 0.31 2015-09-02 No changes from 0.30_1; marking an "official" release. 0.30_1 2015-06-16 Sean Rodman Allow use of Security Group ID for ingress control Mark Allen Based on RT#99779, support v4 signatures. (GH#46) 0.30 2015-03-21 Mark Allen Increase timeout for describe_instance_status() test Mark Allen Make sure functions which are documented to take ARRAYREFs really do. Closes RT#99909 Steve Richards Overhaul security group functionality Anubhav Mishra Update base to new-style URLs Matt West Properly page through very large describe_instances responses Igor Tsiganok Add network inferface support for describe_instances Igor Tsiganok Add release_vpc_address function. RT#102798 Jens-Uwe Schlüßler Support tagsets in DescribeSnapshots and DescribeImages RT#102787 0.29 2014-08-04 Mark Allen Because I am an idiot and forgot to update the MANIFEST, 5 pm files were left out of the previous release. D'oh! 0.28 2014-08-04 Matt West Add describe_instance_status() call and data modules. Mark Allen Fix up describe_instance_status() test if it returns undef 0.27 2014-07-31 Stephen Day Added egress rules to describe_security_groups Stephen Day Add allocate_vpc_address plus minor documentation changes. 0.26 2014-07-23 Jennine Townsend Allow undef in block device mappings Stephen Day Bump API to version '2014-06-15' Stephen Day Add encrypted volume support Stephen Day Remove outdated instance list in docs 0.25 2014-07-02 Steve Caldwell Support VolumeType param to BlockDeviceMapping Mark Allen Fix POD to use proper case for arguments in register_image (RT #88379) Mark Allen Return undef when no new console output is available from the get_console_output call instead of returning garbage. (RT #67748) Mark Allen Fix delete_security_group() failing test 0.24 2013-12-08 Jim Browne Add filter support to describe_snapshots Jim Browne Add support for IAM roles (RT #81664) Graham Knop Add stringification overloads to errors Graham Knop Follow Amazon's signing rules more closely Jim Browne Fix a spurious warn Masaaki Hirose Support BlockDeviceMapping in create_image Jim Browne Support IAM roles in run_instances Vincert K Add optional parameter 'AddressingType' to run_instance Brett Paden Tweak run_instance method to use group_id 0.23 2013-01-01 Mark Allen Decouple CIDR IPs from security groups (RT #80427) Mark Allen Allow undefs in region name (RT #81513) Etienne Michon Allow undefs in group_name (Github PR #16) Mark Allen Add AllocationId support for VPC/EIP (RT #82139) 0.22 2012-10-26 Mark Allen Use AWS signature v2 and SSL by default (RT #80407) Mark Allen Add URI::Escape, POSIX, Digest::SHA dependencies for signature v2. LWP::Protocol::https now required for SSL support. 0.21 2012-10-22 Mark Allen Allow undef or arrayref in AvailabilityZone Mark Phillips Update InstanceType docs Stephen Caldwell Support VolumeType and Iops on EBS volumes Mark Allen DeleteSnapshot does not take an array (Github Issue #13) Mark Allen Allow undef in TagSet values (RT#80071) 0.20 2012-08-10 Mark Allen Stop failing test 0.19 2012-08-08 Mark Allen Make filters optional on describe_tags as docs say RT#76140 Mark Allen Force XML::Simple to make empty elements undef RT#76139 Miquel Ruiz Support exceptions via croak Allard Hoeve Support tagsets on volumes Mark Allen Allow modify_instance_attribute to use a HASHREF Fixes RT #78779 (thanks to Andrew Solomon for the suggestion.) 0.18 2012-02-21 Chia-liang Kao Fix timestamp clear (RT#75194) 0.17 2012-02-20 Chia-liang Kao Support Client Token Chia-liang Kao Support instance filters Chia-liang Kao Don't cache timestamps (to prevent timeout errors) Chia-liang Kao Fix a problem with XML::Simple deserialization of empty value in image description Mark Allen Spelling fix RT #74239 0.16 2012-01-21 Mark Allen Remove union type in ReservationInfo 0.15 2012-01-18 Mark Allen Fix groupSet params RT#67145 Mark Allen Support proxy environment variables RT#67145 Mark Allen Update doc for 0.15 Mark Fowler fix all warnings podchecker warns us about Mark Allen Make tag creation use a hash instead of arrayrefs Jeff Finucane documentation fix Jeff Finucane avoid 'Request has expired' on long lived Net::Amazon::EC2 objects Jeff Finucane add group_name to NAE::GroupSet and fix live test "Checking for running instance" Jeff Finucane add in ssl support as suggested by Brad Barden bradford.barden@supervalu.com stanaka Accept an array for resourceId. toritori0318 remove debug code toritori0318 add delete tags and tags test toritori0318 add describe tags and instance name. stanaka add create_tags stanaka import 0.14 from cpan META.json100644000766000024 344313260744456 15240 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36{ "abstract" : "Perl interface to the Amazon Elastic Compute Cloud (EC2) environment.", "author" : [ "Mark Allen " ], "dynamic_config" : 0, "generated_by" : "Dist::Zilla version 6.010, CPAN::Meta::Converter version 2.150010", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : 2 }, "name" : "Net-Amazon-EC2", "prereqs" : { "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "Carp" : "0", "Data::Dumper" : "0", "Digest::SHA" : "0", "Encode" : "0", "LWP::Protocol::https" : "0", "LWP::UserAgent" : "0", "MIME::Base64" : "0", "Moose" : "0", "POSIX" : "0", "Params::Validate" : "0", "URI" : "0", "URI::Escape" : "0", "XML::Simple" : "0", "overload" : "0", "strict" : "0" } }, "test" : { "requires" : { "Test::Exception" : "0", "Test::More" : "0", "blib" : "0" } } }, "release_status" : "stable", "resources" : { "bugtracker" : { "mailto" : "bug-Net-Amazon-EC2@rt.cpan.org", "web" : "https://rt.cpan.org/Public/Dist/Display.html?Name=Net-Amazon-EC2" }, "homepage" : "https://metacpan.org/dist/Net-Amazon-EC2", "repository" : { "type" : "git", "url" : "git://github.com/mrallen1/net-amazon-ec2.git", "web" : "https://github.com/mrallen1/net-amazon-ec2" } }, "version" : "0.36", "x_serialization_backend" : "Cpanel::JSON::XS version 4.02" } t000755000766000024 013260744456 13716 5ustar00mallenstaff000000000000Net-Amazon-EC2-0.3600_use.t100644000766000024 367713260744456 15353 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/tuse strict; use blib; use Test::More; BEGIN { my @modules = qw( Net::Amazon::EC2::AvailabilityZone Net::Amazon::EC2::BlockDeviceMapping Net::Amazon::EC2::ConfirmProductInstanceResponse Net::Amazon::EC2::ConsoleOutput Net::Amazon::EC2::DescribeAddress Net::Amazon::EC2::DescribeImageAttribute Net::Amazon::EC2::DescribeImagesResponse Net::Amazon::EC2::DescribeKeyPairsResponse Net::Amazon::EC2::Error Net::Amazon::EC2::Errors Net::Amazon::EC2::GroupSet Net::Amazon::EC2::InstanceState Net::Amazon::EC2::IpPermission Net::Amazon::EC2::IpRange Net::Amazon::EC2::KeyPair Net::Amazon::EC2::LaunchPermission Net::Amazon::EC2::LaunchPermissionOperation Net::Amazon::EC2::PlacementResponse Net::Amazon::EC2::ProductCode Net::Amazon::EC2::ProductInstanceResponse Net::Amazon::EC2::ReservationInfo Net::Amazon::EC2::RunningInstances Net::Amazon::EC2::SecurityGroup Net::Amazon::EC2::UserData Net::Amazon::EC2::UserIdGroupPair Net::Amazon::EC2::Volume Net::Amazon::EC2::Attachment Net::Amazon::EC2::Snapshot Net::Amazon::EC2::BundleInstanceResponse Net::Amazon::EC2::Region Net::Amazon::EC2::ReservedInstance Net::Amazon::EC2::ReservedInstanceOffering Net::Amazon::EC2::MonitoredInstance Net::Amazon::EC2::InstancePassword Net::Amazon::EC2::SnapshotAttribute Net::Amazon::EC2::CreateVolumePermission Net::Amazon::EC2::AvailabilityZoneMessage Net::Amazon::EC2::StateReason Net::Amazon::EC2::InstanceBlockDeviceMapping Net::Amazon::EC2::InstanceStateChange Net::Amazon::EC2::DescribeInstanceAttributeResponse Net::Amazon::EC2::EbsInstanceBlockDeviceMapping Net::Amazon::EC2::EbsBlockDevice Net::Amazon::EC2::DescribeTags Net::Amazon::EC2::TagSet Net::Amazon::EC2::Details Net::Amazon::EC2::Events Net::Amazon::EC2::InstanceStatus Net::Amazon::EC2::InstanceStatuses Net::Amazon::EC2::SystemStatus ); plan tests => scalar @modules; use_ok($_) for @modules; } 01_init.t100644000766000024 67513260744456 15476 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/tuse strict; use blib; use Test::More; BEGIN { if (! $ENV{AWS_ACCESS_KEY_ID} || ! $ENV{SECRET_ACCESS_KEY} ) { plan skip_all => "Set AWS_ACCESS_KEY_ID and SECRET_ACCESS_KEY environment variables to run these tests"; } else { plan tests => 1; use_ok( 'Net::Amazon::EC2' ); } }; my $ec2 = Net::Amazon::EC2->new( AWSAccessKeyId => $ENV{AWS_ACCESS_KEY_ID}, SecretAccessKey => $ENV{SECRET_ACCESS_KEY}, ); 02_live.t100644000766000024 2470013260744456 15526 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/tuse strict; use blib; use Test::More; use MIME::Base64 qw(encode_base64); BEGIN { if (! $ENV{AWS_ACCESS_KEY_ID} || ! $ENV{SECRET_ACCESS_KEY} ) { plan skip_all => "Set AWS_ACCESS_KEY_ID and SECRET_ACCESS_KEY environment variables to run these _LIVE_ tests (NOTE: they will incur one instance hour of costs from EC2)"; } else { plan tests => 31; use_ok( 'Net::Amazon::EC2' ); } }; #try ssl first my $ec2 = eval { Net::Amazon::EC2->new( AWSAccessKeyId => $ENV{AWS_ACCESS_KEY_ID}, SecretAccessKey => $ENV{SECRET_ACCESS_KEY}, ssl => 1, debug => 0, return_errors => 1, ); }; $ec2 = Net::Amazon::EC2->new( AWSAccessKeyId => $ENV{AWS_ACCESS_KEY_ID}, SecretAccessKey => $ENV{SECRET_ACCESS_KEY}, debug => 0, return_errors => 1, ) if $@; isa_ok($ec2, 'Net::Amazon::EC2'); my $delete_key_result = $ec2->delete_key_pair(KeyName => "test_keys"); my $delete_group_result = $ec2->delete_security_group(GroupName => "test_group"); # create_key_pair my $key_pair = $ec2->create_key_pair(KeyName => "test_keys"); isa_ok($key_pair, 'Net::Amazon::EC2::KeyPair'); is($key_pair->key_name, "test_keys", "Does new key pair come back?"); # describe_key_pairs my $key_pairs = $ec2->describe_key_pairs; my $seen_test_key = 0; foreach my $key_pair (@{$key_pairs}) { if ($key_pair->key_name eq "test_keys") { $seen_test_key = 1; } } ok($seen_test_key == 1, "Checking for created key pair in describe keys"); # For cleanup purposes $ec2->delete_security_group(GroupName => "test_group"); # create_security_group my $create_result = $ec2->create_security_group(GroupName => "test_group", GroupDescription => "test description"); ok($create_result == 1, "Checking for created security group"); # authorize_security_group_ingress my $authorize_result = $ec2->authorize_security_group_ingress(GroupName => "test_group", IpProtocol => 'tcp', FromPort => '7003', ToPort => '7003', CidrIp => '10.253.253.253/32'); ok($authorize_result == 1, "Checking for authorization of rule for security group"); # Add this for RT Bug: #33883 my $authorize_result_bad = $ec2->authorize_security_group_ingress(GroupName => "test_group_non_existant", IpProtocol => 'tcp', FromPort => '7003', ToPort => '7003', CidrIp => '10.253.253.253/32'); isa_ok($authorize_result_bad, 'Net::Amazon::EC2::Errors'); # describe_security_groups my $security_groups = $ec2->describe_security_groups(); my $seen_test_group = 0; my $seen_test_rule = 0; foreach my $security_group (@{$security_groups}) { if ($security_group->group_name eq "test_group") { $seen_test_group = 1; if ($security_group->ip_permissions->[0]->ip_ranges->[0]->cidr_ip eq '10.253.253.253/32') { $seen_test_rule = 1; } } } ok($seen_test_group == 1, "Checking for created security group in describe results"); ok($seen_test_rule == 1, "Checking for created authorized security group rule in describe results"); # revoke_security_group_ingress my $revoke_result = $ec2->revoke_security_group_ingress(GroupName => "test_group", IpProtocol => 'tcp', FromPort => '7003', ToPort => '7003', CidrIp => '10.253.253.253/32'); ok($revoke_result == 1, "Checking for revocation of rule for security group"); my $user_data =<<_EOF; I am the very model of a modern Major-General, I've information vegetable, animal, and mineral, I know the kings of England, and I quote the fights historical From Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical, I understand equations, both the simple and quadratical, About binomial theorem I'm teeming with a lot o' news, With many cheerful facts about the square of the hypotenuse. I'm very good at integral and differential calculus; I know the scientific names of beings animalculous: In short, in matters vegetable, animal, and mineral, I am the very model of a modern Major-General. I know our mythic history, King Arthur's and Sir Caradoc's; I answer hard acrostics, I've a pretty taste for paradox, I quote in elegiacs all the crimes of Heliogabalus, In conics I can floor peculiarities parabolous; I can tell undoubted Raphaels from Gerard Dows and Zoffanies, I know the croaking chorus from The Frogs of Aristophanes! Then I can hum a fugue of which I've heard the music's din afore, And whistle all the airs from that infernal nonsense Pinafore. Then I can write a washing bill in Babylonic cuneiform, And tell you ev'ry detail of Caractacus's uniform: In short, in matters vegetable, animal, and mineral, I am the very model of a modern Major-General. In fact, when I know what is meant by "mamelon" and "ravelin", When I can tell at sight a Mauser rifle from a Javelin, When such affairs as sorties and surprises I'm more wary at, And when I know precisely what is meant by "commissariat", When I have learnt what progress has been made in modern gunnery, When I know more of tactics than a novice in a nunnery— In short, when I've a smattering of elemental strategy— You'll say a better Major-General has never sat a gee. For my military knowledge, though I'm plucky and adventury, Has only been brought down to the beginning of the century; But still, in matters vegetable, animal, and mineral, I am the very model of a modern Major-General. _EOF # run_instances my $run_result = $ec2->run_instances( MinCount => 1, MaxCount => 1, ImageId => "ami-26b6534f", # ec2-public-images/developer-image.manifest.xml KeyName => "test_keys", SecurityGroup => "test_group", InstanceType => 'm1.small', UserData => encode_base64($user_data, ""), EbsOptimized => 0, ); isa_ok($run_result, 'Net::Amazon::EC2::ReservationInfo'); ok($run_result->group_set->[0]->group_name eq "test_group", "Checking for running instance"); my $instance_id = $run_result->instances_set->[0]->instance_id; # describe_instances my $running_instances = $ec2->describe_instances(); my $seen_test_instance = 0; foreach my $instance (@{$running_instances}) { my $instance_set = $instance->instances_set->[0]; my $key_name = $instance_set->key_name || ''; my $image_id = $instance_set->image_id || ''; if ($key_name eq 'test_keys' and $image_id eq 'ami-26b6534f') { $seen_test_instance = 1; } } ok($seen_test_instance == 1, "Checking for newly run instance"); my $volume = $ec2->create_volume( Size => 10, AvailabilityZone => 'us-east-1a', VolumeType => 'io1', Iops => 300, Encrypted => 1 ); note explain $volume; isa_ok($volume, 'Net::Amazon::EC2::Volume'); my $rc = $ec2->delete_volume( VolumeId => $volume->volume_id ); note explain $rc; ok($rc, "successfully deleted volume"); # create tags my $create_tags_result = $ec2->create_tags( ResourceId => $instance_id, Tags => { Name => 'hoge', test_tag_key => 'test_tag_value', }, ); ok($create_tags_result == 1, "Checking for created tags"); # describe_instances $running_instances = $ec2->describe_instances(); my $test_instance; foreach my $instance (@{$running_instances}) { my $instance_set = $instance->instances_set->[0]; if ($instance_set->instance_id eq $instance_id) { $test_instance = $instance_set; last; } } # instance name is($test_instance->name, 'hoge', 'Checking for instance name'); # instance tags foreach my $tag (@{$test_instance->tag_set}) { if($tag->key eq 'Name' && $tag->value eq 'hoge') { ok(1, 'Checking for tag (Name=hoge)'); }elsif($tag->key eq 'test_tag_key' && $tag->value eq 'test_tag_value') { ok(1, 'Checking for tag (test_tag_key=test_tag_value)'); } } # delete tags my $delete_tags_result = $ec2->delete_tags( ResourceId => $instance_id, 'Tag.Key' => ["Name","test_tag_key"], ); ok($delete_tags_result == 1, "Checking for delete tags"); note("Describe instance status test takes up to 600 seconds to complete. Be patient."); my $instance_statuses; my $loop_count = 0; while ( $loop_count < 120 ) { $instance_statuses = $ec2->describe_instance_status(); if ( not defined $instance_statuses->[0] ) { sleep 5; $loop_count++; next; } else { last; } } isa_ok($instance_statuses->[0], 'Net::Amazon::EC2::InstanceStatuses'); # terminate_instances my $terminate_result = $ec2->terminate_instances(InstanceId => $instance_id); is($terminate_result->[0]->instance_id, $instance_id, "Checking to see if instance was terminated successfully"); # delete_key_pair $delete_key_result = $ec2->delete_key_pair(KeyName => "test_keys"); ok($delete_key_result == 1, "Deleting key pair"); my $availability_zones = $ec2->describe_availability_zones(); my $seen_availability_zone = 0; foreach my $availability_zone (@{$availability_zones}) { if ($availability_zone->zone_name eq 'us-east-1a') { $seen_availability_zone = 1; } } ok($seen_availability_zone == 1, "Describing availability zones"); my $regions = $ec2->describe_regions(); my $seen_region = 0; foreach my $region (@{$regions}) { if ($region->region_name eq 'us-east-1') { $seen_region = 1; } } ok($seen_region == 1, "Describing regions"); my $reserved_instance_offerings = $ec2->describe_reserved_instances_offerings(); my $seen_offering = 0; foreach my $offering (@{$reserved_instance_offerings}) { if ($offering->product_description eq 'Linux/UNIX') { $seen_offering = 1; } } ok($seen_offering == 1, "Describing Reserved Instances Offerings"); note("Delete security group test takes up to 600 seconds to complete. Be patient."); # delete_security_group $loop_count = 0; while ( $loop_count < 120 ) { $delete_group_result = $ec2->delete_security_group(GroupName => "test_group"); if ( ref($delete_group_result) =~ /Error/ ) { # If we get an error, loop until we don't sleep 5; $loop_count++; next; } else { last; } } ok($delete_group_result == 1, "Deleting security group"); # create_volume my $volume = $ec2->create_volume( Size => 1, AvailabilityZone => 'us-east-1a', Encrypted => 'true', ); isa_ok($volume, 'Net::Amazon::EC2::Volume'); my $describe_volume = $ec2->describe_volumes( { VolumeId => $volume->volume_id } ); ok($describe_volume->[0]->volume_id, $volume->volume_id); my $delete_volume = $ec2->delete_volume( { VolumeId => $volume->volume_id } ); ok($delete_volume == 1, "Deleting volume"); # THE REST OF THE METHODS ARE SKIPPED FOR NOW SINCE IT WOULD REQUIRE A DECENT AMOUNT OF TIME IN BETWEEN OPERATIONS TO COMPLETE Makefile.PL100644000766000024 327113260744456 15570 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36# This file was automatically generated by Dist::Zilla::Plugin::MakeMaker v6.010. use strict; use warnings; use ExtUtils::MakeMaker; my %WriteMakefileArgs = ( "ABSTRACT" => "Perl interface to the Amazon Elastic Compute Cloud (EC2) environment.", "AUTHOR" => "Mark Allen ", "CONFIGURE_REQUIRES" => { "ExtUtils::MakeMaker" => 0 }, "DISTNAME" => "Net-Amazon-EC2", "LICENSE" => "perl", "NAME" => "Net::Amazon::EC2", "PREREQ_PM" => { "Carp" => 0, "Data::Dumper" => 0, "Digest::SHA" => 0, "Encode" => 0, "LWP::Protocol::https" => 0, "LWP::UserAgent" => 0, "MIME::Base64" => 0, "Moose" => 0, "POSIX" => 0, "Params::Validate" => 0, "URI" => 0, "URI::Escape" => 0, "XML::Simple" => 0, "overload" => 0, "strict" => 0 }, "TEST_REQUIRES" => { "Test::Exception" => 0, "Test::More" => 0, "blib" => 0 }, "VERSION" => "0.36", "test" => { "TESTS" => "t/*.t" } ); my %FallbackPrereqs = ( "Carp" => 0, "Data::Dumper" => 0, "Digest::SHA" => 0, "Encode" => 0, "LWP::Protocol::https" => 0, "LWP::UserAgent" => 0, "MIME::Base64" => 0, "Moose" => 0, "POSIX" => 0, "Params::Validate" => 0, "Test::Exception" => 0, "Test::More" => 0, "URI" => 0, "URI::Escape" => 0, "XML::Simple" => 0, "blib" => 0, "overload" => 0, "strict" => 0 ); unless ( eval { ExtUtils::MakeMaker->VERSION(6.63_03) } ) { delete $WriteMakefileArgs{TEST_REQUIRES}; delete $WriteMakefileArgs{BUILD_REQUIRES}; $WriteMakefileArgs{PREREQ_PM} = \%FallbackPrereqs; } delete $WriteMakefileArgs{CONFIGURE_REQUIRES} unless eval { ExtUtils::MakeMaker->VERSION(6.52) }; WriteMakefile(%WriteMakefileArgs); 04_live_v4.t100644000766000024 303313260744456 16115 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/tuse strict; use blib; use Test::More; BEGIN { if (! $ENV{AWS_ACCESS_KEY_ID} || ! $ENV{SECRET_ACCESS_KEY} ) { plan skip_all => "Set AWS_ACCESS_KEY_ID and SECRET_ACCESS_KEY environment variables to run these _LIVE_ tests (NOTE: they will incur one instance hour of costs from EC2)"; } else { plan tests => 5; use_ok( 'Net::Amazon::EC2' ); } }; my $ec2 = eval { Net::Amazon::EC2->new( AWSAccessKeyId => $ENV{AWS_ACCESS_KEY_ID}, SecretAccessKey => $ENV{SECRET_ACCESS_KEY}, region => 'eu-central-1', ssl => 1, #debug => 1, signature_version => 4, return_errors => 1, ); }; isa_ok($ec2, 'Net::Amazon::EC2'); my $availability_zones = $ec2->describe_availability_zones(); my $seen_availability_zone = 0; foreach my $availability_zone (@{$availability_zones}) { if ($availability_zone->zone_name eq 'eu-central-1a') { $seen_availability_zone = 1; } } ok($seen_availability_zone == 1, "Describing availability zones"); my $regions = $ec2->describe_regions(); my $seen_region = 0; foreach my $region (@{$regions}) { if ($region->region_name eq 'us-east-1') { $seen_region = 1; } } ok($seen_region == 1, "Describing regions"); my $reserved_instance_offerings = $ec2->describe_reserved_instances_offerings(); my $seen_offering = 0; foreach my $offering (@{$reserved_instance_offerings}) { if ($offering->product_description eq 'Linux/UNIX') { $seen_offering = 1; } } ok($seen_offering == 1, "Describing Reserved Instances Offerings"); 03_failing_calls.t100644000766000024 222213260744456 17332 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/tuse strict; use blib; use Test::More; use Test::Exception; BEGIN { plan tests => 5; use_ok( 'Net::Amazon::EC2' ); }; # Since you don't have an Amazon EC2 api endpoint running locally # (you don't, right?) all api calls should fail, and thus allow us to # test it properly. my $access_id = 'xxx'; my $secret_key = 'yyy'; my $base_url = 'http://localhost:22718'; my $die_ec2 = Net::Amazon::EC2->new( AWSAccessKeyId => $access_id, SecretAccessKey => $secret_key, base_url => $base_url, ); my $old_ec2 = Net::Amazon::EC2->new( AWSAccessKeyId => $access_id, SecretAccessKey => $secret_key, base_url => $base_url, return_errors => 1, ); my $errors; lives_ok { $errors = $old_ec2->describe_instances } "return_errors on , api call lives"; dies_ok { $die_ec2->describe_instances } "return_errors off, api call dies"; is_deeply ($@, $errors, "Same error thrown and returned"); my $dbg_ec2 = Net::Amazon::EC2->new( AWSAccessKeyId => $access_id, SecretAccessKey => $secret_key, base_url => $base_url, debug => 1, ); dies_ok { $dbg_ec2->describe_instances } "with debug on also dies"; Amazon000755000766000024 013260744456 16174 5ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/NetEC2.pm100644000766000024 41153413260744456 17313 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazonpackage Net::Amazon::EC2; $Net::Amazon::EC2::VERSION = '0.36'; use Moose; use strict; use XML::Simple; use LWP::UserAgent; use LWP::Protocol::https; use Digest::SHA qw(hmac_sha256 hmac_sha256_hex sha256_hex); use URI; use MIME::Base64 qw(encode_base64 decode_base64); use POSIX qw(strftime); use Params::Validate qw(validate SCALAR ARRAYREF HASHREF BOOLEAN); use Data::Dumper qw(Dumper); use URI::Escape qw(uri_escape_utf8); use Encode qw(encode_utf8); use Carp; use Net::Amazon::EC2::DescribeImagesResponse; use Net::Amazon::EC2::DescribeKeyPairsResponse; use Net::Amazon::EC2::DescribeSubnetResponse; use Net::Amazon::EC2::GroupSet; use Net::Amazon::EC2::InstanceState; use Net::Amazon::EC2::IpPermission; use Net::Amazon::EC2::LaunchPermission; use Net::Amazon::EC2::LaunchPermissionOperation; use Net::Amazon::EC2::ProductCode; use Net::Amazon::EC2::ProductInstanceResponse; use Net::Amazon::EC2::ReservationInfo; use Net::Amazon::EC2::RunningInstances; use Net::Amazon::EC2::SecurityGroup; use Net::Amazon::EC2::UserData; use Net::Amazon::EC2::UserIdGroupPair; use Net::Amazon::EC2::IpRange; use Net::Amazon::EC2::KeyPair; use Net::Amazon::EC2::DescribeImageAttribute; use Net::Amazon::EC2::ConsoleOutput; use Net::Amazon::EC2::Errors; use Net::Amazon::EC2::Error; use Net::Amazon::EC2::ConfirmProductInstanceResponse; use Net::Amazon::EC2::DescribeAddress; use Net::Amazon::EC2::AvailabilityZone; use Net::Amazon::EC2::BlockDeviceMapping; use Net::Amazon::EC2::PlacementResponse; use Net::Amazon::EC2::Volume; use Net::Amazon::EC2::Attachment; use Net::Amazon::EC2::Snapshot; use Net::Amazon::EC2::BundleInstanceResponse; use Net::Amazon::EC2::Region; use Net::Amazon::EC2::ReservedInstance; use Net::Amazon::EC2::ReservedInstanceOffering; use Net::Amazon::EC2::MonitoredInstance; use Net::Amazon::EC2::InstancePassword; use Net::Amazon::EC2::SnapshotAttribute; use Net::Amazon::EC2::CreateVolumePermission; use Net::Amazon::EC2::AvailabilityZoneMessage; use Net::Amazon::EC2::StateReason; use Net::Amazon::EC2::InstanceBlockDeviceMapping; use Net::Amazon::EC2::InstanceStateChange; use Net::Amazon::EC2::DescribeInstanceAttributeResponse; use Net::Amazon::EC2::EbsInstanceBlockDeviceMapping; use Net::Amazon::EC2::EbsBlockDevice; use Net::Amazon::EC2::TagSet; use Net::Amazon::EC2::DescribeTags; use Net::Amazon::EC2::Details; use Net::Amazon::EC2::Events; use Net::Amazon::EC2::InstanceStatus; use Net::Amazon::EC2::InstanceStatuses; use Net::Amazon::EC2::SystemStatus; use Net::Amazon::EC2::NetworkInterfaceSet; =head1 NAME Net::Amazon::EC2 - Perl interface to the Amazon Elastic Compute Cloud (EC2) environment. =head1 VERSION EC2 Query API version: '2014-06-15' =head1 SYNOPSIS use Net::Amazon::EC2; my $ec2 = Net::Amazon::EC2->new( AWSAccessKeyId => 'PUBLIC_KEY_HERE', SecretAccessKey => 'SECRET_KEY_HERE', signature_version => 4, ); # Start 1 new instance from AMI: ami-XXXXXXXX my $instance = $ec2->run_instances(ImageId => 'ami-XXXXXXXX', MinCount => 1, MaxCount => 1); my $running_instances = $ec2->describe_instances; foreach my $reservation (@$running_instances) { foreach my $instance ($reservation->instances_set) { print $instance->instance_id . "\n"; } } my $instance_id = $instance->instances_set->[0]->instance_id; print "$instance_id\n"; # Terminate instance my $result = $ec2->terminate_instances(InstanceId => $instance_id); If an error occurs while communicating with EC2, these methods will throw a L exception. =head1 DESCRIPTION This module is a Perl interface to Amazon's Elastic Compute Cloud. It uses the Query API to communicate with Amazon's Web Services framework. =head1 CLASS METHODS =head2 new(%params) This is the constructor, it will return you a Net::Amazon::EC2 object to work with. It takes these parameters: =over =item AWSAccessKeyId (required, unless an IAM role is present) Your AWS access key. For information on IAM roles, see L =item SecretAccessKey (required, unless an IAM role is present) Your secret key, B don't give this out or someone will be able to use your account and incur charges on your behalf. =item SecurityToken (optional) When using temporary credentials from STS the Security Token must be passed in along with the temporary AWSAccessKeyId and SecretAccessKey. The most common case is when using IAM credentials with the addition of MFA (multi-factor authentication). See L =item region (optional) The region to run the API requests through. Defaults to us-east-1. =item ssl (optional) If set to a true value, the base_url will use https:// instead of http://. Setting base_url explicitly will override this. Defaults to true as of 0.22. =item debug (optional) A flag to turn on debugging. Among other useful things, it will make the failing api calls print a stack trace. It is turned off by default. =item return_errors (optional) Previously, Net::Amazon::EC2 would return a L object when it encountered an error condition. As of 0.19, this object is thrown as an exception using croak or confess depending on if the debug flag is set. If you want/need the old behavior, set this attribute to a true value. =back =cut has 'AWSAccessKeyId' => ( is => 'ro', isa => 'Str', required => 1, lazy => 1, default => sub { if (defined($_[0]->temp_creds)) { return $_[0]->temp_creds->{'AccessKeyId'}; } else { return undef; } } ); has 'SecretAccessKey' => ( is => 'ro', isa => 'Str', required => 1, lazy => 1, default => sub { if (defined($_[0]->temp_creds)) { return $_[0]->temp_creds->{'SecretAccessKey'}; } else { return undef; } } ); has 'SecurityToken' => ( is => 'ro', isa => 'Maybe[Str]', required => 0, predicate => 'has_SecurityToken', default => sub { if (defined($_[0]->temp_creds)) { return $_[0]->temp_creds->{'Token'}; } else { return undef; } } ); has 'debug' => ( is => 'ro', isa => 'Str', required => 0, default => 0 ); has 'signature_version' => ( is => 'ro', isa => 'Int', required => 1, default => 4 ); has 'version' => ( is => 'ro', isa => 'Str', required => 1, default => '2014-06-15' ); has 'region' => ( is => 'ro', isa => 'Str', required => 1, default => 'us-east-1' ); has 'ssl' => ( is => 'ro', isa => 'Bool', required => 1, default => 1 ); has 'return_errors' => ( is => 'ro', isa => 'Bool', default => 0 ); has 'base_url' => ( is => 'ro', isa => 'Str', required => 1, lazy => 1, default => sub { return 'http' . ($_[0]->ssl ? 's' : '') . '://ec2.' . $_[0]->region . '.amazonaws.com' . ($_[0]->region =~ m/^cn-/ ? '.cn' : ''); } ); has 'temp_creds' => ( is => 'ro', default => sub { my $ret; $ret = $_[0]->_fetch_iam_security_credentials(); }, predicate => 'has_temp_creds' ); sub timestamp { return strftime("%Y-%m-%dT%H:%M:%SZ",gmtime); } sub _fetch_iam_security_credentials { my $self = shift; my $retval = {}; my $ua = LWP::UserAgent->new(); # Fail quickly if this is not running on an EC2 instance $ua->timeout(2); my $url = 'http://169.254.169.254/latest/meta-data/iam/security-credentials/'; $self->_debug("Attempting to fetch instance credentials"); my $res = $ua->get($url); if ($res->code == 200) { # Assumes the first profile is the only profile my $profile = (split /\n/, $res->content())[0]; $res = $ua->get($url . $profile); if ($res->code == 200) { $retval->{'Profile'} = $profile; foreach (split /\n/, $res->content()) { return undef if /Code/ && !/Success/; if (m/.*"([^"]+)"\s+:\s+"([^"]+)",/) { $retval->{$1} = $2; } } return $retval if (keys %{$retval}); } } return undef; } sub _sign { my $self = shift; if ( $self->signature_version == 2 ) { $self->_sign_v2(@_); } elsif ( $self->signature_version == 4 ) { $self->_sign_v4(@_); } else { die "I don't know what signature version " . $self->signature_version . "means.\n"; } } sub _sign_v2 { my $self = shift; my %args = @_; my $action = delete $args{Action}; my %sign_hash = %args; my $timestamp = $self->timestamp; $sign_hash{AWSAccessKeyId} = $self->AWSAccessKeyId; $sign_hash{Action} = $action; $sign_hash{Timestamp} = $timestamp; $sign_hash{Version} = $self->version; $sign_hash{SignatureVersion} = $self->signature_version; $sign_hash{SignatureMethod} = "HmacSHA256"; if ($self->has_temp_creds || $self->has_SecurityToken) { $sign_hash{SecurityToken} = $self->SecurityToken; } my $sign_this = "POST\n"; my $uri = URI->new($self->base_url); $sign_this .= lc($uri->host) . "\n"; $sign_this .= "/\n"; my @signing_elements; foreach my $key (sort keys %sign_hash) { push @signing_elements, uri_escape_utf8($key)."=".uri_escape_utf8($sign_hash{$key}); } $sign_this .= join "&", @signing_elements; $self->_debug("QUERY TO SIGN: $sign_this"); my $encoded = $self->_hashit($self->SecretAccessKey, $sign_this); my $content = join "&", @signing_elements, 'Signature=' . uri_escape_utf8($encoded); my $ur = $uri->as_string(); $self->_debug("GENERATED QUERY URL: $ur"); my $ua = LWP::UserAgent->new(); $ua->env_proxy; my $res = $ua->post($ur, Content => $content); $self->_handle_response($res); } sub _hashit { my $self = shift; my ($secret_access_key, $query_string) = @_; return encode_base64(hmac_sha256($query_string, $secret_access_key), ''); } sub _sign_v4 { my $self = shift; my %args = @_; my $algorithm = 'AWS4-HMAC-SHA256'; my $service = 'ec2'; my @now = gmtime(); my $amz_date = strftime("%Y%m%dT%H%M%SZ", @now); my $datestamp = strftime("%Y%m%d", @now); my $credential_scope = $datestamp . "/" . $self->region . "/" . $service . "/aws4_request"; my $content_type = "application/x-www-form-urlencoded"; my $signed_headers = "content-type;host;x-amz-date"; # Step 1: create canonical request string my $uri = URI->new($self->base_url); my $canonical_headers = "content-type:" . $content_type . "\n" . "host:" . lc($uri->host) . "\n" . "x-amz-date:" . $amz_date . "\n"; $args{Version} = $self->version; if ($self->SecurityToken) { # If we have a security token from an IAM role, passed # as instance metadata, it needs to be included in # the list of canonical headers and passed with the # request $args{'X-Amz-Security-Token'} = $self->SecurityToken; $canonical_headers .= "x-amz-security-token:". $self->SecurityToken . "\n"; $signed_headers .= ";x-amz-security-token"; } my @content_elements; foreach my $key (sort keys %args) { push @content_elements, uri_escape_utf8($key)."=".uri_escape_utf8($args{$key}); } my $content .= join "&", @content_elements; $self->_debug("CONTENT: $content"); my $canonical_request = "POST\n"; # method $canonical_request .= "/\n"; # uri $canonical_request .= "\n"; # query-string $canonical_request .= $canonical_headers . "\n"; # headers $canonical_request .= $signed_headers . "\n"; # signed headers $canonical_request .= sha256_hex($content); # payload $self->_debug("CANONICAL REQUEST: $canonical_request"); # Step 2: create string to sign my $sign_this = $algorithm . "\n"; $sign_this .= $amz_date . "\n"; $sign_this .= $credential_scope . "\n"; $sign_this .= sha256_hex($canonical_request); $self->_debug("STRING TO SIGN: $sign_this"); # Step 3: calculate the signature my $key_date = $self->_hmac(encode_utf8('AWS4' . $self->SecretAccessKey), $datestamp); my $key_region = $self->_hmac($key_date, $self->region); my $key_service = $self->_hmac($key_region, $service); my $signing_key = $self->_hmac($key_service, 'aws4_request'); my $signature = $self->_hmac($signing_key, encode_utf8($sign_this), 1); # send request my $auth_header = $algorithm . ' Credential=' . $self->AWSAccessKeyId . '/' . $credential_scope . ', SignedHeaders=' . $signed_headers . ', Signature=' . $signature; my $hdrs = [ "Authorization" => $auth_header, "Content-Type" => $content_type, "X-Amz-Date" => $amz_date ]; push @{ $hdrs }, "X-Amz-Security-Token" => $self->SecurityToken if $self->SecurityToken; my $req = HTTP::Request->new('POST', $uri, $hdrs, $content); $self->_debug("HTTP REQUEST: " . $req->as_string() . "\n"); my $ua = LWP::UserAgent->new(); $ua->env_proxy; my $res = $ua->request($req); $self->_handle_response($res); } sub _handle_response { my ($self, $res) = @_; # We should force elements to be in an array my $xs = XML::Simple->new( ForceArray => qr/(?:item|Errors)/i, # Always want item elements unpacked to arrays KeyAttr => '', # Turn off folding for 'id', 'name', 'key' elements SuppressEmpty => undef, # Turn empty values into explicit undefs ); my $xml; # Check the result for connectivity problems, if so throw an error if ($res->code >= 500) { my $message = $res->status_line; $xml = < N/A HTTP POST FAILURE $message EOXML } else { $xml = $res->content(); } my $ref = $xs->XMLin($xml); warn Dumper($ref) . "\n\n" if $self->debug == 1; return $ref; } sub _parse_errors { my $self = shift; my $errors_xml = shift; my $es; my $request_id = $errors_xml->{RequestID}; foreach my $e (@{$errors_xml->{Errors}}) { my $error = Net::Amazon::EC2::Error->new( code => $e->{Error}{Code}, message => $e->{Error}{Message}, ); push @$es, $error; } my $errors = Net::Amazon::EC2::Errors->new( request_id => $request_id, errors => $es, ); foreach my $error (@{$errors->errors}) { $self->_debug("ERROR CODE: " . $error->code . " MESSAGE: " . $error->message . " FOR REQUEST: " . $errors->request_id); } # User wants old behaviour if ($self->return_errors) { return $errors; } # Print a stack trace if debugging is enabled if ($self->debug) { confess 'Last error was: ' . $es->[-1]->message; } else { croak $errors; } } sub _debug { my $self = shift; my $message = shift; if ((grep { defined && length} $self->debug) && $self->debug == 1) { print "$message\n\n\n\n"; } } sub _hmac { my $self = shift; my ($key, $msg, $hex) = @_; my $func = $hex ? \&hmac_sha256_hex : \&hmac_sha256; return &$func(encode_utf8($msg), $key); } sub _build_filters { my ($self, $args) = @_; my $filters = delete $args->{Filter}; return unless $filters && ref($filters) eq 'ARRAY'; $filters = [ $filters ] unless ref($filters->[0]) eq 'ARRAY'; my $count = 1; foreach my $filter (@{$filters}) { my ($name, @args) = @$filter; $args->{"Filter." . $count.".Name"} = $name; $args->{"Filter." . $count.".Value.".$_} = $args[$_-1] for 1..scalar @args; $count++; } } #Split a list into hash entries, this takes a printf string so we can add the iterator anywhere. #E.g. _split_into_args('Owner.%s',\%args, \@owners) adds the following to %args: # 'Owner.2' => 'account239' # 'Owner.1' => 'account743' # ... sub _split_into_args { my ( $formatstr, $hashref, $listref ) = @_; my $count = 1; foreach my $value ( @{$listref} ) { my $formatedstr = sprintf "$formatstr", $count++; $hashref->{$formatedstr} = $value if defined($value); } } =head1 OBJECT METHODS =head2 allocate_address() Acquires an elastic IP address which can be associated with an EC2-classic instance to create a movable static IP. Takes no arguments. Returns the IP address obtained. =cut sub allocate_address { my $self = shift; my $xml = $self->_sign(Action => 'AllocateAddress'); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { return $xml->{publicIp}; } } =head2 allocate_vpc_address() Acquires an elastic IP address which can be associated with a VPC instance to create a movable static IP. Takes no arguments. Returns the allocationId of the allocated address. =cut sub allocate_vpc_address { my $self = shift; my $xml = $self->_sign(Action => 'AllocateAddress', Domain => 'vpc'); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { return $xml->{allocationId}; } } =head2 associate_address(%params) Associates an elastic IP address with an instance. It takes the following arguments: =over =item InstanceId (required) The instance id you wish to associate the IP address with =item PublicIp (optional) The IP address. Used for allocating addresses to EC2-classic instances. =item AllocationId (optional) The allocation ID. Used for allocating address to VPC instances. =back Returns true if the association succeeded. =cut sub associate_address { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR }, PublicIp => { type => SCALAR, optional => 1 }, AllocationId => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'AssociateAddress', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 attach_volume(%params) Attach a volume to an instance. =over =item VolumeId (required) The volume id you wish to attach. =item InstanceId (required) The instance id you wish to attach the volume to. =item Device (required) The device id you want the volume attached as. =back Returns a Net::Amazon::EC2::Attachment object containing the resulting volume status. =cut sub attach_volume { my $self = shift; my %args = validate( @_, { VolumeId => { type => SCALAR }, InstanceId => { type => SCALAR }, Device => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'AttachVolume', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $attachment = Net::Amazon::EC2::Attachment->new( volume_id => $xml->{volumeId}, status => $xml->{status}, instance_id => $xml->{instanceId}, attach_time => $xml->{attachTime}, device => $xml->{device}, ); return $attachment; } } =head2 authorize_security_group_ingress(%params) This method adds permissions to a security group. It takes the following parameters: =over =item GroupName (required) The name of the group to add security rules to. =item SourceSecurityGroupName (required when authorizing a user and group together) Name of the group to add access for. =item SourceSecurityGroupOwnerId (required when authorizing a user and group together) Owner of the group to add access for. =item IpProtocol (required when adding access for a CIDR) IP Protocol of the rule you are adding access for (TCP, UDP, or ICMP) =item FromPort (required when adding access for a CIDR) Beginning of port range to add access for. =item ToPort (required when adding access for a CIDR) End of port range to add access for. =item CidrIp (required when adding access for a CIDR) The CIDR IP space we are adding access for. =back Adding a rule can be done in two ways: adding a source group name + source group owner id, or, CIDR IP range. Both methods allow IP protocol, from port and to port specifications. Returns 1 if rule is added successfully. =cut sub authorize_security_group_ingress { my $self = shift; my %args = validate( @_, { GroupName => { type => SCALAR, optional => 1 }, GroupId => { type => SCALAR, optional => 1 }, SourceSecurityGroupName => { type => SCALAR, depends => ['SourceSecurityGroupOwnerId'], optional => 1 , }, SourceSecurityGroupOwnerId => { type => SCALAR, optional => 1 }, IpProtocol => { type => SCALAR, depends => ['FromPort', 'ToPort'], optional => 1 }, FromPort => { type => SCALAR, optional => 1 }, ToPort => { type => SCALAR, optional => 1 }, CidrIp => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'AuthorizeSecurityGroupIngress', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 bundle_instance(%params) Bundles the Windows instance. This procedure is not applicable for Linux and UNIX instances. NOTE NOTE NOTE This is not well tested as I don't run windows instances =over =item InstanceId (required) The ID of the instance to bundle. =item Storage.S3.Bucket (required) The bucket in which to store the AMI. You can specify a bucket that you already own or a new bucket that Amazon EC2 creates on your behalf. If you specify a bucket that belongs to someone else, Amazon EC2 returns an error. =item Storage.S3.Prefix (required) Specifies the beginning of the file name of the AMI. =item Storage.S3.AWSAccessKeyId (required) The Access Key ID of the owner of the Amazon S3 bucket. =item Storage.S3.UploadPolicy (required) An Amazon S3 upload policy that gives Amazon EC2 permission to upload items into Amazon S3 on the user's behalf. =item Storage.S3.UploadPolicySignature (required) The signature of the Base64 encoded JSON document. JSON Parameters: (all are required) expiration - The expiration of the policy. Amazon recommends 12 hours or longer. conditions - A list of restrictions on what can be uploaded to Amazon S3. Must contain the bucket and ACL conditions in this table. bucket - The bucket to store the AMI. acl - This must be set to ec2-bundle-read. =back Returns a Net::Amazon::EC2::BundleInstanceResponse object =cut sub bundle_instance { my $self = shift; my %args = validate( @_, { 'InstanceId' => { type => SCALAR }, 'Storage.S3.Bucket' => { type => SCALAR }, 'Storage.S3.Prefix' => { type => SCALAR }, 'Storage.S3.AWSAccessKeyId' => { type => SCALAR }, 'Storage.S3.UploadPolicy' => { type => SCALAR }, 'Storage.S3.UploadPolicySignature' => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'BundleInstance', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $bundle = Net::Amazon::EC2::BundleInstanceResponse->new( instance_id => $xml->{bundleInstanceTask}{instanceId}, bundle_id => $xml->{bundleInstanceTask}{bundleId}, state => $xml->{bundleInstanceTask}{state}, start_time => $xml->{bundleInstanceTask}{startTime}, update_time => $xml->{bundleInstanceTask}{updateTime}, progress => $xml->{bundleInstanceTask}{progress}, s3_bucket => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, s3_prefix => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, s3_aws_access_key_id => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, s3_upload_policy => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, s3_policy_upload_signature => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, bundle_error_code => $xml->{bundleInstanceTask}{error}{code}, bundle_error_message => $xml->{bundleInstanceTask}{error}{message}, ); return $bundle; } } =head2 cancel_bundle_task(%params) Cancels the bundle task. This procedure is not applicable for Linux and UNIX instances. =over =item BundleId (required) The ID of the bundle task to cancel. =back Returns a Net::Amazon::EC2::BundleInstanceResponse object =cut sub cancel_bundle_task { my $self = shift; my %args = validate( @_, { 'BundleId' => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'CancelBundleTask', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $bundle = Net::Amazon::EC2::BundleInstanceResponse->new( instance_id => $xml->{bundleInstanceTask}{instanceId}, bundle_id => $xml->{bundleInstanceTask}{bundleId}, state => $xml->{bundleInstanceTask}{state}, start_time => $xml->{bundleInstanceTask}{startTime}, update_time => $xml->{bundleInstanceTask}{updateTime}, progress => $xml->{bundleInstanceTask}{progress}, s3_bucket => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, s3_prefix => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, s3_aws_access_key_id => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, s3_upload_policy => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, s3_policy_upload_signature => $xml->{bundleInstanceTask}{storage}{S3}{bucket}, bundle_error_code => $xml->{bundleInstanceTask}{error}{code}, bundle_error_message => $xml->{bundleInstanceTask}{error}{message}, ); return $bundle; } } =head2 confirm_product_instance(%params) Checks to see if the product code passed in is attached to the instance id, taking the following parameter: =over =item ProductCode (required) The Product Code to check =item InstanceId (required) The Instance Id to check =back Returns a Net::Amazon::EC2::ConfirmProductInstanceResponse object =cut sub confirm_product_instance { my $self = shift; my %args = validate( @_, { ProductCode => { type => SCALAR }, InstanceId => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'ConfirmProductInstance', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $confirm_response = Net::Amazon::EC2::ConfirmProductInstanceResponse->new( 'return' => $xml->{'return'}, owner_id => $xml->{ownerId}, ); return $confirm_response; } } =head2 create_image(%params) Creates an AMI that uses an Amazon EBS root device from a "running" or "stopped" instance. AMIs that use an Amazon EBS root device boot faster than AMIs that use instance stores. They can be up to 1 TiB in size, use storage that persists on instance failure, and can be stopped and started. =over =item InstanceId (required) The ID of the instance. =item Name (required) The name of the AMI that was provided during image creation. Note that the image name has the following constraints: 3-128 alphanumeric characters, parenthesis, commas, slashes, dashes, or underscores. =item Description (optional) The description of the AMI that was provided during image creation. =item NoReboot (optional) By default this property is set to false, which means Amazon EC2 attempts to cleanly shut down the instance before image creation and reboots the instance afterwards. When set to true, Amazon EC2 does not shut down the instance before creating the image. When this option is used, file system integrity on the created image cannot be guaranteed. =item BlockDeviceMapping (optional) Array ref of the device names exposed to the instance. You can specify device names as '=' similar to ec2-create-image command. (L) BlockDeviceMapping => [ '/dev/sda=:256:true:standard', '/dev/sdb=none', '/dev/sdc=ephemeral0', '/dev/sdd=ephemeral1', ], =back Returns the ID of the AMI created. =cut sub create_image { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR }, Name => { type => SCALAR }, Description => { type => SCALAR, optional => 1 }, NoReboot => { type => SCALAR, optional => 1 }, BlockDeviceMapping => { type => ARRAYREF, optional => 1 }, }); if (my $bdm = delete $args{BlockDeviceMapping}) { my $n = 0; for my $bdme (@$bdm) { my($device, $block_device) = split /=/, $bdme, 2; $args{"BlockDeviceMapping.${n}.DeviceName"} = $device; if ($block_device =~ /^ephemeral[0-9]+$/) { $args{"BlockDeviceMapping.${n}.VirtualName"} = $block_device; } elsif ($block_device eq 'none') { $args{"BlockDeviceMapping.${n}.NoDevice"} = ''; } else { my @keys = qw( Ebs.SnapshotId Ebs.VolumeSize Ebs.DeleteOnTermination Ebs.VolumeType Ebs.Iops ); for my $bde (split /:/, $block_device) { my $key = shift @keys; next unless $bde; $args{"BlockDeviceMapping.${n}.${key}"} = $bde; } } $n++; } } my $xml = $self->_sign(Action => 'CreateImage', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { return $xml->{imageId}; } } =head2 create_key_pair(%params) Creates a new 2048 bit key pair, taking the following parameter: =over =item KeyName (required) A name for this key. Should be unique. =back Returns a Net::Amazon::EC2::KeyPair object =cut sub create_key_pair { my $self = shift; my %args = validate( @_, { KeyName => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'CreateKeyPair', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $key_pair = Net::Amazon::EC2::KeyPair->new( key_name => $xml->{keyName}, key_fingerprint => $xml->{keyFingerprint}, key_material => $xml->{keyMaterial}, ); return $key_pair; } } =head2 create_security_group(%params) This method creates a new security group. It takes the following parameters: =over =item GroupName (required) The name of the new group to create. =item GroupDescription (required) A short description of the new group. =back Returns 1 if the group creation succeeds. =cut sub create_security_group { my $self = shift; my %args = validate( @_, { GroupName => { type => SCALAR }, GroupDescription => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'CreateSecurityGroup', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 create_snapshot(%params) Create a snapshot of a volume. It takes the following arguments: =over =item VolumeId (required) The volume id of the volume you want to take a snapshot of. =item Description (optional) Description of the Amazon EBS snapshot. =back Returns a Net::Amazon::EC2::Snapshot object of the newly created snapshot. =cut sub create_snapshot { my $self = shift; my %args = validate( @_, { VolumeId => { type => SCALAR }, Description => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'CreateSnapshot', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { unless ( grep { defined && length } $xml->{progress} and ref $xml->{progress} ne 'HASH') { $xml->{progress} = undef; } my $snapshot = Net::Amazon::EC2::Snapshot->new( snapshot_id => $xml->{snapshotId}, status => $xml->{status}, volume_id => $xml->{volumeId}, start_time => $xml->{startTime}, progress => $xml->{progress}, owner_id => $xml->{ownerId}, volume_size => $xml->{volumeSize}, description => $xml->{description}, ); return $snapshot; } } =head2 create_tags(%params) Creates tags. =over =item ResourceId (required) The ID of the resource to create tags. Can be a scalar or arrayref =item Tags (required) Hashref where keys and values will be set on all resources given in the first element. =back Returns true if the tag creation succeeded. =cut sub create_tags { my $self = shift; my %args = validate( @_, { ResourceId => { type => ARRAYREF | SCALAR }, Tags => { type => HASHREF }, }); if (ref ($args{'ResourceId'}) eq 'ARRAY') { my $keys = delete $args{'ResourceId'}; _split_into_args('ResourceId.%s',\%args,$keys); } else { $args{"ResourceId.1"} = delete $args{'ResourceId'}; } if (ref ($args{'Tags'}) eq 'HASH') { my $count = 1; my $tags = delete $args{'Tags'}; foreach my $key ( keys %{$tags} ) { last if $count > 10; $args{"Tag." . $count . ".Key"} = $key; $args{"Tag." . $count . ".Value"} = $tags->{$key}; $count++; } } my $xml = $self->_sign(Action => 'CreateTags', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 create_volume(%params) Creates a volume. =over =item Size (required) The size in GiB ( 1024^3 ) of the volume you want to create. =item SnapshotId (optional) The optional snapshot id to create the volume from. The volume must be equal or larger than the snapshot it was created from. =item AvailabilityZone (required) The availability zone to create the volume in. =item VolumeType (optional) The volume type: 'standard', 'gp2', or 'io1'. Defaults to 'standard'. =item Iops (required if VolumeType is 'io1') The number of I/O operations per second (IOPS) that the volume supports. This is limited to 30 times the volume size with an absolute maximum of 4000. It's likely these numbers will change in the future. Required when the volume type is io1; not used otherwise. =item Encrypted (optional) Encrypt the volume. EBS encrypted volumes are encrypted on the host using AWS managed keys. Only some instance types support encrypted volumes. At the time of writing encrypted volumes are not supported for boot volumes. =back Returns a Net::Amazon::EC2::Volume object containing the resulting volume status =cut sub create_volume { my $self = shift; my %args = validate( @_, { Size => { type => SCALAR }, SnapshotId => { type => SCALAR, optional => 1 }, AvailabilityZone => { type => SCALAR }, VolumeType => { type => SCALAR, optional => 1 }, Iops => { type => SCALAR, optional => 1 }, Encrypted => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'CreateVolume', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { unless ( grep { defined && length } $xml->{snapshotId} and ref $xml->{snapshotId} ne 'HASH') { $xml->{snapshotId} = undef; } my $volume = Net::Amazon::EC2::Volume->new( volume_id => $xml->{volumeId}, status => $xml->{status}, zone => $xml->{availabilityZone}, create_time => $xml->{createTime}, snapshot_id => $xml->{snapshotId}, size => $xml->{size}, volume_type => $xml->{volumeType}, iops => $xml->{iops}, encrypted => $xml->{encrypted}, ); return $volume; } } =head2 delete_key_pair(%params) This method deletes a keypair. Takes the following parameter: =over =item KeyName (required) The name of the key to delete. =back Returns 1 if the key was successfully deleted. =cut sub delete_key_pair { my $self = shift; my %args = validate( @_, { KeyName => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'DeleteKeyPair', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 delete_security_group(%params) This method deletes a security group. It takes the following parameter: =over =item GroupName (required) The name of the security group to delete. =back Returns 1 if the delete succeeded. =cut sub delete_security_group { my $self = shift; my %args = validate( @_, { GroupName => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'DeleteSecurityGroup', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 delete_snapshot(%params) Deletes the snapshots passed in. It takes the following arguments: =over =item SnapshotId (required) A snapshot id can be passed in. Will delete the corresponding snapshot. =back Returns true if the deleting succeeded. =cut sub delete_snapshot { my $self = shift; my %args = validate( @_, { SnapshotId => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'DeleteSnapshot', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 delete_volume(%params) Delete a volume. =over =item VolumeId (required) The volume id you wish to delete. =back Returns true if the deleting succeeded. =cut sub delete_volume { my $self = shift; my %args = validate( @_, { VolumeId => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'DeleteVolume', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 delete_tags(%params) Delete tags. =over =item ResourceId (required) The ID of the resource to delete tags =item Tag.Key (required) Key for a tag, may pass in a scalar or arrayref. =item Tag.Value (required) Value for a tag, may pass in a scalar or arrayref. =back Returns true if the releasing succeeded. =cut sub delete_tags { my $self = shift; my %args = validate( @_, { ResourceId => { type => ARRAYREF | SCALAR }, 'Tag.Key' => { type => ARRAYREF | SCALAR }, 'Tag.Value' => { type => ARRAYREF | SCALAR, optional => 1 }, }); # If we have a array ref of keys lets split them out into their Tag.n.Key format if (ref ($args{'Tag.Key'}) eq 'ARRAY') { my $keys = delete $args{'Tag.Key'}; _split_into_args('Tag.%s.Key',\%args,$keys); } # If we have a array ref of values lets split them out into their Tag.n.Value format if (ref ($args{'Tag.Value'}) eq 'ARRAY') { my $values = delete $args{'Tag.Value'}; _split_into_args('Tag.%s.Value',\%args,$values); } my $xml = $self->_sign(Action => 'DeleteTags', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 deregister_image(%params) This method will deregister an AMI. It takes the following parameter: =over =item ImageId (required) The image id of the AMI you want to deregister. =back Returns 1 if the deregistering succeeded =cut sub deregister_image { my $self = shift; my %args = validate( @_, { ImageId => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'DeregisterImage', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 describe_addresses(%params) This method describes the elastic addresses currently allocated and any instances associated with them. It takes the following arguments: =over =item PublicIp (optional) The IP address to describe. Can be either a scalar or an array ref. =back Returns an array ref of Net::Amazon::EC2::DescribeAddress objects =cut sub describe_addresses { my $self = shift; my %args = validate( @_, { PublicIp => { type => SCALAR | ARRAYREF, optional => 1 }, }); # If we have a array ref of ip addresses lets split them out into their PublicIp.n format if (ref ($args{PublicIp}) eq 'ARRAY') { my $ip_addresses = delete $args{PublicIp}; _split_into_args('PublicIp.%s',\%args,$ip_addresses); } my $addresses; my $xml = $self->_sign(Action => 'DescribeAddresses', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { foreach my $addy (@{$xml->{addressesSet}{item}}) { if (ref($addy->{instanceId}) eq 'HASH') { undef $addy->{instanceId}; } my $address = Net::Amazon::EC2::DescribeAddress->new( public_ip => $addy->{publicIp}, instance_id => $addy->{instanceId}, ); push @$addresses, $address; } return $addresses; } } =head2 describe_availability_zones(%params) This method describes the availability zones currently available to choose from. It takes the following arguments: =over =item ZoneName (optional) The zone name to describe. Can be either a scalar or an array ref. =back Returns an array ref of Net::Amazon::EC2::AvailabilityZone objects =cut sub describe_availability_zones { my $self = shift; my %args = validate( @_, { ZoneName => { type => SCALAR | ARRAYREF, optional => 1 }, }); # If we have a array ref of zone names lets split them out into their ZoneName.n format if (ref ($args{ZoneName}) eq 'ARRAY') { my $zone_names = delete $args{ZoneName}; _split_into_args('ZoneName.%s',\%args,$zone_names); } my $xml = $self->_sign(Action => 'DescribeAvailabilityZones', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $availability_zones; foreach my $az (@{$xml->{availabilityZoneInfo}{item}}) { my $availability_zone_messages; # Create the messages for this zone foreach my $azm (@{$az->{messageSet}{item}}) { my $availability_zone_message = Net::Amazon::EC2::AvailabilityZoneMessage->new( message => $azm->{message}, ); push @$availability_zone_messages, $availability_zone_message; } my $availability_zone = Net::Amazon::EC2::AvailabilityZone->new( zone_name => $az->{zoneName}, zone_state => $az->{zoneState}, region_name => $az->{regionName}, messages => $availability_zone_messages, ); push @$availability_zones, $availability_zone; } return $availability_zones; } } =head2 describe_bundle_tasks(%params) Describes current bundling tasks. This procedure is not applicable for Linux and UNIX instances. =over =item BundleId (optional) The optional ID of the bundle task to describe. =back Returns a array ref of Net::Amazon::EC2::BundleInstanceResponse objects =cut sub describe_bundle_tasks { my $self = shift; my %args = validate( @_, { 'BundleId' => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'DescribeBundleTasks', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $bundle_tasks; foreach my $item (@{$xml->{bundleInstanceTasksSet}{item}}) { my $bundle = Net::Amazon::EC2::BundleInstanceResponse->new( instance_id => $item->{instanceId}, bundle_id => $item->{bundleId}, state => $item->{state}, start_time => $item->{startTime}, update_time => $item->{updateTime}, progress => $item->{progress}, s3_bucket => $item->{storage}{S3}{bucket}, s3_prefix => $item->{storage}{S3}{bucket}, s3_aws_access_key_id => $item->{storage}{S3}{bucket}, s3_upload_policy => $item->{storage}{S3}{bucket}, s3_policy_upload_signature => $item->{storage}{S3}{bucket}, bundle_error_code => $item->{error}{code}, bundle_error_message => $item->{error}{message}, ); push @$bundle_tasks, $bundle; } return $bundle_tasks; } } =head2 describe_image_attributes(%params) This method pulls a list of attributes for the image id specified =over =item ImageId (required) A scalar containing the image you want to get the list of attributes for. =item Attribute (required) A scalar containing the attribute to describe. Valid attributes are: =over =item launchPermission - The AMIs launch permissions. =item ImageId - ID of the AMI for which an attribute will be described. =item productCodes - The product code attached to the AMI. =item kernel - Describes the ID of the kernel associated with the AMI. =item ramdisk - Describes the ID of RAM disk associated with the AMI. =item blockDeviceMapping - Defines native device names to use when exposing virtual devices. =item platform - Describes the operating system platform. =back =back Returns a Net::Amazon::EC2::DescribeImageAttribute object * NOTE: There is currently a bug in Amazon's SOAP and Query API for when you try and describe the attributes: kernel, ramdisk, blockDeviceMapping, or platform AWS returns an invalid response. No response yet from Amazon on an ETA for getting that bug fixed. =cut sub describe_image_attribute { my $self = shift; my %args = validate( @_, { ImageId => { type => SCALAR }, Attribute => { type => SCALAR } }); my $xml = $self->_sign(Action => 'DescribeImageAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $launch_permissions; my $product_codes; my $block_device_mappings; if ( grep { defined && length } $xml->{launchPermission}{item} ) { foreach my $lp (@{$xml->{launchPermission}{item}}) { my $launch_permission = Net::Amazon::EC2::LaunchPermission->new( group => $lp->{group}, user_id => $lp->{userId}, ); push @$launch_permissions, $launch_permission; } } if ( grep { defined && length } $xml->{productCodes}{item} ) { foreach my $pc (@{$xml->{productCodes}{item}}) { my $product_code = Net::Amazon::EC2::ProductCode->new( product_code => $pc->{productCode}, ); push @$product_codes, $product_code; } } if ( grep { defined && length } $xml->{blockDeviceMapping}{item} ) { foreach my $bd (@{$xml->{blockDeviceMapping}{item}}) { my $block_device_mapping = Net::Amazon::EC2::BlockDeviceMapping->new( virtual_name => $bd->{virtualName}, device_name => $bd->{deviceName}, ); push @$block_device_mappings, $block_device_mapping; } } my $describe_image_attribute = Net::Amazon::EC2::DescribeImageAttribute->new( image_id => $xml->{imageId}, launch_permissions => $launch_permissions, product_codes => $product_codes, kernel => $xml->{kernel}, ramdisk => $xml->{ramdisk}, blockDeviceMapping => $block_device_mappings, platform => $xml->{platform}, ); return $describe_image_attribute; } } =head2 describe_images(%params) This method pulls a list of the AMIs which can be run. The list can be modified by passing in some of the following parameters: =over =item ImageId (optional) Either a scalar or an array ref can be passed in, will cause just these AMIs to be 'described' =item Owner (optional) Either a scalar or an array ref can be passed in, will cause AMIs owned by the Owner's provided will be 'described'. Pass either account ids, or 'amazon' for all amazon-owned AMIs, or 'self' for your own AMIs. =item ExecutableBy (optional) Either a scalar or an array ref can be passed in, will cause AMIs executable by the account id's specified. Or 'self' for your own AMIs. =back Returns an array ref of Net::Amazon::EC2::DescribeImagesResponse objects =cut sub describe_images { my $self = shift; my %args = validate( @_, { ImageId => { type => SCALAR | ARRAYREF, optional => 1 }, Owner => { type => SCALAR | ARRAYREF, optional => 1 }, ExecutableBy => { type => SCALAR | ARRAYREF, optional => 1 }, }); # If we have a array ref of instances lets split them out into their ImageId.n format if (ref ($args{ImageId}) eq 'ARRAY') { my $image_ids = delete $args{ImageId}; _split_into_args('ImageId.%s',\%args,$image_ids); } # If we have a array ref of instances lets split them out into their Owner.n format if (ref ($args{Owner}) eq 'ARRAY') { my $owners = delete $args{Owner}; _split_into_args('Owner.%s',\%args,$owners); } # If we have a array ref of instances lets split them out into their ExecutableBy.n format if (ref ($args{ExecutableBy}) eq 'ARRAY') { my $executors = delete $args{ExecutableBy}; _split_into_args('ExecutableBy.%s',\%args,$executors); } my $xml = $self->_sign(Action => 'DescribeImages', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $images; foreach my $item (@{$xml->{imagesSet}{item}}) { my $product_codes; my $state_reason; my $block_device_mappings; if ( grep { defined && length && $_->{code} && $_->{message} } $item->{stateReason} ) { $state_reason = Net::Amazon::EC2::StateReason->new( code => $item->{stateReason}{code}, message => $item->{stateReason}{message}, ); } if ( grep { defined && length } $item->{blockDeviceMapping} ) { foreach my $bdm ( @{$item->{blockDeviceMapping}{item}} ) { my $virtual_name; my $no_device; my $ebs_block_device_mapping; if ( grep { defined && length } $bdm->{ebs} ) { $ebs_block_device_mapping = Net::Amazon::EC2::EbsBlockDevice->new( snapshot_id => $bdm->{ebs}{snapshotId}, volume_size => $bdm->{ebs}{volumeSize}, delete_on_termination => $bdm->{ebs}{deleteOnTermination}, ); } my $block_device_mapping = Net::Amazon::EC2::BlockDeviceMapping->new( device_name => $bdm->{deviceName}, virtual_name => $virtual_name, ebs => $ebs_block_device_mapping, no_device => $no_device, ); push @$block_device_mappings, $block_device_mapping; } } $item->{description} = undef if ref ($item->{description}); my $tag_sets; foreach my $tag_arr (@{$item->{tagSet}{item}}) { if ( ref $tag_arr->{value} eq "HASH" ) { $tag_arr->{value} = ""; } my $tag = Net::Amazon::EC2::TagSet->new( key => $tag_arr->{key}, value => $tag_arr->{value}, ); push @$tag_sets, $tag; } my $image = Net::Amazon::EC2::DescribeImagesResponse->new( image_id => $item->{imageId}, image_owner_id => $item->{imageOwnerId}, image_state => $item->{imageState}, is_public => $item->{isPublic}, image_location => $item->{imageLocation}, architecture => $item->{architecture}, image_type => $item->{imageType}, kernel_id => $item->{kernelId}, ramdisk_id => $item->{ramdiskId}, platform => $item->{platform}, state_reason => $state_reason, image_owner_alias => $item->{imageOwnerAlias}, name => $item->{name}, description => $item->{description}, root_device_type => $item->{rootDeviceType}, root_device_name => $item->{rootDeviceName}, block_device_mapping => $block_device_mappings, tag_set => $tag_sets, ); if (grep { defined && length } $item->{productCodes} ) { foreach my $pc (@{$item->{productCodes}{item}}) { my $product_code = Net::Amazon::EC2::ProductCode->new( product_code => $pc->{productCode} ); push @$product_codes, $product_code; } $image->product_codes($product_codes); } push @$images, $image; } return $images; } } =head2 describe_instances(%params) This method pulls a list of the instances which are running or were just running. The list can be modified by passing in some of the following parameters: =over =item InstanceId (optional) Either a scalar or an array ref can be passed in, will cause just these instances to be 'described' =item Filter (optional) The filters for only the matching instances to be 'described'. A filter tuple is an arrayref constsing one key and one or more values. The option takes one filter tuple, or an arrayref of multiple filter tuples. =back Returns an array ref of Net::Amazon::EC2::ReservationInfo objects =cut sub describe_instances { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR | ARRAYREF, optional => 1 }, Filter => { type => ARRAYREF, optional => 1 }, }); # If we have a array ref of instances lets split them out into their InstanceId.n format if (ref ($args{InstanceId}) eq 'ARRAY') { my $instance_ids = delete $args{InstanceId}; _split_into_args('InstanceId.%s',\%args,$instance_ids); } $self->_build_filters(\%args); my $xml = $self->_sign(Action => 'DescribeInstances', %args); my $reservations; if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { foreach my $reservation_set (@{$xml->{reservationSet}{item}}) { my $group_sets=[]; foreach my $group_arr (@{$reservation_set->{groupSet}{item}}) { my $group = Net::Amazon::EC2::GroupSet->new( group_id => $group_arr->{groupId}, group_name => $group_arr->{groupName}, ); push @$group_sets, $group; } my $running_instances; foreach my $instance_elem (@{$reservation_set->{instancesSet}{item}}) { my $instance_state_type = Net::Amazon::EC2::InstanceState->new( code => $instance_elem->{instanceState}{code}, name => $instance_elem->{instanceState}{name}, ); my $product_codes; my $block_device_mappings; my $state_reason; my $network_interfaces_set; if (grep { defined && length } $instance_elem->{productCodes} ) { foreach my $pc (@{$instance_elem->{productCodes}{item}}) { my $product_code = Net::Amazon::EC2::ProductCode->new( product_code => $pc->{productCode} ); push @$product_codes, $product_code; } } if ( grep { defined && length } $instance_elem->{networkInterfaceSet} ) { foreach my $interface( @{$instance_elem->{networkInterfaceSet}{item}} ) { my $network_interface = Net::Amazon::EC2::NetworkInterfaceSet->new( network_interface_id => $interface->{networkInterfaceId}, subnet_id => $interface->{subnetId}, vpc_id => $interface->{vpcId}, description => $interface->{description}, status => $interface->{status}, mac_address => $interface->{macAddress}, private_ip_address => $interface->{privateIpAddress}, ); if ( grep { defined && length } $interface->{groupSet} ) { my $groups_set = []; foreach my $group( @{$interface->{groupSet}{item}} ) { my $group = Net::Amazon::EC2::GroupSet->new( group_id => $group->{groupId}, group_name => $group->{groupName}, ); push @$groups_set, $group; } $network_interface->{group_sets} = $groups_set; } push @$network_interfaces_set, $network_interface; } } if ( grep { defined && length } $instance_elem->{blockDeviceMapping} ) { foreach my $bdm ( @{$instance_elem->{blockDeviceMapping}{item}} ) { my $ebs_block_device_mapping = Net::Amazon::EC2::EbsInstanceBlockDeviceMapping->new( volume_id => $bdm->{ebs}{volumeId}, status => $bdm->{ebs}{status}, attach_time => $bdm->{ebs}{attachTime}, delete_on_termination => $bdm->{ebs}{deleteOnTermination}, ); my $block_device_mapping = Net::Amazon::EC2::BlockDeviceMapping->new( ebs => $ebs_block_device_mapping, device_name => $bdm->{deviceName}, ); push @$block_device_mappings, $block_device_mapping; } } if ( grep { defined && length && $_->{code} && $_->{message} && $_->{code} && $_->{message} } $instance_elem->{stateReason} ) { $state_reason = Net::Amazon::EC2::StateReason->new( code => $instance_elem->{stateReason}{code}, message => $instance_elem->{stateReason}{message}, ); } unless ( grep { defined && length } $instance_elem->{reason} and ref $instance_elem->{reason} ne 'HASH' ) { $instance_elem->{reason} = undef; } unless ( grep { defined && length } $instance_elem->{privateDnsName} and ref $instance_elem->{privateDnsName} ne 'HASH' ) { $instance_elem->{privateDnsName} = undef; } unless ( grep { defined && length } $instance_elem->{dnsName} and ref $instance_elem->{dnsName} ne 'HASH' ) { $instance_elem->{dnsName} = undef; } unless ( grep { defined && length } $instance_elem->{placement}{availabilityZone} and ref $instance_elem->{placement}{availabilityZone} ne 'HASH' ) { $instance_elem->{placement}{availabilityZone} = undef; } my $placement_response = Net::Amazon::EC2::PlacementResponse->new( availability_zone => $instance_elem->{placement}{availabilityZone} ); my $tag_sets; foreach my $tag_arr (@{$instance_elem->{tagSet}{item}}) { if ( ref $tag_arr->{value} eq "HASH" ) { $tag_arr->{value} = ""; } my $tag = Net::Amazon::EC2::TagSet->new( key => $tag_arr->{key}, value => $tag_arr->{value}, ); push @$tag_sets, $tag; } my $running_instance = Net::Amazon::EC2::RunningInstances->new( ami_launch_index => $instance_elem->{amiLaunchIndex}, dns_name => $instance_elem->{dnsName}, image_id => $instance_elem->{imageId}, kernel_id => $instance_elem->{kernelId}, ramdisk_id => $instance_elem->{ramdiskId}, instance_id => $instance_elem->{instanceId}, instance_state => $instance_state_type, instance_type => $instance_elem->{instanceType}, key_name => $instance_elem->{keyName}, launch_time => $instance_elem->{launchTime}, placement => $placement_response, private_dns_name => $instance_elem->{privateDnsName}, reason => $instance_elem->{reason}, platform => $instance_elem->{platform}, monitoring => $instance_elem->{monitoring}{state}, subnet_id => $instance_elem->{subnetId}, vpc_id => $instance_elem->{vpcId}, private_ip_address => $instance_elem->{privateIpAddress}, ip_address => $instance_elem->{ipAddress}, architecture => $instance_elem->{architecture}, root_device_name => $instance_elem->{rootDeviceName}, root_device_type => $instance_elem->{rootDeviceType}, block_device_mapping => $block_device_mappings, state_reason => $state_reason, tag_set => $tag_sets, network_interface_set => $network_interfaces_set, ); if ($product_codes) { $running_instance->product_codes($product_codes); } push @$running_instances, $running_instance; } my $reservation = Net::Amazon::EC2::ReservationInfo->new( reservation_id => $reservation_set->{reservationId}, owner_id => $reservation_set->{ownerId}, group_set => $group_sets, instances_set => $running_instances, requester_id => $reservation_set->{requesterId}, ); push @$reservations, $reservation; } } return $reservations; } =head2 describe_instance_status(%params) This method pulls a list of the instances based on some status filter. The list can be modified by passing in some of the following parameters: =over =item InstanceId (optional) Either a scalar or an array ref can be passed in, will cause just these instances to be 'described' =item Filter (optional) The filters for only the matching instances to be 'described'. A filter tuple is an arrayref constsing one key and one or more values. The option takes one filter tuple, or an arrayref of multiple filter tuples. =back Returns an array ref of Net::Amazon::EC2::InstanceStatuses objects =cut sub describe_instance_status { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR | ARRAYREF, optional => 1 }, Filter => { type => ARRAYREF, optional => 1 }, MaxResults => { type => SCALAR, optional => 1 }, NextToken => { type => SCALAR, optional => 1 }, IncludeAllInstances => { type => BOOLEAN, optional => 1 }, } ); # If we have a array ref of instances lets split them out into their InstanceId.n format if ( ref( $args{InstanceId} ) eq 'ARRAY' ) { my $instance_ids = delete $args{InstanceId}; my $count = 1; foreach my $instance_id ( @{$instance_ids} ) { $args{ "InstanceId." . $count } = $instance_id; $count++; } } $self->_build_filters( \%args ); my $xml = $self->_sign( Action => 'DescribeInstanceStatus', %args ); my $instancestatuses; my $token; if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { foreach my $instancestatus_elem ( @{ $xml->{instanceStatusSet}{item} } ) { my $instance_status = $self->_create_describe_instance_status( $instancestatus_elem ); push @$instancestatuses, $instance_status; } if ( grep { defined && length } $xml->{nextToken} ) { $token = $xml->{nextToken}; while(1) { $args{NextToken} = $token; $self->_build_filters( \%args ); my $tmp_xml = $self->_sign( Action => 'DescribeInstanceStatus', %args ); if ( grep { defined && length } $tmp_xml->{Errors} ) { return $self->_parse_errors($tmp_xml); } else { foreach my $tmp_instancestatus_elem ( @{ $tmp_xml->{instanceStatusSet}{item} } ) { my $tmp_instance_status = $self->_create_describe_instance_status( $tmp_instancestatus_elem ); push @$instancestatuses, $tmp_instance_status; } if ( grep { defined && length } $tmp_xml->{nextToken} ) { $token = $tmp_xml->{nextToken}; } else { last; } } } } } return $instancestatuses; } =head2 _create_describe_instance_status(%instanceElement) Returns a blessed object. Used internally for wrapping describe_instance_status nextToken calls =over =item InstanceStatusElement (required) The instance status element we want to build out and return =back Returns a Net::Amazon::EC2::InstanceStatuses object =cut sub _create_describe_instance_status { my $self = shift; my $instancestatus_elem = shift; my $group_sets = []; my $instancestatus_state = Net::Amazon::EC2::InstanceState->new( code => $instancestatus_elem->{instanceState}{code}, name => $instancestatus_elem->{instanceState}{name}, ); foreach my $events_arr ( @{ $instancestatus_elem->{eventsSet}{item} } ) { my $events; if ( grep { defined && length } $events_arr->{notAfter} ) { $events = Net::Amazon::EC2::Events->new( code => $events_arr->{code}, description => $events_arr->{description}, not_before => $events_arr->{notBefore}, not_after => $events_arr->{notAfter}, ); } else { $events = Net::Amazon::EC2::Events->new( code => $events_arr->{code}, description => $events_arr->{description}, not_before => $events_arr->{notBefore}, ); } push @$group_sets, $events; } my $instancestatus_istatus; if ( grep { defined && length } $instancestatus_elem->{instanceStatus} ) { my $details_set = []; foreach my $details_arr ( @{ $instancestatus_elem->{instanceStatus}{details}{item} } ) { my $details = Net::Amazon::EC2::Details->new( status => $details_arr->{status}, name => $details_arr->{name}, ); push @$details_set, $details; } $instancestatus_istatus = Net::Amazon::EC2::InstanceStatus->new( status => $instancestatus_elem->{instanceStatus}{status}, details => $details_set, ); } my $instancestatus_sstatus; if ( grep { defined && length } $instancestatus_elem->{systemStatus} ) { my $details_set = []; foreach my $details_arr ( @{ $instancestatus_elem->{systemStatus}{details}{item} } ) { my $details = Net::Amazon::EC2::Details->new( status => $details_arr->{status}, name => $details_arr->{name}, ); push @$details_set, $details; } $instancestatus_sstatus = Net::Amazon::EC2::SystemStatus->new( status => $instancestatus_elem->{systemStatus}{status}, details => $details_set, ); } my $instance_status = Net::Amazon::EC2::InstanceStatuses->new( availability_zone => $instancestatus_elem->{availabilityZone}, events => $group_sets, instance_id => $instancestatus_elem->{instanceId}, instance_state => $instancestatus_state, instance_status => $instancestatus_istatus, system_status => $instancestatus_sstatus, ); return $instance_status; } =head2 describe_instance_attribute(%params) Returns information about an attribute of an instance. Only one attribute can be specified per call. =over =item InstanceId (required) The instance id we want to describe the attributes of. =item Attribute (required) The attribute we want to describe. Valid values are: =over =item * instanceType =item * kernel =item * ramdisk =item * userData =item * disableApiTermination =item * ebsOptimized =item * instanceInitiatedShutdownBehavior =item * rootDeviceName =item * sourceDestCheck =item * blockDeviceMapping =back =back Returns a Net::Amazon::EC2::DescribeInstanceAttributeResponse object =cut sub describe_instance_attribute { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR }, Attribute => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'DescribeInstanceAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $attribute_response; # Test to see which type of attribute we are looking for, to dictacte # how to create the Net::Amazon::EC2::DescribeInstanceAttributeResponse object. if ( $args{Attribute} eq 'instanceType' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, instance_type => $xml->{instanceType}{value}, ); } elsif ( $args{Attribute} eq 'kernel' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, kernel => $xml->{kernel}{value}, ); } elsif ( $args{Attribute} eq 'ramdisk' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, ramdisk => $xml->{ramdisk}{value}, ); } elsif ( $args{Attribute} eq 'userData' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, user_data => $xml->{userData}{value}, ); } elsif ( $args{Attribute} eq 'disableApiTermination' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, disable_api_termination => $xml->{disableApiTermination}{value}, ); } elsif ( $args{Attribute} eq 'ebsOptimized' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, ebs_optimized => $xml->{ebsOptimized}{value}, ); } elsif ( $args{Attribute} eq 'instanceInitiatedShutdownBehavior' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, instance_initiated_shutdown_behavior => $xml->{instanceInitiatedShutdownBehavior}{value}, ); } elsif ( $args{Attribute} eq 'rootDeviceName' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, root_device_name => $xml->{rootDeviceName}{value}, ); } elsif ( $args{Attribute} eq 'sourceDestCheck' ) { $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, source_dest_check => $xml->{sourceDestCheck}{value}, ); } elsif ( $args{Attribute} eq 'blockDeviceMapping' ) { my $block_mappings; foreach my $block_item (@{$xml->{blockDeviceMapping}{item}}) { my $ebs_mapping = Net::Amazon::EC2::EbsInstanceBlockDeviceMapping->new( attach_time => $block_item->{ebs}{attachTime}, delete_on_termination => $block_item->{ebs}{deleteOnTermination}, status => $block_item->{ebs}{status}, volume_id => $block_item->{ebs}{volumeId}, ); my $block_device_mapping = Net::Amazon::EC2::BlockDeviceMapping->new( device_name => $block_item->{deviceName}, ebs => $ebs_mapping, ); push @$block_mappings, $block_device_mapping; } $attribute_response = Net::Amazon::EC2::DescribeInstanceAttributeResponse->new( instance_id => $xml->{instanceId}, block_device_mapping => $block_mappings, ); } return $attribute_response; } } =head2 describe_key_pairs(%params) This method describes the keypairs available on this account. It takes the following parameter: =over =item KeyName (optional) The name of the key to be described. Can be either a scalar or an array ref. =back Returns an array ref of Net::Amazon::EC2::DescribeKeyPairsResponse objects =cut sub describe_key_pairs { my $self = shift; my %args = validate( @_, { KeyName => { type => SCALAR | ARRAYREF, optional => 1 }, }); # If we have a array ref of KeyNames lets split them out into their KeyName.n format if (ref ($args{KeyName}) eq 'ARRAY') { my $keynames = delete $args{KeyName}; _split_into_args('KeyName.%s',\%args,$keynames); } my $xml = $self->_sign(Action => 'DescribeKeyPairs', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $key_pairs; foreach my $pair (@{$xml->{keySet}{item}}) { my $key_pair = Net::Amazon::EC2::DescribeKeyPairsResponse->new( key_name => $pair->{keyName}, key_fingerprint => $pair->{keyFingerprint}, ); push @$key_pairs, $key_pair; } return $key_pairs; } } =head2 describe_regions(%params) Describes EC2 regions that are currently available to launch instances in for this account. =over =item RegionName (optional) The name of the region(s) to be described. Can be either a scalar or an array ref. =back Returns an array ref of Net::Amazon::EC2::Region objects =cut sub describe_regions { my $self = shift; my %args = validate( @_, { RegionName => { type => ARRAYREF | SCALAR, optional => 1 }, }); # If we have a array ref of regions lets split them out into their RegionName.n format if (ref ($args{RegionName}) eq 'ARRAY') { my $regions = delete $args{RegionName}; _split_into_args('RegionName.%s',\%args,$regions); } my $xml = $self->_sign(Action => 'DescribeRegions', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $regions; foreach my $region_item (@{$xml->{regionInfo}{item}}) { my $region = Net::Amazon::EC2::Region->new( region_name => $region_item->{regionName}, region_endpoint => $region_item->{regionEndpoint}, ); push @$regions, $region; } return $regions; } } =head2 describe_reserved_instances(%params) Describes Reserved Instances that you purchased. =over =item ReservedInstancesId (optional) The reserved instance id(s) to be described. Can be either a scalar or an array ref. =back Returns an array ref of Net::Amazon::EC2::ReservedInstance objects =cut sub describe_reserved_instances { my $self = shift; my %args = validate( @_, { ReservedInstancesId => { type => ARRAYREF | SCALAR, optional => 1 }, }); # If we have a array ref of reserved instances lets split them out into their ReservedInstancesId.n format if (ref ($args{ReservedInstancesId}) eq 'ARRAY') { my $reserved_instance_ids = delete $args{ReservedInstancesId}; _split_into_args('ReservedInstancesId.%s',\%args,$reserved_instance_ids); } my $xml = $self->_sign(Action => 'DescribeReservedInstances', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $reserved_instances; foreach my $reserved_instance_item (@{$xml->{reservedInstancesSet}{item}}) { my $reserved_instance = Net::Amazon::EC2::ReservedInstance->new( reserved_instances_id => $reserved_instance_item->{reservedInstancesId}, instance_type => $reserved_instance_item->{instanceType}, availability_zone => $reserved_instance_item->{availabilityZone}, duration => $reserved_instance_item->{duration}, start => $reserved_instance_item->{start}, usage_price => $reserved_instance_item->{usagePrice}, fixed_price => $reserved_instance_item->{fixedPrice}, instance_count => $reserved_instance_item->{instanceCount}, product_description => $reserved_instance_item->{productDescription}, state => $reserved_instance_item->{state}, ); push @$reserved_instances, $reserved_instance; } return $reserved_instances; } } =head2 describe_reserved_instances_offerings(%params) Describes Reserved Instance offerings that are available for purchase. With Amazon EC2 Reserved Instances, you purchase the right to launch Amazon EC2 instances for a period of time (without getting insufficient capacity errors) and pay a lower usage rate for the actual time used. =over =item ReservedInstancesOfferingId (optional) ID of the Reserved Instances to describe. =item InstanceType (optional) The instance type. The default is m1.small. Amazon frequently updates their instance types. See http://aws.amazon.com/ec2/instance-types =item AvailabilityZone (optional) The Availability Zone in which the Reserved Instance can be used. =item ProductDescription (optional) The Reserved Instance description. =back Returns an array ref of Net::Amazon::EC2::ReservedInstanceOffering objects =cut sub describe_reserved_instances_offerings { my $self = shift; my %args = validate( @_, { ReservedInstancesOfferingId => { type => SCALAR, optional => 1 }, InstanceType => { type => SCALAR, optional => 1 }, AvailabilityZone => { type => SCALAR, optional => 1 }, ProductDescription => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'DescribeReservedInstancesOfferings', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $reserved_instance_offerings; foreach my $reserved_instance_offering_item (@{$xml->{reservedInstancesOfferingsSet}{item}}) { my $reserved_instance_offering = Net::Amazon::EC2::ReservedInstanceOffering->new( reserved_instances_offering_id => $reserved_instance_offering_item->{reservedInstancesOfferingId}, instance_type => $reserved_instance_offering_item->{instanceType}, availability_zone => $reserved_instance_offering_item->{availabilityZone}, duration => $reserved_instance_offering_item->{duration}, start => $reserved_instance_offering_item->{start}, usage_price => $reserved_instance_offering_item->{usagePrice}, fixed_price => $reserved_instance_offering_item->{fixedPrice}, instance_count => $reserved_instance_offering_item->{instanceCount}, product_description => $reserved_instance_offering_item->{productDescription}, state => $reserved_instance_offering_item->{state}, ); push @$reserved_instance_offerings, $reserved_instance_offering; } return $reserved_instance_offerings; } } =head2 describe_security_groups(%params) This method describes the security groups available to this account. It takes the following parameter: =over =item GroupName (optional) The name of the security group(s) to be described. Can be either a scalar or an array ref. =item GroupId (optional) The id of the security group(s) to be described. Can be either a scalar or an array ref. =back Returns an array ref of Net::Amazon::EC2::SecurityGroup objects =cut sub describe_security_groups { my $self = shift; my %args = validate( @_, { GroupName => { type => SCALAR | ARRAYREF, optional => 1 }, GroupId => { type => SCALAR | ARRAYREF, optional => 1 }, }); # If we have a array ref of GroupNames lets split them out into their GroupName.n format if (ref ($args{GroupName}) eq 'ARRAY') { my $groups = delete $args{GroupName}; _split_into_args('GroupName.%s',\%args,$groups); } # If we have a array ref of GroupIds lets split them out into their GroupId.n format if (ref ($args{GroupId}) eq 'ARRAY') { my $groups = delete $args{GroupId}; _split_into_args('GroupId.%s',\%args,$groups); } my $xml = $self->_sign(Action => 'DescribeSecurityGroups', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $security_groups; foreach my $sec_grp (@{$xml->{securityGroupInfo}{item}}) { my $owner_id = $sec_grp->{ownerId}; my $group_name = $sec_grp->{groupName}; my $group_id = $sec_grp->{groupId}; my $group_description = $sec_grp->{groupDescription}; my $vpc_id = $sec_grp->{vpcId}; my $tag_set; my $ip_permissions; my $ip_permissions_egress; foreach my $ip_perm (@{$sec_grp->{ipPermissions}{item}}) { my $ip_protocol = $ip_perm->{ipProtocol}; my $from_port = $ip_perm->{fromPort}; my $to_port = $ip_perm->{toPort}; my $icmp_port = $ip_perm->{icmpPort}; my $groups; my $ip_ranges; if (grep { defined && length } $ip_perm->{groups}{item}) { foreach my $grp (@{$ip_perm->{groups}{item}}) { my $group = Net::Amazon::EC2::UserIdGroupPair->new( user_id => $grp->{userId}, group_name => $grp->{groupName}, ); push @$groups, $group; } } if (grep { defined && length } $ip_perm->{ipRanges}{item}) { foreach my $rng (@{$ip_perm->{ipRanges}{item}}) { my $ip_range = Net::Amazon::EC2::IpRange->new( cidr_ip => $rng->{cidrIp}, ); push @$ip_ranges, $ip_range; } } my $ip_permission = Net::Amazon::EC2::IpPermission->new( ip_protocol => $ip_protocol, group_name => $group_name, group_description => $group_description, from_port => $from_port, to_port => $to_port, icmp_port => $icmp_port, ); if ($ip_ranges) { $ip_permission->ip_ranges($ip_ranges); } if ($groups) { $ip_permission->groups($groups); } push @$ip_permissions, $ip_permission; } foreach my $ip_perm (@{$sec_grp->{ipPermissionsEgress}{item}}) { my $ip_protocol = $ip_perm->{ipProtocol}; my $from_port = $ip_perm->{fromPort}; my $to_port = $ip_perm->{toPort}; my $icmp_port = $ip_perm->{icmpPort}; my $groups; my $ip_ranges; if (grep { defined && length } $ip_perm->{groups}{item}) { foreach my $grp (@{$ip_perm->{groups}{item}}) { my $group = Net::Amazon::EC2::UserIdGroupPair->new( user_id => $grp->{userId}, group_name => $grp->{groupName}, ); push @$groups, $group; } } if (grep { defined && length } $ip_perm->{ipRanges}{item}) { foreach my $rng (@{$ip_perm->{ipRanges}{item}}) { my $ip_range = Net::Amazon::EC2::IpRange->new( cidr_ip => $rng->{cidrIp}, ); push @$ip_ranges, $ip_range; } } my $ip_permission = Net::Amazon::EC2::IpPermission->new( ip_protocol => $ip_protocol, group_name => $group_name, group_description => $group_description, from_port => $from_port, to_port => $to_port, icmp_port => $icmp_port, ); if ($ip_ranges) { $ip_permission->ip_ranges($ip_ranges); } if ($groups) { $ip_permission->groups($groups); } push @$ip_permissions_egress, $ip_permission; } foreach my $sec_tag (@{$sec_grp->{tagSet}{item}}) { my $tag = Net::Amazon::EC2::TagSet->new( key => $sec_tag->{key}, value => $sec_tag->{value}, ); push @$tag_set, $tag; } my $security_group = Net::Amazon::EC2::SecurityGroup->new( owner_id => $owner_id, group_name => $group_name, group_id => $group_id, vpc_id => $vpc_id, tag_set => $tag_set, group_description => $group_description, ip_permissions => $ip_permissions, ip_permissions_egress => $ip_permissions_egress, ); push @$security_groups, $security_group; } return $security_groups; } } =head2 describe_snapshot_attribute(%params) Describes the snapshots attributes related to the snapshot in question. It takes the following arguments: =over =item SnapshotId (optional) Either a scalar or array ref of snapshot id's can be passed in. If this isn't passed in it will describe the attributes of all the current snapshots. =item Attribute (required) The attribute to describe, currently, the only valid attribute is createVolumePermission. =back Returns a Net::Amazon::EC2::SnapshotAttribute object. =cut sub describe_snapshot_attribute { my $self = shift; my %args = validate( @_, { SnapshotId => { type => ARRAYREF | SCALAR, optional => 1 }, Attribute => { type => SCALAR }, }); # If we have a array ref of volumes lets split them out into their SnapshotId.n format if (ref ($args{SnapshotId}) eq 'ARRAY') { my $snapshots = delete $args{SnapshotId}; _split_into_args('SnapshotId.%s',\%args,$snapshots); } my $xml = $self->_sign(Action => 'DescribeSnapshotAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $perms; unless ( grep { defined && length } $xml->{createVolumePermission} and ref $xml->{createVolumePermission} ne 'HASH') { $perms = undef; } foreach my $perm_item (@{$xml->{createVolumePermission}{item}}) { my $perm = Net::Amazon::EC2::CreateVolumePermission->new( user_id => $perm_item->{userId}, group => $perm_item->{group}, ); push @$perms, $perm; } my $snapshot_attribute = Net::Amazon::EC2::SnapshotAttribute->new( snapshot_id => $xml->{snapshotId}, permissions => $perms, ); return $snapshot_attribute; } } =head2 describe_snapshots(%params) Describes the snapshots available to the user. It takes the following arguments: =over =item SnapshotId (optional) Either a scalar or array ref of snapshot id's can be passed in. If this isn't passed in it will describe all the current snapshots. =item Owner (optional) The owner of the snapshot. =item RestorableBy (optional) A user who can create volumes from the snapshot. =item Filter (optional) The filters for only the matching snapshots to be 'described'. A filter tuple is an arrayref constsing one key and one or more values. The option takes one filter tuple, or an arrayref of multiple filter tuples. =back Returns an array ref of Net::Amazon::EC2::Snapshot objects. =cut sub describe_snapshots { my $self = shift; my %args = validate( @_, { SnapshotId => { type => ARRAYREF | SCALAR, optional => 1 }, Owner => { type => SCALAR, optional => 1 }, RestorableBy => { type => SCALAR, optional => 1 }, Filter => { type => ARRAYREF, optional => 1 }, }); $self->_build_filters(\%args); # If we have a array ref of volumes lets split them out into their SnapshotId.n format if (ref ($args{SnapshotId}) eq 'ARRAY') { my $snapshots = delete $args{SnapshotId}; _split_into_args('SnapshotId.%s',\%args,$snapshots); } my $xml = $self->_sign(Action => 'DescribeSnapshots', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $snapshots; foreach my $snap (@{$xml->{snapshotSet}{item}}) { unless ( grep { defined && length } $snap->{description} and ref $snap->{description} ne 'HASH') { $snap->{description} = undef; } unless ( grep { defined && length } $snap->{progress} and ref $snap->{progress} ne 'HASH') { $snap->{progress} = undef; } my $tag_sets; foreach my $tag_arr (@{$snap->{tagSet}{item}}) { if ( ref $tag_arr->{value} eq "HASH" ) { $tag_arr->{value} = ""; } my $tag = Net::Amazon::EC2::TagSet->new( key => $tag_arr->{key}, value => $tag_arr->{value}, ); push @$tag_sets, $tag; } my $snapshot = Net::Amazon::EC2::Snapshot->new( snapshot_id => $snap->{snapshotId}, status => $snap->{status}, volume_id => $snap->{volumeId}, start_time => $snap->{startTime}, progress => $snap->{progress}, owner_id => $snap->{ownerId}, volume_size => $snap->{volumeSize}, description => $snap->{description}, owner_alias => $snap->{ownerAlias}, tag_set => $tag_sets, ); push @$snapshots, $snapshot; } return $snapshots; } } =head2 describe_volumes(%params) Describes the volumes currently created. It takes the following arguments: =over =item VolumeId (optional) Either a scalar or array ref of volume id's can be passed in. If this isn't passed in it will describe all the current volumes. =back Returns an array ref of Net::Amazon::EC2::Volume objects. =cut sub describe_volumes { my $self = shift; my %args = validate( @_, { VolumeId => { type => ARRAYREF | SCALAR, optional => 1 }, }); # If we have a array ref of VolumeIds lets split them out into their VolumeId.n format if (ref ($args{VolumeId}) eq 'ARRAY') { my $volumes = delete $args{VolumeId}; _split_into_args('VolumeId.%s',\%args,$volumes); } my $xml = $self->_sign(Action => 'DescribeVolumes', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $volumes; foreach my $volume_set (@{$xml->{volumeSet}{item}}) { my $attachments; unless ( grep { defined && length } $volume_set->{snapshotId} and ref $volume_set->{snapshotId} ne 'HASH') { $volume_set->{snapshotId} = undef; } foreach my $attachment_set (@{$volume_set->{attachmentSet}{item}}) { my $attachment = Net::Amazon::EC2::Attachment->new( volume_id => $attachment_set->{volumeId}, status => $attachment_set->{status}, instance_id => $attachment_set->{instanceId}, attach_time => $attachment_set->{attachTime}, device => $attachment_set->{device}, delete_on_termination => $attachment_set->{deleteOnTermination}, ); push @$attachments, $attachment; } my $tags; foreach my $tag_arr (@{$volume_set->{tagSet}{item}}) { if ( ref $tag_arr->{value} eq "HASH" ) { $tag_arr->{value} = ""; } my $tag = Net::Amazon::EC2::TagSet->new( key => $tag_arr->{key}, value => $tag_arr->{value}, ); push @$tags, $tag; } my $volume = Net::Amazon::EC2::Volume->new( volume_id => $volume_set->{volumeId}, status => $volume_set->{status}, zone => $volume_set->{availabilityZone}, create_time => $volume_set->{createTime}, snapshot_id => $volume_set->{snapshotId}, size => $volume_set->{size}, volume_type => $volume_set->{volumeType}, iops => $volume_set->{iops}, encrypted => $volume_set->{encrypted}, tag_set => $tags, attachments => $attachments, ); push @$volumes, $volume; } return $volumes; } } =head2 describe_subnets(%params) This method describes the subnets on this account. It takes the following parameters: =over =item SubnetId (optional) The id of a subnet to be described. Can either be a scalar or an array ref. =item Filter.Name (optional) The name of the Filter.Name to be described. Can be either a scalar or an array ref. See http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeSubnets.html for available filters. =item Filter.Value (optional) The name of the Filter.Value to be described. Can be either a scalar or an array ref. =back Returns an array ref of Net::Amazon::EC2::DescribeSubnetResponse objects =cut sub describe_subnets { my $self = shift; my %args = validate( @_, { 'SubnetId' => { type => ARRAYREF | SCALAR, optional => 1 }, 'Filter.Name' => { type => ARRAYREF | SCALAR, optional => 1 }, 'Filter.Value' => { type => ARRAYREF | SCALAR, optional => 1 }, }); if (ref ($args{'SubnetId'}) eq 'ARRAY') { my $keys = delete $args{'SubnetId'}; my $count = 1; foreach my $key (@{$keys}) { $args{"SubnetId." . $count } = $key; $count++; } } if (ref ($args{'Filter.Name'}) eq 'ARRAY') { my $keys = delete $args{'Filter.Name'}; my $count = 1; foreach my $key (@{$keys}) { $args{"Filter." . $count . ".Name"} = $key; $count++; } } if (ref ($args{'Filter.Value'}) eq 'ARRAY') { my $keys = delete $args{'Filter.Value'}; my $count = 1; foreach my $key (@{$keys}) { $args{"Filter." . $count . ".Value"} = $key; $count++; } } my $xml = $self->_sign(Action => 'DescribeSubnets', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $subnets; foreach my $pair (@{$xml->{subnetSet}{item}}) { my $tags; foreach my $tag_arr (@{$pair->{tagSet}{item}}) { if ( ref $tag_arr->{value} eq "HASH" ) { $tag_arr->{value} = ""; } my $tag = Net::Amazon::EC2::TagSet->new( key => $tag_arr->{key}, value => $tag_arr->{value}, ); push @$tags, $tag; } my $subnet = Net::Amazon::EC2::DescribeSubnetResponse->new( subnet_id => $pair->{subnetId}, state => $pair->{state}, vpc_id => $pair->{vpcId}, cidr_block => $pair->{cidrBlock}, available_ip_address_count => $pair->{availableIpAddressCount}, availability_zone => $pair->{availabilityZone}, default_for_az => $pair->{defaultForAz}, map_public_ip_on_launch => $pair->{mapPublicIpOnLaunch}, tag_set => $tags, ); push @$subnets, $subnet; } return $subnets; } } =head2 describe_tags(%params) This method describes the tags available on this account. It takes the following parameter: =over =item Filter.Name (optional) The name of the Filter.Name to be described. Can be either a scalar or an array ref. =item Filter.Value (optional) The name of the Filter.Value to be described. Can be either a scalar or an array ref. =back Returns an array ref of Net::Amazon::EC2::DescribeTags objects =cut sub describe_tags { my $self = shift; my %args = validate( @_, { 'Filter.Name' => { type => ARRAYREF | SCALAR, optional => 1 }, 'Filter.Value' => { type => ARRAYREF | SCALAR, optional => 1 }, }); if (ref ($args{'Filter.Name'}) eq 'ARRAY') { my $keys = delete $args{'Filter.Name'}; _split_into_args('Filter.%s.Name',\%args,$keys); } if (ref ($args{'Filter.Value'}) eq 'ARRAY') { my $keys = delete $args{'Filter.Value'}; _split_into_args('Filter.%s.Value',\%args,$keys); } my $xml = $self->_sign(Action => 'DescribeTags', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $tags; foreach my $pair (@{$xml->{tagSet}{item}}) { my $tag = Net::Amazon::EC2::DescribeTags->new( resource_id => $pair->{resourceId}, resource_type => $pair->{resourceType}, key => $pair->{key}, value => $pair->{value}, ); push @$tags, $tag; } return $tags; } } =head2 detach_volume(%params) Detach a volume from an instance. =over =item VolumeId (required) The volume id you wish to detach. =item InstanceId (optional) The instance id you wish to detach from. =item Device (optional) The device the volume was attached as. =item Force (optional) A boolean for if to forcibly detach the volume from the instance. WARNING: This can lead to data loss or a corrupted file system. Use this option only as a last resort to detach a volume from a failed instance. The instance will not have an opportunity to flush file system caches nor file system meta data. =back Returns a Net::Amazon::EC2::Attachment object containing the resulting volume status. =cut sub detach_volume { my $self = shift; my %args = validate( @_, { VolumeId => { type => SCALAR }, InstanceId => { type => SCALAR, optional => 1 }, Device => { type => SCALAR, optional => 1 }, Force => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'DetachVolume', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $attachment = Net::Amazon::EC2::Attachment->new( volume_id => $xml->{volumeId}, status => $xml->{status}, instance_id => $xml->{instanceId}, attach_time => $xml->{attachTime}, device => $xml->{device}, ); return $attachment; } } =head2 disassociate_address(%params) Disassociates an elastic IP address with an instance. It takes the following arguments: =over =item PublicIp (conditional) The IP address to disassociate, mandatory to remove an IP from a EC2-classic instance. =item AssociationId (conditional) The Association ID of an IP address, mandatory to remove an IP from a VPC instance. =back Returns true if the disassociation succeeded. =cut sub disassociate_address { my $self = shift; my %args = validate( @_, { PublicIp => { type => SCALAR, optional => 1 }, AssociationId => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'DisassociateAddress', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 get_console_output(%params) This method gets the output from the virtual console for an instance. It takes the following parameters: =over =item InstanceId (required) A scalar containing a instance id. =back Returns a Net::Amazon::EC2::ConsoleOutput object or C if there is no new output. (This can happen in cases where the console output has not changed since the last call.) =cut sub get_console_output { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'GetConsoleOutput', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ( grep { defined && length } $xml->{output} ) { my $console_output = Net::Amazon::EC2::ConsoleOutput->new( instance_id => $xml->{instanceId}, timestamp => $xml->{timestamp}, output => decode_base64($xml->{output}), ); return $console_output; } else { return undef; } } } =head2 get_password_data(%params) Retrieves the encrypted administrator password for the instances running Windows. This procedure is not applicable for Linux and UNIX instances. =over =item InstanceId (required) The Instance Id for which to retrieve the password. =back Returns a Net::Amazon::EC2::InstancePassword object =cut sub get_password_data { my $self = shift; my %args = validate( @_, { instanceId => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'GetPasswordData', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $instance_password = Net::Amazon::EC2::InstancePassword->new( instance_id => $xml->{instanceId}, timestamp => $xml->{timestamp}, password_data => $xml->{passwordData}, ); return $instance_password; } } =head2 modify_image_attribute(%params) This method modifies attributes of an machine image. =over =item ImageId (required) The AMI to modify the attributes of. =item Attribute (required) The attribute you wish to modify, right now the attributes you can modify are launchPermission and productCodes =item OperationType (required for launchPermission) The operation you wish to perform on the attribute. Right now just 'add' and 'remove' are supported. =item UserId (required for launchPermission) User Id's you wish to add/remove from the attribute. =item UserGroup (required for launchPermission) Groups you wish to add/remove from the attribute. Currently there is only one User Group available 'all' for all Amazon EC2 customers. =item ProductCode (required for productCodes) Attaches a product code to the AMI. Currently only one product code can be assigned to the AMI. Once this is set it cannot be changed or reset. =back Returns 1 if the modification succeeds. =cut sub modify_image_attribute { my $self = shift; my %args = validate( @_, { ImageId => { type => SCALAR }, Attribute => { type => SCALAR }, OperationType => { type => SCALAR, optional => 1 }, UserId => { type => SCALAR | ARRAYREF, optional => 1 }, UserGroup => { type => SCALAR | ARRAYREF, optional => 1 }, ProductCode => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'ModifyImageAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 modify_instance_attribute(%params) Modify an attribute of an instance. =over =item InstanceId (required) The instance id we want to modify the attributes of. =item Attribute (required) The attribute we want to modify. Valid values are: =over =item * instanceType =item * kernel =item * ramdisk =item * userData =item * disableApiTermination =item * instanceInitiatedShutdownBehavior =item * rootDeviceName =item * blockDeviceMapping =back =item Value (required) The value to set the attribute to. You may also pass a hashref with one or more keys and values. This hashref will be flattened and passed to AWS. For example: $ec2->modify_instance_attribute( 'InstanceId' => $id, 'Attribute' => 'blockDeviceMapping', 'Value' => { 'BlockDeviceMapping.1.DeviceName' => '/dev/sdf1', 'BlockDeviceMapping.1.Ebs.DeleteOnTermination' => 'true', } ); =back Returns 1 if the modification succeeds. =cut sub modify_instance_attribute { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR }, Attribute => { type => SCALAR }, Value => { type => SCALAR | HASHREF }, }); if ( ref($args{'Value'}) eq "HASH" ) { # remove the 'Value' key and flatten the hashref my $href = delete $args{'Value'}; map { $args{$_} = $href->{$_} } keys %{$href}; } my $xml = $self->_sign(Action => 'ModifyInstanceAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 modify_snapshot_attribute(%params) This method modifies attributes of a snapshot. =over =item SnapshotId (required) The snapshot id to modify the attributes of. =item UserId (optional) User Id you wish to add/remove create volume permissions for. =item UserGroup (optional) User Id you wish to add/remove create volume permissions for. To make the snapshot createable by all set the UserGroup to "all". =item Attribute (required) The attribute you wish to modify, right now the only attribute you can modify is "CreateVolumePermission" =item OperationType (required) The operation you wish to perform on the attribute. Right now just 'add' and 'remove' are supported. =back Returns 1 if the modification succeeds. =cut sub modify_snapshot_attribute { my $self = shift; my %args = validate( @_, { SnapshotId => { type => SCALAR }, UserId => { type => SCALAR, optional => 1 }, UserGroup => { type => SCALAR, optional => 1 }, Attribute => { type => SCALAR }, OperationType => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'ModifySnapshotAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 monitor_instances(%params) Enables monitoring for a running instance. For more information, refer to the Amazon CloudWatch Developer Guide. =over =item InstanceId (required) The instance id(s) to monitor. Can be a scalar or an array ref =back Returns an array ref of Net::Amazon::EC2::MonitoredInstance objects =cut sub monitor_instances { my $self = shift; my %args = validate( @_, { InstanceId => { type => ARRAYREF | SCALAR, optional => 1 }, }); # If we have a array ref of instances lets split them out into their InstanceId.n format if (ref ($args{InstanceId}) eq 'ARRAY') { my $instance_ids = delete $args{InstanceId}; _split_into_args('InstanceId.%s',\%args,$instance_ids); } my $xml = $self->_sign(Action => 'MonitorInstances', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $monitored_instances; foreach my $monitored_instance_item (@{$xml->{instancesSet}{item}}) { my $monitored_instance = Net::Amazon::EC2::ReservedInstance->new( instance_id => $monitored_instance_item->{instanceId}, state => $monitored_instance_item->{monitoring}{state}, ); push @$monitored_instances, $monitored_instance; } return $monitored_instances; } } =head2 purchase_reserved_instances_offering(%params) Purchases a Reserved Instance for use with your account. With Amazon EC2 Reserved Instances, you purchase the right to launch Amazon EC2 instances for a period of time (without getting insufficient capacity errors) and pay a lower usage rate for the actual time used. =over =item ReservedInstancesOfferingId (required) ID of the Reserved Instances to describe. Can be either a scalar or an array ref. =item InstanceCount (optional) The number of Reserved Instances to purchase (default is 1). Can be either a scalar or an array ref. NOTE NOTE NOTE, the array ref needs to line up with the InstanceCount if you want to pass that in, so that the right number of instances are started of the right instance offering =back Returns 1 if the reservations succeeded. =cut sub purchase_reserved_instances_offering { my $self = shift; my %args = validate( @_, { ReservedInstancesOfferingId => { type => ARRAYREF | SCALAR }, InstanceCount => { type => ARRAYREF | SCALAR, optional => 1 }, }); # If we have a array ref of reserved instance offerings lets split them out into their ReservedInstancesOfferingId.n format if (ref ($args{ReservedInstancesOfferingId}) eq 'ARRAY') { my $reserved_instance_offering_ids = delete $args{ReservedInstancesOfferingId}; _split_into_args('ReservedInstancesOfferingId.%s',\%args,$reserved_instance_offering_ids); } # If we have a array ref of instance counts lets split them out into their InstanceCount.n format if (ref ($args{InstanceCount}) eq 'ARRAY') { my $instance_counts = delete $args{InstanceCount}; _split_into_args('InstanceCount.%s',\%args,$instance_counts); } my $xml = $self->_sign(Action => 'PurchaseReservedInstancesOffering', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{reservedInstancesId} ) { return 1; } else { return undef; } } } =head2 reboot_instances(%params) This method reboots an instance. It takes the following parameters: =over =item InstanceId (required) Instance Id of the instance you wish to reboot. Can be either a scalar or array ref of instances to reboot. =back Returns 1 if the reboot succeeded. =cut sub reboot_instances { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR | ARRAYREF }, }); # If we have a array ref of instances lets split them out into their InstanceId.n format if (ref ($args{InstanceId}) eq 'ARRAY') { my $instance_ids = delete $args{InstanceId}; _split_into_args('InstanceId.%s',\%args,$instance_ids); } my $xml = $self->_sign(Action => 'RebootInstances', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 register_image(%params) This method registers an AMI on the EC2. It takes the following parameter: =over =item ImageLocation (optional) The location of the AMI manifest on S3 =item Name (required) The name of the AMI that was provided during image creation. =item Description (optional) The description of the AMI. =item Architecture (optional) The architecture of the image. Either i386 or x86_64 =item KernelId (optional) The ID of the kernel to select. =item RamdiskId (optional) The ID of the RAM disk to select. Some kernels require additional drivers at launch. =item RootDeviceName (optional) The root device name (e.g., /dev/sda1). =item BlockDeviceMapping (optional) This needs to be a data structure like this: [ { deviceName => "/dev/sdh", (optional) virtualName => "ephemerel0", (optional) noDevice => "/dev/sdl", (optional), ebs => { snapshotId => "snap-0000", (optional) volumeSize => "20", (optional) deleteOnTermination => "false", (optional) }, }, ... ] =back Returns the image id of the new image on EC2. =cut sub register_image { my $self = shift; my %args = validate( @_, { ImageLocation => { type => SCALAR, optional => 1 }, Name => { type => SCALAR }, Description => { type => SCALAR, optional => 1 }, Architecture => { type => SCALAR, optional => 1 }, KernelId => { type => SCALAR, optional => 1 }, RamdiskId => { type => SCALAR, optional => 1 }, RootDeviceName => { type => SCALAR, optional => 1 }, BlockDeviceMapping => { type => ARRAYREF, optional => 1 }, }); # If we have a array ref of block devices, we need to split them up if (ref ($args{BlockDeviceMapping}) eq 'ARRAY') { my $block_devices = delete $args{BlockDeviceMapping}; my $count = 1; foreach my $block_device (@{$block_devices}) { $args{"BlockDeviceMapping." . $count . ".DeviceName"} = $block_device->{deviceName} if $block_device->{deviceName}; $args{"BlockDeviceMapping." . $count . ".VirtualName"} = $block_device->{virtualName} if $block_device->{virtualName}; $args{"BlockDeviceMapping." . $count . ".NoDevice"} = $block_device->{noDevice} if $block_device->{noDevice}; $args{"BlockDeviceMapping." . $count . ".Ebs.SnapshotId"} = $block_device->{ebs}{snapshotId} if $block_device->{ebs}{snapshotId}; $args{"BlockDeviceMapping." . $count . ".Ebs.VolumeSize"} = $block_device->{ebs}{volumeSize} if $block_device->{ebs}{volumeSize}; $args{"BlockDeviceMapping." . $count . ".Ebs.DeleteOnTermination"} = $block_device->{ebs}{deleteOnTermination} if $block_device->{ebs}{deleteOnTermination}; $count++; } } my $xml = $self->_sign(Action => 'RegisterImage', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { return $xml->{imageId}; } } =head2 release_address(%params) Releases an allocated IP address. It takes the following arguments: =over =item PublicIp (required) The IP address to release =back Returns true if the releasing succeeded. =cut sub release_address { my $self = shift; my %args = validate( @_, { PublicIp => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'ReleaseAddress', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } sub release_vpc_address { my $self = shift; my %args = validate( @_, { AllocationId => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'ReleaseAddress', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 reset_image_attribute(%params) This method resets an attribute for an AMI to its default state (NOTE: product codes cannot be reset). It takes the following parameters: =over =item ImageId (required) The image id of the AMI you wish to reset the attributes on. =item Attribute (required) The attribute you want to reset. =back Returns 1 if the attribute reset succeeds. =cut sub reset_image_attribute { my $self = shift; my %args = validate( @_, { ImageId => { type => SCALAR }, Attribute => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'ResetImageAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 reset_instance_attribute(%params) Reset an attribute of an instance. Only one attribute can be specified per call. =over =item InstanceId (required) The instance id we want to reset the attributes of. =item Attribute (required) The attribute we want to reset. Valid values are: =over =item * kernel =item * ramdisk =back =back Returns 1 if the reset succeeds. =cut sub reset_instance_attribute { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR }, Attribute => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'ResetInstanceAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 reset_snapshot_attribute(%params) This method resets an attribute for an snapshot to its default state. It takes the following parameters: =over =item SnapshotId (required) The snapshot id of the snapshot you wish to reset the attributes on. =item Attribute (required) The attribute you want to reset (currently "CreateVolumePermission" is the only valid attribute). =back Returns 1 if the attribute reset succeeds. =cut sub reset_snapshot_attribute { my $self = shift; my %args = validate( @_, { SnapshotId => { type => SCALAR }, Attribute => { type => SCALAR }, }); my $xml = $self->_sign(Action => 'ResetSnapshotAttribute', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 revoke_security_group_ingress(%params) This method revoke permissions to a security group. It takes the following parameters: =over =item GroupName (required) The name of the group to revoke security rules from. =item SourceSecurityGroupName (required when revoking a user and group together) Name of the group to revoke access from. =item SourceSecurityGroupOwnerId (required when revoking a user and group together) Owner of the group to revoke access from. =item IpProtocol (required when revoking access from a CIDR) IP Protocol of the rule you are revoking access from (TCP, UDP, or ICMP) =item FromPort (required when revoking access from a CIDR) Beginning of port range to revoke access from. =item ToPort (required when revoking access from a CIDR) End of port range to revoke access from. =item CidrIp (required when revoking access from a CIDR) The CIDR IP space we are revoking access from. =back Revoking a rule can be done in two ways: revoking a source group name + source group owner id, or, by Protocol + start port + end port + CIDR IP. The two are mutally exclusive. Returns 1 if rule is revoked successfully. =cut sub revoke_security_group_ingress { my $self = shift; my %args = validate( @_, { GroupName => { type => SCALAR, optional => 1 }, GroupId => { type => SCALAR, optional => 1 }, SourceSecurityGroupName => { type => SCALAR, depends => ['SourceSecurityGroupOwnerId'], optional => 1 , }, SourceSecurityGroupOwnerId => { type => SCALAR, optional => 1 }, IpProtocol => { type => SCALAR, depends => ['FromPort', 'ToPort', 'CidrIp'], optional => 1 }, FromPort => { type => SCALAR, optional => 1 }, ToPort => { type => SCALAR, optional => 1 }, CidrIp => { type => SCALAR, optional => 1 }, }); my $xml = $self->_sign(Action => 'RevokeSecurityGroupIngress', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { if ($xml->{return} eq 'true') { return 1; } else { return undef; } } } =head2 run_instances(%params) This method will start instance(s) of AMIs on EC2. The parameters indicate which AMI to instantiate and how many / what properties they have: =over =item ImageId (required) The image id you want to start an instance of. =item MinCount (required) The minimum number of instances to start. =item MaxCount (required) The maximum number of instances to start. =item KeyName (optional) The keypair name to associate this instance with. If omitted, will use your default keypair. =item SecurityGroup (optional) An scalar or array ref. Will associate this instance with the group names passed in. If omitted, will be associated with the default security group. =item SecurityGroupId (optional) An scalar or array ref. Will associate this instance with the group ids passed in. If omitted, will be associated with the default security group. =item AdditionalInfo (optional) Specifies additional information to make available to the instance(s). =item UserData (optional) Optional data to pass into the instance being started. Needs to be base64 encoded. =item InstanceType (optional) Specifies the type of instance to start. See http://aws.amazon.com/ec2/instance-types The options are: =over =item m1.small (default) 1 EC2 Compute Unit (1 virtual core with 1 EC2 Compute Unit). 32-bit or 64-bit, 1.7GB RAM, 160GB disk =item m1.medium Medium Instance 2 EC2 Compute Units (1 virtual core with 2 EC2 Compute Unit), 32-bit or 64-bit, 3.75GB RAM, 410GB disk =item m1.large: Standard Large Instance 4 EC2 Compute Units (2 virtual cores with 2 EC2 Compute Units each). 64-bit, 7.5GB RAM, 850GB disk =item m1.xlarge: Standard Extra Large Instance 8 EC2 Compute Units (4 virtual cores with 2 EC2 Compute Units each). 64-bit, 15GB RAM, 1690GB disk =item t1.micro Micro Instance Up to 2 EC2 Compute Units (for short periodic bursts), 32-bit or 64-bit, 613MB RAM, EBS storage only =item c1.medium: High-CPU Medium Instance 5 EC2 Compute Units (2 virtual cores with 2.5 EC2 Compute Units each). 32-bit or 64-bit, 1.7GB RAM, 350GB disk =item c1.xlarge: High-CPU Extra Large Instance 20 EC2 Compute Units (8 virtual cores with 2.5 EC2 Compute Units each). 64-bit, 7GB RAM, 1690GB disk =item m2.2xlarge High-Memory Double Extra Large Instance 13 EC2 Compute Units (4 virtual cores with 3.25 EC2 Compute Units each). 64-bit, 34.2GB RAM, 850GB disk =item m2.4xlarge High-Memory Quadruple Extra Large Instance 26 EC2 Compute Units (8 virtual cores with 3.25 EC2 Compute Units each). 64-bit, 68.4GB RAM, 1690GB disk =item cc1.4xlarge Cluster Compute Quadruple Extra Large Instance 33.5 EC2 Compute Units (2 x Intel Xeon X5570, quad-core "Nehalem" architecture), 64-bit, 23GB RAM, 1690GB disk, 10Gbit Ethernet =item cc1.8xlarge Cluster Compute Eight Extra Large Instance 88 EC2 Compute Units (2 x Intel Xeon E5-2670, eight-core "Sandy Bridge" architecture), 64-bit, 60.5GB RAM, 3370GB disk, 10Gbit Ethernet =item cg1.4xlarge Cluster GPU Quadruple Extra Large Instance 33.5 EC2 Compute Units (2 x Intel Xeon X5570, quad-core "Nehalem" architecture), 64-bit, 22GB RAM 1690GB disk, 10Gbit Ethernet, 2 x NVIDIA Tesla "Fermi" M2050 GPUs =item hi1.4xlarge High I/O Quadruple Extra Large Instance 35 EC2 Compute Units (16 virtual cores), 60.5GB RAM, 64-bit, 2 x 1024GB SSD disk, 10Gbit Ethernet =back =item Placement.AvailabilityZone (optional) The availability zone you want to run the instance in =item KernelId (optional) The id of the kernel you want to launch the instance with =item RamdiskId (optional) The id of the ramdisk you want to launch the instance with =item BlockDeviceMapping.VirtualName (optional) This is the virtual name for a blocked device to be attached, may pass in a scalar or arrayref =item BlockDeviceMapping.DeviceName (optional) This is the device name for a block device to be attached, may pass in a scalar or arrayref =item BlockDeviceMapping.Ebs.VolumeSize (optional) Specifies the size of the root block device as an integer (GB). If used, required that C also be specified. One may pass in a scalar or arrayref. This parameter will override the disk size settings implied by the C, if used. Additional volume related parameters include, =over =item BlockDeviceMapping.Ebs.SnapshotId May pass in a scalar or arrayref. =item BlockDeviceMapping.Ebs.VolumeType May pass in a scalar or arrayref. =item BlockDeviceMapping.Ebs.DeleteOnTermination May pass in a scalar or arrayref. =back =item Encoding (optional) The encoding. =item Version (optional) The version. =item Monitoring.Enabled (optional) Enables monitoring for this instance. =item SubnetId (optional) Specifies the subnet ID within which to launch the instance(s) for Amazon Virtual Private Cloud. =item ClientToken (optional) Specifies the idempotent instance id. =item EbsOptimized (optional) Whether the instance is optimized for EBS I/O. =item PrivateIpAddress (optional) Specifies the private IP address to use when launching an Amazon VPC instance. =item IamInstanceProfile.Name (optional) Specifies the IAM profile to associate with the launched instance(s). This is the name of the role. =item IamInstanceProfile.Arn (optional) Specifies the IAM profile to associate with the launched instance(s). This is the ARN of the profile. =back Returns a Net::Amazon::EC2::ReservationInfo object =cut sub run_instances { my $self = shift; my %args = validate( @_, { ImageId => { type => SCALAR }, MinCount => { type => SCALAR }, MaxCount => { type => SCALAR }, KeyName => { type => SCALAR, optional => 1 }, SecurityGroup => { type => SCALAR | ARRAYREF, optional => 1 }, SecurityGroupId => { type => SCALAR | ARRAYREF, optional => 1 }, AddressingType => { type => SCALAR, optional => 1 }, AdditionalInfo => { type => SCALAR, optional => 1 }, UserData => { type => SCALAR, optional => 1 }, InstanceType => { type => SCALAR, optional => 1 }, 'Placement.AvailabilityZone' => { type => SCALAR, optional => 1 }, KernelId => { type => SCALAR, optional => 1 }, RamdiskId => { type => SCALAR, optional => 1 }, 'BlockDeviceMapping.VirtualName' => { type => SCALAR | ARRAYREF, optional => 1 }, 'BlockDeviceMapping.DeviceName' => { type => SCALAR | ARRAYREF, optional => 1 }, 'BlockDeviceMapping.Ebs.SnapshotId' => { type => SCALAR | ARRAYREF, optional => 1 }, 'BlockDeviceMapping.Ebs.VolumeSize' => { type => SCALAR | ARRAYREF, optional => 1 }, 'BlockDeviceMapping.Ebs.VolumeType' => { type => SCALAR | ARRAYREF, optional => 1 }, 'BlockDeviceMapping.Ebs.DeleteOnTermination' => { type => SCALAR | ARRAYREF, optional => 1 }, Encoding => { type => SCALAR, optional => 1 }, Version => { type => SCALAR, optional => 1 }, 'Monitoring.Enabled' => { type => SCALAR, optional => 1 }, SubnetId => { type => SCALAR, optional => 1 }, DisableApiTermination => { type => SCALAR, optional => 1 }, InstanceInitiatedShutdownBehavior => { type => SCALAR, optional => 1 }, ClientToken => { type => SCALAR, optional => 1 }, EbsOptimized => { type => SCALAR, optional => 1 }, PrivateIpAddress => { type => SCALAR, optional => 1 }, 'IamInstanceProfile.Name' => { type => SCALAR, optional => 1 }, 'IamInstanceProfile.Arn' => { type => SCALAR, optional => 1 }, }); # If we have a array ref of SecurityGroups lets split them out into their SecurityGroup.n format if (ref ($args{SecurityGroup}) eq 'ARRAY') { my $security_groups = delete $args{SecurityGroup}; _split_into_args('SecurityGroup.%s',\%args,$security_groups); } # If we have a array ref of SecurityGroupIds lets split them out into their SecurityGroupId.n format if (ref ($args{SecurityGroupId}) eq 'ARRAY') { my $security_groups = delete $args{SecurityGroupId}; _split_into_args('SecurityGroupId.%s',\%args,$security_groups); } # If we have a array ref of block device virtual names lets split them out into their BlockDeviceMapping.n.VirtualName format if (ref ($args{'BlockDeviceMapping.VirtualName'}) eq 'ARRAY') { my $virtual_names = delete $args{'BlockDeviceMapping.VirtualName'}; _split_into_args('BlockDeviceMapping.%s.VirtualName',\%args,$virtual_names); } # If we have a array ref of block device device names lets split them out into their BlockDeviceMapping.n.DeviceName format if (ref ($args{'BlockDeviceMapping.DeviceName'}) eq 'ARRAY') { my $device_names = delete $args{'BlockDeviceMapping.DeviceName'}; _split_into_args('BlockDeviceMapping.%s.DeviceName',\%args,$device_names); } # If we have a array ref of block device EBS Snapshots lets split them out into their BlockDeviceMapping.n.Ebs.SnapshotId format if (ref ($args{'BlockDeviceMapping.Ebs.SnapshotId'}) eq 'ARRAY') { my $snapshot_ids = delete $args{'BlockDeviceMapping.Ebs.SnapshotId'}; _split_into_args('BlockDeviceMapping.%s.Ebs.SnapshotId',\%args,$snapshot_ids); } # If we have a array ref of block device EBS VolumeSizes lets split them out into their BlockDeviceMapping.n.Ebs.VolumeSize format if (ref ($args{'BlockDeviceMapping.Ebs.VolumeSize'}) eq 'ARRAY') { my $volume_sizes = delete $args{'BlockDeviceMapping.Ebs.VolumeSize'}; _split_into_args('BlockDeviceMapping.%s.Ebs.VolumeSize',\%args,$volume_sizes); } # If we have a array ref of block device EBS VolumeTypes lets split them out into their BlockDeviceMapping.n.Ebs.VolumeType format if (ref ($args{'BlockDeviceMapping.Ebs.VolumeType'}) eq 'ARRAY') { my $volume_types = delete $args{'BlockDeviceMapping.Ebs.VolumeType'}; _split_into_args('BlockDeviceMapping.%s.Ebs.VolumeType',\%args,$volume_types); } # If we have a array ref of block device EBS DeleteOnTerminations lets split them out into their BlockDeviceMapping.n.Ebs.DeleteOnTermination format if (ref ($args{'BlockDeviceMapping.Ebs.DeleteOnTermination'}) eq 'ARRAY') { my $terminations = delete $args{'BlockDeviceMapping.Ebs.DeleteOnTermination'}; _split_into_args('BlockDeviceMapping.%s.Ebs.DeleteOnTermination',\%args,$terminations); } my $xml = $self->_sign(Action => 'RunInstances', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $group_sets=[]; foreach my $group_arr (@{$xml->{groupSet}{item}}) { my $group = Net::Amazon::EC2::GroupSet->new( group_id => $group_arr->{groupId}, group_name => $group_arr->{groupName}, ); push @$group_sets, $group; } my $running_instances; foreach my $instance_elem (@{$xml->{instancesSet}{item}}) { my $instance_state_type = Net::Amazon::EC2::InstanceState->new( code => $instance_elem->{instanceState}{code}, name => $instance_elem->{instanceState}{name}, ); my $product_codes; my $state_reason; my $block_device_mappings; if (grep { defined && length } $instance_elem->{productCodes} ) { foreach my $pc (@{$instance_elem->{productCodes}{item}}) { my $product_code = Net::Amazon::EC2::ProductCode->new( product_code => $pc->{productCode} ); push @$product_codes, $product_code; } } unless ( grep { defined && length } $instance_elem->{reason} and ref $instance_elem->{reason} ne 'HASH' ) { $instance_elem->{reason} = undef; } unless ( grep { defined && length } $instance_elem->{privateDnsName} and ref $instance_elem->{privateDnsName} ne 'HASH') { $instance_elem->{privateDnsName} = undef; } unless ( grep { defined && length } $instance_elem->{dnsName} and ref $instance_elem->{dnsName} ne 'HASH') { $instance_elem->{dnsName} = undef; } if ( grep { defined && length && $_->{code} && $_->{message} } $instance_elem->{stateReason} ) { $state_reason = Net::Amazon::EC2::StateReason->new( code => $instance_elem->{stateReason}{code}, message => $instance_elem->{stateReason}{message}, ); } if ( grep { defined && length } $instance_elem->{blockDeviceMapping} ) { foreach my $bdm ( @{$instance_elem->{blockDeviceMapping}{item}} ) { my $ebs_block_device_mapping = Net::Amazon::EC2::EbsInstanceBlockDeviceMapping->new( volume_id => $bdm->{ebs}{volumeId}, status => $bdm->{ebs}{status}, attach_time => $bdm->{ebs}{attachTime}, delete_on_termination => $bdm->{ebs}{deleteOnTermination}, ); my $block_device_mapping = Net::Amazon::EC2::BlockDeviceMapping->new( ebs => $ebs_block_device_mapping, device_name => $bdm->{deviceName}, ); push @$block_device_mappings, $block_device_mapping; } } my $placement_response = Net::Amazon::EC2::PlacementResponse->new( availability_zone => $instance_elem->{placement}{availabilityZone} ); my $running_instance = Net::Amazon::EC2::RunningInstances->new( ami_launch_index => $instance_elem->{amiLaunchIndex}, dns_name => $instance_elem->{dnsName}, image_id => $instance_elem->{imageId}, kernel_id => $instance_elem->{kernelId}, ramdisk_id => $instance_elem->{ramdiskId}, instance_id => $instance_elem->{instanceId}, instance_state => $instance_state_type, instance_type => $instance_elem->{instanceType}, key_name => $instance_elem->{keyName}, launch_time => $instance_elem->{launchTime}, placement => $placement_response, private_dns_name => $instance_elem->{privateDnsName}, reason => $instance_elem->{reason}, platform => $instance_elem->{platform}, monitoring => $instance_elem->{monitoring}{state}, subnet_id => $instance_elem->{subnetId}, vpc_id => $instance_elem->{vpcId}, private_ip_address => $instance_elem->{privateIpAddress}, ip_address => $instance_elem->{ipAddress}, architecture => $instance_elem->{architecture}, root_device_name => $instance_elem->{rootDeviceName}, root_device_type => $instance_elem->{rootDeviceType}, block_device_mapping => $block_device_mappings, state_reason => $state_reason, ); if ($product_codes) { $running_instance->product_codes($product_codes); } push @$running_instances, $running_instance; } my $reservation = Net::Amazon::EC2::ReservationInfo->new( reservation_id => $xml->{reservationId}, owner_id => $xml->{ownerId}, group_set => $group_sets, instances_set => $running_instances, ); return $reservation; } } =head2 start_instances(%params) Starts an instance that uses an Amazon EBS volume as its root device. =over =item InstanceId (required) Either a scalar or an array ref can be passed in (containing instance ids to be started). =back Returns an array ref of Net::Amazon::EC2::InstanceStateChange objects. =cut sub start_instances { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR | ARRAYREF }, }); # If we have a array ref of instances lets split them out into their InstanceId.n format if (ref ($args{InstanceId}) eq 'ARRAY') { my $instance_ids = delete $args{InstanceId}; _split_into_args('InstanceId.%s',\%args,$instance_ids); } my $xml = $self->_sign(Action => 'StartInstances', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $started_instances; foreach my $inst (@{$xml->{instancesSet}{item}}) { my $previous_state = Net::Amazon::EC2::InstanceState->new( code => $inst->{previousState}{code}, name => $inst->{previousState}{name}, ); my $current_state = Net::Amazon::EC2::InstanceState->new( code => $inst->{currentState}{code}, name => $inst->{currentState}{name}, ); my $started_instance = Net::Amazon::EC2::InstanceStateChange->new( instance_id => $inst->{instanceId}, previous_state => $previous_state, current_state => $current_state, ); push @$started_instances, $started_instance; } return $started_instances; } } =head2 stop_instances(%params) Stops an instance that uses an Amazon EBS volume as its root device. =over =item InstanceId (required) Either a scalar or an array ref can be passed in (containing instance ids to be stopped). =item Force (optional) If set to true, forces the instance to stop. The instance will not have an opportunity to flush file system caches nor file system meta data. If you use this option, you must perform file system check and repair procedures. This option is not recommended for Windows instances. The default is false. =back Returns an array ref of Net::Amazon::EC2::InstanceStateChange objects. =cut sub stop_instances { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR | ARRAYREF }, Force => { type => SCALAR, optional => 1 }, }); # If we have a array ref of instances lets split them out into their InstanceId.n format if (ref ($args{InstanceId}) eq 'ARRAY') { my $instance_ids = delete $args{InstanceId}; _split_into_args('InstanceId.%s',\%args,$instance_ids); } my $xml = $self->_sign(Action => 'StopInstances', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $stopped_instances; foreach my $inst (@{$xml->{instancesSet}{item}}) { my $previous_state = Net::Amazon::EC2::InstanceState->new( code => $inst->{previousState}{code}, name => $inst->{previousState}{name}, ); my $current_state = Net::Amazon::EC2::InstanceState->new( code => $inst->{currentState}{code}, name => $inst->{currentState}{name}, ); my $stopped_instance = Net::Amazon::EC2::InstanceStateChange->new( instance_id => $inst->{instanceId}, previous_state => $previous_state, current_state => $current_state, ); push @$stopped_instances, $stopped_instance; } return $stopped_instances; } } =head2 terminate_instances(%params) This method shuts down instance(s) passed into it. It takes the following parameter: =over =item InstanceId (required) Either a scalar or an array ref can be passed in (containing instance ids) =back Returns an array ref of Net::Amazon::EC2::InstanceStateChange objects. =cut sub terminate_instances { my $self = shift; my %args = validate( @_, { InstanceId => { type => SCALAR | ARRAYREF }, }); # If we have a array ref of instances lets split them out into their InstanceId.n format if (ref ($args{InstanceId}) eq 'ARRAY') { my $instance_ids = delete $args{InstanceId}; _split_into_args('InstanceId.%s',\%args,$instance_ids); } my $xml = $self->_sign(Action => 'TerminateInstances', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $terminated_instances; foreach my $inst (@{$xml->{instancesSet}{item}}) { my $previous_state = Net::Amazon::EC2::InstanceState->new( code => $inst->{previousState}{code}, name => $inst->{previousState}{name}, ); my $current_state = Net::Amazon::EC2::InstanceState->new( code => $inst->{currentState}{code}, name => $inst->{currentState}{name}, ); # Note, this is a bit of a backwards incompatible change in so much as I am changing # return class for this. I hate to do it but I need to be consistent with this # now being a instance stage change object. This used to be a # Net::Amazon::EC2::TerminateInstancesResponse object. my $terminated_instance = Net::Amazon::EC2::InstanceStateChange->new( instance_id => $inst->{instanceId}, previous_state => $previous_state, current_state => $current_state, ); push @$terminated_instances, $terminated_instance; } return $terminated_instances; } } =head2 unmonitor_instances(%params) Disables monitoring for a running instance. For more information, refer to the Amazon CloudWatch Developer Guide. =over =item InstanceId (required) The instance id(s) to monitor. Can be a scalar or an array ref =back Returns an array ref of Net::Amazon::EC2::MonitoredInstance objects =cut sub unmonitor_instances { my $self = shift; my %args = validate( @_, { InstanceId => { type => ARRAYREF | SCALAR, optional => 1 }, }); # If we have a array ref of instances lets split them out into their InstanceId.n format if (ref ($args{InstanceId}) eq 'ARRAY') { my $instance_ids = delete $args{InstanceId}; _split_into_args('InstanceId.%s',\%args,$instance_ids); } my $xml = $self->_sign(Action => 'UnmonitorInstances', %args); if ( grep { defined && length } $xml->{Errors} ) { return $self->_parse_errors($xml); } else { my $monitored_instances; foreach my $monitored_instance_item (@{$xml->{instancesSet}{item}}) { my $monitored_instance = Net::Amazon::EC2::ReservedInstance->new( instance_id => $monitored_instance_item->{instanceId}, state => $monitored_instance_item->{monitoring}{state}, ); push @$monitored_instances, $monitored_instance; } return $monitored_instances; } } no Moose; 1; __END__ =head1 TESTING Set AWS_ACCESS_KEY_ID and SECRET_ACCESS_KEY environment variables to run the live tests. Note: because the live tests start an instance (and kill it) in both the tests and backwards compat tests there will be 2 hours of machine instance usage charges (since there are 2 instances started) which as of February 1st, 2010 costs a total of $0.17 USD Important note about the windows-only methods. These have not been well tested as I do not run windows-based instances, so exercise caution in using these. =head1 BUGS Please report any bugs or feature requests to C, or through the web interface at L. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes. =head1 AUTHOR Jeff Kim =head1 CONTRIBUTORS John McCullough and others as listed in the Changelog =head1 MAINTAINER The current maintainer is Mark Allen C<< >> =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. Copyright (c) 2012 Mark Allen. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 SEE ALSO Amazon EC2 API: L =cut EC2000755000766000024 013260744456 16545 5ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/AmazonError.pm100644000766000024 155113260744456 20336 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::Error; $Net::Amazon::EC2::Error::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::Error =head1 DESCRIPTION A class representing an EC2 API error. =head1 ATTRIBUTES =over =item code (required) The error code returned from the API request. =item message (required) The long form message about the error. =cut use overload '""' => 'as_string'; has 'code' => ( is => 'ro', isa => 'Str', required => 1 ); has 'message' => ( is => 'ro', isa => 'Str', required => 1 ); sub as_string { my $self = shift; return '['.$self->code.'] '.$self->message; } __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; Errors.pm100644000766000024 221213260744456 20514 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::Errors; $Net::Amazon::EC2::Errors::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::Errors =head1 DESCRIPTION A class representing one or more errors from an API request. =head1 ATTRIBUTES =over =item request_id (required) The ID of the request associated with this error. =item errors (required) An array ref of Net::Amazon::EC2::Error objects associated with this request. =cut use overload '""' => 'as_string'; has 'request_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'errors' => ( is => 'rw', isa => 'ArrayRef[Net::Amazon::EC2::Error]', predicate => 'has_errors', required => 1, ); sub as_string { my $self = shift; my $errors = join '', map { '['.$_->code.'] '.$_->message."\n" } @{$self->errors}; return "Amazon EC2 Errors [Request ".$self->request_id."]:\n$errors" } __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; Events.pm100644000766000024 177013260744456 20514 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::Events; $Net::Amazon::EC2::Events::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::Events =head1 DESCRIPTION A class representing a EC2 Events block =head1 ATTRIBUTES =over =item code (required) The code of the event. =item description (required) The description of the event. =item not_before (required) The date the event will not occur before. =item not_after (optional) The date the event will not occur after. =back =cut has 'code' => ( is => 'ro', isa => 'Str', required => 1 ); has 'description' => ( is => 'ro', isa => 'Str', required => 1 ); has 'not_before' => ( is => 'ro', isa => 'Str', required => 1 ); has 'not_after' => ( is => 'ro', isa => 'Str', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Matt West =head1 COPYRIGHT Copyright (c) 2014 Matt West. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; Region.pm100644000766000024 134713260744456 20473 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::Region; $Net::Amazon::EC2::Region::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::Region =head1 DESCRIPTION A class representing a EC2 region =head1 ATTRIBUTES =over =item region_name (required) The name of the region. =item region_endpoint (required) The region service endpoint. =back =cut has 'region_name' => ( is => 'ro', isa => 'Str', required => 1 ); has 'region_endpoint' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; TagSet.pm100644000766000024 137213260744456 20435 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::TagSet; $Net::Amazon::EC2::TagSet::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::TagSet =head1 DESCRIPTION A class containing information about a tag. =head1 ATTRIBUTES =over =item key (required) The key of the tag. =item value The value of the tag. (May be undefined if there is no value for a given key.) =cut has 'key' => ( is => 'ro', isa => 'Str', required => 1 ); has 'value' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; Volume.pm100644000766000024 403313260744456 20512 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::Volume; $Net::Amazon::EC2::Volume::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::Volume =head1 DESCRIPTION A class representing a volume =head1 ATTRIBUTES =over =item volume_id (required) The ID of the volume. =item size (required) The size, in GiB (1GiB = 2^30 octects) =item snapshot_id (optional) The ID of the snapshot which this volume was created from (if any). =item zone (required) The availability zone the volume was creared in. =item status (required) The volume's status. =item create_time (required) The time the volume was created. =item volume_type (optional) The volume type. =item iops (optional) The number of I/O operations per second (IOPS) that the volume supports (only applies to volumes with a volume_type of io1). =item attachments (optional) An array ref of Net:Amazon::EC2::Attachment objects. =item tag_set (optional) The associated tags (key:value) of the specified volume. =back =cut has 'volume_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'size' => ( is => 'ro', isa => 'Str', required => 1 ); has 'snapshot_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'zone' => ( is => 'ro', isa => 'Str', required => 1 ); has 'status' => ( is => 'ro', isa => 'Str', required => 1 ); has 'create_time' => ( is => 'ro', isa => 'Str', required => 1 ); has 'volume_type' => ( is => 'ro', isa => 'Str', default => 'standard'); has 'iops' => ( is => 'ro', isa => 'Maybe[Int]'); has 'encrypted' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'attachments' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::Attachment]]', required => 0 ); has 'tag_set' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::TagSet]]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; Details.pm100644000766000024 133013260744456 20625 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::Details; $Net::Amazon::EC2::Details::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::Details =head1 DESCRIPTION A class representing a EC2 details block =head1 ATTRIBUTES =over =item name (required) The name of the detail. =item status (required) The status of the detail. =back =cut has 'name' => ( is => 'ro', isa => 'Str', required => 1 ); has 'status' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Matt West =head1 COPYRIGHT Copyright (c) 2014 Matt West. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; IpRange.pm100644000766000024 111313260744456 20564 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::IpRange; $Net::Amazon::EC2::IpRange::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::IpRange =head1 DESCRIPTION A class representing an IP range (CIDR). =head1 ATTRIBUTES =over =item cidr_ip (required) CIDR IP Range. =back =cut has 'cidr_ip' => ( is => 'ro', isa => 'Str' ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; KeyPair.pm100644000766000024 131613260744456 20610 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::KeyPair; $Net::Amazon::EC2::KeyPair::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::KeyPair =head1 DESCRIPTION A class representing a key pair upon creation of a new pair. =head1 ATTRIBUTES =over =item key_material (required) The unencrypted PEM encoded RSA private key. =back =cut extends 'Net::Amazon::EC2::DescribeKeyPairsResponse'; has 'key_material' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; GroupSet.pm100644000766000024 126213260744456 21014 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::GroupSet; $Net::Amazon::EC2::GroupSet::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::GroupSet =head1 DESCRIPTION A class containing information about a group. =head1 ATTRIBUTES =over =item group_id (required) The ID of the group. =cut has 'group_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'group_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; Snapshot.pm100644000766000024 351713260744456 21050 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::Snapshot; $Net::Amazon::EC2::Snapshot::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::Snapshot =head1 DESCRIPTION A class representing a snapshot of a volume. =head1 ATTRIBUTES =over =item snapshot_id (required) The ID of the snapshot. =item status (required) The snapshot's status. =item volume_id (required) The ID of the volume the snapshot was taken from. =item start_time (required) The time the snapshot was started. =item progress (required) The current progress of the snapshop, in percent. =item owner_id (required) AWS Access Key ID of the user who owns the snapshot. =item volume_size (required) The size of the volume, in GiB. =item description (optional) Description of the snapshot. =item owner_alias (optional) The AWS account alias (e.g., "amazon", "redhat", "self", etc.) or AWS account ID that owns the AMI. =back =cut has 'snapshot_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'status' => ( is => 'ro', isa => 'Str', required => 1 ); has 'volume_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'start_time' => ( is => 'ro', isa => 'Str', required => 1 ); has 'progress' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'owner_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'volume_size' => ( is => 'ro', isa => 'Str', required => 1 ); has 'description' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'owner_alias' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'tag_set' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::TagSet]]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; UserData.pm100644000766000024 123013260744456 20747 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::UserData; $Net::Amazon::EC2::UserData::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::UserData =head1 DESCRIPTION A class representing EC2 User Data attached to an instance. =head1 ATTRIBUTES =over =item data (required) User data itself which is passed to the instance. =cut has 'data' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; Attachment.pm100644000766000024 257713260744456 21346 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::Attachment; $Net::Amazon::EC2::Attachment::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::Attachment =head1 DESCRIPTION A class representing a volume attachment to an instance =head1 ATTRIBUTES =over =item volume_id (required) The ID of the volume. =item instance_id (optional) The ID of the instance which this volume was attached to. =item device (required) The device path on the instance that the volume was attached as. =item status (required) The attachment's status. =item attach_time (required) The time the volume was attached. =item delete_on_termination (required) This boolean indicates if an volume is terminated upon instance termination. =back =cut has 'volume_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'instance_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'device' => ( is => 'ro', isa => 'Str', required => 1 ); has 'status' => ( is => 'ro', isa => 'Str', required => 1 ); has 'attach_time' => ( is => 'ro', isa => 'Str', required => 1 ); has 'delete_on_termination' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; ProductCode.pm100644000766000024 116013260744456 21454 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::ProductCode; $Net::Amazon::EC2::ProductCode::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::ProductCode =head1 DESCRIPTION A class representing a product code. =head1 ATTRIBUTES =over =item product_code (required) The product code. =back =cut has 'product_code' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; StateReason.pm100644000766000024 146713260744456 21503 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::StateReason; $Net::Amazon::EC2::StateReason::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::StateReason =head1 DESCRIPTION A class representing additional information on the reason for the current state of the instance. =head1 ATTRIBUTES =over =item code (required) A code for the state change reason. =item message (required) A message providing additional information about the state. =back =cut has 'code' => ( is => 'ro', isa => 'Maybe[Int|Str]' ); has 'message' => ( is => 'ro', isa => 'Maybe[Str]' ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; DescribeTags.pm100644000766000024 234313260744456 21604 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::DescribeTags; $Net::Amazon::EC2::DescribeTags::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::DescribeTags =head1 DESCRIPTION A class containing information about tags =head1 ATTRIBUTES =over =item resource_id (required) The resource_id of the tag. =item resource_type (required) The resource_type of the tag. Values: customer-gateway | dhcp-options | image | instance | internet-gateway | network-acl | reserved-instances | route-table | security-group | snapshot | spot-instances-request | subnet | volume | vpc | vpn-connection | vpn-gateway =item key (required) The key of the tag. =item value (required) The value of the tag. =back =cut has 'resource_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'resource_type' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'key' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'value' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; IpPermission.pm100644000766000024 375613260744456 21677 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::IpPermission; $Net::Amazon::EC2::IpPermission::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::IpPermission =head1 DESCRIPTION A class representing a rule within the security group. =head1 ATTRIBUTES =over =item ip_protocol (required) Protocol for the rule. e.g. tcp =item from_port (required) Start of port range for the TCP and UDP protocols, or an ICMP type number. An ICMP type number of -1 indicates a wildcard (i.e., any ICMP type number). =item to_port (required) End of port range for the TCP and UDP protocols, or an ICMP code. An ICMP code of -1 indicates a wildcard (i.e., any ICMP code). =item ip_ranges (optional) An array ref of Net::Amazon::EC2::IpRange objects to be associated with this rule. =item groups (optional) An array ref of Net::Amazon::EC2::UserIdGroupPair objects to be associated with this rule. =item icmp_port (optional) For the ICMP protocol, the ICMP type and code must be specified. This must be specified in the format type:code where both are integers. Type, code, or both can be specified as -1, which is a wildcard. =back =cut has 'ip_protocol' => ( is => 'ro', isa => 'Str', required => 1 ); has 'from_port' => ( is => 'ro', isa => 'Maybe[Int]', required => 1 ); has 'to_port' => ( is => 'ro', isa => 'Maybe[Int]', required => 1 ); has 'ip_ranges' => ( is => 'rw', isa => 'ArrayRef[Net::Amazon::EC2::IpRange]', predicate => 'has_ip_ranges', required => 0, ); has 'groups' => ( is => 'rw', isa => 'ArrayRef[Net::Amazon::EC2::UserIdGroupPair]', predicate => 'has_groups', required => 0, ); has 'icmp_port' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; SystemStatus.pm100644000766000024 143613260744456 21737 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::SystemStatus; $Net::Amazon::EC2::SystemStatus::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::SystemStatus =head1 DESCRIPTION A class representing a EC2 SystemStatus block =head1 ATTRIBUTES =over =item details (required) The details for the system status. =item status (required) The system status results. =back =cut has 'status' => ( is => 'ro', isa => 'Str', required => 1 ); has 'details' => ( is => 'ro', isa => 'ArrayRef[Net::Amazon::EC2::Details]', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Matt West =head1 COPYRIGHT Copyright (c) 2014 Matt West. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; ConsoleOutput.pm100644000766000024 166513260744456 22076 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::ConsoleOutput; $Net::Amazon::EC2::ConsoleOutput::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::ConsoleOutput =head1 DESCRIPTION A class containing the output from an instance's console =head1 ATTRIBUTES =over =item instance_id (required) The instance id of the output returned. =item timestamp (required) The timestamp of when the console output was last updated. =item output (required) The console output itself. =back =cut has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'timestamp' => ( is => 'ro', isa => 'Str', required => 1 ); has 'output' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; InstanceState.pm100644000766000024 243613260744456 22015 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::InstanceState; $Net::Amazon::EC2::InstanceState::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::InstanceState =head1 DESCRIPTION A class representing the state of an instance. =head1 ATTRIBUTES =over =item code (required) An interger representing the instance state. Valid values are: =over =item * 0: pending =item * 16: running =item * 32: shutting-down =item * 48: terminated =item * 64: stopping =item * 80: stopped =back =item name (required) The current named state of the instance. Valid values are: =over =item * pending: the instance is in the process of being launched =item * running: the instance launched (though booting may not be completed) =item * shutting-down: the instance started shutting down =item * terminated: the instance terminated =item * stopping: the instance is in the process of stopping =item * stopped: the instance has been stopped =back =cut has 'code' => ( is => 'ro', isa => 'Int' ); has 'name' => ( is => 'ro', isa => 'Str' ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; SecurityGroup.pm100644000766000024 376713260744456 22104 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::SecurityGroup; $Net::Amazon::EC2::SecurityGroup::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::SecurityGroup =head1 DESCRIPTION A class representing a security group. =head1 ATTRIBUTES =over =item owner_id (required) The AWS Access Key ID of the owner of the security group. =item group_name (required) The name of the security group. =item group_id (required) The id of the security group. =item group_description (required) The description of the security group. =item ip_permissions (optional) An array ref of Net::Amazon::EC2::IpPermission objects for ingress. =item ip_permissions_egress (optional) An array ref of Net::Amazon::EC2::IpPermission objects for egress. =item vpc_id (optional) The VPC id of the corresponding security group =item tag_set (optional) The set of associated tags for the security group =cut has 'owner_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'group_name' => ( is => 'ro', isa => 'Str', required => 1 ); has 'group_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'group_description' => ( is => 'ro', isa => 'Str', required => 1 ); has 'ip_permissions' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::IpPermission]]', predicate => 'has_ip_permissions', default => sub { [ ] }, ); has 'ip_permissions_egress' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::IpPermission]]', predicate => 'has_ip_permissions_egress', default => sub { [ ] }, ); has 'vpc_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'tag_set' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::TagSet]]', required => 0 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; EbsBlockDevice.pm100644000766000024 177313260744456 22057 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::EbsBlockDevice; $Net::Amazon::EC2::EbsBlockDevice::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::Net::Amazon::EC2::EbsBlockDevice =head1 DESCRIPTION A class representing a EBS block device =head1 ATTRIBUTES =over =item snapshot_id (optional) The EBS snapshot id. =item volume_size (optional) The size, in GiB (1GiB = 2^30 octects) =item delete_on_termination (optional) Specifies whether the Amazon EBS volume is deleted on instance termination. =back =cut has 'snapshot_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'volume_size' => ( is => 'ro', isa => 'Maybe[Int]', required => 0 ); has 'delete_on_termination' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; InstanceStatus.pm100644000766000024 145213260744456 22215 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::InstanceStatus; $Net::Amazon::EC2::InstanceStatus::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::InstanceStatus =head1 DESCRIPTION A class representing a EC2 InstanceStatus block =head1 ATTRIBUTES =over =item details (required) The details for the instance status. =item status (required) The instance status results. =back =cut has 'status' => ( is => 'ro', isa => 'Str', required => 1 ); has 'details' => ( is => 'ro', isa => 'ArrayRef[Net::Amazon::EC2::Details]', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Matt West =head1 COPYRIGHT Copyright (c) 2014 Matt West. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; DescribeAddress.pm100644000766000024 155413260744456 22276 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::DescribeAddress; $Net::Amazon::EC2::DescribeAddress::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::DescribeAddress =head1 DESCRIPTION A class containing information about allocated elastic addresses and the instances they are bound to =head1 ATTRIBUTES =over =item public_ip (required) The public ip address allocated. =item instance_id (optional) The instance id (if any) associated with the public ip. =back =cut has 'public_ip' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'instance_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; ReservationInfo.pm100644000766000024 256313260744456 22366 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::ReservationInfo; $Net::Amazon::EC2::ReservationInfo::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::ReservationInfo =head1 DESCRIPTION A class representing a run instance reservation. =head1 ATTRIBUTES =over =item reservation_id (required) Unique ID attached to the reservation. =item owner_id (required) AWS Account id of the person making the reservation. =item group_set An array ref of Net::Amazon::EC2::GroupSet objects. =item instances_set (required) An array ref of Net::Amazon::EC2::RunningInstances objects. =item requesterId (optional) ID of the requester. =cut has 'reservation_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'owner_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'group_set' => ( is => 'ro', isa => 'ArrayRef[Net::Amazon::EC2::GroupSet]', required => 1, auto_deref => 1, ); has 'instances_set' => ( is => 'ro', isa => 'ArrayRef[Net::Amazon::EC2::RunningInstances]', required => 1, auto_deref => 1, ); has 'requester_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; UserIdGroupPair.pm100644000766000024 147013260744456 22271 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::UserIdGroupPair; $Net::Amazon::EC2::UserIdGroupPair::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::UserIdGroupPair =head1 DESCRIPTION A class representing the User ID and Group pair used with security group operations. =head1 ATTRIBUTES =over =item user_id (required) AWS Access Key ID of the user. =item group_name (required) Name of the security group. =cut has 'user_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'group_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; AvailabilityZone.pm100644000766000024 220713260744456 22512 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::AvailabilityZone; $Net::Amazon::EC2::AvailabilityZone::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::AvailabilityZone =head1 DESCRIPTION A class representing an availability zone =head1 ATTRIBUTES =over =item zone_name (required) Name of the Availability Zone. =item zone_state (required) State of the Availability Zone. =item region_name (required) Name of the region. =item messages (optional) An array ref of Net::Amazon::EC2::AvailabilityZoneMessage objects representing messages for this zone (if any) =back =cut has 'zone_name' => ( is => 'ro', isa => 'Str', required => 1 ); has 'zone_state' => ( is => 'ro', isa => 'Str', required => 1 ); has 'region_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'messages' => ( is => 'ro', isa => 'ArrayRef[Net::Amazon::EC2::AvailabilityZoneMessage]|Undef', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; InstancePassword.pm100644000766000024 165213260744456 22536 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::InstancePassword; $Net::Amazon::EC2::InstancePassword::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::InstancePassword =head1 DESCRIPTION A class representing a instance password for a Windows-based instance. =head1 ATTRIBUTES =over =item instance_id (required) The ID of the instance. =item timestamp (required) The time the data was last updated. =item password_data (required) The password of the instance. =back =cut has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'timestamp' => ( is => 'ro', isa => 'Str', required => 1 ); has 'password_data' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; InstanceStatuses.pm100644000766000024 262213260744456 22545 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::InstanceStatuses; $Net::Amazon::EC2::InstanceStatuses::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::InstanceStatuses =head1 DESCRIPTION A class representing a EC2 InstanceStatuses block =head1 ATTRIBUTES =over =item instance_status (required) The instance status results. =item availability_zone (required) The availability_zone results. =item instance_id (required) The instance_id results. =item instance_state (required) The instance_state results. =item system_status (required) The system_status results. =item events (required) The events results =back =cut has 'availability_zone' => ( is => 'ro', isa => 'Str', required => 1 ); has 'events' => ( is => 'ro', isa => 'ArrayRef[Net::Amazon::EC2::Events]', required => 1 ); has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'instance_status' => ( is => 'ro', isa => 'Net::Amazon::EC2::InstanceStatus', required => 1 ); has 'instance_state' => ( is => 'ro', isa => 'Net::Amazon::EC2::InstanceState', required => 1 ); has 'system_status' => ( is => 'ro', isa => 'Net::Amazon::EC2::SystemStatus', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Matt West =head1 COPYRIGHT Copyright (c) 2014 Matt West. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; LaunchPermission.pm100644000766000024 175613260744456 22537 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::LaunchPermission; $Net::Amazon::EC2::LaunchPermission::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::LaunchPermission =head1 DESCRIPTION A class containing information about the group or user_id associated with this launch permission attribute. =head1 ATTRIBUTES =over =item group (required if user_id not defined) A launch permission for a group. Currently only 'all' is supported, which gives public launch permissions. Either choose a group or a user_id but not both. =item user_id (required if group not defined) The AWS account id of the user with launch permissions. =back =cut has 'group' => ( is => 'ro', isa => 'Str' ); has 'user_id' => ( is => 'ro', isa => 'Str' ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; ReservedInstance.pm100644000766000024 375013260744456 22514 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::ReservedInstance; $Net::Amazon::EC2::ReservedInstance::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::ReservedInstance =head1 DESCRIPTION A class representing a reserved instance. =head1 ATTRIBUTES =over =item reserved_instances_id (required) The ID of the Reserved Instance. =item instance_type (required) The instance type on which the Reserved Instance can be used. =item availability_zone (required) The Availability Zone in which the Reserved Instance can be used. =item duration (required) The duration of the Reserved Instance, in seconds. =item start (required) The date and time the Reserved Instance started. =item usage_price (required) The usage price of the Reserved Instance, per hour. =item fixed_price (required) The purchase price of the Reserved Instance. =item instance_count (required) The number of Reserved Instances purchased. =item product_description (required) The Reserved Instance description. =item state (required) The state of the Reserved Instance purchase. =back =cut has 'reserved_instances_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'instance_type' => ( is => 'ro', isa => 'Str', required => 1 ); has 'availability_zone' => ( is => 'ro', isa => 'Str', required => 1 ); has 'duration' => ( is => 'ro', isa => 'Str', required => 1 ); has 'start' => ( is => 'ro', isa => 'Str', required => 1 ); has 'usage_price' => ( is => 'ro', isa => 'Str', required => 1 ); has 'fixed_price' => ( is => 'ro', isa => 'Str', required => 1 ); has 'instance_count' => ( is => 'ro', isa => 'Str', required => 1 ); has 'product_description' => ( is => 'ro', isa => 'Str', required => 1 ); has 'state' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; RunningInstances.pm100644000766000024 1312113260744456 22551 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::RunningInstances; $Net::Amazon::EC2::RunningInstances::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::RunningInstances =head1 DESCRIPTION A class representing a running instance. =head1 ATTRIBUTES =over =item ami_launch_index (optional) The AMI launch index, which can be used to find this instance within the launch group. =item dns_name (optional) The public DNS name assigned to the instance. This DNS name is contactable from outside the Amazon EC2 network. This element remains empty until the instance enters a running state. =item image_id (required) The image id of the AMI currently running in this instance. =item kernel_id (required) The kernel id of the AKI currently running in this instance. =item ramdisk_id (required) The ramdisk id of the ARI loaded in this instance. =item instance_id (required) The instance id of the launched instance. =item instance_state (required) An Net::Amazon::EC2::InstanceState object. =item instance_type (required) The type of instance launched. =item key_name (optional) The key pair name the instance was launched with. =item launch_time (required) The time the instance was started. =item placement (required) A Net::Amazon::EC2::PlacementResponse object. =item private_dns_name (optional) The private DNS name assigned to the instance. This DNS name can only be used inside the Amazon EC2 network. This element remains empty until the instance enters a running state. =item product_codes (optional) An array ref of Net::Amazon::EC2::ProductCode objects. =item reason (optional) The reason for the most recent state transition. =item platform (optional) The operating system for this instance. =item monitoring (optional) The state of monitoring on this instance. =item subnet_id (optional) Specifies the subnet ID in which the instance is running (Amazon Virtual Private Cloud). =item vpc_id (optional) Specifies the VPC in which the instance is running (Amazon Virtual Private Cloud). =item private_ip_address (optional) Specifies the private IP address that is assigned to the instance (Amazon VPC). =item ip_address (optional) Specifies the IP address of the instance. =item state_reason (optional) The reason for the state change. A Net::Amazon::EC2::StateReason object. =item architecture (optional) The architecture of the image. =item root_device_name (optional) The root device name (e.g., /dev/sda1). =item root_device_type (optional) The root device type used by the AMI. The AMI can use an Amazon EBS or instance store root device. =item block_device_mapping (optional) An array ref of Net::Amazon::EC2::BlockDeviceMapping objects. =item tag_set (optional) An array ref of Net::Amazon::EC2::TagSet objects. =item name (optional) The instance name from tags. =cut has 'ami_launch_index' => ( is => 'ro', isa => 'Str', required => 0 ); has 'dns_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'image_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'kernel_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'ramdisk_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'instance_state' => ( is => 'ro', isa => 'Net::Amazon::EC2::InstanceState', required => 1 ); has 'instance_type' => ( is => 'ro', isa => 'Str', required => 1 ); has 'key_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'launch_time' => ( is => 'ro', isa => 'Str', required => 1 ); has 'placement' => ( is => 'ro', isa => 'Net::Amazon::EC2::PlacementResponse', required => 1 ); has 'private_dns_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'product_codes' => ( is => 'rw', isa => 'ArrayRef[Net::Amazon::EC2::ProductCode]', auto_deref => 1, required => 0, ); has 'reason' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'platform' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'monitoring' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'subnet_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'vpc_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'private_ip_address' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'ip_address' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'state_reason' => ( is => 'ro', isa => 'Maybe[Net::Amazon::EC2::StateReason]', required => 0 ); has 'architecture' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'root_device_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'root_device_type' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'block_device_mapping' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::BlockDeviceMapping]]', required => 0 ); has 'network_interface_set' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::NetworkInterfaceSet]]', required => 0 ); has 'tag_set' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::TagSet]]', required => 0 ); has 'name' => ( is => 'ro', lazy => 1, default => sub { my $self = shift; return '' if !$self->tag_set || scalar @{$self->tag_set} == 0; my $name = (grep {$_->{key} eq 'Name'} @{$self->tag_set})[0]; return $name->{value} || ''; }, ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; MonitoredInstance.pm100644000766000024 143313260744456 22671 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::MonitoredInstance; $Net::Amazon::EC2::MonitoredInstance::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::MonitoredInstance =head1 DESCRIPTION A class representing a monitored instance. =head1 ATTRIBUTES =over =item instance_id (required) The ID of the instance being monitored. =item state (required) The state of monitoring of this instance. =back =cut has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'state' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; PlacementResponse.pm100644000766000024 135113260744456 22672 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::PlacementResponse; $Net::Amazon::EC2::PlacementResponse::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::PlacementResponse =head1 DESCRIPTION A class containing information about the placement of an instance in an availability zone. =head1 ATTRIBUTES =over =item availability_zone (required) The availability zone for the instance. =back =cut has 'availability_zone' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; SnapshotAttribute.pm100644000766000024 156013260744456 22730 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::SnapshotAttribute; $Net::Amazon::EC2::SnapshotAttribute::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::SnapshotAttribute =head1 DESCRIPTION A class representing the snapshot attributes of a volume. =head1 ATTRIBUTES =over =item snapshot_id (required) The ID of the snapshot. =item permissions (required) An arrayref of Net::Amazon::EC2::CreateVolumePermission objects =back =cut has 'snapshot_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'permissions' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::CreateVolumePermission]]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; BlockDeviceMapping.pm100644000766000024 232113260744456 22727 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::BlockDeviceMapping; $Net::Amazon::EC2::BlockDeviceMapping::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::BlockDeviceMapping =head1 DESCRIPTION A class representing a block device mapping =head1 ATTRIBUTES =over =item device_name (required) Name of the device within Amazon EC2. =item ebs (optional) A Net::Amazon::EC2::EbsInstanceBlockDeviceMapping object representing the EBS mapping =item virtual_name (optional) A virtual device name. =item no_device (optional) Specifies the device name to suppress during instance launch. =back =cut has 'device_name' => ( is => 'ro', isa => 'Str', required => 1 ); has 'ebs' => ( is => 'ro', isa => 'Maybe[Net::Amazon::EC2::EbsBlockDevice]|Maybe[Net::Amazon::EC2::EbsInstanceBlockDeviceMapping]', required => 0 ); has 'virtual_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'no_device' => ( is => 'ro', isa => 'Maybe[Int]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; InstanceStateChange.pm100644000766000024 213613260744456 23120 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::InstanceStateChange; $Net::Amazon::EC2::InstanceStateChange::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::InstanceStateChange =head1 DESCRIPTION A class representing the change of a state of an instance. =head1 ATTRIBUTES =over =item instance_id (required) The instance id in question. =item current_state (required) A Net::Amazon::EC2::InstanceState object representing the current state of the instance. =item previous_state (required) A Net::Amazon::EC2::InstanceState object representing the previous state of the instance. =back =cut has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'current_state' => ( is => 'ro', isa => 'Net::Amazon::EC2::InstanceState', required => 1 ); has 'previous_state' => ( is => 'ro', isa => 'Net::Amazon::EC2::InstanceState', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; NetworkInterfaceSet.pm100644000766000024 347613260744456 23203 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::NetworkInterfaceSet; $Net::Amazon::EC2::NetworkInterfaceSet::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::NetworkInterfaceSet =head1 DESCRIPTION A class representing a network interface =head1 ATTRIBUTES =over =item network_interface_id (required) Network interface ID. =item subnet_id (optional) Subnet ID specific interface belongs to. =item vpc_id (optional) VPC ID specific interface belongs to. =item description (optional) Interface description =item status (optional) Current interface status. =item mac_address (optional) Interfaces mac address. =item private_ip_address (optional) Private IP address attached to the interface. =item group_sets (optional) An array of Net::Amazon::EC2::GroupSet objects which representing security groups attached to the interface. =back =cut has 'network_interface_id' => ( is => 'ro', isa => 'Str', required => 1, ); has 'subnet_id' => ( is => 'ro', isa => 'Str', required => 0, ); has 'vpc_id' => ( is => 'ro', isa => 'Str', required => 0, ); has 'description' => ( is => 'ro', isa => 'Maybe[Str]', required => 0, ); has 'status' => ( is => 'ro', isa => 'Str', required => 0, ); has 'mac_address' => ( is => 'ro', isa => 'Str', required => 0, ); has 'private_ip_address' => ( is => 'ro', isa => 'Str', required => 0, ); has 'group_sets' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::GroupSet]]', required => 0, ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Igor Tsigankov =head1 COPYRIGHT This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; BundleInstanceResponse.pm100644000766000024 527213260744456 23666 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::BundleInstanceResponse; $Net::Amazon::EC2::BundleInstanceResponse::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::BundleInstanceResponse =head1 DESCRIPTION A class representing a bundled instance =head1 ATTRIBUTES =over =item instance_id (required) Instance associated with this bundle task. =item bundle_id (required) Identifier for this task. =item state (required) The state of this bundling task. =item start_time (required) The time the bundle task started =item update_time (required) The time of the most recent update for the bundle. =item progress (required) A percentage description of the progress of the task, such as 94%. =item s3_bucket (required) The bucket in which to store the AMI. You can specify a bucket that you already own or a new bucket that Amazon EC2 creates on your behalf. If you specify a bucket that belongs to someone else, Amazon EC2 returns an error. =item s3_prefix (required) Specifies the beginning of the file name of the AMI. =item s3_aws_access_key_id (required) The Access Key ID of the owner of the Amazon S3 bucket. =item s3_upload_policy (required) An Amazon S3 upload policy that gives Amazon EC2 permission to upload items into Amazon S3 on the user's behalf. =item s3_policy_upload_signature (required) The signature of the Base64 encoded JSON document. =item bundle_error_code (optional) Error code for bundle failure. =item bundle_error_message (optional) Error message associated with bundle failure. =back =cut has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'bundle_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'state' => ( is => 'ro', isa => 'Str', required => 1 ); has 'start_time' => ( is => 'ro', isa => 'Str', required => 1 ); has 'update_time' => ( is => 'ro', isa => 'Str', required => 1 ); has 'progress' => ( is => 'ro', isa => 'Str', required => 1 ); has 's3_bucket' => ( is => 'ro', isa => 'Str', required => 1 ); has 's3_prefix' => ( is => 'ro', isa => 'Str', required => 1 ); has 's3_aws_access_key_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 's3_upload_policy' => ( is => 'ro', isa => 'Str', required => 1 ); has 's3_policy_upload_signature' => ( is => 'ro', isa => 'Str', required => 1 ); has 'bundle_error_code' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'bundle_error_message' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; CreateVolumePermission.pm100644000766000024 165613260744456 23717 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::CreateVolumePermission; $Net::Amazon::EC2::CreateVolumePermission::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::CreateVolumePermission =head1 DESCRIPTION A class representing the users or groups allowed to create a volume from the associated snapshot. =head1 ATTRIBUTES =over =item user_id (optional) User ID of a user that can create volumes from the snapshot. =item group (optional) Group that is allowed to create volumes from the snapshot (currently supports "all"). =cut has 'user_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'group' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; DescribeImageAttribute.pm100644000766000024 400713260744456 23613 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::DescribeImageAttribute; $Net::Amazon::EC2::DescribeImageAttribute::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::DescribeImageAttribute =head1 DESCRIPTION A class representing the attributes associated with a machine image. =head1 ATTRIBUTES =over =item image_id (required) Image ID you are describing the image attributes of. =item launch_permissions (optional) An array ref of Net::Amazon::EC2::LaunchPermission objects. =item product_codes (optional) An array ref of Net::Amazon::EC2::ProductCode objects. =item kernel (optional) ID of the kernel associated with the AMI. Returned if kernel is specified. =item ramdisk (optional) ID of the RAM disk associated with the AMI. Returned if ramdisk is specified. =item block_device_mapping (optional) An array ref of Net::Amazon::EC2::BlockDeviceMapping objects. =item platform (optional) Describes the operating system platform. =back =cut has 'image_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'launch_permissions' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::LaunchPermission]]', predicate => 'has_launch_permissions', required => 0, ); has 'product_codes' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::ProductCode]]', predicate => 'has_product_codes', required => 0, ); has 'kernel' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'ramdisk' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'blockDeviceMapping' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::BlockDeviceMapping]]', required => 0, ); has 'platform' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; DescribeImagesResponse.pm100644000766000024 1016213260744456 23650 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::DescribeImagesResponse; $Net::Amazon::EC2::DescribeImagesResponse::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::DescribeImagesResponse =head1 DESCRIPTION A class representing a machine image. =head1 ATTRIBUTES =over =item image_id (required) The image_id you you are describing the image attributes of. =item image_location (required) Path to the AMI itself =item image_state (required) Current state of the AMI. If the operation returns available, the image is successfully registered and available for launching If the operation returns deregistered, the image is deregistered and no longer available for launching. =item image_owner_id (required) AWS access key id of the owner of the image. =item is_public (required) This is true if the AMI can be launched by anyone (has public launch permissions) or false if its only able to be run by the owner of the AMI. =item product_codes (optional) An array ref of Net::Amazon::EC2::ProductCode objects (if any) associated with this AMI. =item architecture (optional) The AMI architecture (i386 or x86_64). =item image_type (optional) The type of AMI this is. Valid values are: =over =item machine =item kernel =item ramdisk =back =item kernel_id (optional) The kernel id associated with this AMI (if any). This is only defined for machine type AMIs. =item ramdisk_id (optional) The ramdisk id associated with this AMI (if any). This is only defined for machine type AMIs. =item platform (optional) The operating system of the instance. =item state_reason (optional) A Net::Amazon::EC2::StateReason object representing the stage change. =item image_owner_alias (optional) The AWS account alias (e.g., "amazon", "redhat", "self", etc.) or AWS account ID that owns the AMI. =item name (optional) The name of the AMI that was provided during image creation. =item description (optional) The description of the AMI that was provided during image creation. =item root_device_type (optional) The root device type used by the AMI. The AMI can use an Amazon EBS or instance store root device. =item root_device_name (optional) The root device name (e.g., /dev/sda1). =item block_device_mapping (optional) An array ref of Net::Amazon::EC2::BlockDeviceMapping objects. =back =cut has 'image_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'image_location' => ( is => 'ro', isa => 'Str', required => 1 ); has 'image_state' => ( is => 'ro', isa => 'Str', required => 1 ); has 'image_owner_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'is_public' => ( is => 'ro', isa => 'Str', required => 1 ); has 'product_codes' => ( is => 'rw', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::ProductCode]]', predicate => 'has_product_codes', required => 0, ); has 'architecture' => ( is => 'ro', isa => 'Str', required => 0 ); has 'image_type' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'kernel_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'ramdisk_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'platform' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'state_reason' => ( is => 'ro', isa => 'Maybe[Net::Amazon::EC2::StateReason]', required => 0 ); has 'image_owner_alias' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'name' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'description' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'root_device_type' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'root_device_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'block_device_mapping' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::BlockDeviceMapping]]', required => 0 ); has 'tag_set' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::TagSet]]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; DescribeSubnetResponse.pm100644000766000024 414713260744456 23671 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::DescribeSubnetResponse; $Net::Amazon::EC2::DescribeSubnetResponse::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::DescribeSubnetResponse =head1 DESCRIPTION A class containing information about subnets =head1 ATTRIBUTES =over =item subnet_id (required) The ID of the subnet. =item state (required) The current state of the subnet. Values: pending | available =item vpc_id (required) The ID of the VPC the subnet is in. =item cidr_block The CIDR block assigned to the subnet. =available_ip_address_count The number of unused IP addresses in the subnet. Note that the IP addresses for any stopped instances are considered unavailable. =availability_zone The Availability Zone of the subnet. =default_for_az Indicates whether this is the default subnet for the Availability Zone. =map_public_ip_on_launch Indicates whether instances launched in this subnet receive a public IP address. =tag_set Any tags assigned to the resource, each one wrapped in an item element. =back =cut has 'subnet_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'state' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'vpc_id' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'cidr_block' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'available_ip_address_count' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'availability_zone' => ( is => 'ro', isa => 'Maybe[Str]', required => 1 ); has 'default_for_az' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'map_public_ip_on_launch' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'tag_set' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::TagSet]]', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jonas Courteau =head1 COPYRIGHT Copyright (c) 2014 Jonas Courteau. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; AvailabilityZoneMessage.pm100644000766000024 125113260744456 24015 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::AvailabilityZoneMessage; $Net::Amazon::EC2::AvailabilityZoneMessage::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::AvailabilityZoneMessage =head1 DESCRIPTION A class containing messaging associated with an availability zone. =head1 ATTRIBUTES =over =item message (required) The message itself. =cut has 'message' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; ProductInstanceResponse.pm100644000766000024 171213260744456 24070 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::ProductInstanceResponse; $Net::Amazon::EC2::ProductInstanceResponse::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::ProductInstanceResponse =head1 DESCRIPTION A class representing the response from a confirm_product_instance call. =head1 ATTRIBUTES =over =item product_code (required) The product code attached to the instance. =item instance_id (required) Instance ID. =item owner_id (required) AWS Account id of the instance owner. =cut has 'product_code' => ( is => 'ro', isa => 'Str', required => 1 ); has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'owner_id' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; DescribeKeyPairsResponse.pm100644000766000024 161313260744456 24153 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::DescribeKeyPairsResponse; $Net::Amazon::EC2::DescribeKeyPairsResponse::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::DescribeKeyPairsResponse =head1 DESCRIPTION A class representing a key pair. =head1 ATTRIBUTES =over =item key_name (required) The name of the key pair. =item key_fingerprint (required) A fingerprint for the private key of the key pair. This is calculated as the SHA-1 of the DER version of the private key. =cut has 'key_name' => ( is => 'ro', isa => 'Str', required => 1 ); has 'key_fingerprint' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =back =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; ReservedInstanceOffering.pm100644000766000024 322213260744456 24166 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::ReservedInstanceOffering; $Net::Amazon::EC2::ReservedInstanceOffering::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::ReservedInstanceOffering =head1 DESCRIPTION A class representing a reserved instance offering. =head1 ATTRIBUTES =over =item reserved_instances_offering_id (required) The ID of the Reserved Instance offering. =item instance_type (required) The instance type on which the Reserved Instance can be used. =item availability_zone (required) The Availability Zone in which the Reserved Instance can be used. =item duration (required) The duration of the Reserved Instance, in seconds. =item usage_price (required) The usage price of the Reserved Instance, per hour. =item fixed_price (required) The purchase price of the Reserved Instance. =item product_description (required) The Reserved Instance description. =back =cut has 'reserved_instances_offering_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'instance_type' => ( is => 'ro', isa => 'Str', required => 1 ); has 'availability_zone' => ( is => 'ro', isa => 'Str', required => 1 ); has 'duration' => ( is => 'ro', isa => 'Str', required => 1 ); has 'usage_price' => ( is => 'ro', isa => 'Str', required => 1 ); has 'fixed_price' => ( is => 'ro', isa => 'Str', required => 1 ); has 'product_description' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; LaunchPermissionOperation.pm100644000766000024 200013260744456 24377 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::LaunchPermissionOperation; $Net::Amazon::EC2::LaunchPermissionOperation::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::LaunchPermissionOperation =head1 DESCRIPTION A class representing the operation type of the launch permission (adding or removing). =head1 ATTRIBUTES =over =item add (required if remove not defined) An Net::Amazon::EC2::LaunchPermission object to add permissions for. =item remove (required if add not defined) An Net::Amazon::EC2::LaunchPermission object to remove permissions for. =back =cut has 'add' => ( is => 'ro', isa => 'Net::Amazon::EC2::LaunchPermission', required => 0 ); has 'remove' => ( is => 'ro', isa => 'Net::Amazon::EC2::LaunchPermission', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; InstanceBlockDeviceMapping.pm100644000766000024 216713260744456 24424 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::InstanceBlockDeviceMapping; $Net::Amazon::EC2::InstanceBlockDeviceMapping::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::InstanceBlockDeviceMapping =head1 DESCRIPTION A class representing a instance block device mapping =head1 ATTRIBUTES =over =item volume_id (required) The volume id of the EBS Volume. =item status (required) The status of the attachment. =item attach_time (required) The time of attachment. =item delete_on_termination (required) A boolean indicating if the volume will be deleted on instance termination. =back =cut has 'volume_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'status' => ( is => 'ro', isa => 'Str', required => 1 ); has 'attach_time' => ( is => 'ro', isa => 'Str', required => 1 ); has 'delete_on_termination' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; EbsInstanceBlockDeviceMapping.pm100644000766000024 216313260744456 25052 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::EbsInstanceBlockDeviceMapping; $Net::Amazon::EC2::EbsInstanceBlockDeviceMapping::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::EbsInstanceBlockDeviceMapping =head1 DESCRIPTION A class representing a EBS block device mapping =head1 ATTRIBUTES =over =item attach_time (required) Time stamp when the attachment initiated. =item delete_on_termination (required) Specifies whether the Amazon EBS volume is deleted on instance termination. =item status (required) Attachment state. =item volume_id (required) The EBS volume id. =back =cut has 'attach_time' => ( is => 'ro', isa => 'Str', required => 1 ); has 'delete_on_termination' => ( is => 'ro', isa => 'Str', required => 1 ); has 'status' => ( is => 'ro', isa => 'Str', required => 1 ); has 'volume_id' => ( is => 'ro', isa => 'Str', required => 1 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; ConfirmProductInstanceResponse.pm100644000766000024 174413260744456 25413 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::ConfirmProductInstanceResponse; $Net::Amazon::EC2::ConfirmProductInstanceResponse::VERSION = '0.36'; use strict; use Moose; =head1 NAME Net::Amazon::EC2::ConfirmProductInstanceResponse =head1 DESCRIPTION A class representing the response from a request to attach a product code to a running instance =head1 ATTRIBUTES =over =item return (required) true if the product code is attached to the instance, false if it is not. =item owner_id (optional) The instance owner's account ID. Only present if the product code is sucessfully attached to the instance. =back =cut has 'return' => ( is => 'ro', isa => 'Str', required => 1 ); has 'owner_id' => ( is => 'ro', isa => 'Str', required => 0 ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1; DescribeInstanceAttributeResponse.pm100644000766000024 520213260744456 26052 0ustar00mallenstaff000000000000Net-Amazon-EC2-0.36/lib/Net/Amazon/EC2package Net::Amazon::EC2::DescribeInstanceAttributeResponse; $Net::Amazon::EC2::DescribeInstanceAttributeResponse::VERSION = '0.36'; use Moose; =head1 NAME Net::Amazon::EC2::DescribeInstanceAttributeResponse =head1 DESCRIPTION A class representing an instance attribute. =head1 ATTRIBUTES =over =item instance_id (required) The instance id you you are describing the attributes of. =item block_device_mapping (optional) Specifies how block devices are exposed to the instance. Each mapping is made up of a virtual_name and a device_name. This should be a Net::Amazon::EC2::BlockDeviceMapping object. =item disable_api_termination (optional) Specifies whether the instance can be terminated. You must modify this attribute before you can terminate any "locked" instances. =item ebsOptimized (optional) Specifies whether the instance is optimized for EBS. =item instance_initiated_shutdown_behavior (optional) Specifies whether the instance's Amazon EBS volumes are deleted when the instance is shut down. =item instance_type (optional) The instance type (e.g., m1.small, t2.medium, m3.xlarge, and so on). =item kernel (optional) The kernel ID. =item ramdisk (optional) The RAM disk ID. =item root_device_name (optional) The root device name (e.g., /dev/sda1). =item source_dest_check (optional) Source and destination checking for incoming traffic =item user_data (optional) MIME, Base64-encoded user data. =back =cut has 'instance_id' => ( is => 'ro', isa => 'Str', required => 1 ); has 'disable_api_termination' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'ebs_optimized' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'instance_initiated_shutdown_behavior' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'instance_type' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'kernel' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'ramdisk' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'root_device_name' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'source_dest_check' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'user_data' => ( is => 'ro', isa => 'Maybe[Str]', required => 0 ); has 'block_device_mapping' => ( is => 'ro', isa => 'Maybe[ArrayRef[Net::Amazon::EC2::BlockDeviceMapping]]', required => 0, ); __PACKAGE__->meta->make_immutable(); =head1 AUTHOR Jeff Kim =head1 COPYRIGHT Copyright (c) 2006-2010 Jeff Kim. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut no Moose; 1;