def change_ip(instance_id):
    latest_ip = get_latest_ip(instance_id)
    if not latest_ip:
        raise RuntimeError('Invalid ec2 instance_id')
    allocation_id = get_allocation_id(latest_ip)
    new_ip = str(ec2.allocate_address()).split(':', 1)[-1]
    ec2.associate_address(instance_id, new_ip)
    ec2.release_address(allocation_id=allocation_id)
Example #2
0
def allocate_address(ec2, domain, reuse_existing_ip_allowed):
    """ Allocate a new elastic IP address (when needed) and return it """
    if reuse_existing_ip_allowed:
        domain_filter = {"domain": domain or "standard"}
        all_addresses = ec2.get_all_addresses(filters=domain_filter)

        unassociated_addresses = [a for a in all_addresses if not a.device_id]
        if unassociated_addresses:
            return unassociated_addresses[0]

    return ec2.allocate_address(domain=domain)
def allocate_address(ec2, domain, reuse_existing_ip_allowed):
    """ Allocate a new elastic IP address (when needed) and return it """
    if reuse_existing_ip_allowed:
        domain_filter = {'domain': domain or 'standard'}
        all_addresses = ec2.get_all_addresses(filters=domain_filter)

        unassociated_addresses = [a for a in all_addresses if not a.device_id]
        if unassociated_addresses:
            return unassociated_addresses[0]

    return ec2.allocate_address(domain=domain)
	def set_allocate_address(self, instance):

		region = str(instance.region).split(":")
		ec2 = boto.ec2.connect_to_region(region[1])
		
		# Allocate an Elastic IP Address. This will be associated with your
		# account until you explicitly release it.
		address = ec2.allocate_address()
		
		# Associate our new Elastic IP Address with our instance.
		instance.use_ip(address)
Example #5
0
def allocate_address(ec2, domain, module, reuse_existing_ip_allowed):
    """ Allocate a new elastic IP address (when needed) and return it """
    # If we're in check mode, nothing else to do
    if module.check_mode:
        module.exit_json(change=True)

    if reuse_existing_ip_allowed:
      if domain:
        domain_filter = { 'domain' : domain }
      else:
        domain_filter = { 'domain' : 'standard' }
      all_addresses = ec2.get_all_addresses(filters=domain_filter)

      unassociated_addresses = filter(lambda a: not a.instance_id, all_addresses)
      if unassociated_addresses:
        address = unassociated_addresses[0];
      else:
        address = ec2.allocate_address(domain=domain)
    else:
      address = ec2.allocate_address(domain=domain)

    return address
Example #6
0
def allocate_address(ec2, domain, module, reuse_existing_ip_allowed):
    """ Allocate a new elastic IP address (when needed) and return it """
    # If we're in check mode, nothing else to do
    if module.check_mode:
        module.exit_json(change=True)

    if reuse_existing_ip_allowed:
      if domain:
        domain_filter = { 'domain' : domain }
      else:
        domain_filter = { 'domain' : 'standard' }
      all_addresses = ec2.get_all_addresses(filters=domain_filter)

      unassociated_addresses = filter(lambda a: not a.instance_id, all_addresses)
      if unassociated_addresses:
        address = unassociated_addresses[0];
      else:
        address = ec2.allocate_address(domain=domain)
    else:
      address = ec2.allocate_address(domain=domain)

    return address
Example #7
0
def get_limit(ec2, domain):
    limit = 0
    temp_ips = []
    try:
        while True:
            temp_ips.append(ec2.allocate_address(domain))
            limit += 1 
    except:
        if not limit:
            print("Unable to allocate any IP addresses. Check your IAM credentials.")
    finally:
        for ip in temp_ips:
            ip.release()
        return limit
Example #8
0
def allocate_address(ec2, domain, reuse_existing_ip_allowed):
    """ Allocate a new elastic IP address (when needed) and return it """
    if reuse_existing_ip_allowed:
        domain_filter = {'domain': domain or 'standard'}
        all_addresses = ec2.get_all_addresses(filters=domain_filter)

        if domain == 'vpc':
            unassociated_addresses = [a for a in all_addresses
                                      if not a.association_id]
        else:
            unassociated_addresses = [a for a in all_addresses
                                      if not a.instance_id]
        if unassociated_addresses:
            return unassociated_addresses[0]

    return ec2.allocate_address(domain=domain)
Example #9
0
def allocate(ec2, domain, number, tolerance):
    eips = []
    subnets = Counter()
    for x in range(number + tolerance):
        if is_vpc:
            ip = ec2.allocate_address(domain)
            eips.append(ip)
            subnets[ip.public_ip.split(".")[2]] += 1

    retry = False

    if subnets.most_common(1)[0][1] < number:
        retry = True
        for ip in eips:
            ip.release()

    return retry, subnets.most_common(1)[0][1]
Example #10
0
def allocate_address(ec2, domain, reuse_existing_ip_allowed):
    """ Allocate a new elastic IP address (when needed) and return it """
    if reuse_existing_ip_allowed:
        domain_filter = {'domain': domain or 'standard'}
        all_addresses = ec2.get_all_addresses(filters=domain_filter)

        if domain == 'vpc':
            unassociated_addresses = [
                a for a in all_addresses if not a.association_id
            ]
        else:
            unassociated_addresses = [
                a for a in all_addresses if not a.instance_id
            ]
        if unassociated_addresses:
            return unassociated_addresses[0], False

    return ec2.allocate_address(domain=domain), True
Example #11
0
inst = reservation.instances[0]
inst.add_tag("Name", "NAT Instance by Python")
print "Tagged the instance!"

while inst.state == 'pending':
    time.sleep(5)
    inst.update()

#Change the attribute for NAT'ing
ec2.modify_instance_attribute(inst.id,
                              attribute='sourceDestCheck',
                              value=False)
print "Attribute changed!"

#Assign elastic IP 54.173.234.49 to the NAT Instance
eip = ec2.allocate_address(None, False)
eip.associate(inst.id, None, None, False, False)

#========================================================================

#========================================================================
# Create the Private Instance
ec2 = boto.ec2.connect_to_region('us-east-1')
reservation = ec2.run_instances('ami-b66ed3de',
                                key_name='east_keypair',
                                instance_type='t2.micro',
                                security_group_ids=[sg_private.id],
                                subnet_id=prvsub.id)

inst = reservation.instances[0]
inst.add_tag("Name", "Private Instance by Python")
def allocate_ip():
    ec2 = boto.ec2.connect_to_region(region)
    address = ec2.allocate_address(domain="vpc", dry_run=False)
    return address.public_ip, address.allocation_id
Example #13
0
inst = reservation.instances[0]
inst.add_tag("Name","NAT Instance by Python")
print "Tagged the instance!"


while inst.state == 'pending':
	time.sleep(5)
	inst.update()

#Change the attribute for NAT'ing
ec2.modify_instance_attribute(inst.id, attribute='sourceDestCheck', value=False)
print "Attribute changed!"

#Assign elastic IP 54.173.234.49 to the NAT Instance
eip = ec2.allocate_address(None, False)
eip.associate(inst.id,None, None,False,False)


#========================================================================

#========================================================================
# Create the Private Instance
ec2 = boto.ec2.connect_to_region('us-east-1')
reservation = ec2.run_instances(
        'ami-b66ed3de',
        key_name='east_keypair',
        instance_type='t2.micro',
        security_group_ids=[sg_private.id],
        subnet_id=prvsub.id)
def allocate_ip():
    ec2 = boto.ec2.connect_to_region(region)
    address = ec2.allocate_address(domain='vpc', dry_run=False)
    return address.public_ip, address.allocation_id
            group.authorize(ip_protocol='tcp',from_port=80, to_port=80, cidr_ip='0.0.0.0/0')
    except ec2.ResponseError, e:
            if e.code == 'InvalidPermission.Duplicate':
                print e.code
            else:
                raise


    #Start a new instance
    reservation_object=ec2.run_instances(image_id='ami-cd5311fd',key_name=key_name,security_groups=[group_name],instance_type='t1.micro')
    instance = reservation_object.instances[0]

    while(instance.state != 'running'):
        instance.update()

    static_address = ec2.allocate_address()
    static_address.associate(instance.id)
    print 'Instance successfully launched'

    reservations = ec2.get_all_instances(instance_ids=[instance.id])
    instance2 = reservations[0].instances[0]

    #Install packages
    for command in install_commands:
        os.system('ssh -o StrictHostKeyChecking=no -i '+path+ key_name+'.pem ubuntu@'+static_address.public_ip+' '+command)

    #Transfer files
    os.system('zip -r csc326 csc326/*')
    os.system('scp -o StrictHostKeyChecking=no -i '+path+ key_name+'.pem '+file_name+' ubuntu@'+static_address.public_ip+':~/'+remote_path)

    #Launch engine