How to use the boto.ec2 function in boto

def __init__(self, *args, **kwargs):
        super(EBSDriver, self).__init__(*args, **kwargs)
        self.VERSION = '1.0.0'
        self._wait_time_sec = 60 * (CONF.AWS.wait_time_min)

        self._check_config()
        region_name = CONF.AWS.region_name
        endpoint = '.'.join(['ec2', region_name, 'amazonaws.com'])
        region = RegionInfo(name=region_name, endpoint=endpoint)
        self._conn = ec2.EC2Connection(aws_access_key_id=CONF.AWS.access_key,
                                       aws_secret_access_key=CONF.AWS.secret_key,
                                       region=region)
        # resort to first AZ for now. TODO: expose this through API
        az = CONF.AWS.az
        self._zone = filter(lambda z: z.name == az,
                            self._conn.get_all_zones())[0]
        self.set_initialized()

def get_autoscaling_members(self):
        me = self.get_my_instace()

        conn = boto.ec2.connect_to_region(self.region)
        res = conn.get_all_reservations(filters={'tag:{}'.format(EtcdMember.AG_TAG): me.autoscaling_group})

        return [i for r in res for i in r.instances if i.state != 'terminated' and i.tags.get(EtcdMember.AG_TAG, '')
                == me.autoscaling_group]

#logging.info("CACHE SUMMARY: instance running :"+str(numRunning))
        summary['keypair'] = -1 if session.clc.caches['keypairs'].isCacheStale() else len(
            session.clc.caches['keypairs'].values)
        summary['sgroup'] = -1 if session.clc.caches['sgroups'].isCacheStale() else len(
            session.clc.caches['sgroups'].values)
        summary['volume'] = -1 if session.clc.caches['volumes'].isCacheStale() else len(
            session.clc.caches['volumes'].values)
        summary['snapshot'] = -1 if session.clc.caches['snapshots'].isCacheStale() else len(
            session.clc.caches['snapshots'].values)
        summary['addresses'] = -1 if session.clc.caches['addresses'].isCacheStale() else len(
            session.clc.caches['addresses'].values)
        if session.scaling != None:
            scaling = 0;
            if not (session.clc.caches['instances'].isCacheStale()):
                for inst in session.scaling.caches['scalinginsts'].values:
                    if isinstance(inst, boto.ec2.autoscale.instance.Instance):
                        if zone == 'all' or inst.availability_zone == zone:
                            scaling += 1
                    else:
                        if zone == 'all' or inst['availability_zone'] == zone:
                            scaling += 1
            else:
                scaling = -1
            summary['scalinginsts'] = scaling
        return summary

def create(self):
        conn = ec2.connect_to_region(
            self.region,
            aws_access_key_id=self.access_key,
            aws_secret_access_key=self.secret_key
        )

        try:
            keypair = conn.create_key_pair(self.key_name)
        except EC2ResponseError as e:
            if e.error_code == 'InvalidKeyPair.Duplicate':
                conn.delete_key_pair(key_name=self.key_name)
                keypair = conn.create_key_pair(self.key_name)
            else:
                raise e

        keypair.save(self.user_path)

def connect(region, aws_key, aws_secret_key):
    # Use AWS keys from config
    conn = boto.ec2.connect_to_region(region,
            aws_access_key_id=aws_key,
            aws_secret_access_key=aws_secret_key)
    return conn

#! /usr/bin/python

import os
from boto import ec2
from boto.manage.cmdshell import sshclient_from_instance
import paramiko
from datetime import datetime


if __name__ == '__main__':

	# create a security group fo this cluster only.  Just create it now so that it can be associated with the new
	# instance at create time.  Add rules to this group once the instance IP addresses are known.

	ec2conn = ec2.connection.EC2Connection( os.environ["AWS_ACCESS_KEY_ID"], os.environ["AWS_SECRET_ACCESS_KEY"] )

	group_name = "BDHA " + str( datetime.utcnow() )

	group = ec2conn.create_security_group( group_name, "BigdataHA Security Group" )
 
	envFile = open( ".aws_security_group", "w" ) 
	envFile.write( 'export AWS_SECURITY_GROUP_PRIVATE="' + group_name + '"')

def todict(obj, classkey=None):
    if isinstance(obj, dict):
        data = {}
        for (k, v) in obj.items():
            data[k] = todict(v, classkey)
        return data
    elif hasattr(obj, "_ast"):
        return todict(obj._ast())
    elif hasattr(obj, "__iter__"):
        return [todict(v, classkey) for v in obj]
    elif hasattr(obj, "__dict__"):
        # This Class causes a recursive loop and at this time is not worth
        # debugging. If it's useful later I'll look into it.
        if not isinstance(obj, boto.ec2.blockdevicemapping.BlockDeviceType):
            data = dict([(key, todict(value, classkey))
                for key, value in obj.__dict__.iteritems()
                if not callable(value) and not key.startswith('_')])
            if classkey is not None and hasattr(obj, "__class__"):
                data[classkey] = obj.__class__.__name__
            return data
    else:
        return obj

try:
                    sn = self.vpc_conn.get_all_subnets(subnet_id)[0]
                    vpc_id = sn.vpc_id
                except (EC2ResponseError, IndexError):
                    bioblend.log.exception("Trouble fetching subnet %s", subnet_id)
            cmsg = self.create_cm_security_group(sg, vpc_id=vpc_id)
            ret['error'] = cmsg['error']
            if ret['error']:
                return ret
            if cmsg['name']:
                ret['sg_names'].append(cmsg['name'])
                ret['sg_ids'].append(cmsg['sg_id'])
                if subnet_id:
                    # Must setup a network interface if launching into VPC
                    security_groups = None
                    interface = boto.ec2.networkinterface.NetworkInterfaceSpecification(
                        subnet_id=subnet_id, groups=[cmsg['sg_id']],
                        associate_public_ip_address=True)
                    network_interfaces = (boto.ec2.networkinterface.
                                          NetworkInterfaceCollection(interface))
                else:
                    network_interfaces = None
        kp_info = self.create_key_pair(key_name)
        ret['kp_name'] = kp_info['name']
        ret['kp_material'] = kp_info['material']
        ret['error'] = kp_info['error']
        if ret['error']:
            return ret
        # If not provided, try to find a placement
        # TODO: Should placement always be checked? To make sure it's correct
        # for existing clusters.
        if not placement:

def run(self, terms, variables=None, **kwargs):
        if isinstance(terms, basestring):
            terms = [terms]
        region = terms[0]
        group_names = terms[1]
        conn = boto.ec2.connect_to_region(region)
        filters = {'group_name': group_names}
        sg = conn.get_all_security_groups(filters=filters)
        sg_list = [x.id.encode('utf-8') for x in sg]
        return sg_list

vpc_zone_identifier = module.params.get('vpc_zone_identifier')
    set_tags = module.params.get('tags')
    health_check_period = module.params.get('health_check_period')
    health_check_type = module.params.get('health_check_type')
    default_cooldown = module.params.get('default_cooldown')
    wait_for_instances = module.params.get('wait_for_instances')
    as_groups = connection.get_all_groups(names=[group_name])
    wait_timeout = module.params.get('wait_timeout')
    termination_policies = module.params.get('termination_policies')
    notification_topic = module.params.get('notification_topic')
    notification_types = module.params.get('notification_types')

    if not vpc_zone_identifier and not availability_zones:
        region, ec2_url, aws_connect_params = get_aws_connection_info(module)
        try:
            ec2_connection = connect_to_aws(boto.ec2, region, **aws_connect_params)
        except (boto.exception.NoAuthHandlerFound, AnsibleAWSError) as e:
            module.fail_json(msg=str(e))
    elif vpc_zone_identifier:
        vpc_zone_identifier = ','.join(vpc_zone_identifier)

    asg_tags = []
    for tag in set_tags:
        for k,v in tag.iteritems():
            if k !='propagate_at_launch':
                asg_tags.append(Tag(key=k,
                     value=v,
                     propagate_at_launch=bool(tag.get('propagate_at_launch', True)),
                     resource_id=group_name))

    if not as_groups:
        if not vpc_zone_identifier and not availability_zones: