def handDownloadModelFile(cmd):
logging.info("handDownloadModelFile: Start to handle Download Model File. cmd=%s", str(cmd))
filePath = "/home/pi/.octoprint/uploads/" + cmd["filename"]
if not os.path.exists(filePath):
logging.warn("handDownloadModelFile: Model file is not exist. file=%s", filePath)
return
url=client.protocol + client.cloudHostPort+ "/api/box/file"
operateInfo = {}
operateInfo["token"] = cmd["token"]
fileInfo = {}
fileInfo["filename"] = str(cmd["filename"])
fileInfo["filetype"] = "application/octet-stream"
fd = open(filePath, "rb")
fileInfo["filecontent"] = fd.read()
fd.close()
headers, body = createFormData(operateInfo, fileInfo)
upload_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
logging.debug("handDownloadModelFile: Start to upload model file. url=%s, file=%s", url, filePath)
response = yield client.http_client.fetch(upload_request, request_timeout=60)
if response.error:
logging.error("handDownloadModelFile: Failed to upload model file. error=%s", response.error)
return
res = json_decode(response.body)
if res["ret_value"] != 0:
logging.warn("handDownloadModelFile: Failed to upload model file. ret_val=", res["ret_value"])
return
logging.debug("handDownloadModelFile: End to upload model file. url=%s", url)
def handleLogs(cmd):
logging.info("handleLogs: Start to upload logs. cmd=%s", str(cmd))
file_name = client.boxID + ".tgz"
logs = os.path.join(os.path.abspath(os.path.dirname(__file__)), file_name)
collect_logs_cmd = os.path.join(os.path.abspath(os.path.dirname(__file__)), "collect_log.sh")
os.system("sudo /bin/rm -f " + logs )
os.system("sudo /bin/bash " + collect_logs_cmd + " " + logs)
with open(logs, 'rb') as logs_file:
url = client.protocol + client.cloudHostPort + "/api/cloud/logs"
operateInfo = {}
operateInfo["token"] = cmd["token"]
operateInfo["boxid"] = client.boxID
fileInfo = {}
fileInfo["filename"] = file_name
fileInfo["filetype"] = "application/octet-stream"
fileInfo["filecontent"] = logs_file.read()
headers, body = createFormData(operateInfo, fileInfo)
operate_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
response = yield client.http_client.fetch(operate_request, request_timeout=60)
if response.error:
logging.error("handleLogs: Failed to upload logs. error=%s", response.error)
return
res = json_decode(response.body)
if res["ret_value"] != 0:
logging.warn("handleLogs: Failed to upload logs. ret_val=", res["ret_value"])
return
logging.info("handleLogs: End to upload logs.")
def login():
logging.debug("login: Start to login.")
client.sessionID = None
loginInfo = {}
loginInfo["token1"] = hashlib.md5(client.token).hexdigest()
loginInfo["token2"] = hashlib.md5(client.boxID).hexdigest()
loginInfo["boxid"] = client.boxID
headers, body = createFormData(loginInfo)
url = client.protocol + client.serverHostPort + "/login"
login_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
logging.debug("login: Login info = %s", str(loginInfo))
response = yield client.http_client.fetch(login_request)
if response.error:
logging.error("login: Failed to login. error=%s", response.error)
return
else:
logging.debug("login: Login result. response.body=%r", response.body)
loginRes = json_decode(response.body)
if loginRes["ret_value"] == 0:
client.sessionID = loginRes["sessionID"]
logging.info("login: Succeed to login. sessionID=%s", loginRes["sessionID"])
else:
logging.error("login: Failed to login. ret_value=%d", loginRes["ret_value"])
return
def keepAlive():
logging.debug("keepAlive: Start to keep alive.")
keepAliveInfo = {}
keepAliveInfo["boxid"] = client.boxID
keepAliveInfo["sessionID"] = client.sessionID
headers, body = createFormData(keepAliveInfo)
url = client.protocol + client.serverHostPort + "/keepalive"
keepalive_request = HTTPRequest(url=url, method="POST", headers=headers, body=body, request_timeout=120)
logging.debug("keepAlive: Send keep alive.")
delta = 1 #next keep alive delta
try:
response = yield client.http_client.fetch(keepalive_request)
if response.error:
logging.error("keepAlive: Failed to keep alive. error=%s", response.error)
delta = 1
else:
logging.debug("keepAlive: Keep alive result. response.body=%r", response.body)
res = json_decode(response.body)
if res["ret_value"] == 1:
#need login
logging.warn("keepAlive: Failed to Keep alive. Reason: need login")
delta = 1
elif res["ret_value"] == 0:
logging.debug("keepAlive: Handle operation. operateType=%d", res["operateType"])
operateType = res["operateType"]
del res["ret_value"]
del res["operateType"]
if operateType in OPERATE_HANDLER_DICT.keys():
OPERATE_HANDLER_DICT[operateType](res)
else:
logging.warn("keepAlive: Unexpect operateType=%d", operateType)
delta = 1
else:
logging.error("keepAlive: Failed to keep alive. ret_value=%d", res["ret_value"])
delta = 1
except HTTPError as e:
# HTTPError is raised for non-200 responses; the response
# can be found in e.response.
if e.response is not None:
logging.error("Failed to keep alive(%s)", native_str(e.response.body))
else:
logging.error("Failed to keep alive(%s)", str(e))
except Exception as e:
# Other errors are possible, such as IOError.
logging.error("Failed to keep alive(%s)", str(e))
finally:
tornado.ioloop.IOLoop.instance().add_timeout(time.time()+delta, keepAlive)
return
def handleGetPic(cmd):
logging.info("handleGetPic: Start to handle GetPic. cmd=%s", str(cmd))
#Send tripping a picture
url = client.protocol + client.localHostPort + "/snapshot?boxid=local&"
url += "uuid=" + str(uuid.uuid4())
response = yield client.http_client.fetch(url, request_timeout=60)
if response.error:
logging.error("handleGetPic: Failed to send GetPic. error=%s", response.error)
return
logging.info("handleGetPic: GetPic result. response.body=%r", response.body)
res = json_decode(response.body)
if res["code"] != 0:
logging.warn("handleGetPic: Failed to execute operation. ret_val=%d", res["code"])
#download picture from localhost
url = client.protocol + client.localHostPort + "/" + res['data']["pic_url"]
logging.debug("handleGetPic: Start to get picture. url=%s", url)
response = yield client.http_client.fetch(url, request_timeout=10)
if response.error:
logging.warn("handleGetPic: Failed to get picture. error=%s", response.error)
return
#upload picture to Server
url = client.protocol + client.cloudHostPort + "/api/cloud/rtpic"
#url = URL_HEADER + client.serverHost + ":" + client.serverPort + "/upload"
operateInfo = {}
operateInfo["token"] = cmd["token"]
operateInfo["boxid"] = client.boxID
fileInfo = {}
fileInfo["filename"] = "picture.jpg"
fileInfo["filetype"] = "image/jpg"
fileInfo["filecontent"] = response.body
headers, body = createFormData(operateInfo, fileInfo)
operate_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
logging.debug("handleGetPic: Start to upload picture. url=%s", url)
response = yield client.http_client.fetch(operate_request, request_timeout=60)
if response.error:
logging.error("handleGetPic: Failed to upload Pic. error=%s", response.error)
return
res = json_decode(response.body)
if res["ret_value"] != 0:
logging.warn("handleGetPic: Failed to upload pic. ret_val=", res["ret_value"])
return
logging.debug("handleGetPic: End to upload picture. url=%s", url)
def handleSendExtendInfo(cmd):
logging.info("handleSendExtendInfo: Start to handle send extend info. cmd=%s", str(cmd))
url = client.protocol + client.localHostPort + "/stlfiles"
type = cmd["type"]
if type == '1':
url = client.protocol + client.localHostPort + "/stlfiles"
elif type == '2':
url = client.protocol + client.localHostPort + "/slicerinfo"
cur_client = HTTPClient()
logging.debug("handleSendExtendInfo: Start to get stl extend info. url=%s, type=%s", url, type)
response = cur_client.fetch(url, request_timeout=10)
if response.error:
logging.error("handleSendExtendInfo: Failed to get stl files. error=%s", response.error)
return
logging.info("handleSendExtendInfo: get stl files result. response.body=%r", response.body)
res = json_decode(response.body)
if res["code"] != 0:
logging.warn("handleSendExtendInfo: Failed to get stl files. ret_val=%d, msg=%s", res["code"], res["msg"])
return
extendInfo = {}
extendInfo["boxid"] = client.boxID
extendInfo["sessionID"] = client.sessionID
extendInfo["type"] = type
extendInfo["data"] = json_encode(res["data"])
headers, body = createFormData(extendInfo)
url = client.protocol + client.serverHostPort + "/sendextendinfo"
heartbeat_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
response = yield client.http_client.fetch(heartbeat_request)
if response.error:
logging.warn("handleSendExtendInfo: Failed to send extend info. error=%s", response.error)
return
else:
logging.debug("handleSendExtendInfo: Succeed to send extend info. response.body=%r", response.body)
res = json_decode(response.body)
if res["ret_value"] == 0:
logging.debug("handleSendExtendInfo: Succeed to send extend info.")
else:
logging.warn("handleSendExtendInfo: Failed to send extend info. ret_value=%d", res["ret_value"])
def handleProfile(cmd):
logging.info("handleProfile: Start to handle profile. cmd=%s", str(cmd))
url = client.protocol + client.localHostPort + "/profile"
profile_data = { 'printer_profile': cmd['profile'],
'token': cmd['token'],
}
headers, body = createFormData(profile_data)
operate_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
response = yield client.http_client.fetch(operate_request, request_timeout=60)
if response.error:
logging.error("handleProfile: Failed to handle profile. error=%s", response.error)
else:
logging.info("handleProfile: handle profile result. response.body=%r", response.body)
res = json_decode(response.body)
if res["ret_value"] != 0:
#need login
logging.warn("handleProfile: Failed to handle profile. ret_val=%s", res["ret_value"])
logging.info("handleProfile: End to handle profile.")
def handleFile(cmd):
logging.info("handleFile: Start to handle operate. cmd=%s", str(cmd))
url = ""
if cmd["type"] == "1":
url = client.protocol + client.localHostPort + "/delete"
else:
url = client.protocol + client.localHostPort + "/rename"
del cmd["type"]
headers, body = createFormData(cmd)
operate_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
response = yield client.http_client.fetch(operate_request, request_timeout=60)
if response.error:
logging.error("handleFile: Failed to send operate. error=%s", response.error)
else:
logging.info("handleFile: Operate result. response.body=%r", response.body)
res = json_decode(response.body)
if res["ret_value"] != 0:
#need login
logging.warn("handleFile: Failed to execute [%s] operation. ret_val=", res["ret_value"])
def handleTest(cmd):
logging.info("handleTest: Start to handle test. cmd=%s", str(cmd))
url = client.protocol + client.localHostPort + "/test"
test_comand = { 'type': cmd['type'],
'data': "",
}
del cmd['type']
test_comand['data'] = json.dumps(cmd)
headers, body = createFormData(test_comand)
operate_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
response = yield client.http_client.fetch(operate_request, request_timeout=60)
if response.error:
logging.error("handleTest: Failed to send test. error=%s", response.error)
else:
logging.info("handleTest: Test result. response.body=%r", response.body)
res = json_decode(response.body)
if res["ret_value"] != 0:
#need login
logging.warn("handleTest: Failed to execute [%s] test. ret_val=", res["ret_value"])
logging.info("handleTest: End to handle test.")
def handleOperate(cmd):
logging.info("handleOperate: Start to handle operate. cmd=%s", str(cmd))
url = client.protocol + client.localHostPort + "/command"
command = {"type": cmd['type'],
"boxid": cmd['boxid'],
"data": "",
}
del cmd['type']
command['data'] = json.dumps(cmd)
headers, body = createFormData(command)
operate_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
response = yield client.http_client.fetch(operate_request, request_timeout=60)
if response.error:
logging.error("handleOperate: Failed to send operate. error=%s", response.error)
else:
logging.info("handleOperate: Operate result. response.body=%r", response.body)
res = json_decode(response.body)
if res["ret_value"] != 0:
#need login
logging.warn("handleOperate: Failed to execute [%s] operation. ret_val=", res["ret_value"])
logging.info("handleOperate: End to handle operate.")
def handleUpdate(cmd):
logging.info("handleUpdate: Start to handle update box. cmd=%s", str(cmd))
update_version = cmd["version"]
send_data = {
'version' : update_version,
}
headers, body = createFormData(send_data)
url = client.protocol + client.updateHostPort + "/netupdate_ajax"
update_request = HTTPRequest(url=url, method="POST", headers=headers, body=body)
logging.debug("handleUpdate: Send to update box. version=%s", update_version)
response = yield client.http_client.fetch(update_request)
if response.error:
logging.error("handleUpdate: Failed to send to update. error=%s", response.error)
return
else:
logging.debug("handleUpdate: result. response.body=%r", response.body)
updateRes = json_decode(response.body)
if updateRes == 0:
logging.info("handleUpdate: Succeed to send.")
else:
logging.error("handleUpdate: Failed to send. ret_value=%d", updateRes)
return