def setCTerminal(self): cmdlist = "cat /boot/grub/grub.conf" statusOutput = commands.getstatusoutput(cmdlist) if statusOutput[0] == 0: content = statusOutput[1] if not QString(content).contains("MCOS cTerminal Client Start"): insertContent = "title MCOS cTerminal Client Start\\n\\t" + \ "root (hd0,0)\\n\\t" + \ "kernel /boot/boot.krn\\n\\t" + \ "boot\\n" # insertContent = "sdfwef" addCmd = "sed -i '$a %s' /boot/grub/grub.conf" % insertContent if os.system(addCmd) != 0: LogRecord.instance().logger(u"执行命令‘sed -i '%sa %s' /boot/grub/grub.conf失败") return False if not self.setMenuDefaultValue(1): return False if not self.setMenuTimeoutValue(5): return False return True else: return False
def checkPasswd(self, passwd,crypasswd): if passwd == "rootroot": return True else: return False temp = crypasswd.split("$"); count = len(temp) if 4 != count: LogRecord.instance().logger.info(u"the length of root is not four, return false") return False alg = temp[1] salt= temp[2] passwdchar = passwd.toLatin1().data() strs = passwdchar,"++++++++++++++" LogRecord.instance().logger.info(strs) randomchar = "$"+alg+"$"+salt+"$" LogRecord.instance().logger.info(randomchar) usercry = crypt.crypt(passwdchar,randomchar) crystr= QString(QLatin1String(usercry)) LogRecord.instance().logger.info(usercry) LogRecord.instance().logger.info(crystr) #加密后的密文与系统存储的root密码密文想比较 if crypasswd == crystr: return True return False
def getCurrentScreenResolution(): currentSolution = "10" reSolution = "auto" solutionMap = {"0":"800x600","1":"1024x768","2":"1280x720","3":"1440x900","4":"1600x1020","5":"1920x1080","6":"1280x1024","7":"1366x768","8":"1600x900","10":"auto"} cmd = "../lib/ccr_jytcapi current_display" errorFlg = True while errorFlg: try: value = getCmdExecValueT(cmd) errorFlg = False except: errorFlg = True for i in range(len(value)): LogRecord.instance().logger.info("#".join(value)) if len(value[i].split(":"))==2 and value[i].split(":")[0]=="res" and value[i].split(":")[1] !="auto": currentSolution = value[i].split(":")[1] break if solutionMap.has_key(currentSolution): reSolution = solutionMap[currentSolution] if reSolution == "auto": LogRecord.instance().logger.info("resolution is auto") reSolution = getGdkResolution() return reSolution
def dataReceived(self): try: dataValue = self.getDataContent() if dataValue: LogRecord.instance().logger.info(u'接收到广播信息:%s' % dataValue) self.emit(SIGNAL("operaterCmd"), dataValue) except: LogRecord.instance().logger.info(u'广播信息有误:%s' % dataValue)
def start_simulation(ndict, cdict, sink_node): lrec = LogRecord('packetlogger.txt') lrec.truncate_log() beginner_node = 1 queues = Queues() #Create dissipation event dissipation_event = threading.Event() transmission_event = threading.Event() transmission_done_event = threading.Event() #initialize the beginner, node and the sink threads try: for nod in neighbor_dict: if nod == beginner_node: bthread = node.Node(beginner_node, cdict[beginner_node], ndict, queues, dissipation_event, transmission_event, True) else: exec("Thread_" + str(nod) + " = node.Node(" + str(nod) + ", " + str(cdict[nod]) + ",ndict, queues, dissipation_event, transmission_event)") except Exception: print "Thread already started" #Get the node level dictionary of all nodes according to their neighbors node_level_dict = thread_start_order(ndict, beginner_node) for keyy in node_level_dict: #Get unique values of node IDs in the list node_set = set(node_level_dict[keyy]) unique_node_list = list(node_set) node_level_dict.update({keyy: unique_node_list}) #Start the beginner thread bthread.start() time.sleep(1) #Start rest of the threads level-wise wait_constant = 0.2 popped_level_0 = node_level_dict.pop(0) for key in node_level_dict: for every_node in node_level_dict[key]: try: thname = "Thread_" + str(every_node) exec("alive_status = " + thname + ".isAlive()") if not alive_status: exec("Thread_" + str(every_node) + ".start()") except Exception: print "Thread already started" time.sleep(wait_constant * key) sthread = sink.Sink(sink_node, cdict[sink_node], ndict, queues, dissipation_event, transmission_event, transmission_done_event) print "Starting the sink node" sthread.start() result = start_transmission(queues, transmission_event) transmission_done_event.wait() return
def run(self): LogRecord.instance().logger.info(u"开始启动网络") self.emit(SIGNAL("restartNetwork"), "Start") ok = -1 ok = self.jytcapi.jysetwiredconf(str(self.netconf)) if ok != 0: self.emit(SIGNAL("restartNetwork"), "Failed") else: self.emit(SIGNAL("restartNetwork"), "Success") self.networkInfoFlg = True self.setNetFlag(True)
def __init__(self,parent=None): super(WaitingBroadCast,self).__init__(parent) self.port = 5555 self.udpSocket = QUdpSocket(self) self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceived) result = self.udpSocket.bind(self.port) if not result: LogRecord.instance().logger.info(u'udpserver create error!') return
def autoOpenOffVMLesson(self): LogRecord.instance().logger.info(u'自动打开相应的虚拟机') if len(self.vmInfoList) == 1: if self.vmInfoList[0]["name"] in self.downloadingList: return else: self.startVmInfo = self.vmInfoList[0] self.domainManager.setDomainInfo(self.startVmInfo) self.domainManager.startDomainByName() else: return
def getCurrentScreenResolution(self, screenName): currentSolution = "10" reSolution = "auto" solutionMap = {"0":"800x600","1":"1024x768","2":"1280x720","3":"1440x900","4":"1600x1020","5":"1920x1080","6":"1280x1024","7":"1366x768","8":"1600x900","10":"auto"} cmd = "../lib/ccr_jytcapi current_display" value = self.getCmdExecValueT(cmd) for i in range(len(value)): LogRecord.instance().logger.info("#".join(value)) if len(value[i].split(":"))==2 and value[i].split(":")[0]=="res" and value[i].split(":")[1] !="auto": currentSolution = value[i].split(":")[1] break if solutionMap.has_key(currentSolution): reSolution = solutionMap[currentSolution] return reSolution
def monitor_async(self, subsystems, device_type, callbak): context = Context() monitor = Monitor.from_netlink(context) monitor.filter_by(subsystems) def device_event(device): self.emit(SIGNAL("signal_udev"), device) if callbak != None: callbak(device) try: self.observer = MonitorObserver(monitor, callback=device_event, name='udev-monitor-observer') self.observer.daemon self.observer.start() #observer.stop() except Exception as e: LogRecord.instance().logger.info(u'USB监听启动异常(%s)'%(str(e)))
def setMenuDefaultValue(self, value): cmdlist = "cat /boot/grub/grub.conf | awk '{ if($0 ~ \"default=\") {print NR}}'" statusOutput = commands.getstatusoutput(cmdlist) if statusOutput[0] == 0: rowNum = statusOutput[1] defaultValueCmd = QString("sed -i '%1s/.*/default=%2/g' /boot/grub/grub.conf").arg(rowNum).arg(value) ok = os.system(str(defaultValueCmd)) if ok != 0: LogRecord.instance().logger(u"执行命令‘sed -i '%1s/.*/default=%s/g' /boot/grub/grub.conf’失败" % str(value)) return False else: LogRecord.instance().logger(u"执行命令‘cat /boot/grub/grub.conf | awk '{ if($0 ~ \"default=\") {print NR}}’失败") return False return True
def parseLocalData(self): framedatas = self.dataframelist for key in framedatas.keys(): if len(framedatas[key]) == self.datagramcount: self.localframenum+=1 dataframe = framedatas[key] imgdata = "" for i in range(0,self.datagramcount): keys = "%02d"%i imgdata = imgdata + dataframe[keys] #imgdata = dataframe["00"] + dataframe["01"] + dataframe["02"] + dataframe["03"] self.framelist[key] = imgdata self.framedata.pop(key) return LogRecord.instance().logger.info(self.joinGroup)
def __init__(self, nodeID, coordinates, neighbor_dict, q_obj, dissipation_event, transmission_event, transmission_done_event): threading.Thread.__init__(self) self.nodeID = nodeID self.coordinates = coordinates self.neighbor_dict = neighbor_dict self.q_obj = q_obj self.dissipation_event = dissipation_event self.transmission_event = transmission_event self.transmission_done_event = transmission_done_event self.sink_pattern = '51NK' self.pend_on_queue_time = 600 self.packet_logger = LogRecord('packetlogger.txt') self.sent_flag = 'SENT' self.received_flag = 'RCVD'
def startDomain(self): pbp = CustomVMButton().sender() buttonName = pbp.objectName() vmInfo = pbp.vmInfo for item in self.vmOffInfoList: if item["name"] == vmInfo["name"]: self.startVmInfo = item #return vmid = buttonName.split(":")[0] row = buttonName.split(":")[1] column = buttonName.split(":")[2] self.domainManager.setDomainInfo(self.startVmInfo) LogRecord.instance().logger.info(u"开始开启虚拟机-----------------------------------------------00") self.domainManager.startDomainByName() LogRecord.instance().logger.info(u"结束开启虚拟机-----------------------------------------------11")
def autoOpenCourse(self,name,classid = None): LogRecord.instance().logger.info(u'自动打开相应的虚拟机') self.autoCourse = name if name in self.downloadingList: self.courseTimer = QTimer() self.courseTimer.start(1000) self.connect(self.courseTimer, SIGNAL("timeout()"),self.checkDownloadOver) else: for item in self.vmOffInfoList: if name == item["name"]: vmInfo = item if classid != None: vmInfo["classid"] = classid self.domainManager.setDomainInfo(vmInfo) self.domainManager.startDomainByName() return
def replaceFirstMenuName(self): # pass grub_file = QFile("/boot/grub/grub.conf") if not grub_file.open(QIODevice.ReadOnly): grub_file.close() return fs = QTextStream(grub_file) fileContent = fs.readAll() grub_file.close() if QString(fileContent).contains("MCOS cDesktop Client Start"): return cmd = "sed -i \"s/CentOS (2.6.32-431.el6.i686)/MCOS cDesktop Client Start/g\" /boot/grub/grub.conf"; ok = os.system(cmd) if ok != 0: LogRecord.instance().logger(u"替换grub.cfg中的'CentOS (2.6.32-431.el6.i686)'失败") if QString(fileContent).contains("hiddenmenu"): os.system("sed -i \"/hiddenmenu/d\" /boot/grub/grub.conf")
def autoOpenVMLesson(self, vmName, allflag = False): LogRecord.instance().logger.info(u'自动打开相应的虚拟机') if self.vmButtonList: vmInfo = self.vmButtonList[0].getVMInfo() VMOperation.instance().setCurrentVMInfo(vmInfo) #thread.start_new_thread(VMOperation.instance().openVM,()) if allflag == True: if VMOperation.instance().openVM(): LogRecord.instance().logger.info(u'start the lesson') else: if VMOperation.instance().openVM(): LogRecord.instance().logger.info(u'start the lesson') else: LogRecord.instance().logger.info(u'未监测到虚拟机%s的信息' % vmName)
def __init__(self, nodeID, coordinates, neighbor_dict, q_obj, dissipation_event, transmission_event, beginner=False): threading.Thread.__init__(self) self.nodeID = nodeID self.coordinates = coordinates self.neighbor_dict = neighbor_dict self.beginner = beginner self.q_obj = q_obj self.dissipation_event = dissipation_event self.transmission_event = transmission_event self.queue = None self.pend_on_queue_time = 480 self.packet_types = {1: 'INIT_ROUTE', 2: 'PATTERN', 3: 'DATA'} self.packet_logger = LogRecord('packetlogger.txt') self.sent_flag = 'SENT' self.received_flag = 'RCVD'
def parseMsg(self,msg): if len(msg.split("#")) >= 2: if msg.split("#")[0] == "teacherip": self.teacherIp = msg.split("#")[1] self.emit(SIGNAL("receiveteacherip"),self.teacherIp) elif msg.split("#")[0] == "mousepos": self.slotSetMousePos(msg) elif msg.split("#")[0] == "startbroadcast": LogRecord.instance().logger.info("startbroadcast") self.slotStartAllBroadcast(msg) elif msg.split("#")[0] == "startstucomputerbroadcast": self.slotStartStuBroadcast(msg) elif msg.split("#")[0] == "stopbroadcast": self.udpSocket.leaveMulticastGroup(self.mcast_addr_own) self.emit(SIGNAL("stopbroadcast")) self.broadFlag = False # lent = len(self.framedata) # file = open("frame.txt","w") # file.write(QString.number(self.datanum)) # file.write("++") # file.write(QString.number(self.datareceivenum)) # file.write("++") # file.write(QString.number(self.localframenum)) # file.write("++") # file.write(QString.number(self.necnum)) # file.write("++") # file.write(QString.number(self.avilableframenum)) # file.write("++") # file.write(QString.number(lent)) # file.close() self.framedata.clear() self.dataframelist.clear() self.currentframe = None
def getLinuxOperationSystemType(): """得到linux操作系统的类型""" statusOutput = commands.getstatusoutput("head -n 1 /etc/issue") LogRecord.instance().logger.info(u"/etc/issue文件内容:%s" % statusOutput[1]) if statusOutput[0] == 0: output = QString(statusOutput[1]) if output.contains("Ubuntu 12.04"): return "Ubuntu 12.04" if output.contains("Ubuntu 13.04"): return "Ubuntu 13.04" elif output.contains("CentOS release 6.5"): return "CentOS 6.5" elif output.contains("CentOS release 7.0"): return "CentOS 7.0" elif output.contains("Ubuntu 14.04"): return "Ubuntu 14.04" elif output.contains("Ubuntu"): return "Ubuntu" elif output.contains("MCOS-cClassroom-student"): return "CentOS 7.0" elif output.contains("CentOS"): return "CentOS" return None
def getNetInfo(): netList = ["0.0.0.0","255.255.255.0","1.1.1.1", "dhcp", "dhcp", "0.0.0.0", "0.0.0.0"] networkInfo = getCmdExecValueT("../lib/ccr_jytcapi network") for item in networkInfo: if len(item.split(":")) == 2: if item.split(":")[0] == "ip": netList[0] = item.split(":")[1] elif item.split(":")[0] == "mask": netList[1] = item.split(":")[1] elif item.split(":")[0] == "gateway": netList[2] = item.split(":")[1] elif item.split(":")[0] == "conf": if item.split(":")[1] == "0": netList[3] = "dhcp" else: netList[3] = "static" elif item.split(":")[0] == "dns1": netList[4] = "static" netList[5] = item.split(":")[1] elif item.split(":")[0] == "dns2": netList[6] = item.split(":")[1] LogRecord.instance().logger.info(netList) return netList
def getGdkResolution(): import gtk.gdk LogRecord.instance().logger.info("getGdkResolution in") resolution = "1024x768" w = gtk.gdk.get_default_root_window() sz = w.get_size() #(1440,900) if len(sz) == 2: LogRecord.instance().logger.info(str(sz[0])) LogRecord.instance().logger.info(str(sz[1])) resolution = str(sz[0]) + "x" + str(sz[1]) return resolution
def setNetworkCardFilePath(self): #self.networkconfigFile = common.NETWORK_CONFIG_CENTOS_7_0 + "br0" #self.bridgeNetworkconfigFile = common.NETWORK_CONFIG_CENTOS_7_0 + "br0" ethName = common.DEFAULT_NETCARD_NAME ethNameList = globalfunc.getEthNameList() if not ethNameList: LogRecord.instance().logger.info(u"获取网卡名称失败!") else: ethName = ethNameList[0] self.originalNetConfigFile = common.NETWORK_CONFIG_CENTOS_7_0 + ethName LogRecord.instance().logger.info(u"获取网卡名称:%s" % self.originalNetConfigFile) self.originalBridgerNetConfigFile = common.BRIDGER_NETWORK_CONFIG_CENTOS_7_0 LogRecord.instance().logger.info(u"获取bridge网卡名称:%s" % self.originalNetConfigFile) self.networkconfigFile = self.originalNetConfigFile self.bridgeNetworkconfigFile = self.originalBridgerNetConfigFile if globalvariable.PROGRAM_RUNNING_TYPE == common.OPERATION_ENV_TYPE:#running env self.networkconfigFile = globalfunc.convertPathToConfigPath(self.originalNetConfigFile) self.bridgeNetworkconfigFile = globalfunc.convertPathToConfigPath(self.originalBridgerNetConfigFile)
def updateVMList(self): language = StoreInfoParser.instance().getLanguage() m_pTranslator = QTranslator() exePath = "./" if language == "chinese": QmName = "zh_CN.qm" StoreInfoParser.instance().setLanguage("chinese") else: QmName = "en_US.qm" if(m_pTranslator.load(QmName, exePath)): QCoreApplication.instance().installTranslator(m_pTranslator) if self.vmstatusTimer.isActive(): self.vmstatusTimer.stop() else: pass subWidget = QWidget() vmNum = len(self.vmInfoList) rowNum = 0 subMainLayout = QVBoxLayout() subMainLayout.setMargin(0) #subMainLayout.addStretch() #subMainLayout.addSpacing(10) #subMainLayout.setSpacing(10) self.vmButtonList = [] if vmNum % 3 != 0: rowNum = vmNum / 3 + 1 else: rowNum = vmNum / 3 for i in range(rowNum): indexEnd = 3 if i == rowNum - 1: indexEnd = vmNum - (i*3) parentWidth = self.parent.width() resolutionValue = StoreInfoParser.instance().getResolutionValue() if resolutionValue: if len(resolutionValue.split("x")) >= 2: parentWidth = int(resolutionValue.split("x")[0])*5/9.0 ratio = parentWidth/800.0 vmWidth = (parentWidth - 20*2 -50*2*ratio)/3 if vmNum > 3: vmWidth = (parentWidth - 20*2 -50*2*ratio)/3 - 20*(1 - ratio) vmRowButtonList = [] for j in range(indexEnd): vmButton = CustomVMButton(self) vmButton.setFixedSize(QSize(vmWidth, vmWidth + 5)) vmButton.setIconSize(QSize(vmWidth - 60*ratio,vmWidth - 30*ratio)) vmButton.setText(self.vmInfoList[i*3 + j]["name"]) vmButton.setToolTip(self.tr("course: ") + self.vmInfoList[i*3 + j]["name"]) vmButton.setStyleSheet(u"QToolTip{border-radius:5px;background-color:white;color:black;font-size:20px;font-family:微软雅黑;}") vmButton.setFlat(True) vmButton.setFont(QFont("Times", 15, QFont.Bold)) vmInfo = self.vmInfoList[i*3 + j] vmButton.setVMInfo(vmInfo) imageName = "other.png" if self.vmInfoList[i*3 + j].has_key("os_distro"): if common.imageMap.has_key(self.vmInfoList[i*3 + j]["os_distro"]): imageName = common.imageMap[self.vmInfoList[i*3 + j]["os_distro"]] else: LogRecord.instance().logger.info(u'common.imageMap中未找到键值%s' % self.vmInfoList[i*3 + j]["os_distro"]) vmButton.setIcon(QIcon("images/systemImage/%s" % imageName)) if globalvariable.CLASS_STATUS and not globalvariable.TICHU_STATUS: self.connect(vmButton, SIGNAL("clicked()"),self.slotOpenVMLesson) self.connect(vmButton, SIGNAL("controlvm"),self.slotControlVM) else: self.connect(vmButton, SIGNAL("clicked()"),self.slotCreateVMLesson) vmRowButtonList.append(vmButton) self.vmButtonList.append(vmButton) btnLayout = QHBoxLayout() if vmNum > 3: btnLayout.setSpacing(10) #btnLayout.setMargin(10) btnLayout.addSpacing(30) for vmbtn in vmRowButtonList: btnLayout.addWidget(vmbtn) btnLayout.addStretch() subMainLayout.addLayout(btnLayout) #subMainLayout.addStretch() subWidget.setLayout(subMainLayout) if self.scrollArea.widget(): self.scrollArea.takeWidget() self.scrollArea.setWidgetResizable(False) self.scrollArea.setWidget(subWidget)
class Node(threading.Thread): def __init__(self, nodeID, coordinates, neighbor_dict, q_obj, dissipation_event, transmission_event, beginner=False): threading.Thread.__init__(self) self.nodeID = nodeID self.coordinates = coordinates self.neighbor_dict = neighbor_dict self.beginner = beginner self.q_obj = q_obj self.dissipation_event = dissipation_event self.transmission_event = transmission_event self.queue = None self.pend_on_queue_time = 480 self.packet_types = {1: 'INIT_ROUTE', 2: 'PATTERN', 3: 'DATA'} self.packet_logger = LogRecord('packetlogger.txt') self.sent_flag = 'SENT' self.received_flag = 'RCVD' def run(self): logger.debug("Booted node: %s", str(self.nodeID)) self.q_list, self.neighbor_qname_list = self.create_neighbor_queues() if self.beginner: q = 'q_' + str(self.nodeID) exec(q + " = self.q_obj.create_queue(" + "'" + str(q) + "'" + ")") exec("self.queue = self.q_obj.get_from_repository(" + "'" + "q_" + str(self.nodeID) + "'" + ")") seed = self.create_random_seed() init_route_packet = InitialRoutePacket(self.nodeID, seed) qname_index = 0 for q in self.q_list: deep_obj_copy = deepcopy(init_route_packet) deep_obj_copy.packet_id = self.generate_uuid() status = self.q_obj.put_to_queue(q, deep_obj_copy) temp_node_name = self.neighbor_qname_list[qname_index].split( '_')[1] log_msg = self.packet_logger_message(deep_obj_copy.packet_id, temp_node_name, 'SENT', 'INIT_ROUTE') self.packet_logger.write_log(log_msg) qname_index = qname_index + 1 else: exec("self.queue = self.q_obj.get_from_repository(" + "'" + "q_" + str(self.nodeID) + "'" + ")") exec("q_size = self.q_obj.get_qsize (" + "'" + self.queue + "'" + ")") q_counter = 0 for i in range(q_size): exec("init_route_packet_" + str(self.nodeID) + "_" + str(q_counter) + " = self.q_obj.get_from_queue (" + repr(self.queue) + ")") seed = self.create_random_seed() exec("pkt_id = init_route_packet_" + str(self.nodeID) + "_" + str(q_counter) + ".packet_id") log_msg = self.packet_logger_message(pkt_id, "r", 'RCVD', 'INIT_ROUTE') self.packet_logger.write_log(log_msg) exec("disp_pkt = init_route_packet_" + str(self.nodeID) + "_" + str(q_counter) + ".get_packet()") exec("init_route_packet_" + str(self.nodeID) + "_" + str(q_counter) + ".add_id_seed(self.nodeID, seed)") deep_copy_dict_name = "deep_copy_dict_" + str(self.nodeID) exec(deep_copy_dict_name + " = {}") deep_copy_key = 0 for q in self.q_list: #deep_obj_copy = deepcopy(init_route_packet) exec(deep_copy_dict_name + "[deep_copy_key] = deepcopy(init_route_packet_" + str(self.nodeID) + "_" + str(q_counter) + ")") exec(deep_copy_dict_name + "[deep_copy_key].packet_id = self.generate_uuid()") exec("pkt_id = " + deep_copy_dict_name + "[deep_copy_key].packet_id") exec("status = self.q_obj.put_to_queue(q," + deep_copy_dict_name + "[deep_copy_key])") temp_node_name = self.neighbor_qname_list[ deep_copy_key].split('_')[1] log_msg = self.packet_logger_message( pkt_id, temp_node_name, 'SENT', 'INIT_ROUTE') self.packet_logger.write_log(log_msg) deep_copy_key = deep_copy_key + 1 q_counter = q_counter + 1 self.dissipation_event.wait() exec("q_size_for_pattern = self.q_obj.get_qsize (" + "'" + self.queue + "'" + ")") self.pattern_packet = self.q_obj.get_from_queue(self.queue) pkt_id = self.pattern_packet.packet_id log_msg = self.packet_logger_message(pkt_id, "r", 'RCVD', 'PATTERN') self.packet_logger.write_log(log_msg) if self.beginner: self.dissipation_event.clear() self.pattern = self.pattern_packet.get_this_pattern() self.next_pattern = self.pattern_packet.get_next_pattern() self.queue = self.q_obj.get_object_by_name(self.queue) self.transmission_event.wait() pkt_to_forward = self.pend_on_queue(self.queue, self.pend_on_queue_time) return def pend_on_queue(self, q_, timeout, sleeptime=0): retrieved_get = None while (sleeptime < timeout): time.sleep(0.1) if q_.empty(): sleeptime = sleeptime + 1 timeout = timeout - 1 retrieved_get = self.pend_on_queue(q_, timeout, sleeptime) return retrieved_get else: retrieved_get = q_.get_nowait() pkt_to_forward = retrieved_get if pkt_to_forward is not None: if isinstance(pkt_to_forward, DataPacket): if pkt_to_forward.packet_id: pkt_id = pkt_to_forward.packet_id else: pkt_id = self.generate_uuid() log_msg = self.packet_logger_message( pkt_id, "r", 'RCVD', 'DATA') self.packet_logger.write_log(log_msg) if not pkt_to_forward.get_pattern(): pkt_to_forward.pattern.append(self.pattern) if pkt_to_forward.get_pattern()[ len(pkt_to_forward.get_pattern()) - 1] == self.pattern: forward_counter = 1 for q in self.q_list: exec("deep_copy_" + str(forward_counter) + " = deepcopy(pkt_to_forward) ") exec("deep_copy_" + str(forward_counter) + ".pattern.append(self.next_pattern)") exec("deep_copy_" + str(forward_counter) + ".packet_id= self.generate_uuid()") exec("pkt_id = deep_copy_" + str(forward_counter) + ".packet_id") exec( "status = self.q_obj.put_to_queue(q, deep_copy_" + str(forward_counter) + ")") #get packet id and add packet sent debug temp_node_name = str( self.neighbor_qname_list[forward_counter - 1]).split('_')[1] log_msg = self.packet_logger_message( pkt_id, temp_node_name, 'SENT', 'DATA') self.packet_logger.write_log(log_msg) forward_counter = forward_counter + 1 retrieved_get = self.pend_on_queue(self.queue, self.pend_on_queue_time) return retrieved_get def create_random_seed(self): from random import randrange return randrange(255) def create_neighbor_queues(self): qname_list = [] for neighbor in self.neighbor_dict[self.nodeID]: qname = "q_" + str(neighbor) qname_list.append(qname) queue_object_list = [] for q in qname_list: if self.q_obj.check_if_created(q): exec(q + " = self.q_obj.get_object_by_name(" + "'" + str(q) + "'" + ")") else: exec(q + " = self.q_obj.create_queue(" + "'" + str(q) + "'" + ")") exec("queue_object_list.append(" + str(q) + ")") return queue_object_list, qname_list def packet_logger_message(self, pktid, to_, sent_or_received, pkt_type): message = "" if sent_or_received == self.sent_flag: message = pktid + " " + pkt_type + " " + str( self.nodeID) + " " + str(to_) + " " + sent_or_received + "\n" elif sent_or_received == self.received_flag: message = pktid + " " + pkt_type + " " + str(to_) + " " + str( self.nodeID) + " " + sent_or_received + "\n" return message def generate_uuid(self): str_uuid_full = str(uuid.uuid4()).split('-') pkt_id = str_uuid_full[len(str_uuid_full) - 1] return pkt_id
def mountFile(filePath): mountPath = convertPathToConfigPath(filePath) if os.system("mount --bind %s %s" % (mountPath, filePath)) != 0: LogRecord.instance().logger.info(u"挂载配置文件失败,挂载路径:%s, 配置文件路径:%s" % (mountPath, filePath))
def umountFile(filePath): if os.system("umount %s" % filePath) != 0: LogRecord.instance().logger.info(u"卸载配置文件失败,文件路径:%s" % filePath)
class Sink(threading.Thread): def __init__(self, nodeID, coordinates, neighbor_dict, q_obj, dissipation_event, transmission_event, transmission_done_event): threading.Thread.__init__(self) self.nodeID = nodeID self.coordinates = coordinates self.neighbor_dict = neighbor_dict self.q_obj = q_obj self.dissipation_event = dissipation_event self.transmission_event = transmission_event self.transmission_done_event = transmission_done_event self.sink_pattern = '51NK' self.pend_on_queue_time = 600 self.packet_logger = LogRecord('packetlogger.txt') self.sent_flag = 'SENT' self.received_flag = 'RCVD' def run(self): init_sink_list = [] exec("pop_queue = self.q_obj.get_from_repository(" + "'" + "q_" + str(self.nodeID) + "'" + ")") exec("q_size = self.q_obj.get_qsize(" + "'" + str(pop_queue) + "'" + ")") for i in range(q_size): exec("init_route_packet = self.q_obj.get_from_queue(" + "'" + str(pop_queue) + "'" + ")") pkt_id = init_route_packet.packet_id log_msg = self.packet_logger_message(pkt_id, "r", 'RCVD', 'INIT_ROUTE') self.packet_logger.write_log(log_msg) init_sink_list.append(init_route_packet) self.all_routes_dict = self.condense_packets_store_seeds( init_sink_list) self.maps_to_route_id = self.map_nodes_to_route_id( self.all_routes_dict, self.neighbor_dict) self.routes_for_nodes = self.decide_routes_for_nodes( self.maps_to_route_id, self.all_routes_dict) self.final_path_list = self.get_full_paths(self.routes_for_nodes, self.all_routes_dict) self.create_and_store_pattern(self.final_path_list) self.create_push_pattern_packets() exec("self.queue = self.q_obj.get_from_repository(" + "'" + "q_" + str(self.nodeID) + "'" + ")") self.queue = self.q_obj.get_object_by_name(self.queue) self.transmission_event.wait() pkt_to_forward = self.pend_on_queue(self.queue, self.pend_on_queue_time) return def pend_on_queue(self, q_, timeout, sleeptime=0): retrieved_get = None while (sleeptime < timeout): time.sleep(0.1) if q_.empty(): sleeptime = sleeptime + 1 timeout = timeout - 1 print "Queue Empty. Pending again" retrieved_get = self.pend_on_queue(q_, timeout, sleeptime) else: retrieved_get = q_.get_nowait() logging.debug("%s: Received packet from the queue", str(self.nodeID)) if isinstance(retrieved_get, DataPacket): if (retrieved_get.get_pattern() [len(retrieved_get.get_pattern()) - 1] == self.sink_pattern): packet_data = retrieved_get.get_data() packet_sender = retrieved_get.get_pattern()[0] pkt_id = retrieved_get.packet_id log_msg = self.packet_logger_message( pkt_id, packet_sender, 'RCVD', 'DATA') self.packet_logger.write_log(log_msg) retrieved_get = self.pend_on_queue( q_, timeout, self.pend_on_queue_time) return retrieved_get def condense_packets_store_seeds(self, full_pkt_list): self.seed_dict = {} return_dict = {} condensed_list = [] for item in full_pkt_list: condensed_list_item = [] for node_x in item.get_packet(): self.seed_dict.update({node_x[0]: node_x[1]}) condensed_list_item.append(node_x[0]) condensed_list.append(condensed_list_item) route_id = 1 for item in condensed_list: return_dict.update({route_id: item}) route_id = route_id + 1 return return_dict def map_nodes_to_route_id(self, initial_packet_dict, neighbor_dict): all_nodes = neighbor_dict.keys() visited_nodes = [] every_node_to_sink = [] node_and_route_id = {} for node_x in all_nodes: rid_length_dict = {} for route in initial_packet_dict.items(): update_value = {} if node_x in route[1]: inx = route[1].index(node_x) rid_length_dict.update({route[0]: len(route[1][inx:])}) min_path = min(rid_length_dict.values()) for route in rid_length_dict.items(): if route[1] == min_path: update_value = {node_x: route[0]} break node_and_route_id.update(update_value) return node_and_route_id def decide_routes_for_nodes(self, node_to_route_dict, ini_dict): self.final_list = [] for value in node_to_route_dict.items(): exec("route_" + str(value[1]) + " = []") temp_iter_list = list(set(node_to_route_dict.values())) for route_ in temp_iter_list: for val in node_to_route_dict.items(): if route_ == val[1]: exec("route_" + str(val[1]) + ".append(" + str(val[0]) + ")") exec("self.final_list.append(route_" + str(route_) + ")") return self.final_list def get_full_paths(self, ntor_list, ini_dict): route_ = 1 final_path_list = [] for item in ntor_list: for node_x in item: for n in ini_dict[route_]: if node_x == n: path_tmp = ini_dict[route_][ini_dict[route_].index(n):] final_path_list.append(path_tmp) break route_ = route_ + 1 break return final_path_list def create_and_store_pattern(self, final_path_list): import random import string self.path_pattern_dict = {} self.next_node_dict = {} for seed_item in self.seed_dict.items(): alpha = random.choice(string.letters) new_seed = str(seed_item[1]) + alpha self.seed_dict.update({seed_item[0]: new_seed}) node_pattern = '' self.seed_dict.update({self.nodeID: self.sink_pattern}) for path in final_path_list: for node_ in path: node_pattern = node_pattern + str(self.seed_dict[node_]) self.path_pattern_dict.update({node_pattern: node_}) try: self.next_node_dict.update( {node_: path[path.index(node_) + 1]}) except IndexError: self.next_node_dict.update({node_: self.nodeID}) return def create_push_pattern_packets(self): from PatternPacket import PatternPacket self.q_rep = self.q_obj.get_q_repository() for node_ in self.next_node_dict: #if node id is beginner, delay sending the pattern packets. When node 1 receives the pattern, clear the dissipation event #creating pattern packets exec("pkt_" + str(node_) + " = PatternPacket (" + "'" + str(self.seed_dict[node_]) + "'" + ", " + "'" + str(self.seed_dict[self.next_node_dict[node_]]) + "'" + ")") exec("pkt_" + str(node_) + ".packet_id = self.generate_uuid()") #pushing pattern packets to queues qname = 'q_' + str(node_) if qname in self.q_rep.keys(): queue_obj = self.q_rep[qname] exec("pkt_id = pkt_" + str(node_) + ".packet_id") exec("status = self.q_obj.put_to_queue( queue_obj " + ", " + "pkt_" + str(node_) + ")") log_msg = self.packet_logger_message(pkt_id, str(node_), 'SENT', 'PATTERN') self.packet_logger.write_log(log_msg) self.dissipation_event.set() return def packet_logger_message(self, pktid, to_, sent_or_received, pkt_type): message = "" if sent_or_received == self.sent_flag: message = pktid + " " + pkt_type + " " + str( self.nodeID) + " " + str(to_) + " " + sent_or_received + "\n" elif sent_or_received == self.received_flag: message = pktid + " " + pkt_type + " " + str(to_) + " " + str( self.nodeID) + " " + sent_or_received + "\n" return message def generate_uuid(self): import uuid str_uuid_full = str(uuid.uuid4()).split('-') pkt_id = str_uuid_full[len(str_uuid_full) - 1] return pkt_id
def slotCreateVMLesson(self): vmBtn = self.sender() if vmBtn: LogRecord.instance().logger.info(u'开始创建虚拟机') if globalvariable.VM_IS_CREATE_STATUS: LogRecord.instance().logger.info(u'重复点击!') return else: globalvariable.VM_IS_CREATE_STATUS = True LogRecord.instance().logger.info(u'准备获取虚拟机信息!') paramInfo = vmBtn.getVMInfo() LogRecord.instance().logger.info(u'准备获取虚拟机信息完成!') try: vmName = VMOperation.instance().createVMLesson(paramInfo) except: LogRecord.instance().logger.info(u'创建虚拟机异常.........!') LogRecord.instance().logger.info(u'得到创建的虚拟机信息!') if vmName: LogRecord.instance().logger.info(u'创建虚拟机%s成功' % vmName) vmInfo = NetworkManager.instance().getVMInfo(vmName) if vmInfo == None: globalvariable.VM_IS_CREATE_STATUS = False return if len(vmInfo) == 0: globalvariable.VM_IS_CREATE_STATUS = False return vmInfo[0]["vmname"] = vmInfo[0]["name"] if vmInfo: VMOperation.instance().setCurrentVMInfo(vmInfo[0]) if VMOperation.instance().openVM(True): #保存开启虚拟机的名称 #globalvariable.VM_IS_CREATE_STATUS = False WindowMonitor.instance().insertVmId(vmName) else: globalvariable.VM_IS_CREATE_STATUS = False #删除没有成功运行的虚拟机 if VMOperation.instance().removeVMLesson(vmName): LogRecord.instance().logger.info(u"删除后台相应的虚拟机成功") else: LogRecord.instance().logger.info(u'未查询到相应的虚拟机:%s' % vmName) globalvariable.VM_IS_CREATE_STATUS = False else: LogRecord.instance().logger.info(u'创建虚拟机失败') globalvariable.VM_IS_CREATE_STATUS = False #刷新虚拟机界面 self.emit(SIGNAL("refreshVMS"))
def setRowColumnWidget(self,row,column,vmid): status = "sfw" #self.vmTableWidget.clear() mainWidget = QWidget() #self.vmTableWidget.hideColumn() #vmRowButtonList = [] parentWidth = self.parent.width() resolutionValue = StoreInfoParser.instance().getResolutionValue() if resolutionValue: if len(resolutionValue.split("x")) >= 2: parentWidth = int(resolutionValue.split("x")[0])*5/9.0 ratio = parentWidth/800.0 vmWidth = (parentWidth - 20*2 -50*2*ratio)/3 if len(self.vmInfoList) > 3: vmWidth = (parentWidth - 20*2 -50*2*ratio)/3 - 20*(1 - ratio) vmButton = CustomVMButton() vmButton.setFixedSize(QSize(vmWidth, vmWidth + 5)) vmButton.setIconSize(QSize(vmWidth - 60*ratio,vmWidth - 30*ratio)) vmButton.setText(self.vmInfoList[row*3 + column]["name"]) vmButton.setFlat(True) vmButton.setFont(QFont("Times", 15, QFont.Bold)) vmInfo = self.vmInfoList[row*3 + column] vmButton.setVMInfo(vmInfo) imageName = "other.png" if self.vmInfoList[row*3 + column].has_key("os_distro"): if common.imageMap.has_key(self.vmInfoList[row*3 + column]["os_distro"]): imageName = common.imageMap[self.vmInfoList[row*3 + column]["os_distro"]] else: LogRecord.instance().logger.info(u'common.imageMap中未找到键值%s' % self.vmInfoList[row*3 + column]["os_distro"]) vmButton.setIcon(QIcon("images/systemImage/%s" % imageName)) # if globalvariable.CLASS_STATUS and not globalvariable.TICHU_STATUS: # self.connect(vmButton, SIGNAL("clicked()"),self.slotOpenVMLesson) # self.connect(vmButton, SIGNAL("controlvm"),self.slotControlVM) # else: # self.connect(vmButton, SIGNAL("clicked()"),self.slotCreateVMLesson) #vmRowButtonList.append(vmButton) self.vmButtonList.append(vmButton) #firMybutton.setStatus("undownload") vmButton.setObjectName(vmid + ":" + QString.number(row) + ":" + QString.number(column)) self.connect(vmButton, SIGNAL("clicked()"),self.startDomain) progressBar = WidgetProgress() progressBar.setFixedSize(vmWidth, vmWidth + 5) #progressBar.progressBar.setValue(0) progressBar.setVmName(self.vmInfoList[row*3 + column]["name"]) progressBar.setObjectName(vmid + ":" + QString.number(row) + ":" + QString.number(column)) #progressBar.objectName() #self.firMybutton.setText(self.tr("确萨")) #progressBar = QProgressBar() myLayout = QHBoxLayout() myLayout.setMargin(0) myLayout.addStretch() myLayout.addWidget(vmButton) myLayout.addWidget(progressBar) myLayout.addStretch() if vmid in self.downloadingList: vmButton.hide() else: progressBar.hide() #firMybutton.hide() mainWidget.setLayout(myLayout) self.vmTableWidget.setCellWidget(row, column, mainWidget)