def configure_region(environment, regions, bastion_instance_type,
bastion_coreos_channel, bastion_coreos_version, nat_per_az,
admins):
if not regions:
logger.warn('Must specify region(s) to update.')
return
updates = get_updates(bastion_instance_type, bastion_coreos_channel,
bastion_coreos_version, nat_per_az, admins)
if not updates:
logger.warn('No updates to do!')
return
for aws_region in regions:
dynamo = boto.dynamodb2.connect_to_region(aws_region)
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup(['regions', 'users'])
db = FlotillaClientDynamo(None, tables.regions, None, None, None,
tables.users, None)
admins = updates.get('admins')
if admins:
missing_users = db.check_users(admins)
if len(missing_users) > 0:
logger.error('User(s): %s do not exist in %s.',
', '.join(missing_users), region)
continue
db.configure_region(aws_region, updates)
logger.info('Region(s): %s updated.', ', '.join(regions))
def configure_service(environment, regions, service_name, updates):
for region in regions:
dynamo = boto.dynamodb2.connect_to_region(region)
kms = boto.kms.connect_to_region(region)
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup(['services'])
db = FlotillaClientDynamo(None, None, None, tables.services, None, None,
kms)
db.configure_service(service_name, updates)
def get_keys(environment, region, service, bastion):
dynamo = boto.dynamodb2.connect_to_region(region)
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup(['regions', 'services', 'users'])
db = FlotillaSshDynamo(tables.regions, tables.services, tables.users,
region)
if service is not None:
users = db.get_service_admins(service)
elif bastion:
users = db.get_bastion_users()
else:
users = db.get_region_admins()
ssh_keys = db.get_keys(users)
print '\n'.join(ssh_keys)
def get_keys(environment, region, service, bastion):
dynamo = boto.dynamodb2.connect_to_region(region)
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup(['regions', 'services', 'users'])
db = FlotillaSshDynamo(tables.regions, tables.services, tables.users,
region)
if service is not None:
users = db.get_service_admins(service)
elif bastion:
users = db.get_bastion_users()
else:
users = db.get_region_admins()
ssh_keys = db.get_keys(users)
print '\n'.join(ssh_keys)
def start_scheduler(environment, domain, regions, lock_interval, loop_interval,
provision_interval):
instance_id = get_instance_id()
coreos = CoreOsAmiIndex()
cloudformation = FlotillaCloudFormation(environment, domain, coreos)
funcs = []
for region in regions:
# DynamoDB:
dynamo = boto.dynamodb2.connect_to_region(region)
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup([
'assignments', 'locks', 'regions', 'services', 'stacks', 'status'
])
db = FlotillaSchedulerDynamo(tables.assignments, tables.regions,
tables.services, tables.stacks,
tables.status)
locks = DynamoDbLocks(instance_id, tables.locks)
# Assemble into scheduler:
schedule = FlotillaScheduler(db, locks, lock_ttl=lock_interval * 3)
provisioner = FlotillaProvisioner(environment, region, schedule, db,
cloudformation)
funcs += [
RepeatingFunc('scheduler-lock-%s' % region, schedule.lock,
lock_interval),
RepeatingFunc('scheduler-%s' % region, schedule.loop,
loop_interval),
RepeatingFunc('provisioner-%s' % region, provisioner.provision,
provision_interval)
]
queue_name = 'flotilla-%s-scheduler' % environment
sqs = boto3.resource('sqs', region)
message_q = get_queue(sqs, queue_name)
if message_q:
elb = boto3.client('elb', region)
doctor = ServiceDoctor(db, elb)
messaging = FlotillaSchedulerMessaging(message_q, schedule, doctor)
funcs.append(
RepeatingFunc('scheduler-message-%s' % region,
messaging.receive, 0))
# Start loops:
map(RepeatingFunc.start, funcs)
def configure_user(environment, regions, name, ssh_keys, active):
updates = get_updates(ssh_keys, active)
if not updates:
logger.warn('No updates to do!')
return
for region in regions:
dynamo = boto.dynamodb2.connect_to_region(region)
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup(['users'])
db = FlotillaClientDynamo(None, None, None, None, None, tables.users,
None)
db.configure_user(name, updates)
logger.info('User: %s updated in region(s): %s updated.', name,
', '.join(regions))
def configure_user(environment, regions, name, ssh_keys, active):
updates = get_updates(ssh_keys, active)
if not updates:
logger.warn('No updates to do!')
return
for region in regions:
dynamo = boto.dynamodb2.connect_to_region(region)
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup(['users'])
db = FlotillaClientDynamo(None, None, None, None, None, tables.users,
None)
db.configure_user(name, updates)
logger.info('User: %s updated in region(s): %s updated.', name,
', '.join(regions))
def start_agent(environment, service, region, elb_name, health_interval,
assignment_interval):
# Identity:
instance_id = get_instance_id()
logger.debug('Resolved id: %s', instance_id)
# Systemd:
manager = Manager()
systemd = SystemdUnits(manager)
# AWS services:
lb = get_elb(instance_id, elb_name, region)
dynamo = boto.dynamodb2.connect_to_region(region)
kms = boto.kms.connect_to_region(region)
# DynamoDB:
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup(['status', 'assignments', 'revisions', 'units', 'locks'])
db = FlotillaAgentDynamo(instance_id, service, tables.status,
tables.assignments, tables.revisions,
tables.units, kms)
locks = DynamoDbLocks(instance_id, tables.locks)
# SQS:
sqs = boto3.resource('sqs', region)
scheduler_q = get_queue(sqs, 'flotilla-%s-scheduler' % environment)
service_q = get_queue(sqs, 'flotilla-%s-service-%s' %
(environment, service))
messaging = FlotillaAgentMessaging(service, instance_id, scheduler_q,
service_q)
# Assemble into agent:
agent = FlotillaAgent(service, db, locks, systemd, messaging, lb)
# Start loops:
funcs = [
RepeatingFunc('health', agent.health, health_interval),
RepeatingFunc('assignment', agent.assignment, assignment_interval),
]
if service_q:
funcs.append(RepeatingFunc('message', messaging.receive, 0))
map(RepeatingFunc.start, funcs)
logger.info('Startup complete.')
def start_scheduler(environment, domain, regions, lock_interval, loop_interval,
provision_interval):
instance_id = get_instance_id()
coreos = CoreOsAmiIndex()
cloudformation = FlotillaCloudFormation(environment, domain, coreos)
funcs = []
for region in regions:
# DynamoDB:
dynamo = boto.dynamodb2.connect_to_region(region)
tables = DynamoDbTables(dynamo, environment=environment)
tables.setup(['assignments', 'locks', 'regions', 'services', 'stacks',
'status'])
db = FlotillaSchedulerDynamo(tables.assignments, tables.regions,
tables.services, tables.stacks,
tables.status)
locks = DynamoDbLocks(instance_id, tables.locks)
# Assemble into scheduler:
schedule = FlotillaScheduler(db, locks, lock_ttl=lock_interval * 3)
provisioner = FlotillaProvisioner(environment, region, schedule, db,
cloudformation)
funcs += [
RepeatingFunc('scheduler-lock-%s' % region, schedule.lock,
lock_interval),
RepeatingFunc('scheduler-%s' % region, schedule.loop,
loop_interval),
RepeatingFunc('provisioner-%s' % region, provisioner.provision,
provision_interval)
]
queue_name = 'flotilla-%s-scheduler' % environment
sqs = boto3.resource('sqs', region)
message_q = get_queue(sqs, queue_name)
if message_q:
elb = boto3.client('elb', region)
doctor = ServiceDoctor(db, elb)
messaging = FlotillaSchedulerMessaging(message_q, schedule, doctor)
funcs.append(RepeatingFunc('scheduler-message-%s' % region,
messaging.receive, 0))
# Start loops:
map(RepeatingFunc.start, funcs)
