Ejemplo n.º 1
0
def start_rolebuild(step, behaviors):
    behaviors = behaviors.strip().split(',')
    if not 'chef' in behaviors:
        behaviors.append('chef')
    location = CONF.platforms[CONF.main.platform]['location']
    if CONF.main.driver == Platform.GCE:
        location = 'all'
    platform = Platform.to_scalr(Platform.from_driver_name(CONF.main.platform))
    os_dist, os_ver = get_scalr_dist_info(CONF.main.dist)
    if CONF.main.driver == Platform.GCE:
        image = filter(lambda x: x['os_family']==os_dist and x['os_version'].startswith(os_ver),
                       images(Platform.to_scalr(CONF.main.driver)).all()['images'])[0]
    else:
        image = filter(lambda x: x['cloud_location']==CONF.platforms[CONF.main.platform]['location'] and
                             x['os_family']==os_dist and x['os_version'].startswith(os_ver),
                       images(CONF.main.platform).all()['images'])[0]
    bundle_id = IMPL.rolebuilder.build2(platform=platform,
                                        location=location,
                                        arch='x86_64',
                                        behaviors=behaviors,
                                        os_family=image['os_family'],
                                        os_version=image['os_version'],
                                        name='tmp-%s-%s-%s' % (CONF.main.platform, CONF.main.dist,
                                                               datetime.now().strftime('%m%d-%H%M')),
                                        scalarizr='',
                                        mysqltype='percona' if 'percona' in behaviors else 'mysql')
    setattr(world, 'role_type', CONF.main.behaviors[0])
    setattr(world, 'bundle_id', bundle_id)
Ejemplo n.º 2
0
def update_scalarizr(step, serv_as):
    server = getattr(world, serv_as)
    node = world.cloud.get_node(server)
    if "ubuntu" in node.os[0].lower():
        LOG.info("Update scalarizr in Ubuntu")
        node.run("apt-get update")
        node.run("apt-get install scalarizr-base scalarizr-%s -y" % Platform.to_scalr(CONF.main.driver))
    elif "centos" in node.os[0].lower():
        LOG.info("Update scalarizr in CentOS")
        node.run("yum install scalarizr-base scalarizr-%s -y" % Platform.to_scalr(CONF.main.driver))
Ejemplo n.º 3
0
def given_server_in_cloud(step, user_data):
    #TODO: Add install behaviors
    LOG.info('Create node %s in cloud' % user_data)
    #Convert dict to formatted str
    dict_to_str = lambda d: ';'.join(['='.join([key, value]) if value else key for key, value in d.iteritems()])
    #Get user data fixture for tested Cloud
    user_data = dict_to_str(USER_DATA[Platform.get_platform_group(CONF.main.driver)]) if user_data \
        else None
    #Create node
    node = world.cloud.create_node(userdata=user_data)
    setattr(world, 'cloud_server', node)
    if CONF.main.driver in [Platform.CLOUDSTACK, Platform.IDCF, Platform.KTUCLOUD]:
        #Get node external ip
        #Run command
        out = node.run('wget -qO- ifconfig.me/ip')
        if not out[1]:
            ip_address = out[0].rstrip("\n")
            LOG.info('Received external ip address of the node. IP:%s' % ip_address)
            setattr(world, 'ip', ip_address)
        else:
            raise AssertionError("Can't get node external ip address. Original error: %s" % out[1])
        #Open port, set firewall rule
        new_port = world.cloud.open_port(node, 8013, ip=ip_address)
        setattr(world, 'forwarded_port', new_port)
        if not new_port == 8013:
            raise AssertionError('Import will failed, because opened port is not 8013, '
                                 'an installed port is: %s' % new_port)
Ejemplo n.º 4
0
def add_role_to_farm(step, behavior=None, options=None):
    additional_storages = None
    scripting = None
    farm_options = {"base.hostname_format": "{SCALR_FARM_NAME}-{SCALR_ROLE_NAME}-{SCALR_INSTANCE_INDEX}"}
    if not behavior:
        behavior = os.environ.get("RV_BEHAVIOR", "base")
    else:
        behavior = behavior.strip()
    options = options.strip() if options else None
    if options:
        for opt in [o.strip() for o in options.strip().split(",")]:
            LOG.info("Inspect option: %s" % opt)
            if "redis processes" in opt:
                LOG.info("Add redis processes")
                redis_count = re.findall(r"(\d+) redis processes", options)[0].strip()
                farm_options.update({"db.msr.redis.num_processes": int(redis_count)})
            elif opt == "scripts":
                LOG.info("Add scripting")
                script_id = Script.get_id("Linux ping-pong")["id"]
                scripting = [
                    {
                        "script_id": script_id,
                        "script": "Linux ping-pong",
                        "params": {},
                        "target": "instance",
                        "version": "-1",
                        "timeout": "1200",
                        "issync": "1",
                        "order_index": "1",
                        "event": "HostInit",
                        "run_as": "root",
                    },
                    {
                        "script_id": script_id,
                        "script": "Linux ping-pong",
                        "params": {},
                        "target": "instance",
                        "version": "-1",
                        "timeout": "1200",
                        "issync": "1",
                        "order_index": "10",
                        "event": "BeforeHostUp",
                        "run_as": "revizor",
                    },
                    {
                        "script_id": script_id,
                        "script": "Linux ping-pong",
                        "params": {},
                        "target": "instance",
                        "version": "-1",
                        "timeout": "1200",
                        "issync": "1",
                        "order_index": "20",
                        "event": "HostUp",
                        "run_as": "ubuntu",
                    },
                ]
            elif opt == "storages":
                LOG.info("Add additional storages")
                if CONF.main.driver in [Platform.EC2]:
                    LOG.info("Add storages from EC2")
                    additional_storages = {
                        "configs": [
                            {
                                "id": None,
                                "type": "ebs",
                                "fs": "ext3",
                                "settings": {"ebs.size": "1", "ebs.type": "standard", "ebs.snapshot": None},
                                "mount": True,
                                "mountPoint": "/media/ebsmount",
                                "reUse": True,
                                "status": "",
                            },
                            {
                                "id": None,
                                "type": "raid.ebs",
                                "fs": "ext3",
                                "settings": {
                                    "raid.level": "10",
                                    "raid.volumes_count": 4,
                                    "ebs.size": "1",
                                    "ebs.type": "standard",
                                    "ebs.snapshot": None,
                                },
                                "mount": True,
                                "mountPoint": "/media/raidmount",
                                "reUse": True,
                                "status": "",
                            },
                        ]
                    }
                elif CONF.main.driver in [Platform.IDCF, Platform.CLOUDSTACK]:
                    LOG.info("Add storages from IDCF/CloudStack")
                    additional_storages = {
                        "configs": [
                            {
                                "id": None,
                                "type": "csvol",
                                "fs": "ext3",
                                "settings": {"csvol.size": "1"},
                                "mount": True,
                                "mountPoint": "/media/ebsmount",
                                "reUse": True,
                                "status": "",
                            },
                            {
                                "id": None,
                                "type": "raid.csvol",
                                "fs": "ext3",
                                "settings": {"raid.level": "10", "raid.volumes_count": 4, "csvol.size": "1"},
                                "mount": True,
                                "mountPoint": "/media/raidmount",
                                "reUse": True,
                                "status": "",
                            },
                        ]
                    }
                elif CONF.main.driver in [Platform.OPENSTACK, Platform.ECS]:
                    LOG.info("Add storages from OpenStack")
                    additional_storages = {
                        "configs": [
                            {
                                "id": None,
                                "type": "cinder",
                                "fs": "ext3",
                                "settings": {"cinder.size": "1"},
                                "mount": True,
                                "mountPoint": "/media/ebsmount",
                                "reUse": True,
                                "status": "",
                                "rebuild": False,
                            },
                            {
                                "id": None,
                                "type": "raid.cinder",
                                "fs": "ext3",
                                "settings": {"raid.level": "10", "raid.volumes_count": 4, "cinder.size": "1"},
                                "mount": True,
                                "mountPoint": "/media/raidmount",
                                "reUse": True,
                                "status": "",
                                "rebuild": False,
                            },
                        ]
                    }
            else:
                LOG.info("Add %s" % opt)
                farm_options.update(FARM_OPTIONS.get(opt, {}))
    if behavior == "rabbitmq":
        del (farm_options["base.hostname_format"])
    if behavior == "tomcat6" and CONF.main.dist.startswith("ubuntu"):
        behavior = "tomcat7"
    if behavior == "redis":
        LOG.info("Add redis settings")
        farm_options.update(
            {
                "db.msr.redis.persistence_type": os.environ.get("RV_REDIS_SNAPSHOTTING", "aof"),
                "db.msr.redis.use_password": True,
            }
        )
    if behavior in ["mysql", "mysql2", "percona2", "mariadb", "postgresql", "redis", "mongodb", "percona"]:
        storage = STORAGES.get(Platform.to_scalr(CONF.main.driver), None)
        if storage:
            LOG.info("Add main settings for %s storage" % CONF.main.storage)
            farm_options.update(storage.get(CONF.main.storage, {}))
    world.role_type = behavior
    world.role_options = farm_options
    world.role_scripting = scripting
    LOG.debug("All farm settings: %s" % farm_options)
    role = world.add_role_to_farm(
        world.role_type, options=farm_options, scripting=scripting, storages=additional_storages
    )
    setattr(world, "%s_role" % world.role_type, role)
    world.role = role
    if behavior in ["mysql", "postgresql", "redis", "mongodb", "percona", "mysql2", "percona2", "mariadb"]:
        db = Database.create(role)
        if not db:
            raise AssertionError("Database for role %s not found!" % role)
        world.database_users = {}
        world.db = db