def use_and_generate(host, port, bucket_name, frequency_width, volume, add_shutdown, iterations):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
connection = httplib.HTTPConnection(host, port)
connection.request('GET', '/api', None, {})
response = connection.getresponse()
if response.status != httplib.OK:
msg = 'Error while processing GET request for {0}:{1}/api (status {2}): {3}'.format(host, port, response.status, response.read())
raise Exception(msg)
json_data = response.read()
message_details = json.loads(json_data)
host_list = message_details['hosts']
nodes_running = get_nodes_running(host_list)
if len(nodes_running) > 0:
# Now build the graph
session_id = get_session_id()
graph = BuildGraphJpeg2000(bucket_name, volume, PARALLEL_STREAMS, nodes_running, add_shutdown, frequency_width, iterations, session_id, host)
graph.build_graph()
LOG.info('Connection to {0}:{1}'.format(host, port))
client = DataIslandManagerClient(host, port)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.warning('No nodes are running')
def submit_single_graph(self, graph_id, algo="sarkar", deploy=False):
lgn = lgnames[graph_id]
fp = pkg_resources.resource_filename("dfms.dropmake", "web/{0}".format(lgn))
lg = LG(fp)
drop_list = lg.unroll_to_tpl()
# node_list = self.get_avail_hosts()
node_list = self._dc.nodes()
pgtp = MySarkarPGTP(drop_list, len(node_list), merge_parts=True)
pgtp.json
pg_spec = pgtp.to_pg_spec(node_list, ret_str=False)
if self._output:
with open(self._output, "w") as f:
json.dump(pg_spec, f, indent=2)
completed_uids = [x["oid"] for x in droputils.get_roots(pg_spec)]
ssid = "{0}-{1}".format(lgn.split(".")[0], lg._session_id)
self._dc.create_session(ssid)
print "session created"
self._dc.append_graph(ssid, pg_spec)
print "graph appended"
if deploy:
ret = self._dc.deploy_session(ssid, completed_uids=completed_uids)
print "session deployed"
return ret
def test_get_roots(self):
"""
Check that the get_roots method from the droputils module works as intended
"""
"""
A --> B
"""
pg_spec = [{"oid":"A", "type":"plain", "storage":"memory", "consumers":["B"]},
{"oid":"B", "type":"app", "app":"test.test_graph_loader.DummyApp"}]
roots = droputils.get_roots(pg_spec)
self.assertEquals(1, len(roots))
self.assertEquals('A', roots[0]['oid'])
"""
A --> B
The same, but now B references A
"""
pg_spec = [{"oid":"A", "type":"plain", "storage":"memory"},
{"oid":"B", "type":"app", "app":"test.test_graph_loader.DummyApp", "inputs": ["A"]}]
roots = droputils.get_roots(pg_spec)
self.assertEquals(1, len(roots))
self.assertEquals('A', roots[0]['oid'])
"""
A --> C --> D --|
|--> E --> F
B --------------|
"""
pg_spec = [{"oid":"A", "type":"plain", "storage": "memory"},
{"oid":"B", "type":"plain", "storage": "memory"},
{"oid":"C", "type":"app", "app":"dfms.apps.crc.CRCApp", "inputs": ['A']},
{"oid":"D", "type":"plain", "storage": "memory", "producers": ["C"]},
{"oid":"E", "type":"app", "app":"test.test_drop.SumupContainerChecksum", "inputs": ["D"]},
{"oid":"F", "type":"plain", "storage": "memory", "producers":["E"]}]
roots = droputils.get_roots(pg_spec)
self.assertEquals(2, len(roots))
self.assertListEqual(['A', 'B'], [x['oid'] for x in roots])
def gen_pg():
"""
RESTful interface to convert a PGT(P) into PG by mapping
PGT(P) onto a given set of available resources
"""
pgt_id = request.query.get('pgt_id')
pgtp = pg_mgr.get_pgt(pgt_id)
if (pgtp is None):
response.status = 404
return "PGT(P) with id {0} not found in the Physical Graph Manager".format(
pgt_id)
mhost = request.query.get('dfms_mgr_host')
if (mhost is None):
response.status = 500
return "Must specify DFMS manager host"
try:
mport = int(request.query.get('dfms_mgr_port'))
mgr_client = CompositeManagerClient(host=mhost, port=mport, timeout=30)
# 1. get a list of nodes
node_list = mgr_client.nodes()
# 2. mapping PGTP to resources (node list)
pg_spec = pgtp.to_pg_spec([mhost] + node_list, ret_str=False)
dt = datetime.datetime.now().strftime('%Y-%m-%dT%H-%M-%S.%f')
ssid = "{0}_{1}".format(
pgt_id.split('.json')[0].split('_pgt')[0].split('/')[-1], dt)
mgr_client.create_session(ssid)
#print "session created"
mgr_client.append_graph(ssid, pg_spec)
#print "graph appended"
completed_uids = droputils.get_roots(pg_spec)
mgr_client.deploy_session(ssid, completed_uids=completed_uids)
#mgr_client.deploy_session(ssid, completed_uids=[])
#print "session deployed"
# 3. redirect to the master drop manager
redirect("http://{0}:{1}/session?sessionId={2}".format(
mhost, mport, ssid))
except RestClientException as re:
response.status = 500
return "Fail to interact with DFMS Drop Manager: {0}".format(re)
except HTTPResponse:
raise
except Exception as ex:
response.status = 500
print(traceback.format_exc())
return "Fail to deploy physical graph: {0}".format(ex)
def use_and_generate(host, port, bucket_name, frequency_width, volume, add_shutdown):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
connection = httplib.HTTPConnection(host, port)
connection.request('GET', '/api', None, {})
response = connection.getresponse()
if response.status != httplib.OK:
msg = 'Error while processing GET request for {0}:{1}/api (status {2}): {3}'.format(host, port, response.status, response.read())
raise Exception(msg)
json_data = response.read()
message_details = json.loads(json_data)
host_list = message_details['hosts']
nodes_running = get_nodes_running(host_list)
if len(nodes_running) > 0:
work_to_do = WorkToDo(
width=frequency_width,
bucket_name=bucket_name,
s3_split_name=get_s3_split_name(frequency_width))
work_to_do.calculate_work_to_do()
# Now build the graph
session_id = get_session_id()
graph = BuildGraphMsTransform(
work_to_do=work_to_do.work_to_do,
bucket_name=bucket_name,
volume=volume,
parallel_streams=7,
node_details=nodes_running,
shutdown=add_shutdown,
width=frequency_width,
session_id=session_id,
dim_ip=host,
)
graph.build_graph()
LOG.info('Connection to {0}:{1}'.format(host, port))
client = DataIslandManagerClient(host, port)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.warning('No nodes are running')
def submit(host,
port,
pg,
skip_deploy=False,
session_id=None,
completed_uids=None):
from dfms import droputils
from dfms.manager.client import CompositeManagerClient
session_id = session_id or "%f" % (time.time())
completed_uids = completed_uids or droputils.get_roots(pg)
with CompositeManagerClient(host, port, timeout=10) as client:
client.create_session(session_id)
logger.info("Session %s created", session_id)
client.append_graph(session_id, pg)
logger.info("Graph for session %s appended", session_id)
if not skip_deploy:
client.deploy_session(session_id, completed_uids=completed_uids)
logger.info("Session %s deployed", session_id)
def gen_pg():
"""
RESTful interface to convert a PGT(P) into PG by mapping
PGT(P) onto a given set of available resources
"""
pgt_id = request.query.get('pgt_id')
pgtp = pg_mgr.get_pgt(pgt_id)
if (pgtp is None):
response.status = 404
return "PGT(P) with id {0} not found in the Physical Graph Manager"
mhost = request.query.get('dfms_mgr_host')
if (mhost is None):
response.status = 500
return "Must specify DFMS manager host"
try:
mport = int(request.query.get('dfms_mgr_port'))
mgr_client = CompositeManagerClient(host=mhost, port=mport, timeout=30)
# 1. get a list of nodes
node_list = mgr_client.nodes()
# 2. mapping PGTP to resources (node list)
pg_spec = pgtp.to_pg_spec(node_list, ret_str=False)
dt = datetime.datetime.now().strftime('%Y-%m-%dT%H-%M-%S.%f')
ssid = "{0}_{1}".format(pgt_id.split('.json')[0].split('_pgt')[0], dt)
mgr_client.create_session(ssid)
#print "session created"
mgr_client.append_graph(ssid, pg_spec)
#print "graph appended"
completed_uids = [x['oid'] for x in droputils.get_roots(pg_spec)]
mgr_client.deploy_session(ssid, completed_uids=completed_uids)
#mgr_client.deploy_session(ssid, completed_uids=[])
#print "session deployed"
# 3. redirect to the master drop manager
redirect("http://{0}:{1}/session?sessionId={2}".format(mhost, mport, ssid))
except RestClientException, re:
response.status = 500
return "Fail to interact with DFMS Drop Manager: {0}".format(re)
def use_and_generate(
host,
port,
bucket_name,
frequency_width,
w_projection_planes,
volume,
add_shutdown,
min_frequency,
max_frequency,
scan_statistics,
dump_json):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
connection = httplib.HTTPConnection(host, port)
connection.request('GET', '/api', None, {})
response = connection.getresponse()
if response.status != httplib.OK:
msg = 'Error while processing GET request for {0}:{1}/api (status {2}): {3}'.format(host, port, response.status, response.read())
raise Exception(msg)
json_data = response.read()
message_details = json.loads(json_data)
host_list = message_details['hosts']
nodes_running = get_nodes_running(host_list)
if len(nodes_running) > 0:
work_to_do = WorkToDo(
width=frequency_width,
bucket_name=bucket_name,
s3_uvsub_name=get_s3_uvsub_name(frequency_width),
s3_split_name=get_s3_split_name(frequency_width),
min_frequency=min_frequency,
max_frequency=max_frequency)
work_to_do.calculate_work_to_do()
# Now build the graph
session_id = get_session_id()
graph = BuildGraphUvsub(
work_to_do=work_to_do.work_to_do,
bucket_name=bucket_name,
volume=volume,
parallel_streams=PARALLEL_STREAMS,
node_details=nodes_running,
shutdown=add_shutdown,
scan_statistics=scan_statistics,
width=frequency_width,
w_projection_planes=w_projection_planes,
session_id=session_id,
dim_ip=host)
graph.build_graph()
if dump_json:
json_dumps = json.dumps(graph.drop_list, indent=2)
with open("/tmp/json_uvsub.txt", "w") as json_file:
json_file.write(json_dumps)
LOG.info('Connection to {0}:{1}'.format(host, port))
client = DataIslandManagerClient(host, port)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.warning('No nodes are running')
def create_and_generate(
bucket_name,
frequency_width,
w_projection_planes,
ami_id,
spot_price,
volume,
nodes,
add_shutdown,
min_frequency,
max_frequency,
scan_statistics,
dump_json):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
work_to_do = WorkToDo(
width=frequency_width,
bucket_name=bucket_name,
s3_uvsub_name=get_s3_uvsub_name(frequency_width),
s3_split_name=get_s3_split_name(frequency_width),
min_frequency=min_frequency,
max_frequency=max_frequency)
work_to_do.calculate_work_to_do()
nodes_required, node_count = get_nodes_required(nodes, spot_price)
if len(nodes_required) > 0:
uuid = get_uuid()
ec2_data = EC2Controller(
ami_id,
nodes_required,
get_node_manager_user_data(boto_data, uuid, max_request_size=50),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE NM - Uvsub',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
ec2_data.start_instances()
reported_running = get_reported_running(
uuid,
node_count,
wait=600
)
if len(reported_running) == 0:
LOG.error('Nothing has reported ready')
else:
hosts = build_hosts(reported_running)
# Create the Data Island Manager
data_island_manager = EC2Controller(
ami_id,
[
{
'number_instances': 1,
'instance_type': 'm4.large',
'spot_price': spot_price
}
],
get_data_island_manager_user_data(boto_data, hosts, uuid, max_request_size=50),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE DIM - Uvsub',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
data_island_manager.start_instances()
data_island_manager_running = get_reported_running(
uuid,
1,
wait=600
)
if len(data_island_manager_running['m4.large']) == 1:
# Now build the graph
session_id = get_session_id()
instance_details = data_island_manager_running['m4.large'][0]
host = instance_details['ip_address']
graph = BuildGraphUvsub(
work_to_do=work_to_do.work_to_do,
bucket_name=bucket_name,
volume=volume,
parallel_streams=PARALLEL_STREAMS,
node_details=reported_running,
shutdown=add_shutdown,
scan_statistics=scan_statistics,
width=frequency_width,
w_projection_planes=w_projection_planes,
session_id=session_id,
dim_ip=host)
graph.build_graph()
if dump_json:
json_dumps = json.dumps(graph.drop_list, indent=2)
with open("/tmp/json_uvsub.txt", "w") as json_file:
json_file.write(json_dumps)
LOG.info('Connection to {0}:{1}'.format(host, DIM_PORT))
client = DataIslandManagerClient(host, DIM_PORT)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.error('Unable to find the AWS credentials')
def create_and_generate(bucket_name, frequency_width, ami_id, spot_price, volume, bottom_frequency, nodes, add_shutdown):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
uuid = get_uuid()
ec2_data = EC2Controller(
ami_id,
[
{
'number_instances': nodes,
'instance_type': 'i2.2xlarge',
'spot_price': spot_price
}
],
get_node_manager_user_data(boto_data, uuid),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE NM - Find bad MS',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
ec2_data.start_instances()
reported_running = get_reported_running(
uuid,
nodes,
wait=600
)
if len(reported_running) == 0:
LOG.error('Nothing has reported ready')
else:
hosts = build_hosts(reported_running)
# Create the Data Island Manager
data_island_manager = EC2Controller(
ami_id,
[
{
'number_instances': 1,
'instance_type': 'm4.large',
'spot_price': spot_price
}
],
get_data_island_manager_user_data(boto_data, hosts, uuid),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE DIM - Find bad MS',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
data_island_manager.start_instances()
data_island_manager_running = get_reported_running(
uuid,
1,
wait=600
)
if len(data_island_manager_running['m4.large']) == 1:
# Now build the graph
session_id = get_session_id()
instance_details = data_island_manager_running['m4.large'][0]
host = instance_details['ip_address']
graph = BuildGraphFindBadMeasurementSet(
bucket_name,
volume,
PARALLEL_STREAMS,
reported_running,
add_shutdown,
frequency_width,
bottom_frequency,
session_id,
host,
)
graph.build_graph()
LOG.info('Connection to {0}:{1}'.format(host, DIM_PORT))
client = DataIslandManagerClient(host, DIM_PORT)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.error('Unable to find the AWS credentials')
def test_get_roots(self):
"""
Check that the get_roots method from the droputils module works as intended
"""
"""
A --> B
"""
pg_spec = [{
"oid": "A",
"type": "plain",
"storage": "memory",
"consumers": ["B"]
}, {
"oid": "B",
"type": "app",
"app": "test.test_graph_loader.DummyApp"
}]
roots = droputils.get_roots(pg_spec)
self.assertEqual(1, len(roots))
self.assertEqual('A', next(iter(roots)))
"""
A --> B
The same, but now B references A
"""
pg_spec = [{
"oid": "A",
"type": "plain",
"storage": "memory"
}, {
"oid": "B",
"type": "app",
"app": "test.test_graph_loader.DummyApp",
"inputs": ["A"]
}]
roots = droputils.get_roots(pg_spec)
self.assertEqual(1, len(roots))
self.assertEqual('A', next(iter(roots)))
"""
A --> C --> D --|
|--> E --> F
B --------------|
"""
pg_spec = [{
"oid": "A",
"type": "plain",
"storage": "memory"
}, {
"oid": "B",
"type": "plain",
"storage": "memory"
}, {
"oid": "C",
"type": "app",
"app": "dfms.apps.crc.CRCApp",
"inputs": ['A']
}, {
"oid": "D",
"type": "plain",
"storage": "memory",
"producers": ["C"]
}, {
"oid": "E",
"type": "app",
"app": "test.test_drop.SumupContainerChecksum",
"inputs": ["D"]
}, {
"oid": "F",
"type": "plain",
"storage": "memory",
"producers": ["E"]
}]
roots = droputils.get_roots(pg_spec)
self.assertEqual(2, len(roots))
self.assertListEqual(['A', 'B'], sorted(roots))
# The same as before but using dropdicts
pg_spec_dropdicts = [dropdict(dropspec) for dropspec in pg_spec]
roots = droputils.get_roots(pg_spec_dropdicts)
self.assertEqual(2, len(roots))
self.assertListEqual(['A', 'B'], sorted(roots))
def create_and_generate(bucket_name, input_dir, ami_id, spot_price, volume, nodes, add_shutdown, log_level):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
work_to_do = WorkToDo(frequency_width, bucket_name, get_s3_uvsub_name(frequency_width), database_connection)
work_to_do.calculate_work_to_do()
nodes_required, node_count = get_nodes_required(nodes, spot_price)
if len(nodes_required) > 0:
uuid = get_uuid()
ec2_data = EC2Controller(
ami_id,
nodes_required,
get_node_manager_user_data(boto_data, uuid, max_request_size=50, log_level=log_level),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE NM - Stats',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
ec2_data.start_instances()
reported_running = get_reported_running(
uuid,
node_count,
wait=600
)
if len(reported_running) == 0:
LOG.error('Nothing has reported ready')
else:
hosts = build_hosts(reported_running)
# Create the Data Island Manager
data_island_manager = EC2Controller(
ami_id,
[
{
'number_instances': 1,
'instance_type': 'm4.large',
'spot_price': spot_price
}
],
get_data_island_manager_user_data(
boto_data,
hosts,
uuid,
need_node_manager=True,
max_request_size=50
),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE DIM - Stats',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
data_island_manager.start_instances()
data_island_manager_running = get_reported_running(
uuid,
1,
wait=600,
)
if len(data_island_manager_running['m4.large']) == 1:
# Now build the graph
session_id = get_session_id()
instance_details = data_island_manager_running['m4.large'][0]
host = instance_details['ip_address']
graph = BuildGraphStats(
work_to_do.work_to_do,
bucket_name,
volume,
PARALLEL_STREAMS,
reported_running,
add_shutdown,
frequency_width,
session_id,
map_day_name,
password,
database_ip,
host
)
graph.build_graph()
LOG.info('Connection to {0}:{1}'.format(host, DIM_PORT))
client = DataIslandManagerClient(host, DIM_PORT)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.error('Unable to find the AWS credentials')
def create_and_generate(bucket_name, frequency_width, ami_id, spot_price1, spot_price2, volume, days_per_node, add_shutdown):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
work_to_do = WorkToDo(
width=frequency_width,
bucket_name=bucket_name,
s3_split_name=get_s3_split_name(frequency_width))
work_to_do.calculate_work_to_do()
days = work_to_do.work_to_do.keys()
nodes_required, node_count = get_nodes_required(
days=days,
days_per_node=days_per_node,
spot_price1=spot_price1,
spot_price2=spot_price2)
if len(nodes_required) > 0:
uuid = get_uuid()
ec2_data = EC2Controller(
ami_id,
nodes_required,
get_node_manager_user_data(boto_data, uuid),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE NM - MsTransform',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
ec2_data.start_instances()
reported_running = get_reported_running(
uuid,
node_count,
wait=600
)
hosts = build_hosts(reported_running)
# Create the Data Island Manager
data_island_manager = EC2Controller(
ami_id,
[
{
'number_instances': 1,
'instance_type': 'm4.large',
'spot_price': spot_price1
}
],
get_data_island_manager_user_data(boto_data, hosts, uuid),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE DIM - MsTransform',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
data_island_manager.start_instances()
data_island_manager_running = get_reported_running(
uuid,
1,
wait=600
)
if len(data_island_manager_running['m4.large']) == 1:
# Now build the graph
session_id = get_session_id()
instance_details = data_island_manager_running['m4.large'][0]
host = instance_details['ip_address']
graph = BuildGraphMsTransform(
work_to_do=work_to_do.work_to_do,
bucket_name=bucket_name,
volume=volume,
parallel_streams=7,
node_details=reported_running,
shutdown=add_shutdown,
width=frequency_width,
session_id=session_id,
dim_ip=hosts,
)
graph.build_graph()
graph.tag_all_app_drops({
"session_id": session_id,
})
LOG.info('Connection to {0}:{1}'.format(host, DIM_PORT))
client = DataIslandManagerClient(host, DIM_PORT)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.error('Unable to find the AWS credentials')
def use_and_generate(
host,
port,
bucket_name,
frequency_width,
volume,
add_shutdown,
iterations,
arcsec,
w_projection_planes,
robust,
image_size,
clean_channel_average,
min_frequency,
max_frequency,
clean_directory_name,
only_image):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
connection = httplib.HTTPConnection(host, port)
connection.request('GET', '/api', None, {})
response = connection.getresponse()
if response.status != httplib.OK:
msg = 'Error while processing GET request for {0}:{1}/api (status {2}): {3}'.format(host, port, response.status, response.read())
raise Exception(msg)
json_data = response.read()
message_details = json.loads(json_data)
host_list = message_details['hosts']
nodes_running = get_nodes_running(host_list)
if len(nodes_running) > 0:
work_to_do = WorkToDo(
frequency_width,
bucket_name,
get_s3_clean_name(frequency_width, iterations, arcsec) if clean_directory_name is None else clean_directory_name,
min_frequency,
max_frequency
)
work_to_do.calculate_work_to_do()
# Now build the graph
session_id = get_session_id()
graph = BuildGraphClean(
work_to_do=work_to_do.work_to_do,
bucket_name=bucket_name,
volume=volume,
parallel_streams=PARALLEL_STREAMS,
node_details=nodes_running,
shutdown=add_shutdown,
width=frequency_width,
iterations=iterations,
arcsec=arcsec,
w_projection_planes=w_projection_planes,
robust=robust,
image_size=image_size,
clean_channel_average=clean_channel_average,
clean_directory_name=clean_directory_name,
only_image=only_image,
session_id=session_id,
dim_ip=host)
graph.build_graph()
# TODO: Save the run parameters
LOG.info('Connection to {0}:{1}'.format(host, port))
client = DataIslandManagerClient(host, port)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.warning('No nodes are running')
def create_and_generate(
bucket_name,
frequency_width,
ami_id,
spot_price,
volume,
frequencies_per_node,
add_shutdown,
iterations,
arcsec,
w_projection_planes,
robust,
image_size,
clean_channel_average,
min_frequency,
max_frequency,
clean_directory_name,
only_image,
log_level):
boto_data = get_aws_credentials('aws-chiles02')
if boto_data is not None:
work_to_do = WorkToDo(
frequency_width,
bucket_name,
get_s3_clean_name(frequency_width, iterations, arcsec) if clean_directory_name is None else clean_directory_name,
min_frequency,
max_frequency
)
work_to_do.calculate_work_to_do()
nodes_required, node_count = get_nodes_required(work_to_do.work_to_do, frequencies_per_node, spot_price)
if len(nodes_required) > 0:
uuid = get_uuid()
ec2_data = EC2Controller(
ami_id,
nodes_required,
get_node_manager_user_data(boto_data, uuid, log_level=log_level),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE NM - Clean',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
ec2_data.start_instances()
reported_running = get_reported_running(
uuid,
node_count,
wait=600
)
if len(reported_running) == 0:
LOG.error('Nothing has reported ready')
else:
hosts = build_hosts(reported_running)
# Create the Data Island Manager
data_island_manager = EC2Controller(
ami_id,
[
{
'number_instances': 1,
'instance_type': 'm4.large',
'spot_price': spot_price
}
],
get_data_island_manager_user_data(boto_data, hosts, uuid, need_node_manager=True, log_level=log_level),
AWS_REGION,
tags=[
{
'Key': 'Owner',
'Value': getpass.getuser(),
},
{
'Key': 'Name',
'Value': 'DALiuGE DIM - Clean',
},
{
'Key': 'uuid',
'Value': uuid,
}
]
)
data_island_manager.start_instances()
data_island_manager_running = get_reported_running(
uuid,
1,
wait=600
)
if len(data_island_manager_running['m4.large']) == 1:
# Now build the graph
session_id = get_session_id()
instance_details = data_island_manager_running['m4.large'][0]
host = instance_details['ip_address']
graph = BuildGraphClean(
work_to_do=work_to_do.work_to_do,
bucket_name=bucket_name,
volume=volume,
parallel_streams=PARALLEL_STREAMS,
node_details=reported_running,
shutdown=add_shutdown,
width=frequency_width,
iterations=iterations,
arcsec=arcsec,
w_projection_planes=w_projection_planes,
robust=robust,
image_size=image_size,
clean_channel_average=clean_channel_average,
clean_directory_name=clean_directory_name,
only_image=only_image,
session_id=session_id,
dim_ip=host)
graph.build_graph()
# TODO: Safe the run parameters
LOG.info('Connection to {0}:{1}'.format(host, DIM_PORT))
client = DataIslandManagerClient(host, DIM_PORT)
client.create_session(session_id)
client.append_graph(session_id, graph.drop_list)
client.deploy_session(session_id, get_roots(graph.drop_list))
else:
LOG.error('Unable to find the AWS credentials')
