def getSensorLocationInfo(sensorId): """ Get sensor location information. This returns all the Loc messages posted by the sensor. """ util.debugPrint("getSensorLocationInfo") try: cur = DbCollections.getLocationMessages().find({SENSOR_ID: sensorId}) cur.batch_size(20) retval = {} locations = [] for c in cur: location = {} location['Lat'] = c['Lat'] location['Lon'] = c['Lon'] location['Alt'] = c['Alt'] location['t'] = c['t'] location['bandInfo'] = c['bandInfo'] locations.append(location) retval["locations"] = locations retval[STATUS] = "OK" return retval except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() raise return retval
def denyAccount(email, token, urlPrefix): # If the admin denies the account creation, # The system will send the user a "we regret to inform you..." email that their account # was denied. AccountLock.acquire() try: tempAccounts = DbCollections.getTempAccounts() account = tempAccounts.find_one({ ACCOUNT_EMAIL_ADDRESS: email, TEMP_ACCOUNT_TOKEN: token }) if account is None: util.debugPrint( "Token not found for email address; invalid request") return False else: # remove email from tempAccounts: tempAccounts.remove({"_id": account["_id"]}) # email user to let them know that their request was denied: t = threading.Thread(target=generateUserDenyAccountEmail, args=(email, urlPrefix)) t.daemon = True t.start() return True except: return False finally: AccountLock.release()
def getLocationInfo(): """ Get all the location and system messages that we know about. """ util.debugPrint("getLocationInfo") try: cur = DbCollections.getLocationMessages().find({}) cur.batch_size(20) retval = {} locationMessages = [] sensorIds = sets.Set() for c in cur: (c["tStartLocalTime"], c["tStartLocalTimeTzName"]) = timezone.getLocalTime( c["t"], c[TIME_ZONE_KEY]) del c["_id"] locationMessages.append(c) sensorIds.add(c[SENSOR_ID]) retval["locationMessages"] = locationMessages systemMessages = [] for sensorId in sensorIds: systemMessage = DbCollections.getSystemMessages().find_one( {SENSOR_ID: sensorId}) # Issue 139 if systemMessage is not None: del systemMessage["_id"] systemMessages.append(systemMessage) retval["systemMessages"] = systemMessages except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() raise return retval
def generateZipFileForDownload(sensorId, startTime, days, sys2detect, minFreq, maxFreq, sessionId): """ Prepare a zip file for download. """ try: util.debugPrint("generateZipFileForDownload: " + sensorId + " startTime = " + str(startTime) + " days " + str(days) + " sys2detect " + sys2detect + " minFreq " + str(minFreq) + " maxFreq " + str(maxFreq)) if not checkForDataAvailability(sensorId, startTime, days, sys2detect, minFreq, maxFreq): util.debugPrint("No data found") retval = {STATUS: "NOK", "StatusMessage": "No data found"} else: dumpFileNamePrefix = "dump-" + sensorId + "." + str( minFreq) + "." + str(maxFreq) + "." + str( startTime) + "." + str(days) zipFileName = sessionId + "/" + dumpFileNamePrefix + ".zip" t = threading.Thread(target=generateZipFile, args=(sensorId, startTime, days, sys2detect, minFreq, maxFreq, dumpFileNamePrefix, sessionId)) t.daemon = True t.start() url = Config.getGeneratedDataPath() + "/" + zipFileName # generateZipFile(sensorId,startTime,days,minFreq,maxFreq,dumpFileNamePrefix,sessionId) retval = {STATUS: "OK", "dump": zipFileName, URL: url} return retval except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() raise
def resetPassword(accountData): """ Reset the password. """ util.debugPrint("resetPassword " + str(accountData)) userName = accountData[ACCOUNT_EMAIL_ADDRESS].strip() password = accountData[ACCOUNT_PASSWORD] privilege = accountData[ACCOUNT_PRIVILEGE] passwordHash = Accounts.computeMD5hash(password) existingAccount = DbCollections.getAccounts().find_one({ ACCOUNT_EMAIL_ADDRESS: userName, ACCOUNT_PASSWORD: passwordHash }) if existingAccount is None: return {STATUS: "NOK", ERROR_MESSAGE: "Authentication Failure"} elif existingAccount[ACCOUNT_LOCKED]: return {STATUS: "NOK", ERROR_MESSAGE: "Account Locked"} else: newPassword = accountData[ACCOUNT_NEW_PASSWORD] newPasswordHash = Accounts.computeMD5Hash(newPassword) result = Accounts.isPasswordValid(newPassword) if result[0] != "OK": return Accounts.packageReturn(result) else: existingAccount[ACCOUNT_PASSWORD] = newPasswordHash DbCollections.getAccounts().update({"_id": existingAccount["_id"]}, {"$set": existingAccount}, upsert=False) return {STATUS: "OK"}
def getData(msg): """ get the data associated with a data message. """ fs = gridfs.GridFS(DbCollections.getSpectrumDb(), msg[SENSOR_ID] + "_data") messageBytes = fs.get(ObjectId(msg[Defines.DATA_KEY])).read() nM = int(msg["nM"]) n = int(msg["mPar"]["n"]) lengthToRead = nM * n #int(nM * n) if lengthToRead == 0: util.debugPrint("No data to read") return None if msg[DATA_TYPE] == ASCII: powerVal = eval(messageBytes) elif msg[DATA_TYPE] == BINARY_INT8: powerVal = np.array(np.zeros(n * nM)) for i in range(0, int(lengthToRead)): powerVal[i] = float(struct.unpack('b', messageBytes[i:i + 1])[0]) elif msg[DATA_TYPE] == BINARY_INT16: powerVal = np.array(np.zeros(n * nM)) for i in range(0, lengthToRead, 2): powerVal[i] = float(struct.unpack('h', messageBytes[i:i + 2])[0]) elif msg[DATA_TYPE] == BINARY_FLOAT32: powerVal = np.array(np.zeros(n * nM)) for i in range(0, lengthToRead, 4): powerVal[i] = float(struct.unpack('f', messageBytes[i:i + 4])[0]) return list(powerVal)
def restartService(service, sessionId): """ Restart specified service URL Path: sessionId the session Id of the login in session. URL Args: None Request Body: A String of the name of the service """ try: util.debugPrint("restartService " + str(service)) if not authentication.checkSessionId(sessionId, ADMIN): abort(403) util.debugPrint("passed authentication") if restartThisService(service): return jsonify({"status": "OK"}) else: return jsonify({ "status": "NOK", "ErrorMessage": "Unknown service" }) except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() util.logStackTrace(sys.exc_info()) raise
def thisServiceStatus(service): try: if service in SERVICE_NAMES: output = subprocess.Popen(["service", service, "status"], stdout=subprocess.PIPE) statusRawInit, errorStr = output.communicate() if not errorStr is None: util.debugPrint("Error String detected (status): " + str(errorStr)) return {STATUS: NOK, ERROR_MESSAGE: errorStr} statusRaw = statusRawInit.split() util.debugPrint("statusRaw: " + str(statusRaw)) if "running" in statusRaw: return {STATUS: OK, SERVICE_STATUS: "Running"} elif "stopped" in statusRaw: return {STATUS: OK, SERVICE_STATUS: "Stopped"} else: return {STATUS: OK, SERVICE_STATUS: "UNKNOWN"} else: util.errorPrint(service + " does not match a service") return { STATUS: NOK, ERROR_MESSAGE: service + " does not match a service" } except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() util.logStackTrace(sys.exc_info()) raise
def runForensics(sensorId, algorithm, timestamp, sessionId): """ Run forensics at the sensor. This just relays the command to the sensor. The sensor will post back after the processing is done. timestamp -- the timestamp of the capture. algorithm -- the algortithm to appy (from the toolbox that lives on the sensor) sessionId -- the login session id. """ try: if not authentication.checkSessionId(sessionId, USER): util.debugPrint("runForensics - request body not found") abort(403) command = { "sensorId": sensorId, "timestamp": int(timestamp), "algorithm": algorithm, "command": "analyze" } sendCommandToSensor(sensorId, json.dumps(command)) return jsonify({STATUS: OK}) except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() util.logStackTrace(sys.exc_info()) raise
def addESAgentWorker(sessionId): try: if not authentication.checkSessionId(sessionId, ADMIN): abort(403) requestStr = request.data agentConfig = json.loads(requestStr) agentName = agentConfig["agentName"] bad_chars = invalid_chars.intersection(agentName) if bad_chars: msg = "Invalid character in agentName: {}" util.debugPrint(msg.format(bad_chars)) abort(400) key = agentConfig["key"] bad_chars = invalid_chars.intersection(key) if bad_chars: msg = "Invalid character in key: {}" util.debugPrint(msg.format(bad_chars)) abort(400) Config.addESAgent(agentName, key) agents = Config.getESAgents() retval = {"esAgents": agents} retval[STATUS] = 'OK' return jsonify(retval) except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() util.logStackTrace(sys.exc_info()) raise
def log(): if DebugFlags.debug: data = request.data jsonValue = json.loads(data) if "message" in jsonValue: message = jsonValue["message"] else: message = "" if "ExceptionInfo" in jsonValue: exceptionInfo = jsonValue["ExceptionInfo"] else: exceptionInfo = {} if len(exceptionInfo) != 0: util.errorPrint("Client Log Message: " + message) util.errorPrint("Client Exception Info:") for i in range(0, len(exceptionInfo)): util.errorPrint("Exception Message:") exceptionMessage = exceptionInfo[i]["ExceptionMessage"] util.errorPrint("Client Stack Trace:") stackTrace = exceptionInfo[i]["StackTrace"] util.errorPrint(exceptionMessage) decodeStackTrace(stackTrace) if "Traceback" in jsonValue: traceback = jsonValue["Traceback"] util.errorPrint("Traceback: " + traceback) else: util.debugPrint("Client Log Message: " + message) return "OK"
def deleteCaptureEvents(sensorId, startDate, sessionId): """ Delete the events from the capture db. Send a message to the sensor to do the same. """ try: if not authentication.checkSessionId(sessionId, ADMIN): util.debugPrint("deleteCaptureEvents: failed authentication") abort(403) sdate = int(startDate) if sdate < 0: util.debugPrint("deleteCaptureEvents: illegal param") abort(400) else: CaptureDb.deleteCaptureDb(sensorId, sdate) global memCache if memCache is None: memCache = MemCache() command = json.dumps({ "sensorId": sensorId, "timestamp": sdate, "command": "garbage_collect" }) sendCommandToSensor(sensorId, command) return jsonify({STATUS: "OK"}) except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() util.logStackTrace(sys.exc_info()) raise
def watchForFileAndSendMail(emailAddress, url, uri): """ Watch for the dump file to appear and send an email to the user after it has appeared. """ for i in range(0, 100): filePath = util.getPath(STATIC_GENERATED_FILE_LOCATION + uri) if os.path.exists(filePath) and os.stat(filePath).st_size != 0: message = "This is an automatically generated message.\n"\ + "The requested data has been generated.\n"\ + "Please retrieve your data from the following URL: \n"\ + url \ + "\nYou must retrieve this file within 24 hours." util.debugPrint(message) SendMail.sendMail(message, emailAddress, "Your Data Download Request") return else: util.debugPrint("Polling for file " + filePath) time.sleep(10) message = "This is an automatically generated message.\n"\ + "Tragically, the requested data could not be generated.\n"\ + "Sorry to have dashed your hopes into the ground.\n" SendMail.sendMail(message, emailAddress, "Your Data Download Request")
def getCaptureEvents(sensorId, startDate, dayCount, sessionId): """ get the capture events for a given sensor within the specified date range. """ try: if not authentication.checkSessionId(sessionId, USER): util.debugPrint("getCaptureEvents: failed authentication") abort(403) try: sdate = int(startDate) dcount = int(dayCount) except ValueError: abort(400) if sdate < 0 or dcount < 0: abort(400) elif dcount == 0: abort(400) return jsonify(CaptureDb.getEvents(sensorId, sdate, dcount)) except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() util.logStackTrace(sys.exc_info()) raise
def getDataSummary(sensorId, latitude, longitude, altitude, tmin=None, dayCount=None): """ Compute and return the data summary for the sensor, given its ID and position. """ locationMessage = DbCollections.getLocationMessages().find_one({ SENSOR_ID: sensorId, LON: longitude, LAT: latitude, ALT: altitude }) if locationMessage is None: util.debugPrint("Location Message not found") return {STATUS: "NOK", ERROR_MESSAGE: "Location Message Not Found"} retval = getSensorDataSummary(sensorId, locationMessage) if retval[STATUS] == "OK": retval[LOCATION_MESSAGE_ID] = str(locationMessage['_id']) bandStats = getDataSummaryForAllBands(sensorId, locationMessage, tmin=tmin, dayCount=dayCount) if bandStats[STATUS] == "OK": retval[BAND_STATISTICS] = bandStats["bands"] else: retval = {STATUS: "NOK", ERROR_MESSAGE: bandStats[ERROR_MESSAGE]} return retval
def stochasticGradientDescent(allData, trainExamples, key, numDays): # hyperparameters numIters = 200 eta = 0.0001 # initialize weights w = getInitialWeights(key, numDays) loss = trainLoss(allData, trainExamples, w, numDays, key) util.debugPrint("initial: w = %s, loss = %.4f" % (util.roundDictValues(w, 4), loss)) for t in range(1, numIters + 1): oldW = copy.deepcopy(w) for i in trainExamples: # loop through each training example # loss = sF(allData, w, i) gradient = sdF(allData, w, i, key, numDays) # gradient = gradient * eta util.scaleDict(gradient, eta) # weights = weights - gradient util.subtractDict(w, gradient) # util.debugPrint("iteration %d | example %d: w = %s" % (t, i, w)) # print weights and loss loss = trainLoss(allData, trainExamples, w, numDays, key) # util.debugPrint("iteration %d: w = %s, loss = %.4f" % (t, util.roundDictValues(w,4), loss)) if weightsAreSame(oldW, w): break # util.debugPrint("iteration %d: w = %s, loss = %.4f" % (t, util.roundDictValues(w,4), loss)) return w
def startStreamingServer(port): """ Start the streaming server and accept connections. """ global memCache if memCache is None: memCache = MemCache() soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM) l_onoff = 1 l_linger = 0 soc.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', l_onoff, l_linger)) portAssigned = False for p in range(port, port + 10, 2): try: print 'Trying port ', p soc.bind(('0.0.0.0', p)) soc.listen(10) socketServerPort = p memCache.setSocketServerPort(p) portAssigned = True util.debugPrint("DataStreaming: Bound to port " + str(p)) break except: print sys.exc_info() traceback.print_exc() util.debugPrint("DataStreaming: Bind failed - retry") if portAssigned: global occupancyQueue socketServer = startSocketServer(soc, socketServerPort) socketServer.start() else: util.errorPrint( "DataStreaming: Streaming disabled on worker - no port found.")
def deleteAccount(emailAddress): AccountLock.acquire() try: numAdmin = numAdminAccounts() util.debugPrint("delete account.") accounts = DbCollections.getAccounts() account = accounts.find_one({ACCOUNT_EMAIL_ADDRESS: emailAddress}) if account is None: util.debugPrint("Cannot delete account, email not found " + emailAddress) retVal = ["INVALUSER", "Account not found."] elif numAdmin == 1 and account[ACCOUNT_PRIVILEGE] == ADMIN: util.debugPrint("Cannot delete account, last admin account.") retVal = [ "LASTADMIN", "Last admin account, cannot perform operation or there would be no admin accounts left." ] else: util.debugPrint("Removing account.") accounts.remove({"_id": account["_id"]}) util.debugPrint("account deleted: " + emailAddress) retVal = ["OK", ""] except: retVal = [ "NOK", "There was an issue on the server, please check the system logs." ] finally: AccountLock.release() return packageAccountsReturn(retVal)
def loadLastDataMessage(self, sensorId, bandName): key = str(STREAMING_LAST_DATA_MESSAGE + sensorId + ":" + bandName).encode("UTF-8") util.debugPrint("loadLastDataMessage: " + key) lastDataMessage = self.mc.get(key) if lastDataMessage is not None: self.lastDataMessage[sensorId + ":" + bandName] = lastDataMessage return self.lastDataMessage
def disconnectSensor(sensorId): """ Send a sensor a command to exit. URL Path: sensorId -- the session ID of the login session. URL Args: None Request Body: Contains authentication information for the agent that is authorized to arm and disarm the sensor: - agentName: Name of the agent to arm/disarm sensor. - key : password of the agent to arm/disarm the sensor. HTTP Return Codes: - 200 OK: invocation was successful. - 403 Forbidden: authentication failure - 400 Bad request: Sensor is not a streaming sensor. Example Invocation: :: params = {} params["agentName"] = "NIST_ESC" params["key"] = "ESC_PASS" r = requests.post("https://"+ host + ":" + str(443) + "/sensorcontrol/disconnectSensor/" + self.sensorId + "/LTE:70315780:713315880",data=json.dumps(params),verify=False) """ try: util.debugPrint("disconnectSensor: sensorId " + sensorId) requestStr = request.data if requestStr is None: abort(400) accountData = json.loads(requestStr) if not authentication.authenticateSensorAgent(accountData): abort(403) sensorConfig = SensorDb.getSensorObj(sensorId) if sensorConfig is None: abort(404) if not sensorConfig.isStreamingEnabled(): abort(400) sendCommandToSensor( sensorId, json.dumps({ "sensorId": sensorId, "command": "exit" })) return jsonify({STATUS: OK}) except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() util.logStackTrace(sys.exc_info()) raise
def getSensorDataSummary(sensorId, locationMessage): sensor = SensorDb.getSensorObj(sensorId) if sensor is None: return {STATUS: NOK, ERROR_MESSAGE: "Sensor Not found"} measurementType = sensor.getMeasurementType() tzId = locationMessage[TIME_ZONE_KEY] acquisitionCount = LocationMessage.getMessageCount(locationMessage) util.debugPrint("AquistionCount " + str(acquisitionCount)) if acquisitionCount == 0: return { "status": "OK", "minOccupancy": 0, "tStartReadings": 0, "tStartLocalTime": 0, "tStartLocalTimeFormattedTimeStamp": "UNKNOWN", "tStartDayBoundary": 0, "tEndDayBoundary": 0, "tEndReadings": 0, "tEndLocalTimeFormattedTimeStamp": "UNKNOWN", "maxOccupancy": 0, "measurementType": measurementType, "isStreamingEnabled": sensor.isStreamingEnabled(), "sensorStatus": sensor.getSensorStatus(), COUNT: 0 } minTime = LocationMessage.getFirstDataMessageTimeStamp(locationMessage) maxTime = LocationMessage.getLastDataMessageTimeStamp(locationMessage) tStartDayBoundary = timezone.getDayBoundaryTimeStampFromUtcTimeStamp( minTime, tzId) (minLocalTime, tStartLocalTimeTzName) = timezone.getLocalTime(minTime, tzId) tEndDayBoundary = timezone.getDayBoundaryTimeStampFromUtcTimeStamp( maxTime, tzId) tstampMin = timezone.formatTimeStampLong(minTime, tzId) tstampMax = timezone.formatTimeStampLong(maxTime, tzId) retval = { "status": "OK", "maxOccupancy": 0, "minOccupancy": 0, "tStartReadings": minTime, "tStartLocalTime": minLocalTime, "tStartLocalTimeFormattedTimeStamp": tstampMin, "tStartDayBoundary": tStartDayBoundary, "tEndDayBoundary": tEndDayBoundary, "tEndReadings": maxTime, "tEndLocalTimeFormattedTimeStamp": tstampMax, "measurementType": measurementType, "isStreamingEnabled": sensor.isStreamingEnabled(), "sensorStatus": sensor.getSensorStatus(), COUNT: acquisitionCount } return retval
def generateUserDenyAccountEmail(emailAddress, serverUrlPrefix): """ Generate and send email. This is a thread since the SMTP timeout is 30 seconds """ message = "This is an automatically generated message from the Spectrum Monitoring System.\n"\ + "We regret to inform you that your request for a new account from the CAC Measured Spectrum Occupancy Database was denied.\n"\ + "Please contact the system administrator for more information.\n" util.debugPrint(message) SendMail.sendMail(message, emailAddress, "Account information")
def generateSpectrumForFFTPower(msg, milisecOffset, sessionId): chWidth = Config.getScreenConfig()[CHART_WIDTH] chHeight = Config.getScreenConfig()[CHART_HEIGHT] startTime = msg["t"] nM = int(msg["nM"]) n = int(msg["mPar"]["n"]) measurementDuration = int(msg["mPar"]["td"]) miliSecondsPerMeasurement = float( measurementDuration * MILISECONDS_PER_SECOND) / float(nM) powerVal = np.array(msgutils.getData(msg)) spectrogramData = np.transpose(powerVal.reshape(nM, n)) col = int(milisecOffset / miliSecondsPerMeasurement) util.debugPrint("Col = " + str(col)) spectrumData = spectrogramData[:, col] maxFreq = msg["mPar"]["fStop"] minFreq = msg["mPar"]["fStart"] nSteps = len(spectrumData) freqDelta = float(maxFreq - minFreq) / float(1E6) / nSteps freqArray = [ float(minFreq) / float(1E6) + i * freqDelta for i in range(0, nSteps) ] plt.figure(figsize=(chWidth, chHeight)) plt.scatter(freqArray, spectrumData, color='red', label='Signal Power') # TODO -- fix this when the sensor is calibrated. wnI = msg[NOISE_FLOOR] noiseFloorData = [wnI for i in range(0, len(spectrumData))] plt.scatter(freqArray, noiseFloorData, color='black', label="Noise Floor") xlabel = "Freq (MHz)" ylabel = "Power (dBm)" plt.xlabel(xlabel) plt.ylabel(ylabel) locationMessage = DbCollections.getLocationMessages().find_one( {"_id": ObjectId(msg["locationMessageId"])}) t = msg["t"] + milisecOffset / float(MILISECONDS_PER_SECOND) tz = locationMessage[TIME_ZONE_KEY] title = "Spectrum at " + timezone.formatTimeStampLong(t, tz) plt.title(title) spectrumFile = sessionId + "/" + msg[SENSOR_ID] + "." + str( startTime) + "." + str(milisecOffset) + ".spectrum.png" spectrumFilePath = util.getPath( STATIC_GENERATED_FILE_LOCATION) + spectrumFile plt.savefig(spectrumFilePath, pad_inches=0, dpi=100) plt.clf() plt.close() # plt.close("all") retval = { "status": "OK", "spectrum": Config.getGeneratedDataPath() + "/" + spectrumFile, "freqArray": freqArray, "spectrumData": spectrumData.tolist(), "noiseFloorData": noiseFloorData, "title": title, "xlabel": xlabel, "ylabel": ylabel } return retval
def decodeStackTrace(stackTrace): lines = stackTrace.split() for line in lines: pieces = line.split(":") if pieces[0] in gwtSymbolMap: print gwtSymbolMap.get(pieces[0]) file = gwtSymbolMap.get(pieces[0])["file"] lineNo = gwtSymbolMap.get(pieces[0])["line"] util.debugPrint(file + ": " + lineNo + ": " + pieces[1])
def generateSysMessagesZipFile(emailAddress, dumpFileNamePrefix, sensorId, sessionId): dumpFileName = sessionId + "/" + dumpFileNamePrefix + ".txt" zipFileName = sessionId + "/" + dumpFileNamePrefix + ".zip" dirname = util.getPath(STATIC_GENERATED_FILE_LOCATION + sessionId) if not os.path.exists(dirname): os.makedirs(dirname) dumpFilePath = util.getPath(STATIC_GENERATED_FILE_LOCATION) + dumpFileName zipFilePath = util.getPath(STATIC_GENERATED_FILE_LOCATION) + zipFileName if os.path.exists(dumpFilePath): os.remove(dumpFilePath) if os.path.exists(zipFilePath): os.remove(zipFilePath) systemMessages = DbCollections.getSystemMessages().find( {SENSOR_ID: sensorId}) if systemMessages is None: util.debugPrint("generateZipFileForDownload: No system info found") return dumpFile = open(dumpFilePath, "a") zipFile = zipfile.ZipFile(zipFilePath, mode="w") try: for systemMessage in systemMessages: data = msgutils.getCalData(systemMessage) del systemMessage["_id"] if CAL in systemMessage and DATA_KEY in systemMessage[CAL]: del systemMessage[CAL][DATA_KEY] systemMessage[DATA_TYPE] = ASCII systemMessageString = json.dumps(systemMessage, sort_keys=False, indent=4) + "\n" length = len(systemMessageString) dumpFile.write(str(length)) dumpFile.write("\n") dumpFile.write(systemMessageString) if data is not None: dataString = str(data) dumpFile.write(dataString) dumpFile.write("\n") zipFile.write(dumpFilePath, arcname=dumpFileNamePrefix + ".txt", compress_type=zipfile.ZIP_DEFLATED) zipFile.close() session = SessionLock.getSession(sessionId) if session is None: os.remove(dumpFilePath) os.remove(zipFilePath) return url = Config.getGeneratedDataPath() + "/" + zipFileName watchForFileAndSendMail(emailAddress, url, zipFileName) except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() finally: os.remove(dumpFilePath) zipFile.close()
def generateUserAccountPendingAuthorizationEmail(emailAddress, serverUrlPrefix): """ Generate and send email. This is a thread since the SMTP timeout is 30 seconds """ message = "This is an automatically generated message from the Spectrum Monitoring System.\n"\ + "You requested a new account for the CAC Measured Spectrum Occupancy Database.\n"\ + "Your request has been sent to the system administrator for authorization.\n" util.debugPrint(message) SendMail.sendMail(message, emailAddress, "Account pending authorization")
def generateChangePasswordEmail(emailAddress, serverUrlPrefix): """ Generate and send email. This is a thread since the SMTP timeout is 30 seconds """ message = "This is an automatically generated message from the Spectrum Monitoring System.\n"\ + "Your password has been changed to value you entered into " + str(serverUrlPrefix + "/spectrumbrowser") + "\n"\ + "If you did not originate the change password request, please contact the system administrator.\n" util.debugPrint(message) SendMail.sendMail(message, emailAddress, "change password link")
def getResourceData(ws): """ Web-browser websocket connection handler. """ util.debugPrint("getResourceData") try: ResourceDataStreaming.getResourceData(ws) except: util.logStackTrace(sys.exc_info()) traceback.print_exc() raise
def removeSession(self, sessionId): self.acquire() try: util.debugPrint("removeSession: " + sessionId) activeSessions = self.mc.get(SESSIONS) self.mc.delete(SESSIONS) if sessionId in activeSessions: del activeSessions[sessionId] self.mc.add(SESSIONS, activeSessions) finally: self.release()
def unlockAccountWorker(emailAddress, sessionId): try: if not authentication.checkSessionId(sessionId, ADMIN): abort(403) util.debugPrint("unlockAccount") return jsonify(AccountsManagement.unlockAccount(emailAddress)) except: print "Unexpected error:", sys.exc_info()[0] print sys.exc_info() traceback.print_exc() util.logStackTrace(sys.exc_info()) raise