def upload_file(self, zipfile, manifest, upload_type='data'):
register_openers()
# create post vars for encoding
pvars = {'kiosk-id': Beagleboard.get_dieid(),
'software_version': Constants.VERSION, 'type': upload_type}
self.logger.debug("Sync variables: %s" % str(pvars))
# check to see if zipfile exists
if isfile(zipfile):
zh = open(zipfile, 'rb')
pvars['payload'] = zh
else:
zh = None
# check to see if manifest exists
if isfile(manifest):
mf = open(manifest, 'rb')
pvars['manifest'] = mf
else:
mf = None
get_target = urllib2.Request(Constants.URLUploadRequest)
try:
resp_url = urllib2.urlopen(get_target)
url_targ = resp_url.read().strip()
except urllib2.URLError:
self.logger.exception("Unable to get upload link.")
if zh is not None:
zh.close()
if mf is not None:
mf.close()
return False
#pvars['reference'] = resp_url.headers['X-eko-challenge']
datagen, headers = multipart_encode(pvars)
headers['X-eko-challenge'] = resp_url.headers['X-eko-challenge']
headers['X-eko-signature'] = solve_challenge(resp_url.headers['X-eko-challenge'])
headers['kiosk-id'] = Beagleboard.get_dieid()
self.logger.debug("Challenge: %s." % headers['X-eko-challenge'])
self.logger.debug("Sig: %s." % headers['X-eko-signature'])
self.logger.debug("Kiosk-id: %s" % headers['kiosk-id'])
upload = urllib2.Request(url_targ, datagen, headers)
try:
response = urllib2.urlopen(upload)
except urllib2.HTTPError, e:
self.logger.exception("Server error: %s" % str(e.code))
self.logger.error("Server return val: %s." % e.read())
def get_messages():
json_query = {}
json_query['method'] = 'get_messages'
json_query['id'] = '0'
json_query['params'] = {'kiosk-id': Beagleboard.get_dieid()}
json_query_str = json.dumps(json_query)
logger.debug("Sending JSON Query: %s" % json_query_str)
hash = MD5.new(json_query_str).digest()
# encoding signature
encoded_sig = Security.sign_digest(hash)
headers = {'X-eko-signature': encoded_sig}
urlreq = urllib2.Request(Constants.URLJsonAPI, json_query_str, headers)
try:
response = urllib2.urlopen(urlreq)
except urllib2.URLError:
logger.exception("Unable to open URL to fetch server messages")
return False
json_reply = response.read()
try:
response_dict = json.loads(json_reply)
except:
logger.exception("Unable to decode response JSON!")
return False
messages = response_dict['result']
return messages
def send_heartbeat(url, uptime, rwip='0.0.0.0'):
json_msg = {}
json_msg['method'] = 'heartbeat'
json_msg['id'] = 0
params = {'rwanda-ip':rwip}
params['kiosk-id'] = Beagleboard.get_dieid()
if uptime < 60:
# under a minute
uptimestr = "%.2f seconds" % uptime
elif uptime < 60*60:
# under a hour
uptimestr = "%.2f minutes" % (uptime/(60.0))
elif uptime < 60*60*24*3:
# under 3 days
uptimestr = "%.2f hours" % (uptime/(60.0*60.0))
else:
# over 3 days
uptimestr = "%.2f days" % (uptime/(60.0*60.0*24.0))
params['uptime'] = uptimestr
params['sw-version'] = '1.0.0'
params['time'] = datetime.utcnow()
json_msg['params'] = params
jsstr = json.dumps(json_msg)
hash = MD5.new(jsstr).digest()
logger.info("System has been up for %s." % uptime)
sign_16encode = Security.sign_digest(hash)
#print "encoded: %s" % sign_16encode
#print "signature: %d" % key.sign(hash, "")[0]
#print "hash: %s" % "".join(["%02x " % ord(x) for x in hash])
headers = {'X-eko-signature': sign_16encode}
#test decoding
try:
logger.info("Transmiting heartbeat.")
req = urllib2.Request(url, jsstr, headers)
response = urllib2.urlopen(req)
the_page = response.read()
except:
logger.exception("Transmit failed.")
return False
try:
jsondict = json.loads(the_page)
except:
logger.exception('Could not load reply json')
jsondict = {'error':'json not loaded'}
if jsondict['result'] == "success":
logger.info("Heartbeat Success.")
return True
else:
logger.debug("Response: %s." % the_page)
logger.info("Sleeping.")
return False
def __init__(self, cfg):
config = ConfigParser()
try:
config.read(cfg)
except:
self.logger.exception("Unable to read config file %s." % cfg)
# try to open the databases
self.logger.info("Opening databases.")
try:
DBSetup.check_databases()
except (sqlite3.Error, IOError, OSError):
self.logger.exception("Databases could not be opened.")
self.disp = DisplayController()
try:
## removes all modules, shutsdown hub
Beagleboard.goto_known_state()
except (OSError, IOError):
self.logger.exception("Unable to reset board to default setting.")
def datalog(self):
# instantiate a harvest dispatcher
try:
x = Beagleboard.set_gpio_usbhub_power()
x = Beagleboard.handle_modprobe_ehcihcd()
except (OSError, IOError):
self.logger.exception("Error encountered when attempting to turn on USB Hub.")
x = False
time.sleep(10)
dispatch = EkoDispatcher()
dispatch.import_configs()
self.logger.info("Dispatching all sensor polling operations.")
dispatch.dispatch_all()
self.logger.info("All sensors polled.")
try:
x = Beagleboard.handle_modprobe_ehcihcd(insert = False)
x = Beagleboard.set_gpio_usbhub_power(on = False)
except:
self.logger.exception("Error encountered when attempting to power off USB hub.")
return
def main():
run_count = 0
run_error_threshold = 15
usage = 'usage: %prog [-d] [-v] [-c CONFIG]'
parser = optparse.OptionParser(usage=usage, version="%prog " + VERSION)
parser.add_option("-d", "--debug", help="Enable debug output.",
action="store_true", dest="debug", default=False)
parser.add_option("-c", "--config",
dest="configfile", default="/etc/eko/eko.conf",
metavar="CONFIG", help="Path to configuration file.")
(options, args) = parser.parse_args()
if options.configfile is not None:
configfile = options.configfile
else:
configfile = '/etc/eko/eko.cfg'
loglvl_console = logging.DEBUG if options.debug else logging.INFO
logger = LogHelper.getLoggerInstance(verbose_level=loglvl_console)
try:
board_rev = Beagleboard.get_board_revision()
logger.info("Beagleboard Revision 0x%02x" % board_rev)
except:
logger.exception("Unable to test board revision, defaulting to XM rev C")
# create datalogger instance and run it
while True:
try:
logger.info("Executing main code with config %s. Attempt #%d." % (configfile, run_count))
datalogger = DataLogger(configfile)
time.sleep(5)
datalogger.run()
except KeyboardInterrupt:
sys.exit(0)
except:
run_count += 1
if run_count > run_error_threshold:
logger.critical("Too many crashes, exiting.")
sys.exit(-1)
logger.exception("DataLogger crashed! Attempting to retry.")
def transmit_clientmessages(configpath=Constants.CONFIGPATH):
# upload
logger.info("Transmitting client messages to server.")
con = sqlite3.connect(join(configpath, 'sync.db'), detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
c = con.cursor()
try:
c.execute("SELECT message, sessionref, origin, origintime, id FROM clientmsg WHERE synctime is NULL LIMIT 15")
rows = c.fetchall()
except sqlite3.Error:
logger.exception("Error fetching rows from sync.db.")
rows = None
finally:
c.close()
con.close()
# bug out if execute failed
if (rows is None) or (rows == []):
logger.info("No messages to sync.")
return False
list = []
for row in rows:
data={}
data['session-ref'] = row[1]
data['message'] = row[0]
data['origin'] = row[2]
data['origin-date'] = row[3]
list.append(data)
# list contains a list of messages
msg = {}
msg['method'] = 'post_messages'
msg['id'] = 0
msg['params'] = {'kiosk-id' : Beagleboard.get_dieid(), 'messages' : list}
jsonstr = json.dumps(msg)
hash = MD5.new(jsonstr).digest()
sig = Security.sign_digest(hash)
headers = {'X-eko-signature': sig}
urlreq = urllib2.Request(Constants.URLJsonAPI, jsonstr, headers)
try:
resp = urllib2.urlopen(urlreq)
except urllib2.URLError:
logger.exception("Unable to send client messages")
return False
try:
resp_str = resp.read()
jsonreply = json.loads(resp_str)
logger.debug("JSON reply reads: %s" % resp_str)
except:
logger.exception("Could not read reply json.")
jsonreply = {'result':'Could not load json'}
if jsonreply['result'].lower().strip() != 'success':
logger.error("Server replied with error: %s" % str(jsonreply))
return False
else:
logger.info("Succesfully uploaded messages.")
_update_clientmsg_table([row[4] for row in rows])
return True
def netsync(self):
# open a internet connection
## power the modem
self.disp.control_led('all', False)
try:
x = Beagleboard.turn_on_usbhub()
except (OSError, IOError):
self.logger.exception("Error encountered when attempting to turn on USB Hub.")
x = False
### raise error led if hub power failed
if not x:
self.disp.control_led('neterr', True)
## wait for system to settle
time.sleep(10)
retrycount = 3
while retrycount > 0:
try:
res = self.ready_internet()
except InternetConnectionError:
self.logger.exception('Could not dial modem.')
res = None
if res is not None:
break
self.logger.info("Waiting 30 seconds till next attempt.")
time.sleep(30)
retrycount -= 1
self.logger.info("%d attempts left." % retrycount)
# Assume we have net connectivity by this point.
## sync time if need be
os.popen('ntpdate -t 90 0.pool.ntp.org 1.pool.ntp.org 2.pool.ntp.org')
time.sleep(30)
self.disp.control_led('sync', True)
try:
self.upload_kiosk_messages()
except:
self.logger.exception("Unable to upload kiosk messages")
self.disp.control_led('neterr', True)
try:
self.upload_data_messages()
except:
self.logger.exception('Network Synchronisation Failed!')
self.disp.control_led('neterr', True)
try:
self.service_server_messages()
except:
self.logger.exception("Unable to get commands from server.")
self.disp.control_led('sync', False)
# terminate network
self.stop_internet()
time.sleep(5)
## power off the modem
try:
Beagleboard.turn_off_usbhub()
except:
self.logger.exception("Error encountered when attempting to power off USB hub.")
