def add_role_to_given_farm(step, role_type, redis_count):
LOG.info("Add role to farm")
engine = CONF.main.storage
LOG.info('Use storage engine: %s' % engine)
world.role_type = role_type
options_list = {'eph':{'db.msr.data_storage.engine': 'eph',
'db.msr.data_storage.eph.disk': '/dev/sda2',
'aws.instance_type':'m1.small',
'aws.use_ebs': '0'},
'lvm':{'db.msr.data_storage.engine': 'lvm',
'aws.instance_type':'m1.large',
'db.msr.data_storage.fstype': 'ext3',
'db.msr.data_storage.eph.disk': '/dev/sdb'},
'raid10':{'db.msr.data_storage.engine': 'raid.ebs',
'db.msr.data_storage.raid.level': '10',
'db.msr.data_storage.raid.volume_size': '15',
'db.msr.data_storage.raid.volumes_count': '8',
'db.msr.data_storage.fstype': 'ext3',
},
'raid5':{'db.msr.data_storage.engine': 'raid.ebs',
'db.msr.data_storage.raid.level': '5',
'db.msr.data_storage.raid.volume_size': '1',
'db.msr.data_storage.raid.volumes_count': '3',},
'raid0':{'db.msr.data_storage.engine': 'raid.ebs',
'db.msr.data_storage.raid.level': '0',
'db.msr.data_storage.raid.volume_size': '1',
'db.msr.data_storage.raid.volumes_count': '2',},
'raid1':{'db.msr.data_storage.engine': 'raid.ebs',
'db.msr.data_storage.raid.level': '1',
'db.msr.data_storage.raid.volume_size': '1',
'db.msr.data_storage.raid.volumes_count': '2',},
'ebs':{'db.msr.data_storage.engine':'ebs',
'db.msr.data_storage.ebs.size': '1',}}
scripting = []
if CONF.main.platform == 'ec2':
if role_type == 'mysql':
options = {'mysql.data_storage_engine' : 'ebs',
'mysql.ebs_volume_size' : 1}
else:
options = options_list[engine]
else:
options = {}
options.update({'db.msr.redis.persistence_type': os.environ.get('RV_REDIS_SNAPSHOTTING', 'aof'),
'db.msr.redis.num_processes': int(redis_count)})
world.role_options = options
world.role_scripting = scripting
role = world.add_role_to_farm(world.role_type, options=options, scripting=scripting)
setattr(world, world.role_type + '_role', role)
LOG.info("Set DB object to world")
if role_type in ['mysql', 'postgresql', 'redis', 'mongodb', 'percona', 'mysql2', 'percona2']:
db = Database.create(role)
if not db:
raise AssertionError('Database for role %s not found!' % role)
setattr(world, 'db', db)
def add_new_role_to_farm(step):
options = getattr(world, "role_options", {})
scripting = getattr(world, "role_scripting", [])
if world.role_type == "redis":
options.update(
{
"db.msr.redis.persistence_type": os.environ.get("RV_REDIS_SNAPSHOTTING", "aof"),
"db.msr.redis.use_password": True,
}
)
world.farm.add_role(world.new_role_id, options=options, scripting=scripting)
world.farm.roles.reload()
role = world.farm.roles[0]
setattr(world, world.role_type + "_role", role)
LOG.info("Set DB object to world")
if world.role_type in ["mysql", "mariadb", "percona", "postgresql", "redis", "mongodb", "mysql2", "percona2"]:
db = Database.create(role)
if db:
setattr(world, "db", db)
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
