Add Client Code

1 files changed, 319 insertions, 0 deletions

diff --git a/client_code/sbhsclient.py b/client_code/sbhsclient.py
new file mode 100644
index 0000000..d27e320
--- /dev/null
+++ b/client_code/sbhsclient.py
@@ -0,0 +1,319 @@
+import htmlPy
+from htmlPy import Bridge, attach
+import urllib2, cookielib, urllib
+import time
+import os, json, sys, logging
+from threading import Thread
+logging.basicConfig(level=logging.DEBUG)
+
+global_cur_heat = 0
+global_cur_fan = 0
+global_cur_temp = 0
+global_iter = 0
+global_remaining_time = 0
+global_error = ""
+
+class SBHSClient(Bridge):
+	def __init__(self):
+
+		self.path = os.path.dirname(sys.executable) if getattr(sys, 'frozen', False) else os.path.dirname(os.path.realpath(__file__))
+		super(SBHSClient, self).__init__()
+		self.app = htmlPy.AppWindow(title="SBHS Vlabs Client", width=360, height=600, x_pos=32, y_pos=32)
+		self.app.window.setFixedSize(360, 600)
+		try:
+			config_options = {}
+			with open(os.path.join(self.path, "config.txt")) as f:
+				logging.debug("config.txt present. Loading configuration.")
+				for line in f:
+					if len(line.strip()) > 2:
+						opt = line.split(":")
+						config_options[opt[0].strip()] = opt[1].strip()
+
+			if config_options["base_link"] != "None" and len(config_options["base_link"]) > 2:
+				link = config_options["base_link"]
+			else:
+				link = "http://vlabs.iitb.ac.in/"
+		#############################################
+			link = "http://192.168.43.144/sbhs/"
+			if config_options["use_proxy"] != "Yes":
+				proxy_handler = urllib2.ProxyHandler({})
+				logging.debug("Proxy: None")
+			else:
+				logging.debug("Loading proxy.")
+				proxy_url = config_options["proxy_type"] + "://"
+				proxy_url += (urllib.quote(config_options["proxy_username"]) + ":" if config_options["proxy_username"] != "" else "")
+				proxy_url += (urllib.quote(config_options["proxy_password"]) + "@" if config_options["proxy_username"] != "" else "")
+				proxy_url += config_options["proxy_host"] + ":"
+				proxy_url += config_options["proxy_port"] + "/"
+				proxy_handler = urllib2.ProxyHandler({config_options["proxy_type"]: proxy_url})
+				logging.debug("Proxy: " + config_options["proxy_type"] + ": " + proxy_url)
+			logging.debug("BASE_LINK: " + link)
+		except Exception:
+			logging.exception("Error while loading config. Switching to default configuration.")
+			link = "http://vlabs.iitb.ac.in/"
+		#############################################
+			link = "http://192.168.43.144/sbhs/"
+			proxy_handler = urllib2.ProxyHandler({})
+			logging.debug("Proxy: None")
+			logging.debug("BASE_LINK: " + link)
+
+		self.base_url = link + "experiment/"
+		self.version = "3"
+		self.urllib2 = urllib2
+		self.logdir = "logs"
+		self.scilabreadfname = "scilabread.sce"
+		self.scilabwritefname = "scilabwrite.sce"
+		self.cur_heat = 0
+		self.cur_fan = 0
+		self.cur_temp = 0
+		self.iter = 0
+		self.remaining_time = 0
+		self.error = ""
+		self.status = False
+		self.machine_ip=""#ADDED
+		self.machine_url=""#ADDED
+		self.link = link
+
+		cookie_support = cookielib.CookieJar()
+		opener = urllib2.build_opener(proxy_handler, urllib2.HTTPCookieProcessor(cookie_support))
+		self.urllib2.install_opener(opener)
+
+		self.app.setTemplatePath(self.path)
+
+	@attach(result=str)
+	def check_connection(self):
+		try:
+			print self.base_url+"check_connection"
+			br = urllib2.urlopen(self.base_url + "check_connection")
+			return br.read()
+		except Exception:
+			logging.exception("Failed in checking server connection")
+			return "NO"
+
+	@attach(result=bool)
+	def client_version(self):
+		try:
+			br = urllib2.urlopen(self.base_url + "client_version")
+			return br.read() == self.version
+		except Exception:
+			logging.exception("Failed in checking client version")
+			return False
+
+	@attach(str, str, result=str)
+	def authenticate(self, username, password):
+		try:
+			username = str(username)
+			password = str(password)
+
+			input_data = urllib.urlencode({"username": username, "password": password})
+			
+			ip_req = self.urllib2.Request(self.base_url + "initiate", input_data) 
+			json_response = urllib2.urlopen(ip_req)
+
+			data = json.loads(json_response.read())
+			if not data["STATUS"]==200:
+				self.error = data["MESSAGE"]
+				global_error = self.error
+				return data["MESSAGE"]
+
+			self.machine_ip = data["MESSAGE"]
+			self.machine_url = self.base_url + "/pi/" + self.machine_ip +"/pi/experiment/"
+
+			req = self.urllib2.Request(self.machine_url + "initiate", input_data)
+			br = urllib2.urlopen(req)
+
+			data = json.loads(br.read())
+			if data["STATUS"] == 1:
+				self.username = username
+				if not os.path.exists(self.logdir):
+					os.makedirs(self.logdir)
+				logdir = os.path.join(self.logdir, username)
+				if not os.path.exists(logdir):
+					os.makedirs(logdir)
+
+				self.logfile_handler = open(os.path.join(logdir, data["MESSAGE"]), "a")
+				self.status = True
+				self.app.execute_javascript("document.getElementById('logfile').innerHTML='" + data["MESSAGE"] + "'")
+				f = open(self.scilabreadfname, 'w')
+				f.close()
+				f = open(self.scilabwritefname, 'w')
+				f.close()
+				global global_error
+				global_error = ""
+				return "TRUE"
+			else:
+				self.error = data["MESSAGE"]
+				global_error = self.error
+				return data["MESSAGE"]
+		except Exception:
+			logging.exception("Error in authentication")
+			self.error = "Cannot connect to SBHS server."
+			global global_error
+			global_error = self.error
+			return self.error
+
+	@attach(result=str)
+	def get_data(self):
+		return json.dumps({
+			"iter": global_iter,
+			"heat": global_cur_heat,
+			"fan": global_cur_fan,
+			"temp": global_cur_temp,
+			"time": global_remaining_time,
+			"error": global_error
+		})
+
+	def experiment(self):
+		while self.status == False:
+			time.sleep(0.2)
+		try:
+			scilabreadf = file(self.scilabreadfname, 'w')
+			scilabwritef = file(self.scilabwritefname, 'r')
+			logf = self.logfile_handler
+
+			self.scilabreadf = scilabreadf
+			self.scilabwritef = scilabwritef
+
+			scilabreadf.flush()
+		except Exception:
+			logging.exception("Error in experiment files.")
+			self.error = 'Failed to access files needed for experiment'
+			global global_error
+			global_error = self.error
+			return False
+
+
+		while True:
+			# read data from file that scilab writes to
+			retry_read = True
+			while retry_read:
+				time.sleep(0.001)
+				cur_scilabwrite_pos = scilabwritef.tell()
+				scilabwritestr = scilabwritef.readline()
+				if not scilabwritestr.endswith('\n'):
+					scilabwritef.seek(cur_scilabwrite_pos)
+					retry_read = True
+				else:
+					retry_read = False
+			scilabwritestr = scilabwritestr.strip()
+
+			if scilabwritestr != "":
+				try:
+					scilabwritedata = scilabwritestr.split(' ', 3)
+					cur_iter = int(float(scilabwritedata[0]))
+					cur_heat = int(float(scilabwritedata[1]))
+					cur_fan = int(float(scilabwritedata[2]))
+					if (cur_heat > 100):
+						cur_heat = 100
+					elif (cur_heat < 0):
+						cur_heat = 0
+					if (cur_fan > 100):
+						cur_fan = 100
+					elif (cur_fan < 0):
+						cur_fan = 0
+					cur_variables = ''.join(scilabwritedata[3:]) # converting variable arguments list to string
+					cur_time = int(time.time() * 1000)
+
+					self.cur_heat = cur_heat
+					self.cur_fan = cur_fan
+					self.iter = cur_iter
+				except Exception:
+					logging.exception("Error in reading data.")
+					self.error = 'Invalid data format in ' + self.scilabwritefname + '.'
+					global global_error
+					global_error = self.error
+					return False
+			else:
+				continue
+
+			# read data from server
+			srv_data = False
+			while not srv_data:
+				try:
+					url_com = self.machine_url + 'experiment'
+					postdata = urllib.urlencode({
+						'iteration' : cur_iter,
+						'heat' : cur_heat,
+						'fan' : cur_fan,
+						'variables' : cur_variables,
+						'timestamp' : cur_time
+					})
+					req = self.urllib2.Request(url_com)
+					res = self.urllib2.urlopen(req, postdata)
+					content = res.read()
+					srv_data = True
+					content = json.loads(content)
+					# print content
+					# check if content is received properly
+					if content["STATUS"] == 1:
+						data_str = content["MESSAGE"]
+						data = data_str.split(",")
+						data_str = data[0]
+						data_str += ' %d' % int(time.time() * 1000) # add client received time stamp
+						# if variable arguments present in server response append it
+						if data[1] != "":
+							data_str += ' ' + data[1]
+						# calculating and printing time remaining in minutes
+						self.remaining_time = data[2]
+						# write data to file
+						scilabreadf.write(data_str + '\n')
+						scilabreadf.flush()
+						templist = data_str.split(" ")
+						self.cur_temp = templist[3]
+						# write data to log
+						logf.write(data_str + '\n')
+						logf.flush()
+
+						global global_cur_heat, global_cur_fan, global_cur_temp
+						global global_iter, global_remaining_time, global_error
+						global_cur_heat = self.cur_heat
+						global_cur_fan = self.cur_fan
+						global_cur_temp = self.cur_temp
+						global_iter = self.iter
+						global_remaining_time = self.remaining_time
+						global_error = ""
+					else:
+						self.error = content["MESSAGE"]
+						global global_error
+						global_error = self.error
+						self.status = False
+						return False
+				except Exception:
+					logging.exception("Error in communicating data to server")
+					self.error = "Failed to connect to SBHS. Retrying....."
+					global global_error
+					global_error = self.error
+					time.sleep(0.1)
+					srv_data = False
+
+	def run(self):
+		self.app.setTemplate("index.html")
+		t2 = Thread(target=self.experiment)
+		t2.setDaemon(True)
+		t2.start()
+
+		self.app.window.resize(self.app.width, self.app.height)
+		self.app.window.move(self.app.x_pos, self.app.y_pos)
+		self.app.window.show()
+
+		def runner():
+			self.app.app.exec_()
+			try:
+				self.reset()
+				self.logfile_handler.close()
+				self.scilabreadf.close()
+				self.scilabwritef.close()
+			except Exception:
+				logging.exception("Error while reseting SBHS.")
+				pass
+
+		import sys
+		sys.exit(runner())
+	def reset(self):
+		print self.machine_url + "reset"
+		self.urllib2.urlopen(self.machine_url + "reset")
+
+if __name__ == "__main__":
+	s = SBHSClient()
+	s.app.register(s)
+	s.run()