Ejemplo n.º 1
0
    def __init__(self, extra_args=None):
        self.setuptestcase()
        self.setup_parser()
        if extra_args:
            for arg in extra_args:
                self.parser.add_argument(arg)
        self.get_args()
        # Setup basic eutester object
        if self.args.emi:
            self.tester = Eucaops(credpath=self.args.credpath,
                                  region=self.args.region)
        else:
            self.tester = Eucaops(credpath=self.args.credpath)

    ### Add and authorize a group for the instance
        self.group = self.tester.add_group(group_name="group-" +
                                           str(time.time()))
        self.tester.authorize_group_by_name(group_name=self.group.name)
        self.tester.authorize_group_by_name(group_name=self.group.name,
                                            port=-1,
                                            protocol="icmp")
        ### Generate a keypair for the instance
        self.keypair = self.tester.add_keypair("keypair-" + str(time.time()))
        self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)

        self.image = self.args.emi
        if not self.image:
            self.image = self.tester.get_emi(root_device_type="instance-store")
        self.address = None
Ejemplo n.º 2
0
    def __init__(self):
        #### Pre-conditions
        self.setuptestcase()
        self.setup_parser()
        self.parser.add_argument("--test-zone", default="PARTI00")
        self.parser.add_argument("--test-emi", default=None)
        self.parser.add_argument("--build-number", default='')
        self.get_args()

        # Setup basic eutester object
        if not self.args.credpath:
            self.tester = Eucaops(config_file=self.args.config,
                                  password=self.args.password)
        else:
            self.tester = Eucaops(credpath=self.args.credpath)
        self.reservation = None

        ### Generate a group for the instance
        self.group = self.tester.add_group(
            group_name="inst-kvm-grp-" + str(time.time()).replace(".", "") +
            self.tester.id_generator() + "-" + self.args.build_number)
        self.tester.authorize_group_by_name(group_name=self.group.name)
        self.tester.authorize_group_by_name(group_name=self.group.name,
                                            port=-1,
                                            protocol="icmp")

        self.keypair = self.tester.add_keypair(
            "inst-kvm-" + str(time.time()).replace(".", "") +
            self.tester.id_generator() + "-" + self.args.build_number)

        if not self.args.emi:
            self.image = self.tester.get_emi(root_device_type="instance-store")
        else:
            self.image = self.tester.get_emi(self.args.test_emi)
Ejemplo n.º 3
0
    def __init__(self):
        self.setuptestcase()
        self.setup_parser()
        self.parser.add_argument("-b", "--buckets", type=int, default=5)
        self.parser.add_argument("-o", "--objects", type=int, default=5)
        self.parser.add_argument("-T", "--threads", type=int, default=5)
        self.parser.add_argument("-S", "--object-size", type=int, default=64, help="Object size in KB")
        self.parser.add_argument("-M", "--mpu-threshold", type=int, default=5120,
                                 help="Multipart upload is used when the object size is bigger than the mpu-threshold "
                                      "value in Kilobyte. Any value less than 5120KB will result single file upload. "
                                      "Default value is used when not passed as an argument.")
        self.get_args()
        # Setup basic eutester object
        if self.args.region:
            self.tester = S3ops( credpath=self.args.credpath, region=self.args.region)
        else:
            self.tester = Eucaops(credpath=self.args.credpath, config_file=self.args.config,password=self.args.password)
        self.start = time.time()

        self.bucket_names = []
        self.bucket_name = "concurrency-" + str(int(self.start)) + "-"

        for i in xrange(self.args.buckets):
            bucket_name = self.bucket_name + str(i)
            self.bucket_names.append(bucket_name)
            self.tester.create_bucket(bucket_name)

        self.temp_files = []
Ejemplo n.º 4
0
 def __init__(self, extra_args=None):
     self.setuptestcase()
     self.setup_parser()
     self.parser.add_argument("--euca-url", )
     self.parser.add_argument("--enterprise-url")
     self.parser.add_argument("--branch")
     self.parser.add_argument("--nogpg", action='store_true')
     self.parser.add_argument("--nightly", action='store_true')
     if extra_args:
         for arg in extra_args:
             self.parser.add_argument(arg)
     self.get_args()
     # Setup basic eutester object
     self.tester = Eucaops(config_file=self.args.config_file,
                           password=self.args.password)
     self.clc_service = self.tester.service_manager.get("eucalyptus")[0]
     self.zones = self.tester.get_zones()
     if not self.args.branch and not self.args.euca_url and not self.args.enterprise_url:
         self.args.branch = self.args.upgrade_to_branch
     machine = self.tester.get_component_machines("clc")[0]
     self.old_version = machine.sys(
         "cat /etc/eucalyptus/eucalyptus-version")[0]
     ### IF we were passed a branch, fetch the correct repo urls from the repo API
     if self.args.branch:
         self.args.euca_url = self.get_repo_url("eucalyptus",
                                                self.args.branch)
         self.args.enterprise_url = self.get_repo_url(
             "internal", self.args.branch)
Ejemplo n.º 5
0
 def setUp(self):
     self.conf = "cloud.conf"
     self.cond = 1
     self.tester = Eucaops(config_file=self.conf, password="******")
     self.doAuth()
     self.clc1 = self.tester.service_manager.get_enabled_clc()
     self.IP = self.tester.get_ec2_ip()
Ejemplo n.º 6
0
 def __init__(self,
              tester=None,
              config_file='../input/2b_tested.lst',
              password="******",
              url=None,
              list=None,
              volumes=None,
              keypair=None,
              group=None,
              image=None,
              zone='PARTI00',
              eof=1):
     if tester is None:
         self.tester = Eucaops(config_file=config_file, password=password)
         self.tester.exit_on_fail = eof
     else:
         self.tester = tester
         self.tester.exit_on_fail = eof
     self.zone = zone
     self.url = url
     self.url_export_string = str(" ")
     if self.url is not None:
         self.url_export_string = "export EUSTORE_URL=" + str(
             self.url) + " &> /dev/null &&"
     if list is None:
         self.list = self.get_eustore_images()
     else:
         self.list = list
     self.group = self.get_a_group()
     self.keypair = self.get_a_key()
     self.sync_installed_list()
Ejemplo n.º 7
0
    def __init__(self):
        #### Pre-conditions
        self.setuptestcase()
        self.setup_parser()
        self.get_args()
        # Setup basic eutester object
        self.tester = Eucaops(credpath=self.args.credpath)
        self.tester.poll_count = 120

        ### Add and authorize a group for the instance
        self.group = self.tester.add_group(group_name="group-" +
                                           str(time.time()))
        self.tester.authorize_group_by_name(group_name=self.group.name)
        self.tester.authorize_group_by_name(group_name=self.group.name,
                                            port=-1,
                                            protocol="icmp")

        ### Generate a keypair for the instance
        self.keypair = self.tester.add_keypair("keypair-" + str(time.time()))
        self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)

        ### Get an image
        self.image = self.args.emi
        if not self.image:
            self.image = self.tester.get_emi(root_device_type="instance-store")
        self.reservation = None
Ejemplo n.º 8
0
 def __init__(self, download_creds=False, extra_args= None):
     self.setuptestcase()
     self.setup_parser()
     self.parser.add_argument("--euca-url",)
     self.parser.add_argument("--enterprise-url")
     self.parser.add_argument("--branch")
     self.parser.add_argument("--nogpg",action='store_true')
     self.parser.add_argument("--nightly",action='store_true')
     self.parser.add_argument("--lvm-extents")
     self.parser.add_argument("--vnet-mode", default="MANAGED-NOVLAN")
     self.parser.add_argument("--vnet-subnet", default="1.0.0.0")
     self.parser.add_argument("--vnet-netmask", default="255.255.0.0")
     self.parser.add_argument("--vnet-publicips")
     self.parser.add_argument("--vnet-privateips")
     self.parser.add_argument("--vnet_addrspernet", default="32")
     self.parser.add_argument("--vnet_privinterface", default="br0")
     self.parser.add_argument("--vnet_pubinterface", default="br0")
     self.parser.add_argument("--vnet_bridge", default="br0")
     self.parser.add_argument("--vnet-dns", default="8.8.8.8")
     self.parser.add_argument("--root-lv", default="/dev/vg01/")
     self.parser.add_argument("--dnsdomain")
     self.parser.add_argument("--block-device-manager", default="das")
     if extra_args:
         for arg in extra_args:
             self.parser.add_argument(arg)
     self.get_args()
     # Setup basic eutester object
     self.tester = Eucaops( config_file=self.args.config_file, password=self.args.password, download_creds=download_creds)
Ejemplo n.º 9
0
 def __init__(self, 
              name=None,
              args=None,
              tester=None, 
              zone=None, 
              config_file='../input/2b_tested.lst', 
              password="******", 
              inst_pass=None,
              credpath=None, 
              volumes=None, 
              keypair=None, 
              group=None, 
              emi=None,
              root_device_type='instance-store',
              vmtype='c1.medium',
              eof=1):
     
     self.args = args
     self.setuptestcase(name)
     if tester is None:
         self.tester = Eucaops( config_file=config_file,password=password,credpath=credpath)
     else:
         self.tester = tester
     self.tester.exit_on_fail = eof
 
     self.testlist =[]
     self.inst_pass=inst_pass
     if emi:
         self.image = self.tester.get_emi(emi=emi)
     else:
         self.image = self.tester.get_emi(root_device_type=root_device_type, not_location='windows')
     
     self.vmtype = vmtype
     self.zone = None    
     self.zonelist = []
         
     #create some zone objects and append them to the zonelist
     if self.zone:
         self.zone = TestZone(zone)
         self.zonelist.append(self.zone)
     else: 
         self.setup_testzones()
 
     #If the list of volumes passed in looks good, sort them into the zones
     if self.volumes_list_check(volumes):
         self.sort_volumes(volumes)
         
     #Setup our security group for later use
     if (group is not None):
         self.group = group
     else:
         group_name='EbsTestGroup'
         
         try:
             self.group = self.tester.add_group(group_name,fail_if_exists=False)
             self.tester.authorize_group_by_name(self.group.name)
             self.tester.authorize_group_by_name(self.group.name,protocol="icmp",port=-1)
         except Exception, e:  
             self.debug(self.tester.get_traceback())  
             raise Exception("Error when setting up group:"+str(group_name)+", Error:"+str(e))   
 def __init__(self, extra_args=None):
     self.setuptestcase()
     self.setup_parser()
     self.parser.add_argument('--template_urls',
                              dest='template_urls',
                              help='comma separated list of template_urls',
                              default=None)
     self.parser.add_argument(
         '--timeout',
         dest='timeout',
         help='number of seconds to wait for stacks to complete',
         default=300)
     if extra_args:
         for arg in extra_args:
             self.parser.add_argument(arg)
     self.get_args()
     self.show_args()
     self.template_urls = self.args.template_urls.split(',')
     self.timeout = int(self.args.timeout)
     # Setup basic eutester object
     if self.args.region:
         self.tester = CFNops(credpath=self.args.credpath,
                              region=self.args.region)
     else:
         self.tester = Eucaops(credpath=self.args.credpath,
                               config_file=self.args.config,
                               password=self.args.password)
     # Generate a keypair for the instance
     self.keypair = self.tester.add_keypair("keypair-" + str(time.time()))
     self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)
     self.stacks = []
Ejemplo n.º 11
0
    def __init__(self):
        self.setuptestcase()
        self.setup_parser()
        self.get_args()
        # Setup basic eutester object
        self.tester = Eucaops(config_file=self.args.config_file,
                              password=self.args.password)
        self.tester.poll_count = 120

        ### Add and authorize a group for the instance
        self.group = self.tester.add_group(group_name="group-" +
                                           str(time.time()))
        self.tester.authorize_group_by_name(group_name=self.group.name)
        self.tester.authorize_group_by_name(group_name=self.group.name,
                                            port=-1,
                                            protocol="icmp")
        ### Generate a keypair for the instance
        self.keypair = self.tester.add_keypair("keypair-" + str(time.time()))
        self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)
        self.image = self.tester.get_emi(root_device_type="instance-store")
        self.reservation = None
        self.private_addressing = False
        zones = self.tester.ec2.get_all_zones()
        self.zone = random.choice(zones).name
        clcs = self.tester.get_component_machines("clc")
        if len(clcs) is 0:
            raise Exception("No CLC found")
        else:
            self.clc = clcs[0]
        self.cur_time = str(int(time.time()))
        self.ncs = self.tester.get_component_machines("nc")
Ejemplo n.º 12
0
 def setUp(self):
     self.conf = "cloud.conf"
     self.fakeId = "OOO000000000"
     self.cmdMod = " euca-modify-image-attribute --launch-permission "
     self.tester = Eucaops(config_file=self.conf, password="******")
     self.source = "source " + self.tester.credpath + "/eucarc && "
     self.doAuth()
Ejemplo n.º 13
0
 def get_creds():
     try:
         self.tester = Eucaops(config_file=self.args.config_file, password=self.args.password,download_creds=False)
         self.tester.get_credentials()
         return True
     except Exception:
         return False
Ejemplo n.º 14
0
    def __init__(self):
        self.setuptestcase()
        self.setup_parser()
        self.parser.add_argument("--endpoint", default=None)
        self.get_args()
        # Setup basic eutester object
        if self.args.endpoint:
            self.tester = S3ops(credpath=self.args.credpath,
                                endpoint=self.args.endpoint)
        else:
            self.tester = Eucaops(credpath=self.args.credpath,
                                  config_file=self.args.config,
                                  password=self.args.password)

        self.bucket_prefix = "eutester-" + str(int(time.time())) + "-"
        self.buckets_used = set()
        random.seed(time.time())
        self.test_bucket_name = self.bucket_prefix + str(random.randint(
            0, 100))
        self.test_bucket = self.tester.create_bucket(self.test_bucket_name)
        self.buckets_used.add(self.test_bucket_name)

        #Create some test data for the objects
        def ensure_bucket_exists():
            try:
                self.tester.s3.get_bucket(self.test_bucket_name)
                return True
            except Exception:
                return False

        self.tester.wait_for_result(ensure_bucket_exists, True)
        self.test_object_data = ""
        for i in range(0, self.data_size):
            self.test_object_data += chr(random.randint(32, 126))
        print "Generated data for objects: " + self.test_object_data
Ejemplo n.º 15
0
 def setUp(self):
     self.conf = "cloud.conf"
     self.cond = 0
     self.tester = Eucaops(config_file=self.conf, password="******")
     self.doAuth()
     self.sbin = self.tester.eucapath + "/usr/sbin/"
     self.source = "source " + self.tester.credpath + "/eucarc && "
Ejemplo n.º 16
0
 def __init__(self, extra_args=None):
     self.setuptestcase()
     self.setup_parser()
     self.parser.add_argument('-c', '--command', help='Command to monitor')
     self.parser.add_argument('-n',
                              '--namespace',
                              help='Namespace to put data under')
     self.parser.add_argument('-m',
                              '--metric-name',
                              help='Metric name to put data under')
     self.parser.add_argument('-u',
                              '--unit',
                              default=None,
                              help="Unit that the value be returned with")
     self.parser.add_argument(
         '-i',
         '--interval',
         default=10,
         type=int,
         help='Time between exectutions of the monitoring task')
     if extra_args:
         for arg in extra_args:
             self.parser.add_argument(arg)
     self.get_args()
     # Setup basic eutester object
     if self.args.region:
         self.tester = EC2ops(credpath=self.args.credpath,
                              region=self.args.region)
     else:
         self.tester = Eucaops(credpath=self.args.credpath,
                               config_file=self.args.config,
                               password=self.args.password)
Ejemplo n.º 17
0
 def set_block_storage_manager(self):
     if not hasattr(self.tester, 'service_manager'):
         self.tester = Eucaops(config_file=self.args.config_file,
                               password=self.args.password)
     enabled_clc = self.tester.service_manager.get_enabled_clc()
     self.zones = self.tester.get_zones()
     for zone in self.zones:
         ebs_manager = "overlay"
         if hasattr(self.args, 'ebs_storage_manager'):
             if re.search("DASManager", self.args.ebs_storage_manager):
                 ebs_manager = "das"
             if re.search("SANManager", self.args.ebs_storage_manager):
                 if hasattr(self.args, 'san_provider'):
                     if re.search("EquallogicProvider",
                                  self.args.san_provider):
                         ebs_manager = "equallogic"
                     if re.search("NetappProvider", self.args.san_provider):
                         ebs_manager = "netapp"
                     if re.search("EmcVnxProvider", self.args.san_provider):
                         ebs_manager = "emc-fastsnap"
         else:
             ebs_manager = self.args.block_device_manager
         self.tester.modify_property(zone + ".storage.blockstoragemanager",
                                     ebs_manager)
         self.tester.modify_property(zone + ".storage.dasdevice",
                                     self.args.root_lv)
Ejemplo n.º 18
0
def init_callback():
    tester = Eucaops(credpath=CREDPATH)
    global PLUGINS
    PLUGINS = ExtensionManager(namespace=NAMESPACE,
                               invoke_on_load=True,
                               invoke_args=(tester, ))
    PLUGINS.propagate_map_exceptions = True
Ejemplo n.º 19
0
    def __init__(self, extra_args=None):
        self.setuptestcase()
        self.setup_parser()
        if extra_args:
            for arg in extra_args:
                self.parser.add_argument(arg)
        self.get_args()

        # Setup basic eutester object
        if self.args.region:
            self.tester = ELBops(credpath=self.args.credpath,
                                 region=self.args.region)
        else:
            self.tester = Eucaops(credpath=self.args.credpath,
                                  config_file=self.args.config,
                                  password=self.args.password)
        self.tester.poll_count = 120

        ### Populate available zones
        zones = self.tester.ec2.get_all_zones()
        self.zone = random.choice(zones).name
        self.load_balancer_port = 80
        self.lb_name = "test-" + str(int(time.time()))
        self.load_balancer = self.tester.create_load_balancer(
            zones=[self.zone],
            name=self.lb_name,
            load_balancer_port=self.load_balancer_port)
        assert isinstance(self.load_balancer, LoadBalancer)
Ejemplo n.º 20
0
    def CreateResources(self):
        users = self.tester.get_all_users()
        testers = []
        for user in users:
            keys = self.tester.create_access_key(
                user_name=user['user_name'],
                delegate_account=user['account_name'])
            testers.append(
                Eucaops(aws_access_key_id=keys['access_key_id'],
                        aws_secret_access_key=keys['secret_access_key'],
                        ec2_ip=self.tester.ec2.host,
                        s3_ip=self.tester.s3.host))

        for tester in testers:
            import random
            zone = random.choice(tester.get_zones())
            volume = self.tester.create_volume(size=1, azone=zone)
            snapshot = self.tester.create_snapshot(volume_id=volume.id)
            volume_from_snap = self.tester.create_volume(snapshot=snapshot,
                                                         azone=zone)
            bucket = self.tester.create_bucket(
                self.tester.id_generator(
                    12, string.ascii_lowercase + string.digits))
            key = self.tester.upload_object(
                bucket_name=bucket.name,
                key_name=self.tester.id_generator(
                    12, string.ascii_lowercase + string.digits),
                contents=self.tester.id_generator(200))
            keypair = self.tester.add_keypair(self.tester.id_generator())
            group = self.tester.add_group(self.tester.id_generator())
Ejemplo n.º 21
0
 def __init__(self,
              tester=None,
              config_file=None,
              cred_path=None,
              password="******",
              credpath=None,
              destpath='/disk1/storage/',
              time_per_gig=300,
              inter_bundle_timeout=120,
              upload_timeout=0,
              eof=True,
              work_component=None,
              component_credpath=None,
              bucketname=None,
              url=None):
     if tester is None:
         self.tester = Eucaops(config_file=config_file,
                               password=password,
                               credpath=credpath)
     else:
         self.tester = tester
     self.tester.exit_on_fail = eof
     self.destpath = str(destpath)
     self.bucketname = bucketname
     self.component = work_component
     self.component_credpath = component_credpath
     self.time_per_gig = time_per_gig
     self.credpath = credpath or self.tester.credpath
     self.url = url
     self.upload_timeout = upload_timeout
     self.inter_bundle_timeout = inter_bundle_timeout
     self.iu = ImageUtils(tester=self.tester,
                          destpath=self.destpath,
                          time_per_gig=self.time_per_gig,
                          work_component=self.component)
Ejemplo n.º 22
0
 def setUp(self):
     self.tester = Eucaops(credpath="/etc/eutester/.euca_cloud1_user/")
     self.keypair = self.tester.add_keypair()
     self.group = self.tester.add_group()
     self.tester.authorize_group(self.group)
     self.tester.authorize_group(self.group, port=-1, protocol="icmp")
     self.reservation = None
Ejemplo n.º 23
0
 def __init__(self):
     self.setuptestcase()
     self.setup_parser()
     self.get_args()
     # Setup basic eutester object
     self.tester = Eucaops(config_file=self.args.config,
                           password=self.args.password)
Ejemplo n.º 24
0
    def __init__(self, extra_args= None):
        self.setuptestcase()
        self.setup_parser()
        if extra_args:
            for arg in extra_args:
                self.parser.add_argument(arg)
        self.get_args()
        # Setup basic eutester object
        if self.args.region:
            self.tester = EC2ops( credpath=self.args.credpath, region=self.args.region)
        else:
            self.tester = Eucaops(config_file=self.args.config, password=self.args.password, credpath=self.args.credpath)
        self.tester.poll_count = 120

        ### Add and authorize a group for the instance
        self.group = self.tester.add_group(group_name="group-" + str(time.time()))
        self.tester.authorize_group_by_name(group_name=self.group.name )
        self.tester.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp" )
        ### Generate a keypair for the instance
        self.keypair = self.tester.add_keypair( "keypair-" + str(time.time()))
        self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)
        self.image = self.args.emi
        if not self.image:
            self.image = self.tester.get_emi(root_device_type="instance-store")
        self.address = None
        self.volume = None
        self.snapshot = None
        self.private_addressing = False
        zones = self.tester.ec2.get_all_zones()
        self.zone = random.choice(zones).name
        self.reservation = None
Ejemplo n.º 25
0
    def __init__(self, **kwargs):
        self.setuptestcase()
        self.setup_parser()
        self.parser.add_argument("--admin-name", dest='admin_name', default=None)
        self.parser.add_argument("--admin-email", dest='admin_email', default=None)
        self.parser.add_argument("--template-path", dest='template_path', default=None,
                                 help='path to riak templates, default is '
                                      '<eutester_dir>/testcases/cloud_admin/riak_cs/templates/')
        self.parser.add_argument("--riak-cs-port", default="9090")
        self.parser.add_argument("--bare-machines", dest='bare_machines', default=None,
                                 help='Comma delimited list of hosts to install riak on')
        self.parser.add_argument("--machine-password", dest='machine_password', default=None,
                                 help='password used to log into remote machines when '
                                      'installing riak')
        self.parser.add_argument("--walrus-fallback", dest='walrus_fallback', default=True,
                                 help='Allow test to configure system for Walrus in the case'
                                      'Riak fails to install or a riak component(s) is not listed')
        self.parser.add_argument("--basho-url", dest='basho_url',
                                 default='http://yum.basho.com/gpg/basho-release-6-1.noarch.rpm',
                                 help="default basho repo")
        self.get_args()
        # Allow __init__ to get args from __init__'s kwargs or through command line parser...
        for kw in kwargs:
            print 'Setting kwarg:'+str(kw)+" to "+str(kwargs[kw])
            self.set_arg(kw ,kwargs[kw])
        self.show_args()
        # Setup basic eutester object
        self.tester = Eucaops( config_file=self.args.config,password=self.args.password)
        self.machines = []
        if self.args.bare_machines:
            b_machines = self.args.bare_machines
            if not isinstance(b_machines, list) and isinstance(b_machines, str):
                b_machines = b_machines.split(',')
            else:
                raise ValueError('Unknown type for machine arg:"{0}", type:"{1}"'
                                 .format(b_machines, type(b_machines)))
            for mach in b_machines:
                if not isinstance(mach, Machine):
                    if not self.args.machine_password:
                        raise ValueError('Must provide machine password for machine list')
                    mach = Machine(str(mach).strip(), password=self.args.machine_password)
                self.machines.append(mach)
        else:
            try:
                self.machines = self.tester.get_component_machines("riak")
            except IndexError as ex:
                self.tester.info("No Riak component found in component specification. ")

                if self.args.walrus_fallback:
                    self.tester.info('walrus_fallback set to True, attempting to configure for'
                                     'walrus...')
                    self.configure_eucalyptus_for_walrus()
                else:
                    raise
        self.template_dir = self.args.template_path or os.path.join(self._get_script_filepath(),
                                                                    'templates/')
        self.primary_machine = None
        self.user_dict = None
        self.args.admin_name = self.args.admin_name or 'testuser_' + str(int(time.time()))
        self.args.admin_email = self.args.admin_email or self.args.admin_name +'@testemail'
Ejemplo n.º 26
0
    def __init__(self, extra_args=None):
        self.setuptestcase()
        self.setup_parser()
        self.parser.add_argument("--region", default=None)
        if extra_args:
            for arg in extra_args:
                self.parser.add_argument(arg)
        self.get_args()
        # Setup basic eutester object
        if self.args.region:
            self.tester = EC2ops(credpath=self.args.credpath,
                                 region=self.args.region)
        else:
            self.tester = Eucaops(credpath=self.args.credpath,
                                  config_file=self.args.config,
                                  password=self.args.password)
        self.tester.poll_count = 120

        self.security_groups = []

        ### Generate a keypair for the instance
        self.keypair = self.tester.add_keypair("keypair-" + str(time.time()))
        self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name)
        self.image = self.args.emi
        if not self.image:
            self.image = self.tester.get_emi(root_device_type="instance-store")
        self.address = None
        self.volume = None
        self.snapshot = None
        self.private_addressing = False
        zones = self.tester.ec2.get_all_zones()
        self.zone = random.choice(zones).name
        self.reservation = None
Ejemplo n.º 27
0
 def setUp(self):
     self.start_total_time = time.time()
     self.conf = 'cloud.conf'
     self.tester = Eucaops(config_file=self.conf, password='******')
     self.doAuth()
     self.OK = '\033[1m\033[37m\033[42m'
     self.ENDC = '\033[0m'
     self.imgName = "windowsserver2003r2_ent_x64.kvm.img"
Ejemplo n.º 28
0
 def __init__(self, config_file=None, password=None):
     self.setuptestcase()
     self.setup_parser()
     self.parser.add_argument("--command", default="free")
     self.parser.add_argument("--component", default=None)
     self.get_args()
     # Setup basic eutester object
     self.tester = Eucaops( config_file=self.args.config_file, password=self.args.password,download_creds=False)
Ejemplo n.º 29
0
 def __init__(self):
     self.setuptestcase()
     self.setup_parser()
     self.parser.add_argument("--no-cleanup", action='store_true')
     self.get_args()
     # Setup basic eutester object
     self.tester = Eucaops( credpath=self.args.credpath, config_file=self.args.config, password=self.args.password)
     self.testers = []
Ejemplo n.º 30
0
 def setUp(self):
     self.conf = "cloud.conf"
     self.tester = Eucaops(config_file=self.conf, password="******")
     self.doAuth()
     self.STARTC = '\033[1m\033[1m\033[42m'
     self.ENDC = '\033[0m'
     self.cc = self.tester.service_manager.get_all_cluster_controllers()[3]
     self.orig_name = self.cc.name