def main(argv=None):
settings, args = process_command_line(sys.argv[1:])
port = 8021
synthesis_options = dict()
synthesis_options[protocol.SYNTHESIS_OPTION_DISPLAY_VNC] = settings.display_vnc
synthesis_options[protocol.SYNTHESIS_OPTION_EARLY_START] = settings.early_start
app_function = default_app_function
cloudlet_ip = None
if settings.server_ip:
cloudlet_ip = settings.server_ip
elif settings.discovery_server:
cloudlet_list = list()
if discovery_api.RET_FAILED == API.find_nearby_cloudlets(cloudlet_list):
sys.stderr.write(API.discovery_err_str)
sys.exit(1)
for index, each_cloudlet in enumerate(cloudlet_list):
API.get_cloudlet_info(each_cloudlet)
print "%d : %s" % (index, each_cloudlet)
print ""
while True:
user_input = raw_input("Choose Cloudlet (0~%d): " % (len(cloudlet_list)-1))
if not user_input.isdigit():
continue
selected_number = int(user_input)
if 0 <= selected_number < len(cloudlet_list):
break
cloudlet_ip = cloudlet_list[selected_number].ip_v4
else:
message = "You need either specify cloudlet ip(option -s) or enable to discover cloudlet service(option -c)"
sys.stderr.write(message)
sys.exit(1)
synthesis(cloudlet_ip, port, settings.overlay_path, app_function, synthesis_options)
return 0
def synthesis(address, port, overlay_path, app_function, synthesis_option):
if os.path.exists(overlay_path) == False:
sys.stderr.write("Invalid overlay path: %s\n" % overlay_path)
sys.exit(1)
# get session
cloudlet = Cloudlet(ip_address=address)
session_id = API.associate_with_cloudlet(cloudlet)
if session_id == discovery_api.RET_FAILED:
sys.stderr.write("Cannot create session : ")
sys.stderr.write(API.discovery_err_str + "\n")
sys.exit(1)
start_cloudlet(cloudlet, session_id, overlay_path, app_function, synthesis_option)
print "finished"
def start_cloudlet(cloudlet, session_id, overlay_meta_path, app_function, synthesis_options=dict()):
# connection
start_time = time.time()
sock = Util.connect(cloudlet)
if not sock:
print API.discovery_err_str
sys.exit(1)
blob_request_list = list()
time_dict = dict()
app_time_dict = dict()
print "Overlay Meta: %s" % (overlay_meta_path)
print "Session ID: %ld" % (session_id)
meta_info = Util.decoding(open(overlay_meta_path, "r").read())
# send header
header_dict = {
protocol.KEY_COMMAND : protocol.MESSAGE_COMMAND_SEND_META,
protocol.KEY_META_SIZE : os.path.getsize(overlay_meta_path),
protocol.KEY_SESSION_ID: session_id,
}
if len(synthesis_options) > 0:
header_dict[protocol.KEY_SYNTHESIS_OPTION] = synthesis_options
header = Util.encoding(header_dict)
sock.sendall(struct.pack("!I", len(header)))
sock.sendall(header)
sock.sendall(open(overlay_meta_path, "r").read())
time_dict['send_end_time'] = time.time()
# recv header
data = recv_all(sock, 4)
msg_size = struct.unpack("!I", data)[0]
msg_data = recv_all(sock, msg_size);
message = Util.decoding(msg_data)
command = message.get(protocol.KEY_COMMAND, None)
if command != protocol.MESSAGE_COMMAND_SUCCESS:
sys.stderr.write("[ERROR] Failed to send overlay meta header\n")
sys.stderr.write("[ERROR] Reason : %s\n" % message.get(protocol.KEY_FAILED_REASON, None))
sys.exit(1)
app_thread = None
total_blob_count = len(meta_info['overlay_files'])
sent_blob_list = list()
while True:
inputready, outputready, exceptrdy = select.select([sock], [sock], [], 0.01)
for i in inputready:
if i == sock:
data = sock.recv(4)
if not data:
break
msg_size = struct.unpack("!I", data)[0]
msg_data = recv_all(sock, msg_size);
message = Util.decoding(msg_data)
command = message.get(protocol.KEY_COMMAND)
if command == protocol.MESSAGE_COMMAND_SUCCESS: # RET_SUCCESS
pass
elif command == protocol.MESSAGE_COMMAND_FAIELD: # RET_FAIL
sys.stderr.write("Synthesis Failed\n")
if command == protocol.MESSAGE_COMMAND_SYNTHESIS_DONE: # RET_SUCCESS
sys.stdout.write("Synthesis SUCCESS\n")
time_dict['recv_success_time'] = time.time()
#run user input waiting thread
app_thread = client_thread(app_function)
app_thread.start()
elif command == protocol.MESSAGE_COMMAND_ON_DEMAND: # request blob
#sys.stdout.write("Request: %s\n" % (message.get(protocol.KEY_REQUEST_SEGMENT)))
blob_request_list.append(str(message.get(protocol.KEY_REQUEST_SEGMENT)))
else:
sys.stderr.write("protocol error:%d\n" % (command))
# send data
for i in outputready:
if (i == sock) and (len(sent_blob_list) < total_blob_count):
# check request list
requested_uri = None
if len(blob_request_list) == 0:
continue
requested_uri = blob_request_list.pop(0)
if requested_uri not in sent_blob_list:
sent_blob_list.append(requested_uri)
else:
raise RapidClientError("sending duplicated blob: %s" % requested_uri)
filename = os.path.basename(requested_uri)
blob_path = os.path.join(os.path.dirname(overlay_meta_path), filename)
segment_info = {
protocol.KEY_COMMAND : protocol.MESSAGE_COMMAND_SEND_OVERLAY,
protocol.KEY_REQUEST_SEGMENT : requested_uri,
protocol.KEY_REQUEST_SEGMENT_SIZE : os.path.getsize(blob_path),
protocol.KEY_SESSION_ID: session_id,
}
# send close signal to cloudlet server
header = Util.encoding(segment_info)
sock.sendall(struct.pack("!I", len(header)))
sock.sendall(header)
sock.sendall(open(blob_path, "rb").read())
if len(sent_blob_list) == total_blob_count:
time_dict['send_end_time'] = time.time()
# check condition
if (app_thread != None) and (app_thread.isAlive() == False) and (len(sent_blob_list) == total_blob_count):
break
app_thread.join()
time_dict.update(app_thread.time_dict)
time_dict.update(app_time_dict)
send_end = time_dict['send_end_time']
recv_end = time_dict['recv_success_time']
app_start = time_dict['app_start']
app_end = time_dict['app_end']
client_info = {
protocol.KEY_COMMAND : protocol.MESSAGE_COMMAND_FINISH,
protocol.KEY_SESSION_ID : session_id,
'Transfer End':(send_end-start_time),
'Synthesis Success': (recv_end-start_time),
'App Start': (app_start-start_time),
'App End': (app_end-start_time)
}
pprint(client_info)
# send close signal to cloudlet server
header = Util.encoding(client_info)
sock.sendall(struct.pack("!I", len(header)))
sock.sendall(header)
# recv finish success (as well as residue) from server
data = recv_all(sock, 4)
msg_size = struct.unpack("!I", data)[0]
msg_data = recv_all(sock, msg_size);
message = Util.decoding(msg_data)
command = message.get(protocol.KEY_COMMAND)
if command != protocol.MESSAGE_COMMAND_SUCCESS:
raise RapidClientError("finish sucess errror: %d" % command)
# close session
if API.disassociate(cloudlet, session_id) == False:
print API.discovery_err_str
