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)
#加密后的密文与系统存储的ｒｏｏｔ密码密文想比较
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)
