def __init__(self, socketio, rtklib_path = None, config_path=None, enable_led = True, log_path = None):
print("RTKLIB 1")
print(rtklib_path)
print(log_path)
if rtklib_path is None:
rtklib_path = os.path.join(os.path.expanduser("~"), "RTKLIB")
if config_path is None:
self.config_path = os.path.join(os.path.dirname(__file__), "rtklib_configs")
else:
self.config_path = config_path
if log_path is None:
#TODO find a better default location
self.log_path = "../data"
else:
self.log_path = log_path
# This value should stay below the timeout value or the Satellite/Coordinate broadcast
# thread will stop
self.sleep_count = 0
# default state for RTKLIB is "rover single"
self.state = "base"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtklib_path, self.config_path)
self.conm = ConfigManager(rtklib_path, self.config_path)
# this one handles base settings
self.s2sc = Str2StrController(rtklib_path)
# take care of serving logs
self.logm = LogManager(rtklib_path, self.log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
# self.enable_led = enable_led
# if self.enable_led:
# self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
self.conversion_thread = None
self.system_time_correct = False
# self.system_time_correct = True
self.time_thread = Thread(target = self.setCorrectTime)
self.time_thread.start()
def processRun(self, processNumber):
"""
The code to run a new worker process
"""
# Process code
signal.signal(signal.SIGTERM, signal.SIG_DFL)
signal.signal(signal.SIGHUP, signal.SIG_DFL)
self.log = LogManager("%s.%u" % (CONFIG.hostname, processNumber),
False)
self.ovtDB.reconnect(quiet=True, log=self.log)
innerexception = None
try:
try:
scheduler = Scheduler.Scheduler(self, processNumber)
scheduler.run()
except Exception, e:
innerexception = formatExceptionInfo()
try:
self.ovtDB.FORCEROLLBACK()
except DatabaseRetryException, e:
self.ovtDB.reconnect()
self.ovtDB.setAutoCommit(True)
self.logDB(processNumber, innerexception)
self.log.write("%s: %s" % (time.asctime(), innerexception))
sys.exit(3)
def main():
lm = LogManager(cur_prog_name)
logger = lm.get_logger()
logger.info('..MAIN PROCESS START..')
sw_exit_on_err = True
# pc = ProgController(logger, env.FILE_PATH_CONTROLLER, sw_exit_on_err)
pc = ProgController(logger, '/home/mon', sw_exit_on_err)
exl_type, input_folder, output_file = pc.chk_parm(sys.argv)
l_folders_chk_mnt.append(input_folder)
pc.chk_mount(l_folders_chk_mnt)
# pc.chk_run_controller()
mm = MailManager(logger)
# m a i l e r inheritance?
# m a i l e r inheritance?
# fh = FileHandler(logger, input_folder, exl_type)
# df_ifile_read, col_list, val_conv = fh.handle_input_file()
# fh.handle_input_file()
# eh = ExcelHandler(logger, df_ifile_read, col_list, val_conv)
# eh = ExcelHandler(logger, fh)
eh = ExcelHandler(logger, input_folder, exl_type, output_file)
eh.exl_handle()
logger.info('**MAIN PROCESS END**')
def __init__(self, parent=None):
''' Initialization function of the class
Binding the GUI to the corresponding logic implemented in this class
'''
QtWidgets.QWidget.__init__(self, parent)
# Read UI from Qt Creator
self.ui = Ui_BioEECoinsMain()
# Link the Opal Kelly FPGA
self.device = OpalKelly()
# Local log manager
self.log = LogManager()
# Control variables
self.updateFlag = True
self.iterateFlag = False
self.displayNumber = 1
# Initialize quick access to gui items
self.bChannel = [None]*48
self.ledChannel = [None]*48
self.initializeUI()
self.ui.setupUi(self)
self.device.openDevice()
self.device.configurePLL()
self.linkGUI()
# Configure log manager
self.log.setFileLog(Constants.LOG_FILE_NAME)
self.log.setQTextLog(self.ui.logWindow)
def Search(update, context, query=None):
text = "<b>Hemen buluyorum</b>. 🔍🔍"
context.bot.send_message(chat_id=update.message.chat_id,
text=text,
parse_mode=ParseMode.HTML)
urhoba = UrhobA()
if query == None:
searchText = update.message.text
else:
searchText = query
searchResult = urhoba.SearchVideo(searchText)
try:
if len(searchResult) > 0:
buttons = []
for video in searchResult:
buttonOne = [
InlineKeyboardButton(text=f'{video.title}',
callback_data='none')
]
buttonTwo = [
InlineKeyboardButton(
text=f'🎬',
callback_data=f'videourhoba{video.video_id}'),
InlineKeyboardButton(text=f'🔗',
url="https://www.urhoba.net"),
InlineKeyboardButton(
text=f'🎧',
callback_data=f'audiourhoba{video.video_id}')
]
buttons.append(buttonOne)
buttons.append(buttonTwo)
replyMarkup = InlineKeyboardMarkup(buttons)
context.bot.send_message(
chat_id=update.message.chat_id,
text=f"<b>Arama sonucu:</b>\n{searchText}",
parse_mode=ParseMode.HTML,
reply_markup=replyMarkup)
else:
text = "Aradığın şeyi bulamadım. 😢"
context.bot.send_message(chat_id=update.message.chat_id,
text=text,
parse_mode=ParseMode.HTML)
urhoba.SearchCountUpdateUser(update.message.from_user.id,
update.message.from_user.username)
except:
text = "İstediğin şeyi ararken bir sorun meydana geldi! 😢\nBunun ile en kısa süre içerisinde ilgileneceğiz."
context.bot.send_message(chat_id=update.message.chat_id,
text=text,
parse_mode=ParseMode.HTML)
logManager = LogManager("TelegramLog")
logManager.AddLog(
f'Telegram (YouTube) arama yaparken bir sorun meydana geldi!\n Search Text : {searchText} \n Search result : {searchResult}'
)
def __init__(self):
"""Classe que representa o programa RMQuality."""
try:
self._TIME_TO_WAIT = 3
self._SECOND_TO_NEW_EXECUTION = 60
# Define a data padrão da última execução da extensão
self._logger = LogManager(log_path="./log/",
file_name="issuequality")
self._report_analiser = IssueReportAnalyser()
except Exception as e:
raise e
class LAManager():
def __init__(self):
self.__param = loadparam.Param()
self.__logger = LogManager()
self.__error_code = "2x"
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(self.__param.Open["GPIO"], GPIO.OUT)
GPIO.setup(self.__param.Close["GPIO"], GPIO.OUT)
GPIO.output(self.__param.Open["GPIO"], GPIO.LOW)
GPIO.output(self.__param.Close["GPIO"], GPIO.LOW)
def Open(self):
self.__Move(self.__param.Open)
def Close(self):
self.__Move(self.__param.Close)
def SavePosition(self, pos):
try:
with open(self.__param.PositionFile, 'r+') as f:
f.seek(0)
f.write(str(pos))
except Exception as e:
self.__logger.Err(
"something bad just happened while trying to save position in position.txt",
self.__error_code + '1')
self.__logger.Err(e, self.__error_code + '1')
def __Move(self, param):
try:
gpio = param["GPIO"]
duration = param["duration"]
pos = param["position"]
GPIO.output(gpio, GPIO.HIGH)
sleep(int(duration) / 1000)
GPIO.output(gpio, GPIO.LOW)
self.SavePosition(pos)
self.__logger.Log("switching gpio {0} for {1} ms".format(
gpio, duration))
except Exception as e:
print(e)
self.__logger.Err(
"error while moving linear actuator gpio={0} duration={1} ms - see error below for more info"
.format(gpio, duration), self.__error_code + '2')
self.__logger.Err(e, self.__error_code + '2')
finally:
GPIO.cleanup()
def __init__(self):
self.__param = loadparam.Param()
self.__logger = LogManager()
self.__error_code = "2x"
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(self.__param.Open["GPIO"], GPIO.OUT)
GPIO.setup(self.__param.Close["GPIO"], GPIO.OUT)
GPIO.output(self.__param.Open["GPIO"], GPIO.LOW)
GPIO.output(self.__param.Close["GPIO"], GPIO.LOW)
def __init__(self, ovtDB, log=None):
"""
Finds testruns that are ready to be processed
Verifies the internal consistency of the testrun
Determines which overtest host to allocate the test to
Locks the testrun so no further editing can happen
"""
self.ovtDB = ovtDB
if log == None:
self.log = LogManager("host_allocator", True)
else:
self.log = log
self.ovtDB.registerLog(self.log)
self.depCheck = DependencyCheck(ovtDB, log=False)
class MailManager:
#region Init
def __init__(self) -> None:
self.fromMail = MailSettings.fromMail
self.fromPassword = MailSettings.fromPassword
self.smtpHost = MailSettings.smtpHost
self.smtpPort = MailSettings.smtpPort
self.logManager = LogManager("MailManager")
#endregion
#region Send Mail
def SendMail(self, subject, content, toMail):
try:
message = MIMEMultipart("alternative")
message["Subject"] = subject
message["From"] = self.fromMail
message["To"] = toMail
_content = MIMEText(content.encode('utf-8'), _charset='utf-8')
message.attach(_content)
with smtplib.SMTP_SSL(self.smtpHost, self.smtpPort) as server:
server.login(self.fromMail, self.fromPassword)
server.sendmail(self.fromMail, toMail, message.as_string())
except Exception as e:
self.logManager.AddLog(
f"Mail gönderilemedi!\nHata Kodu: {e}\nMail başlığı : {subject} \nMail içeriği : {content} \nAlıcı : {toMail}"
)
ColoredPrint.RedPrint(
f"Mail gönderilemedi!\nHata Kodu: {e}\nMail başlığı : {subject} \nMail içeriği : {content} \nAlıcı : {toMail}"
)
#endregion
def __init__(self,
socketio,
rtklib_path=None,
enable_led=True,
log_path=None):
if rtklib_path is None:
rtklib_path = "/home/reach/RTKLIB"
if log_path is None:
log_path = "/home/reach/logs"
# default state for RTKLIB is "rover single"
self.state = "rover"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtklib_path)
self.conm = ConfigManager(rtklib_path)
# this one handles base settings
self.s2sc = Str2StrController(rtklib_path)
# take care of serving logs
self.logm = LogManager(rtklib_path, log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
self.conversion_thread = None
self.system_time_correct = False
self.time_thread = Thread(target=self.setCorrectTime)
self.time_thread.start()
class Host:
"""
A host is a machine that can host tests. Hosts have attributes in the group:
'Overtest Host'
This class initialises a host and manages the process count.
"""
def __init__(self, ovtDB):
self.shuttingDown = False
self.ovtDB = ovtDB
self.log = LogManager(CONFIG.hostname, False)
self.ovtDB.registerLog(self.log)
self.pidfile = None
def getHostID(self):
"""
Return the host identified (a resource id)
"""
return self.hostid
def processRun(self, processNumber):
"""
The code to run a new worker process
"""
# Process code
signal.signal(signal.SIGTERM, signal.SIG_DFL)
signal.signal(signal.SIGHUP, signal.SIG_DFL)
self.log = LogManager("%s.%u" % (CONFIG.hostname, processNumber),
False)
self.ovtDB.reconnect(quiet=True, log=self.log)
innerexception = None
try:
try:
scheduler = Scheduler.Scheduler(self, processNumber)
scheduler.run()
except Exception, e:
innerexception = formatExceptionInfo()
try:
self.ovtDB.FORCEROLLBACK()
except DatabaseRetryException, e:
self.ovtDB.reconnect()
self.ovtDB.setAutoCommit(True)
self.logDB(processNumber, innerexception)
self.log.write("%s: %s" % (time.asctime(), innerexception))
sys.exit(3)
def __init__(self, ovtDB):
"""
Submit a result for an action in a testsuite
"""
self.ovtDB = ovtDB
self.log = LogManager(None, True)
self.ovtDB.registerLog(self.log)
self.debug = False
class NsIdCreation(Resource, ServiceManager):
logger = LogManager.getInstance().get_logger()
def post(self):
# 1. [WEB->RESTIF] RECEIVE PROCESS
try:
content = request.get_json(force=True)
data = json.dumps(content)
except Exception as e:
data = ''
# 2. [WEB->RESTIF] RECEIVE LOGGING
ServiceManager.RecvLogging(self.logger, data, request)
# 3. [RESTIF->APP] MAKE SEND STRUCT
header = HttpHeader()
header.method = ServiceManager.getMethodType(request.method)
header.api_type = ApiType.NSLCM_API_TYPE
header.resource_type = ResourceType.NSLCM_NS_INSTANCES
header.op_type = OPType.Create_NS_Identifier_OP_TYPE
header.encoding = ContentEncoding.PLAIN
Info = ServiceManager.getHttpInfo()
self.logger.info(type(MethodType.POST_METHOD_TYPE))
self.clientId = PLTEManager.getInstance().getClientReqId()
reqMsg = ServiceManager.setApiToStructMsg(request, data, self.clientId,
header, Info)
# 4. [RESTIF->APP] SEND QUEUE MESSAGE(RELAY)
PLTEManager.getInstance().sendCommand(ApiDefine.NS_ID_CREATE, self,
reqMsg)
# 5. WAIT
self.receiveReqId = -1
while self.clientId != self.receiveReqId:
try:
time.sleep(1)
except Exception as e:
self.logger.error(e)
# 6. [RESTIF->WEB] SEND LOGGING
ServiceManager.SendLogging(self.logger, self.resMsg)
# 7. [RESTIF->WEB] SEND RESPONSE
return flask.Response(
self.resMsg.jsonBody,
# mimetype=content_type,
status=self.rspCode)
# overide method
def setComplete(self, rspCode, reqId, rcvMsg):
self.resMsg = rcvMsg
self.rspCode = rspCode
self.receiveReqId = reqId
def __init__(self, ovtDB):
"""
Resource claiming system
"""
self.ovtDB = ovtDB
self.log = LogManager(None, True)
self.ovtDB.registerLog(self.log)
self.debug = False
self.globals = {}
self.userclaimid = None
class PLTEManager(Manager):
__instance = None
logger = LogManager.getInstance().get_logger()
# SenderInfo Class Object List
plteMembers = []
@staticmethod
def getInstance():
""" Static access method. """
if PLTEManager.__instance == None:
PLTEManager.__instance = PLTEManager()
return PLTEManager.__instance
def __init__(self):
self.logger.debug('PLTE Manager Init')
self.clientReqId = 0
pass
def receiveHandling(self, rspCode, reqId, rcvMsg):
for member in PLTEManager.plteMembers:
if member.getCliReqId() == reqId:
# Service Manager
source = member.getSource()
# Service setComplete
source.setComplete(rspCode, reqId, rcvMsg)
PLTEManager.plteMembers.remove(member)
def getClientReqId(self):
self.clientReqId += 1
if self.clientReqId > 2000000000:
self.clientReqId = 0
return self.clientReqId
@staticmethod
def sendCommand(command, source, reqId, msg):
# To avoid circular dependencies --> import under Function.
from PLTEConnector import PLTEConnector
senderInfo = SenderInfo(source, reqId)
# Transcation List Add
PLTEManager.plteMembers.append(senderInfo)
if not PLTEConnector.getInstance().sendMessage(command, reqId, msg):
# Transcation List Remove
PLTEManager.plteMembers.remove(senderInfo)
class VirtualWallet():
userMoney = {} # 存放所有用户的金额数据, 实际中应使用数据库
systemBankAmount: TPAD = None
bankManager: SBM = None
logManager: LogManager = None
def __init__(self, sba: TPAD):
self.bankManager = SBM(sba)
self.logManager = LogManager()
def pay(self, payerID: int, receiverID: int, amount: float) -> int:
try:
self.userMoney[payerID] -= amount
self.userMoney[receiverID] += amount
self.logManager.doLog()
return ConstVar.successCode
except Exception as e:
return ConstVar.failCode
def recharge(self, userID: int, userAmount: TPAD, amount: float) -> int:
try:
self.bankManager.transfer(sender=userAmount,
receiver=self.systemBankAmount,
amount=amount)
self.userMoney[userID] += amount
self.logManager.doLog()
return ConstVar.successCode
except Exception as e:
return ConstVar.failCode
def withDraw(self, userID: int, userAmount: TPAD, amount: float) -> int:
try:
self.bankManager.transfer(sender=self.systemBankAmount,
receiver=userAmount,
amount=amount)
self.userMoney[userID] -= amount
self.logManager.doLog()
return ConstVar.successCode
except Exception as e:
return ConstVar.failCode
def checkBalance(self, userID: int) -> float:
return self.userMoney[userID]
def checkLog(self, userID: int) -> str:
try:
return self.logManager.checklog(userID=userID)
except Exception as e:
return ConstVar.failCode
class QueryPmJob(Resource, ServiceManager):
logger = LogManager.getInstance().get_logger()
def post(self, pmJobId, reportId):
# 1. [WEB->RESTIF] RECEIVE PROCESS
try:
content = request.get_json(force=True)
data = json.dumps(content)
except Exception as e:
data = ''
# 2. [WEB->RESTIF] RECEIVE LOGGING
ServiceManager.RecvLogging(self.logger, data, request)
# 3. [RESTIF->APP] MAKE SEND STRUCT
self.clientId = PLTEManager.getInstance().getClientReqId()
reqMsg = ServiceManager.setApiToStructMsg(request, data, self.clientId)
# 4. [RESTIF->APP] SEND QUEUE MESSAGE(RELAY)
PLTEManager.getInstance().sendCommand(ApiDefine.QUERY_PM_JOB, self,
reqMsg)
# 5. WAIT
self.receiveReqId = -1
while self.clientId != self.receiveReqId:
try:
time.sleep(1)
except Exception as e:
self.logger.error(e)
# 6. [RESTIF->WEB] SEND LOGGING
ServiceManager.SendLogging(self.logger, self.resMsg)
# 7. [RESTIF->WEB] SEND RESPONSE
return flask.Response(
self.resMsg.jsonBody,
# mimetype=content_type,
status=self.rspCode)
# overide method
def setComplete(self, rspCode, reqId, rcvMsg):
self.resMsg = rcvMsg
self.rspCode = rspCode
self.receiveReqId = reqId
def __init__(self, socketio, rtklib_path = None, enable_led = True, log_path = None):
if rtklib_path is None:
rtklib_path = "/home/reach/RTKLIB"
if log_path is None:
log_path = "/home/reach/logs"
# default state for RTKLIB is "rover single"
self.state = "rover"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtklib_path)
self.conm = ConfigManager(rtklib_path)
# this one handles base settings
self.s2sc = Str2StrController(rtklib_path)
# take care of serving logs
self.logm = LogManager(rtklib_path, log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
self.conversion_thread = None
self.system_time_correct = False
self.time_thread = Thread(target = self.setCorrectTime)
self.time_thread.start()
def loadManager(self, methodToGetManager, *args, **kwargs):
"""
Show splash screen while calling `methodToGetManager(*args, **kwargs)`
to get a reference to the ObsLightManager.
"""
pixmap = QPixmap(join(UI_PATH, "splashscreen.png"))
self.splash = QSplashScreen(pixmap)
self.splash.show()
self.processEvents()
self.splash.showMessage(u"Loading...",
Qt.AlignBottom | Qt.AlignHCenter,
QColor(u"white"))
self.processEvents()
self.__obsLightManager = methodToGetManager(*args, **kwargs)
self.__logManager = LogManager(self)
self.__loadMainWindow()
self.__obsProjectManager = ObsProjectsManager(self)
self.__micProjectsManager = MicProjectsManager(self)
self.__mainWindow.callBeforeCloseEvent.append(self.__saveGeometry)
self.__mainWindow.callBeforeCloseEvent.append(self.__logManager.close)
self.splash.finish(self.mainWindow)
class Connector():
#class Connector(threading.Thread):
__metaclass__ = ABCMeta
logger = LogManager.getInstance().get_logger()
myQueue = None
# def signal_handler(signal, frame):
# self.logger.info('You pressed Ctrl+C!')
# sys.exit(0)
def __init__(self, manager):
super(Connector, self).__init__()
self.logger.debug("Connector Init")
self.manager = manager
# signal.signal(signal.SIGINT, self.signal_handler)
return
@abstractmethod
def sendMessage(self):
pass
def __init__(self, ovtDB):
self.ovtDB = ovtDB
self.log = LogManager("notification_daemon", True)
self.ovtDB.registerLog(self.log)
"""Binds an event to a widget and all its descendants."""
widget.bind(event, callback, add)
for child in widget.children.values():
bind_tree(child, event, callback)
if __name__ == "__main__":
# Set logging level to DEBUG
logging.basicConfig(level=logging.ERROR)
# Initialize the low-level drivers (don't list the debug drivers)
cflib.crtp.init_drivers(enable_debug_driver=False)
period_ms = 50
period_s = period_ms / 1000
# Log manager initialization
log = LogManager()
swarm = AsyncSwarm(uri_indices=(), log=log)
# Controller initialization
controller = FlockingController(ref=(0, 0, 1))
# controller = DistanceController(ref=(0, 0, 1), period_ms=period_ms)
controller_thread = ControllerThread(swarm=swarm,
controller_func=controller.compute,
period_ms=period_ms)
# controller_thread.start()
# GUI initialization
swarm_thread = SwarmThread(swarm=swarm,
controller=controller,
period_ms=period_ms)
gui = GUI(swarm_thread=swarm_thread,
def __init__(self, _ovtDB):
Interactive.__init__(self, _ovtDB)
self.wrapper = TextWrapper(initial_indent=" Description: ", subsequent_indent=" ", expand_tabs=False)
self.log = LogManager("monitor", True, local=True)
self.ovtDB.registerLog(self.log)
def __init__(self, ovtDB, log=True):
self.ovtDB = ovtDB
self.dependencies = Dependencies.Dependencies(ovtDB)
self.log = None
if log:
self.log = LogManager("dependency_check", True)
def __init__(self, ovtDB, log=True):
self.ovtDB = ovtDB
self.dependencies = Dependencies.Dependencies(ovtDB)
self.log = None
if log:
self.log = LogManager("grid_submitter", True)
def main():
user_id = sys.argv[1]
ip_addr, port = user_id.split(":")
if len(ip_addr) == 0:
ip_addr = '0.0.0.0'
port = int(port)
#Port = 10000 + index
ip_addr = (ip_addr, port)
localaddr = ip_addr
user_id = str(ip_addr).ljust(20)
user_id = user_id.replace(',', ':')
remote_ip, remote_port = sys.argv[2].split(":")
remote_port = int(remote_port)
remote_ip_addr = (remote_ip, remote_port)
remote_uid = str(remote_ip_addr).ljust(20)
remote_uid = remote_uid.replace(',', ':')
b = BroadCast()
um = UserManager(b, localaddr, user_id)
#Daemon threading for keeping adding the users
ua = user_add(um)
ua.setDaemon(True)
ua.start()
#auto UserManager update user list
#Try to connect the other members
#Testing version 1
'''
for i in range(20):
if i == index:
continue #don't need to connect itself
remote_uid = str(i).ljust(20)
port = 10000 + i
addr = (ip_addr, port)
sock = um.add_user(addr, remote_uid)
#if sock != None:
#add_new_user_abcast_list(remote_uid)
'''
#offset = int(sys.argv[2])
#remote_ip_addr = ("localhost", 10000 + offset)
#remote_uid = str(offset).ljust(20)
sock = um.add_user(remote_ip_addr, remote_uid)
'''
user_list = um.temp_user_list
um.update_user_list(user_list.keys(), um.view_id + 1)
user_list, view_id = um.get_user_list()
'''
#Init CASTSelecter
t_cast_s = CASTSelecter(b)
t_cast_s.setDaemon(True)
t_cast_s.start()
#Init ABCAST
#fake
ab_m = ABCASTManager(user_id, t_cast_s, um, LogManager())
ab_m.start()
#ABCAST Reader
t_ab_reader = read_from_abcast(ab_m)
t_ab_reader.setDaemon(True)
t_ab_reader.start()
#Init GBCAST
gb_m = GBCASTManager(user_id,t_cast_s, um, ab_m)
t_gbcast = Thread_GBCAST(gb_m)
t_gbcast.setDaemon(True)
t_gbcast.start()
print '====================================================='
#message
count = 0
while True:
message = raw_input()
if (message == "sync"):
gb_m.send_user_dict_request()
elif message == "clock":
gb_m.test_clock(str(count))
count += 1
elif message == "userlist":
#print gb_m.user_m.temp_user_list.keys()
print gb_m.user_m.get_user_list()
elif message == "prepare":
gb_m.send_prepare()
elif message == "prepare-ok":
gb_m.send_prepare_ok()
elif message == "abcast":
print 'abcast'
for i in xrange(10):
ab_m.write(str(i))
elif message == "command":
while True:
message = raw_input()
if (message == "exit"):
break
try:
exec(message)
except:
print 'error'
else:
ab_m.write(message)
class PLTEConnector(Connector):
__instance = None
logger = LogManager.getInstance().get_logger()
@staticmethod
def getInstance():
""" Static access method. """
if PLTEConnector.__instance == None:
PLTEConnector.__instance = PLTEConnector()
return PLTEConnector.__instance
def __init__(self):
self.logger.debug('PLTEConnector Init')
Connector.__init__(self, PLTEManager.getInstance())
self.plteQueId = int(ConfManager.getInstance().getConfigData(
ConfManager.MSGQUEUE_INFO, "PLTEIB"))
try:
maxQSize = ConfManager.getInstance().getConfigData(
ConfManager.MSGQUEUE_INFO, "MAX_QUEUE_SIZE")
self.plteQueue = sysv_ipc.MessageQueue(
self.plteQueId, max_message_size=int(maxQSize))
except Exception as e:
self.logger.error(
"msgQueue Connection Failed.. PLTE QUEUE_ID[%d] SIZE[%s]" %
(self.plteQueId, maxQSize))
# NBI, SBI
def sendMessage(self, apiName, httpReqMsg):
self.logger.info("Send Message..!")
#GenQMsg = GeneralQReqMsg()
#GenQMsg.body = httpReqMsg
pData = ctypes.cast(
ctypes.byref(httpReqMsg),
ctypes.POINTER(ctypes.c_char * ctypes.sizeof(httpReqMsg)))
try:
if self.plteQueue is not None:
if httpReqMsg.http_hdr.resource_type == ResourceType.NSLCM_NOTIFICATION_ENDPOINT:
self.plteQueue.send(pData.contents.raw, True,
MTYPE_SBRESTIF_TO_SLEE_REQ)
else:
self.plteQueue.send(pData.contents.raw, True,
MTYPE_NBRESTIF_TO_SLEE_REQ)
except Exception as e:
self.logger.error("sendMessage Error! %s" % e)
return False
info = httpReqMsg.info
header = httpReqMsg.http_hdr
if ConfManager.getInstance().getLogFlag():
self.logger.info("===============================================")
self.logger.info("NBRESTIF -> SLEE")
self.logger.info("===============================================")
self.logger.info("API_NAME : " + str(apiName))
self.logger.info("mType : " + str(MTYPE_NBRESTIF_TO_SLEE_REQ))
self.logger.info("totlen : " + str(httpReqMsg.tot_len))
self.logger.info("msgId : " + str(httpReqMsg.msgId))
self.logger.info("ehttp_idex : " + str(httpReqMsg.ehttpf_idx))
self.logger.info("tid : " + str(httpReqMsg.tid))
self.logger.info("srcQid : " + str(httpReqMsg.srcQid))
self.logger.info("srcSysId: " + str(httpReqMsg.srcSysId))
self.logger.info("HEADER----------------------------------------")
self.logger.info("header.method : " + str(header.method))
self.logger.info("header.api_type : " + str(header.api_type))
self.logger.info("header.op_type : " + str(header.op_type))
self.logger.info("header.resource_type : " +
str(header.resource_type))
self.logger.info("header.length : " + str(header.length))
self.logger.info("header.encoding : " + str(header.encoding))
self.logger.info("INFO ----------------------------------------")
self.logger.info("info.ns_instance_id : " +
str(info.ns_instance_id))
self.logger.info("info.nfvo_ip : " + str(info.nfvo_ip))
self.logger.info("info.nfvo_port : " + str(info.nfvo_port))
self.logger.info("===============================================")
return True
# SBI
def sendResMessage(self, apiName, resMsg):
#GenQMsg = GeneralQResMsg()
#GenQMsg.body = resMsg
pData = ctypes.cast(
ctypes.byref(resMsg),
ctypes.POINTER(ctypes.c_char * ctypes.sizeof(resMsg)))
try:
if self.plteQueue is not None:
# MSG TYPE Check!
self.plteQueue.send(pData.contents.raw, True,
MTYPE_SBRESTIF_TO_SLEE_RES)
except Exception as e:
self.logger.error("sendMessage Error! %s" % e)
return False
header = resMsg.http_hdr
if ConfManager.getInstance().getLogFlag():
self.logger.info("===============================================")
self.logger.info("SBRESTIF -> SLEE")
self.logger.info("===============================================")
self.logger.info("API_NAME : " + str(apiName))
self.logger.info("mType : " + str(MTYPE_SBRESTIF_TO_SLEE_RES))
self.logger.info("totlen : " + str(resMsg.tot_len))
self.logger.info("msgId : " + str(resMsg.msgId))
self.logger.info("ehttp_idex : " + str(resMsg.ehttpf_idx))
self.logger.info("tid : " + str(resMsg.tid))
self.logger.info("srcQid : " + str(resMsg.srcQid))
self.logger.info("srcSysId: " + str(resMsg.srcSysId))
self.logger.info("RESTCODE : " + str(resMsg.nResult))
self.logger.info("BODY : " + resMsg.jsonBody)
self.logger.info("HEADER----------------------------------------")
self.logger.info("header.method : " + str(header.method))
self.logger.info("header.api_type : " + str(header.api_type))
self.logger.info("header.op_type : " + str(header.op_type))
self.logger.info("header.resource_type : " +
str(header.resource_type))
self.logger.info("header.length : " + str(header.length))
self.logger.info("header.encoding : " + str(header.encoding))
self.logger.info("===============================================")
return True
#!/usr/bin/python
import VersionCheck
from OvtDB import OvtDB
import getopt
import signal
from utils.TerminalUtilities import *
from OvertestExceptions import *
from LogManager import LogManager
import resource
resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
(slimit, hlimit) = resource.getrlimit(resource.RLIMIT_STACK)
resource.setrlimit(resource.RLIMIT_STACK, (10485760, hlimit))
try:
log = LogManager(None, True)
ovtDB = OvtDB(log)
except Exception, e:
print e
print "Failed to connect to database"
sys.exit(1)
def usage():
print "Overtest Usage:"
print "overtest -r --resource Enter interactive resource management"
print "overtest -p --prepare Prepare actions and dependencies"
print "overtest -h <host> --host=<host> Start the overtest daemon for <host>"
print "overtest -g --gridhost Start the overtest execution engine for a testrun"
print "overtest -a --allocate Start the overtest allocator daemon"
print "overtest -c --check Start the overtest dependency checker daemon"
class ResReceiver(Receiver):
myQueue = None
__instance = None
logger = LogManager.getInstance().get_logger()
@staticmethod
def getInstance():
""" Static access method. """
if ResReceiver.__instance == None:
ResReceiver.__instance = ResReceiver()
return ResReceiver.__instance
def __init__(self):
Receiver.__init__(self)
ResReceiver.logger.info("ResReceiver Init")
try :
myQueId = 0
if ResReceiver.myQueue is None:
#IPC_CREAT : create or return key if it is allocated.
#IPC_CREX : IPC_CREAT | IPC_EXCL
#IPC_EXCL : return -1 if there is already allocated.
myQueId = int(ConfManager.getInstance().getConfigData( ConfManager.MSGQUEUE_INFO , "RESTIF_S" ))
maxQSize = ConfManager.getInstance().getConfigData( ConfManager.MSGQUEUE_INFO , "MAX_QUEUE_SIZE" )
#ResReceiver.myQueue = sysv_ipc.MessageQueue(myQueId, sysv_ipc.IPC_CREAT, mode=0777, max_message_size = int(maxQSize) )
ResReceiver.myQueue = sysv_ipc.MessageQueue(myQueId, sysv_ipc.IPC_CREAT )
self.resReceiver = self
self.resReceiver.start()
except Exception as e:
ResReceiver.logger.error("msgQueue Connection Failed.. RESTIF_S QUEUE_ID[%d] SIZE[%s] %s" % (myQueId, maxQSize, e))
return None
def readMessage(self):
try:
if ResReceiver.myQueue is None:
self.logger.error("msgQueue[MYQUEUE] Get Failed...")
return
#GenQMsg = GeneralQResMsg()
resMsg = HttpRes()
(message, msgType) = ResReceiver.myQueue.receive(ctypes.sizeof(resMsg))
mydata = ctypes.create_string_buffer( message )
self.logger.error("ResReceiver Queue Read Message ..")
if msgType == MTYPE_SLEE_TO_NBRESTIF_RES or msgType == MTYPE_SLEE_TO_SBRESTIF_RES :
# Server Mode( Handling Response Message )
ctypes.memmove(ctypes.pointer(resMsg), mydata ,ctypes.sizeof(resMsg))
#resMsg = GenQMsg.body
headerMsg = resMsg.http_hdr
# Receive Message Logging
if ConfManager.getInstance().getLogFlag():
self.logger.info("===============================================");
self.logger.info("SLEE -> NBRESTIF")
self.logger.info("===============================================");
self.logger.info("QmsgType: %d" %msgType )
self.logger.info("tot_len : %s" %resMsg.tot_len )
self.logger.info("tid : %d" %resMsg.tid )
self.logger.info("msgId : %d" %resMsg.msgId )
self.logger.info("ehttp_idx : %d" %resMsg.ehttpf_idx )
self.logger.info("srcQid : %d" %resMsg.srcQid )
self.logger.info("srcSysId : %c" %resMsg.srcSysId )
self.logger.info("nResult : %d" %resMsg.nResult )
self.logger.info("jsonBody: %s" %resMsg.jsonBody )
self.logger.info("HEADER----------------------------------------");
self.logger.info("method: %d" %headerMsg.method )
self.logger.info("api_type: %d" %headerMsg.api_type )
self.logger.info("op_type: %d" %headerMsg.op_type )
self.logger.info("resource_type: %d" %headerMsg.resource_type )
self.logger.info("length: %d" %headerMsg.length )
self.logger.info("encoding: %c" %headerMsg.encoding )
self.logger.info("===============================================");
#if msgType == PLTEMANAGER_TYPE:
PLTEManager.getInstance().receiveHandling(resMsg.nResult, resMsg.tid, resMsg )
except Exception as e :
self.logger.error("Msgrcv Failed.. %s" %e)
time.sleep(1)
def run(self):
try:
while self.resReceiver == self:
usleep(100)
self.readMessage()
except Exception as e:
self.logger.error(e)
class RTKLIB:
# we will save RTKLIB state here for later loading
state_file = "/home/reach/.reach/rtk_state"
# if the state file is not available, these settings are loaded
default_state = {
"base": {
"base_position": [],
"gps_cmd_file": "GPS_10Hz.cmd",
"input_stream": "serial://ttyMFD1:230400:8:n:1:off#ubx",
"output_stream": "tcpsvr://:9000#rtcm3",
"rtcm3_messages": [
"1002",
"1006",
"1008",
"1010",
"1019",
"1020"
]
},
"rover": {
"current_config": "reach_single_default.conf"
},
"started": "no",
"state": "rover"
}
def __init__(self, socketio, rtklib_path = None, enable_led = True, log_path = None):
if rtklib_path is None:
rtklib_path = "/home/reach/RTKLIB"
if log_path is None:
log_path = "/home/reach/logs"
# default state for RTKLIB is "rover single"
self.state = "rover"
# we need this to broadcast stuff
self.socketio = socketio
# these are necessary to handle rover mode
self.rtkc = RtkController(rtklib_path)
self.conm = ConfigManager(rtklib_path)
# this one handles base settings
self.s2sc = Str2StrController(rtklib_path)
# take care of serving logs
self.logm = LogManager(rtklib_path, log_path)
# basic synchronisation to prevent errors
self.semaphore = Semaphore()
# we need this to send led signals
self.enable_led = enable_led
if self.enable_led:
self.led = ReachLED()
# broadcast satellite levels and status with these
self.server_not_interrupted = True
self.satellite_thread = None
self.coordinate_thread = None
self.conversion_thread = None
self.system_time_correct = False
self.time_thread = Thread(target = self.setCorrectTime)
self.time_thread.start()
# we try to restore previous state
# in case we can't, we start as rover in single mode
# self.loadState()
def setCorrectTime(self):
# determine if we have ntp service ready or we need gps time
if not gps_time.time_synchronised_by_ntp():
# wait for gps time
print("Time is not synced by NTP")
self.updateLED("orange,off")
gps_time.set_gps_time("/dev/ttyMFD1", 230400)
print("Time is synced by NTP!")
self.system_time_correct = True
self.socketio.emit("system time corrected", {}, namespace="/test")
self.loadState()
self.socketio.emit("system state reloaded", {}, namespace="/test")
def launchRover(self, config_name = None):
# config_name may be a name, or a full path
# if the parameter contains "/", then we consider it a full path
# else, we will be looking for it one directory higher than the rtkrcv bin
self.semaphore.acquire()
print("Attempting to launch rtkrcv...")
if config_name == None:
res = self.rtkc.launch()
else:
res = self.rtkc.launch(config_name)
if res < 0:
print("rtkrcv launch failed")
elif res == 1:
print("rtkrcv launch successful")
self.state = "rover"
elif res == 2:
print("rtkrcv already launched")
self.state = "rover"
self.saveState()
if self.enable_led:
self.updateLED()
print("Rover mode launched")
self.semaphore.release()
return res
def shutdownRover(self):
self.stopRover()
self.semaphore.acquire()
print("Attempting rtkrcv shutdown")
res = self.rtkc.shutdown()
if res < 0:
print("rtkrcv shutdown failed")
elif res == 1:
print("rtkrcv shutdown successful")
self.state = "inactive"
elif res == 2:
print("rtkrcv already shutdown")
self.state = "inactive"
self.saveState()
if self.enable_led:
self.updateLED()
print("Rover mode shutdown")
self.semaphore.release()
return res
def startRover(self):
self.semaphore.acquire()
print("Attempting to start rtkrcv...")
res = self.rtkc.start()
if res == -1:
print("rtkrcv start failed")
elif res == 1:
print("rtkrcv start successful")
print("Starting coordinate and satellite broadcast")
elif res == 2:
print("rtkrcv already started")
# start fresh data broadcast
self.server_not_interrupted = True
if self.satellite_thread is None:
self.satellite_thread = Thread(target = self.broadcastSatellites)
self.satellite_thread.start()
if self.coordinate_thread is None:
self.coordinate_thread = Thread(target = self.broadcastCoordinates)
self.coordinate_thread.start()
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def stopRover(self):
self.semaphore.acquire()
print("Attempting to stop RTKLIB...")
res = self.rtkc.stop()
if res == -1:
print("rtkrcv stop failed")
elif res == 1:
print("rtkrcv stop successful")
elif res == 2:
print("rtkrcv already stopped")
self.server_not_interrupted = False
if self.satellite_thread is not None:
self.satellite_thread.join()
self.satellite_thread = None
if self.coordinate_thread is not None:
self.coordinate_thread.join()
self.coordinate_thread = None
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def launchBase(self):
# due to the way str2str works, we can't really separate launch and start
# all the configuration goes to startBase() function
# this launchBase() function exists to change the state of RTKLIB instance
# and to make the process for base and rover modes similar
self.semaphore.acquire()
self.state = "base"
self.saveState()
if self.enable_led:
self.updateLED()
print("Base mode launched")
self.semaphore.release()
def shutdownBase(self):
# due to the way str2str works, we can't really separate launch and start
# all the configuration goes to startBase() function
# this shutdownBase() function exists to change the state of RTKLIB instance
# and to make the process for base and rover modes similar
self.stopBase()
self.semaphore.acquire()
self.state = "inactive"
self.saveState()
if self.enable_led:
self.updateLED()
print("Base mode shutdown")
self.semaphore.release()
def startBase(self, rtcm3_messages = None, base_position = None, gps_cmd_file = None):
self.semaphore.acquire()
print("Attempting to start str2str...")
if not self.rtkc.started:
res = self.s2sc.start(rtcm3_messages, base_position, gps_cmd_file)
if res < 0:
print("str2str start failed")
elif res == 1:
print("str2str start successful")
elif res == 2:
print("str2str already started")
else:
print("Can't start str2str with rtkrcv still running!!!!")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def stopBase(self):
self.semaphore.acquire()
print("Attempting to stop str2str...")
res = self.s2sc.stop()
if res == -1:
print("str2str stop failed")
elif res == 1:
print("str2str stop successful")
elif res == 2:
print("str2str already stopped")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def readConfigBase(self):
self.semaphore.acquire()
print("Got signal to read base config")
self.socketio.emit("current config base", self.s2sc.readConfig(), namespace = "/test")
self.semaphore.release()
def writeConfigBase(self, config):
self.semaphore.acquire()
print("Got signal to write base config")
self.s2sc.writeConfig(config)
print("Restarting str2str...")
res = self.s2sc.stop() + self.s2sc.start()
if res > 1:
print("Restart successful")
else:
print("Restart failed")
self.saveState()
if self.enable_led:
self.updateLED()
self.semaphore.release()
return res
def writeConfigRover(self, config):
# config dict must include config_name field
self.semaphore.acquire()
if "config_file_name" not in config:
config_file = None
else:
config_file = config["config_file_name"]
print("Got signal to write rover config to file " + config_file)
self.conm.writeConfig(config_file, config)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
self.semaphore.release()
def loadConfigRover(self, config_file = None):
# we might want to write the config, but dont need to load it every time
self.semaphore.acquire()
if config_file == None:
config_file == self.conm.default_rover_config
print("Loading config " + config_file)
# loading config to rtkrcv
if self.rtkc.loadConfig(config_file) < 0:
print("ERROR: failed to load config!!!")
print("abort load")
self.semaphore.release()
return -1
print("load successful!")
print("Now we need to restart rtkrcv for the changes to take effect")
if self.rtkc.started:
print("rtkrcv is already started, we need to do a simple restart!")
res = self.rtkc.restart()
if res == 3:
print("Restart successful")
print(config_file + " config loaded")
elif res == 1:
print("rtkrcv started instead of restart")
elif res < 1:
print("ERROR: rtkrcv restart failed")
self.semaphore.release()
self.saveState()
return res
else:
print("We were not started before, so we need to perform a full start")
self.semaphore.release()
return self.startRover()
def readConfigRover(self, config):
self.semaphore.acquire()
if "config_file_name" not in config:
config_file = None
else:
config_file = config["config_file_name"]
print("Got signal to read the rover config by the name " + str(config_file))
print("Sending rover config " + str(config_file))
# read from file
self.conm.readConfig(config_file)
# send to the browser
self.socketio.emit("current config rover", self.conm.buffered_config.items, namespace="/test")
self.semaphore.release()
def shutdown(self):
# shutdown whatever mode we are in. stop broadcast threads
# clean up broadcast and blink threads
self.server_not_interrupted = False
self.led.blinker_not_interrupted = False
if self.coordinate_thread is not None:
self.coordinate_thread.join()
if self.satellite_thread is not None:
self.satellite_thread.join()
if self.led.blinker_thread is not None:
self.led.blinker_thread.join()
# shutdown base or rover
if self.state == "rover":
return self.shutdownRover()
elif self.state == "base":
return self.shutdownBase()
# otherwise, we are inactive
return 1
def deleteConfig(self, config_name):
# pass deleteConfig to conm
print("Got signal to delete config " + config_name)
self.conm.deleteConfig(config_name)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
print(self.conm.available_configs)
def resetConfigToDefault(self, config_name):
# pass reset config to conm
print("Got signal to reset config " + config_name)
self.conm.resetConfigToDefault(config_name)
self.conm.updateAvailableConfigs()
# send available configs to the browser
self.socketio.emit("available configs", {"available_configs": self.conm.available_configs}, namespace="/test")
print(self.conm.available_configs)
def cancelLogConversion(self, raw_log_path):
if self.logm.log_being_converted:
print("Canceling log conversion for " + raw_log_path)
self.logm.convbin.child.kill(signal.SIGINT)
self.conversion_thread.join()
self.logm.convbin.child.close(force = True)
print("Thread killed")
self.logm.cleanLogFiles(raw_log_path)
self.logm.log_being_converted = ""
print("Canceled msg sent")
def processLogPackage(self, raw_log_path):
currently_converting = False
try:
print("conversion thread is alive " + str(self.conversion_thread.isAlive()))
currently_converting = self.conversion_thread.isAlive()
except AttributeError:
pass
log_filename = os.path.basename(raw_log_path)
potential_zip_path = os.path.splitext(raw_log_path)[0] + ".zip"
can_send_file = True
# can't send if there is no converted package and we are busy
if (not os.path.isfile(potential_zip_path)) and (currently_converting):
can_send_file = False
if can_send_file:
print("Starting a new bg conversion thread for log " + raw_log_path)
self.logm.log_being_converted = raw_log_path
self.conversion_thread = Thread(target = self.getRINEXPackage, args = (raw_log_path, ))
self.conversion_thread.start()
else:
error_msg = {
"name": os.path.basename(raw_log_path),
"conversion_status": "A log is being converted at the moment. Please wait",
"messages_parsed": ""
}
self.socketio.emit("log conversion failed", error_msg, namespace="/test")
def conversionIsRequired(self, raw_log_path):
log_filename = os.path.basename(raw_log_path)
potential_zip_path = os.path.splitext(raw_log_path)[0] + ".zip"
print("Comparing " + raw_log_path + " and " + potential_zip_path + " for conversion")
if os.path.isfile(potential_zip_path):
print("Raw logs differ " + str(self.rawLogsDiffer(raw_log_path, potential_zip_path)))
return self.rawLogsDiffer(raw_log_path, potential_zip_path)
else:
print("No zip file!!! Conversion required")
return True
def rawLogsDiffer(self, raw_log_path, zip_package_path):
# check if the raw log is the same size in the zip and in filesystem
log_name = os.path.basename(raw_log_path)
raw_log_size = os.path.getsize(raw_log_path)
zip_package = zipfile.ZipFile(zip_package_path)
raw_file_inside_info = zip_package.getinfo("Raw/" + log_name)
raw_file_inside_size = raw_file_inside_info.file_size
print("Sizes:")
print("Inside: " + str(raw_file_inside_size))
print("Raw: " + str(raw_log_size))
if raw_log_size == raw_file_inside_size:
return False
else:
return True
def getRINEXPackage(self, raw_log_path):
# if this is a solution log, return the file right away
if "sol" in raw_log_path:
log_url_tail = "/logs/download/" + os.path.basename(raw_log_path)
self.socketio.emit("log download path", {"log_url_tail": log_url_tail}, namespace="/test")
return raw_log_path
# return RINEX package if it already exists
# create one if not
log_filename = os.path.basename(raw_log_path)
potential_zip_path = os.path.splitext(raw_log_path)[0] + ".zip"
result_path = ""
if self.conversionIsRequired(raw_log_path):
print("Conversion is Required!")
result_path = self.createRINEXPackage(raw_log_path)
# handle canceled conversion
if result_path is None:
log_url_tail = "/logs/download/" + os.path.basename(raw_log_path)
self.socketio.emit("log download path", {"log_url_tail": log_url_tail}, namespace="/test")
return None
else:
result_path = potential_zip_path
print("Conversion is not Required!")
already_converted_package = {
"name": log_filename,
"conversion_status": "Log already converted. Details inside the package",
"messages_parsed": ""
}
self.socketio.emit("log conversion results", already_converted_package, namespace="/test")
log_url_tail = "/logs/download/" + os.path.basename(result_path)
self.socketio.emit("log download path", {"log_url_tail": log_url_tail}, namespace="/test")
self.cleanBusyMessages()
self.logm.log_being_converted = ""
return result_path
def cleanBusyMessages(self):
# if user tried to convert other logs during conversion, he got an error message
# this function clears them to show it's ok to convert again
self.socketio.emit("clean busy messages", {}, namespace="/test")
def createRINEXPackage(self, raw_log_path):
# create a RINEX package before download
# in case we fail to convert, return the raw log path back
result = raw_log_path
log_filename = os.path.basename(raw_log_path)
conversion_time_string = self.logm.calculateConversionTime(raw_log_path)
start_package = {
"name": log_filename,
"conversion_time": conversion_time_string
}
conversion_result_package = {
"name": log_filename,
"conversion_status": "",
"messages_parsed": "",
"log_url_tail": ""
}
self.socketio.emit("log conversion start", start_package, namespace="/test")
try:
log = self.logm.convbin.convertRTKLIBLogToRINEX(raw_log_path, self.logm.getRINEXVersion())
except ValueError, IndexError:
print("Conversion canceled")
conversion_result_package["conversion_status"] = "Conversion canceled, downloading raw log"
self.socketio.emit("log conversion results", conversion_result_package, namespace="/test")
return None
print("Log conversion done!")
if log is not None:
result = log.createLogPackage()
if log.isValid():
conversion_result_package["conversion_status"] = "Log converted to RINEX"
conversion_result_package["messages_parsed"] = log.log_metadata.formValidMessagesString()
else:
conversion_result_package["conversion_status"] = "Conversion successful, but log does not contain any useful data. Downloading raw log"
else:
print("Could not convert log. Is the extension wrong?")
conversion_result_package["conversion_status"] = "Log conversion failed. Downloading raw log"
self.socketio.emit("log conversion results", conversion_result_package, namespace="/test")
print("Log conversion results:")
print(str(log))
return result
def logManager():
from LogManager import LogManager
return LogManager.manager()
class Coins(QtWidgets.QMainWindow):
def __init__(self, parent=None):
''' Initialization function of the class
Binding the GUI to the corresponding logic implemented in this class
'''
QtWidgets.QWidget.__init__(self, parent)
# Read UI from Qt Creator
self.ui = Ui_BioEECoinsMain()
# Link the Opal Kelly FPGA
self.device = OpalKelly()
# Local log manager
self.log = LogManager()
# Control variables
self.updateFlag = True
self.iterateFlag = False
self.displayNumber = 1
# Initialize quick access to gui items
self.bChannel = [None]*48
self.ledChannel = [None]*48
self.initializeUI()
self.ui.setupUi(self)
self.device.openDevice()
self.device.configurePLL()
self.linkGUI()
# Configure log manager
self.log.setFileLog(Constants.LOG_FILE_NAME)
self.log.setQTextLog(self.ui.logWindow)
def initializeUI(self):
''' Configure UI options that needs to go before setupUI()
'''
# Change options for pyqtgraph
pg.setConfigOption('background',(239,235,231))
pg.setConfigOption('foreground','k')
def linkGUI(self):
''' Linking GUI element's to their corresponding logic
'''
self.bondButtons()
self.configureDisplays()
self.ui.logWindow.setReadOnly(True)
def configureDisplays(self):
''' Configure the options for displaying the data
'''
self.ui.display1.setMouseEnabled(x=True, y=False)
self.ui.display2.setMouseEnabled(x=True, y=False)
def bondButtons(self):
''' Bond all the buttons of the GUI to their corresponding logic
'''
for i in range(48):
# Save quick access to all the buttons since this is the first access to them
self.bChannel[i] = getattr(self.ui, 'channel_sel_'+str(i+1))
self.bChannel[i].clicked.connect(partial(self.respondChannelClick, i+1))
self.ui.findFile.clicked.connect(self.findBitFile)
self.ui.loadFile.clicked.connect(self.loadBitFile)
def findBitFile(self):
''' Open a new dialog to find the bit file needed to be read into the gui
'''
fileFinder = QtGui.QFileDialog(self)
filename = fileFinder.getOpenFileName()
self.filename = filename[0]
if (self.filename[-3:] != 'bit'):
self.log.write("WARNING: This is probably not a proper bit file for FPGA configuration")
self.ui.fileName.setText(self.filename)
def loadBitFile(self):
''' Load the corresponding bit file to the device (FPGA, Opal Kelly 6010)
'''
self.filename = self.ui.fileName.text().encode('ascii','ignore')
if (os.path.isfile(self.filename)):
self.log.write("Loading bit file " + self.filename)
self.device.loadFile(self.filename)
self.log.write("Reset FPGA and the ECC chip...")
self.device.reset()
self.log.write("Reset completed!")
else :
self.log.write("ERROR: FPGA bit file not found")
def respondChannelClick(self, channelNumber):
''' Respond to channel clicks
Argument channelNumber: the number of the channel. For test channels, it is 38+i, and for extra channels, it is 46+i
'''
self.log.write("Channel " + str(channelNumber) + " selected...")
self.device.tryDisplay1()
def iterateDisplay(self):
if (self.displayNumber == 1):
self.device.tryDisplay1()
self.displayNumber = 2
elif (self.displayNumber == 2):
self.device.tryDisplay2()
self.displayNumber = 1
else :
pass
if (self.updateFlag):
threading.Timer(1, self.iterateDisplay).start()
def closeEvent(self, event):
''' Override function
Re-define what to do at user hit quitting the GUI
'''
print("Killing auto-updating threads ...")
self.log.write("Killing auto-updating threads ...", 2)
self.updateFlag = False
print("Closing the connection to the Opal Kelly ...")
self.log.write("Closing the connection to the Opal Kelly ...", 2)
# Wait for the opal kelly components to clean itself properly
# Otherwise core dump is likely to be raised
time.sleep(1.1)
event.accept()
class IssueQuality(object):
"""Docstring for RMQuality. """
def __init__(self):
"""Classe que representa o programa RMQuality."""
try:
self._TIME_TO_WAIT = 3
self._SECOND_TO_NEW_EXECUTION = 60
# Define a data padrão da última execução da extensão
self._logger = LogManager(log_path="./log/",
file_name="issuequality")
self._report_analiser = IssueReportAnalyser()
except Exception as e:
raise e
def save_comment_as_csv(self, issue_comment, csv_file_name, header=False):
"""TODO: Docstring for save_comment_as_csv.
:comment: TODO
:file_name: TODO
:returns: TODO
"""
with codecs.open(csv_file_name, 'ab') as f:
writer_csv = csv.writer(f,
delimiter=';',
quotechar='"',
quoting=csv.QUOTE_NONNUMERIC)
repo_name = issue_comment.get_repo_name()
issue_number = issue_comment.get_issue_number()
row_tuple = (
repo_name,
issue_number,
)
dict_metrics = issue_comment.get_all_metrics()
if header:
header_tuple = (
'repo_name',
'issue_number',
)
for key in dict_metrics:
if key == 'keyword_completude' or key == 'readability':
dict_key_compl = dict_metrics[key]
for key2 in dict_key_compl:
row_tuple += (dict_key_compl[key2], )
if header:
if key == 'keyword_completude':
header_tuple += (('keyword completude - ' +
key2), )
elif key == 'readability':
header_tuple += ('readability - ' + key2, )
else:
row_tuple += (dict_metrics[key], )
if header:
header_tuple += (key, )
row_tuple += (
issue_comment.get_start_time(),
issue_comment.get_finish_time(),
issue_comment.get_body(),
)
if header:
header_tuple += (
'start_time',
'finish_time',
'comment',
)
# Escreve no aquivo se tiver o header
if header:
writer_csv.writerow(header_tuple)
writer_csv.writerow(row_tuple)
def run(self):
"""TODO: Docstring for run.
:returns: TODO
"""
try:
reload(sys)
sys.setdefaultencoding('utf-8')
gh_pool = GithubRepoPool()
# pdb.set_trace()
header = True
seconds_to_wait = 10
csv_file_name = ('outputs/' +
datetime.now().strftime('%Y%m%d_%H%M%S_') +
'comments.csv')
for full_name in self.get_all_repo_fullname():
gh_repo_cli = gh_pool.create_github_repo_client(full_name)
repo_name = gh_repo_cli.get_repo_name()
self._logger.log_info(("Analisando as issues do "
"repositório {0}".format(repo_name)))
issue_counter = 0
for issue in gh_repo_cli.get_issues():
has_issuequality_comment = False
issue_counter = issue_counter + 1
self._logger.log_info(("Analisando a issue "
"de nº {0}. Título: '{1}'").format(
issue.number, issue.title))
for comment_proj in issue.get_comments():
if comment_proj.user.login == 'issuequality':
has_issuequality_comment = True
self._logger.log_info(
('Já existe comentário '
'do issuequality '
'para a issue {0}. '
'Nada para fazer!'.format(issue.number)))
break
if not has_issuequality_comment:
gh_repo_cli.set_last_issue(issue.number)
# Gerando um comentário na issue com base no
# que foi reportado inicial
comment = self._report_analiser.analyse(
repo_name, issue)
if comment.get_body() is not None:
issue.create_comment(comment.get_body())
comment.set_finish_time(datetime.now())
self.save_comment_as_csv(comment, csv_file_name,
header)
header = False
self._logger.log_info(
('Esperando {0} segundos para '
'uma nova '
'consulta!').format(seconds_to_wait))
sleep(seconds_to_wait)
if issue_counter == 0:
self._logger.log_info("Nenhuma issue para ser tratada")
else:
gh_repo_cli.set_last_execution(datetime.now())
self._logger.log_info(("Finalizada análise das issues do"
" repositório {0}".format(repo_name)))
self._logger.log_info(
("Aguardando {0} segundos para"
" uma nova execução.").format(self._TIME_TO_WAIT))
sleep(self._TIME_TO_WAIT)
self._logger.log_info("Execução efetuada com sucesso.")
except Exception as e:
self._logger.log_error(e)
def get_all_repo_fullname(self):
"""TODO: Docstring for get_all_repo_fullname.
:returns: TODO
"""
repo_fullname_list = [
'vagnerclementino/elasticsearch',
'vagnerclementino/spring-framework', 'vagnerclementino/guava'
]
return iter(repo_fullname_list)
