def lock(self):
self._homedir = get_user_dir(
) + utils.path_sep + u"." + self._name.lower()
if not utils.path_exists(self._homedir):
utils.path_makedirs(self._homedir)
self._lockfilename = self._homedir + utils.path_sep + "monitor.lock"
try:
if is_linux():
import fcntl
self._lockfile = utils.file_open(self._lockfilename, "w")
fcntl.lockf(self._lockfile, fcntl.LOCK_EX | fcntl.LOCK_NB)
else:
if utils.path_exists(self._lockfilename):
utils.path_remove(self._lockfilename)
self._lockfile = utils.file_open(self._lockfilename, "w")
self._lockfile.write("\x00")
except:
try:
self._lockfile.close()
except:
None
if self._mode == "systray":
print("An Instance is already running.")
else:
self.add_show_file()
return False
#self.remove_show_file()
return True
def get_cpu_logical_count(self):
num = 0
try:
try:
num = os.sysconf("SC_NPROCESSORS_ONLN")
except ValueError:
None
if num == 0:
f = utils.file_open('/proc/cpuinfo', 'rb')
try:
lines = f.readlines()
finally:
f.close()
for line in lines:
if line.lower().startswith('processor'):
num += 1
if num == 0:
f = utils.file_open('/proc/stat', 'rt')
try:
lines = f.readlines()
finally:
f.close()
search = re.compile('cpu\d')
for line in lines:
line = line.split(' ')[0]
if search.match(line):
num += 1
except:
None
return num
def _write(self, path, prop):
if "encoding" in prop:
enc = prop["encoding"]
else:
enc = sys.getfilesystemencoding()
if "endline" in prop:
endl = prop["endline"]
else:
endl = utils.line_sep
bm = None
#CREA FILE TEMPORANEO
pathtmp = None
sprnpath = utils.path_dirname(path)
while True:
r = "".join([random.choice("0123456789") for x in xrange(6)])
pathtmp = sprnpath + utils.path_sep + "temporary" + r + ".dwstext"
if not utils.path_exists(pathtmp):
utils.file_open(
pathtmp,
'wb').close() #Crea il file per imposta i permessi
self._agent_main.get_osmodule().fix_file_permissions(
"CREATE_FILE", pathtmp)
if (enc is not None):
flgop = "w"
if "bom" in prop and prop["bom"] == 'true':
bm = self._get_bom_byname(enc)
if bm is not None:
#Scrive BOM
text_file = utils.file_open(pathtmp, 'wb')
text_file.write(bm["Data"])
text_file.close()
flgop = "a"
text_file = utils.file_open(pathtmp, flgop, enc)
else:
text_file = utils.file_open(pathtmp, 'w')
break
try:
s = prop["text"]
s = endl.join(s.split("\n"))
text_file.write(s)
finally:
text_file.close()
if utils.path_exists(path):
if utils.path_isdir(path):
utils.path_remove(self._tmpname)
raise Exception("PATH is directory.")
else:
self._agent_main.get_osmodule().fix_file_permissions(
"COPY_FILE", pathtmp, path)
utils.path_remove(path)
shutil.move(pathtmp, path)
def create(self, fname, fieldsdef, fixperm=None):
self._semaphore.acquire()
try:
if self._binit:
raise Exception("Already initialized.")
self._path = sharedmem_manager.getPath(fname)
if utils.path_exists(self._path):
if fixperm is not None:
fixperm(self._path)
self.open(fname)
#Verifica se la struttura è identica
bok = True
for f in fieldsdef:
if f["name"] in self._fields:
if f["size"] != self._fields[f["name"]]["size"]:
bok = False
break
else:
bok = False
break
if not bok:
self.close()
#Prova a rimuovere il file
try:
utils.path_remove(self._path)
except:
raise Exception("Shared file is locked.")
else:
self._binit = True
return
#CREAZIONE DEL FILE
self._fields = {}
szdata = 0
for f in fieldsdef:
self._fields[f["name"]] = {"pos": szdata, "size": f["size"]}
szdata += f["size"]
shead = json.dumps(self._fields)
self._len_def = len(shead)
self._size = 4 + self._len_def + szdata
with utils.file_open(self._path, "wb") as f:
f.write(" " * self._size)
if fixperm is not None:
fixperm(self._path)
self._file = utils.file_open(self._path, "r+b")
self._mmap = mmap.mmap(self._file.fileno(), 0)
self._mmap.seek(0)
self._mmap.write(struct.pack('!i', self._len_def))
self._mmap.write(shead)
self._binit = True
finally:
self._semaphore.release()
def _create_disk(self, fixperm):
while True:
self.fname = "stream_" + self._rndseq(8)
self.fpath = SHAREDMEM_PATH + utils.path_sep + self.fname + ".shm"
if not utils.path_exists(self.fpath):
with utils.file_open(self.fpath, "wb") as f:
f.write(" " * MapFile._SIZE)
if fixperm is not None:
fixperm(self.fpath)
self.file = utils.file_open(self.fpath, "r+b")
self.ftype = "F"
self._prepare_map()
self.bdestroy = False
break
def start(self, bgui=True):
confjson = {}
try:
f = utils.file_open('config.json')
confjson = json.loads(f.read())
f.close()
except Exception:
None
prmsui = {}
if "name" in confjson:
self._name = unicode(confjson["name"])
prmsui["title"] = self._get_message('configureTitle')
if "topinfo" in confjson:
prmsui["topinfo"] = confjson["topinfo"]
if "topimage" in confjson:
prmsui[
"topimage"] = u"ui" + utils.path_sep + u"images" + utils.path_sep + u"custom" + utils.path_sep + confjson[
"topimage"]
applg = gdi._get_logo_from_conf(
confjson, u"ui" + utils.path_sep + u"images" + utils.path_sep +
u"custom" + utils.path_sep)
if applg != "":
prmsui["logo"] = applg
if "leftcolor" in confjson:
prmsui["leftcolor"] = confjson["leftcolor"]
self._uinterface = ui.UI(prmsui, self.step_init)
self._uinterface.start(bgui)
self.close_req()
def __init__(self,
sock,
body_file_name=None,
response_transfer_progress=None):
data = ''
while data.find('\r\n\r\n') == -1:
app = sock.recv(1024 * 4)
if app is None or len(app) == 0:
raise Exception('Close connection')
data += app
ar = data.split('\r\n\r\n')
head = ar[0].split('\r\n')
appbody = []
appbody.append(ar[1])
self._code = None
self._headers = {}
clenkey = None
for item in head:
if self._code is None:
self._code = item.split(' ')[1]
else:
apppos = item.index(':')
appk = item[0:apppos].strip()
if appk.lower() == "content-length":
clenkey = appk
self._headers[appk] = item[apppos + 1:].strip()
#Legge eventuale body
if self._code != '301' and clenkey is not None:
self._extra_data = None
lenbd = int(self._headers[clenkey])
fbody = None
try:
if body_file_name is not None:
fbody = utils.file_open(body_file_name, 'wb')
fbody.write(''.join(appbody))
cnt = len(''.join(appbody))
if response_transfer_progress is not None:
response_transfer_progress.fire_on_data(cnt, lenbd)
szbuff = 1024 * 2
buff = None
while lenbd > cnt:
buff = sock.recv(szbuff)
if buff is None or len(buff) == 0:
break
cnt += len(buff)
if response_transfer_progress is not None:
response_transfer_progress.fire_on_data(cnt, lenbd)
if body_file_name is None:
appbody.append(buff)
else:
fbody.write(buff)
finally:
if fbody is not None:
fbody.close()
else:
self._body = ''.join(appbody)
else:
self._extra_data = ''.join(appbody)
if len(self._extra_data) == 0:
self._extra_data = None
def get_diskpartition_info(self):
arret = []
phydevs = []
f = utils.file_open("/proc/filesystems", "r")
try:
for line in f:
if not line.startswith("nodev"):
phydevs.append(line.strip())
finally:
f.close()
#Legge fstab
f = utils.file_open("/etc/fstab", "r")
try:
for line in f:
line=line.strip()
if not line.strip().startswith("#"):
line=line.replace('\t',' ')
ar=[]
arapp = line.split(" ")
for a in arapp:
if a.strip()!="":
ar.append(a.strip())
if len(ar)>=3:
nm = ar[1]
tp = ar[2]
if tp in phydevs:
path=nm
try:
st = os.statvfs(path)
except UnicodeEncodeError:
if isinstance(path, unicode):
try:
import sys
path = path.encode(sys.getfilesystemencoding())
except UnicodeEncodeError:
pass
st = os.statvfs(path)
else:
raise
free = (st.f_bavail * st.f_frsize)
size = (st.f_blocks * st.f_frsize)
arret.append({"Name":nm, "Size":size, "Free":free})
finally:
f.close()
return arret
def init_guilnc(self, ag):
self._propguilnc_semaphore.acquire()
try:
#COMPATIBILITA VERSIONI PRECEDENTI
if utils.path_exists("native/dwagguilnc"):
self._propguilnc = {}
if not utils.path_exists("guilnc.run"):
f = utils.file_open("guilnc.run", "wb")
f.close()
finally:
self._propguilnc_semaphore.release()
def get_service_list(self):
ret=[]
if self._which("systemctl"):
p = subprocess.Popen("systemctl --all --full list-units | grep \.service", stdout=subprocess.PIPE, shell=True)
(po, pe) = p.communicate()
p.wait()
if po is not None and len(po)>0:
appar = po.split("\n")
for appln in appar:
sv = ""
stcnt = -1
stapp = ""
ar = appln.split(" ")
for k in ar:
if len(k)>0:
if stcnt == -1:
if k.endswith(".service"):
sv+=k[0:len(k)-8]
stcnt+=1
else:
sv+=k
else:
stcnt+=1
if stcnt==3:
stapp=k
if stcnt != -1:
if stapp == "running":
st = 4
else:
st = 1
ret.append({"Name":sv,"Label":"","Status":st})
else:
#SYSVINIT
for x in utils.path_list('/etc/init.d'):
if x.lower()!="rc" and x.lower()!="rcs" and x.lower()!="halt" and x.lower()!="reboot" and x.lower()!="single":
xp = "/etc/init.d/" + x
st = utils.path_stat(xp)
if bool(st.st_mode & stat.S_IXUSR) or bool(st.st_mode & stat.S_IXGRP) or bool(st.st_mode & stat.S_IXOTH):
appf = utils.file_open("/etc/init.d/" + x)
apps = appf.read()
appf.close()
if "status)" in apps or "status|" in apps:
p = subprocess.Popen("/etc/init.d/" + x + " status", stdout=subprocess.PIPE, shell=True)
(po, pe) = p.communicate()
p.wait()
if po is not None and len(po)>0:
st = 999
if "running" in po.lower() or "started" in po.lower():
st = 4
elif "not running" in po.lower() or "not started" in po.lower() or "failed" in po.lower():
st = 1
ret.append({"Name":x,"Label":"","Status":st})
return ret
def _initialize(self):
self._binit = True
self._terminate_time = 0
self._terminate_retry = -1
self._side_size = (self._size - CONDITION_SIZE_BYTE) / 2
self._condition_shared = None
self._condition_shared_pos = 0
if self._side == 1:
self._state_pos = CONDITION_SIZE_BYTE + 0
self._alive_pos = CONDITION_SIZE_BYTE + 1
self._pid_pos = CONDITION_SIZE_BYTE + 2
self._write_pnt_pos = CONDITION_SIZE_BYTE + 6
self._write_data_pos = CONDITION_SIZE_BYTE + 14
self._state_other_pos = CONDITION_SIZE_BYTE + self._side_size
self._alive_other_pos = CONDITION_SIZE_BYTE + self._side_size + 1
self._pid_other_pos = CONDITION_SIZE_BYTE + self._side_size + 2
self._read_pnt_pos = CONDITION_SIZE_BYTE + self._side_size + 10
self._read_data_pos = CONDITION_SIZE_BYTE + self._side_size + 14
self._write_limit = CONDITION_SIZE_BYTE + self._side_size
self._read_limit = self._size
elif self._side == 2:
self._state_pos = CONDITION_SIZE_BYTE + self._side_size
self._alive_pos = CONDITION_SIZE_BYTE + self._side_size + 1
self._pid_pos = CONDITION_SIZE_BYTE + self._side_size + 2
self._write_pnt_pos = CONDITION_SIZE_BYTE + self._side_size + 6
self._write_data_pos = CONDITION_SIZE_BYTE + self._side_size + 14
self._state_other_pos = CONDITION_SIZE_BYTE + 0
self._alive_other_pos = CONDITION_SIZE_BYTE + 1
self._pid_other_pos = CONDITION_SIZE_BYTE + 2
self._read_pnt_pos = CONDITION_SIZE_BYTE + 10
self._read_data_pos = CONDITION_SIZE_BYTE + 14
self._write_limit = self._size
self._read_limit = CONDITION_SIZE_BYTE + self._side_size
self._last_read_time = long(time.time() * 1000)
self._last_write_time = long(time.time() * 1000)
self._file = utils.file_open(self._path, "r+b")
self._mmap = mmap.mmap(self._file.fileno(), 0)
self._mmap.seek(0)
self._mmap.write(
struct.pack("!qiqqiqqiqqiq", -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1))
if self._side == 1:
self._mmap.seek(CONDITION_SIZE_BYTE)
self._mmap.write(struct.pack('!cciii', 'C', 'K', os.getpid(), 0,
0))
self._mmap.seek(CONDITION_SIZE_BYTE + self._side_size)
self._mmap.write(struct.pack('!cciii', 'W', 'K', -1, 0, 0))
self._waitconn_tm = long(time.time() * 1000)
elif self._side == 2:
self._mmap.seek(CONDITION_SIZE_BYTE + self._side_size)
self._mmap.write(struct.pack('!cciii', 'C', 'K', os.getpid(), 0,
0))
sharedmem_manager.add(self)
def detect_bom_file(self, path):
enc=None
text_file = utils.file_open(path, 'rb')
try:
s = text_file.read(10)
for bm in self.TEXTFILE_BOM_TYPE :
if s.startswith(bm["Data"]):
enc=bm
break
finally:
text_file.close()
return enc;
def get_library_config(name):
fn = None
if utils.path_exists(".srcmode"):
fn = ".." + utils.path_sep + "lib_" + name + utils.path_sep + "config.json"
else:
fn = "native" + utils.path_sep + "lib_" + name + ".json"
if utils.path_exists(fn):
f = utils.file_open(fn)
jsapp = json.loads(f.read())
f.close()
return jsapp
else:
return None
def __init__(self):
self._name = u"DWAgent"
self._logo = None
self._properties = {}
try:
f = utils.file_open('config.json')
self._properties = json.loads(f.read())
f.close()
except Exception:
None
if 'name' in self._properties:
self._name = unicode(self._properties["name"])
if "logo" in self._properties:
self._logo = self._properties["logo"]
def get_task_list(self):
import pwd
ret = []
for x in utils.path_list('/proc') :
if x.isdigit():
try:
itm={}
#PID
itm["PID"]=long(x)
#Name
f = utils.file_open("/proc/%s/stat" % x)
try:
itm["Name"] = f.read().split(' ')[1].replace('(', '').replace(')', '')
finally:
f.close()
#Memory
f = utils.file_open("/proc/%s/statm" % x)
try:
vms, rss = f.readline().split()[:2]
itm["Memory"] = long(rss) * long(self._PAGESIZE)
#int(vms) * _PAGESIZE)
finally:
f.close()
#Owner
f = utils.file_open("/proc/%s/status" % x)
try:
for line in f:
if line.startswith('Uid:'):
r = line.split()
itm["Owner"] = pwd.getpwuid(int(r[1])).pw_name
break
finally:
f.close()
ret.append(itm)
except:
None
return ret
def req_read(self, cinfo ,params):
path = self.check_and_replace_path(cinfo, agent.get_prop(params,'path',None), self._get_app_filesystem().OPERATION_VIEW)
position = agent.get_prop(params,'position','')
maxline = int(agent.get_prop(params,'position','1000'))
fpos = -1l
flen = utils.path_size(path)
if position!="":
fpos = int(position)
if fpos > flen:
fpos = -1
arl=[]
if fpos < flen:
bm = self._get_app_filesystem().detect_bom_file(path)
enc=None
if bm is not None:
enc = bm["Name"]
f = utils.file_open(path, 'r')
try:
if (fpos!=-1):
f.seek(fpos)
while True:
ln = f.readline()
if ln=="":
break
if enc is None:
enc="UTF-8"
try:
ln=ln.decode(enc)
except:
enc=sys.getfilesystemencoding()
ln=ln.decode(enc, 'replace')
else:
ln=ln.decode(enc, 'replace')
arl.append(ln.rstrip('\n').rstrip('\r'))
if len(arl)>=maxline+1:
arl.remove(arl[0])
if len(arl)>0:
arl.append("")
fpos = f.tell()
finally:
f.close()
ret={}
ret["text"]='\n'.join(arl)
if fpos!=-1:
ret["position"]=str(fpos)
return json.dumps(ret)
def __init__(self):
self._name = u"DWAgent"
self._logo = None
self._properties = {}
try:
f = utils.file_open('config.json')
self._properties = json.loads(f.read())
f.close()
except Exception:
None
if 'name' in self._properties:
self._name = unicode(self._properties["name"])
applg = gdi._get_logo_from_conf(
self._properties, u"ui" + utils.path_sep + u"images" +
utils.path_sep + u"custom" + utils.path_sep)
if applg != "":
self._logo = applg
def _read(self, path):
if utils.path_size(path) > 2 * 1024 * 1024:
raise Exception("File too large.")
prop = {}
enc = None
bom = False
text_file = utils.file_open(path, 'rb')
try:
s = text_file.read()
for bm in self._get_app_filesystem().TEXTFILE_BOM_TYPE:
if s.startswith(bm["Data"]):
enc = bm["Name"]
bom = True
break
if not bom:
#Verifica prima utf8
enc = "UTF-8"
try:
s = s.decode(enc)
except:
enc = sys.getfilesystemencoding()
s = s.decode(enc, 'replace')
else:
s = self._remove_bom(s)
s = s.decode(enc, 'replace')
endline = utils.line_sep
if s.find("\r\n") > 0:
endline = "\r\n"
elif s.find("\n") > 0:
endline = "\n"
elif s.find("\r") > 0 and s[len(s) - 1] != "\r":
endline = "\r"
prop["bom"] = bom
prop["encoding"] = enc
prop["endline"] = endline
sret = s.splitlines()
for i in range(len(sret)):
sret[i] = sret[i].rstrip('\n').rstrip('\r')
prop["text"] = "\n".join(sret)
finally:
text_file.close()
return prop
def open(self, fname, bpath=None):
self._semaphore.acquire()
try:
if self._binit:
raise Exception("Already initialized.")
self._path = sharedmem_manager.getPath(fname, path=bpath)
if not utils.path_exists(self._path):
raise Exception("Shared file not found")
self._file = utils.file_open(self._path, "r+b")
self._mmap = mmap.mmap(self._file.fileno(), 0)
self._mmap.seek(0)
#Legge struttura
self._len_def = struct.unpack('!i', self._mmap.read(4))[0]
shead = self._mmap.read(self._len_def)
self._fields = json.loads(shead)
self._binit = True
finally:
self._semaphore.release()
def get_hw_name():
sapp = platform.machine()
if is_linux() and len(sapp)>=3 and (sapp[0:3].lower()=="arm" or sapp[0:7].lower()=="aarch64"):
#VERIFICA SE RASPBERRY
try:
if utils.path_exists("/sys/firmware/devicetree/base/model"):
fin=utils.file_open("/sys/firmware/devicetree/base/model","r")
appmdl = fin.read()
fin.close()
appmdl=check_hw_string(appmdl);
if appmdl is not None:
return appmdl
appmdl=check_hw_string(platform.node());
if appmdl is not None:
return appmdl
except:
None
return None
def get_hw_name():
sapp = platform.machine()
if is_linux() and len(sapp)>=3 and (sapp[0:3].lower()=="arm" or sapp[0:7].lower()=="aarch64"):
#VERIFICA SE RASPBERRY
try:
if utils.path_exists("/sys/firmware/devicetree/base/model"):
fin=utils.file_open("/sys/firmware/devicetree/base/model","r")
appmdl = fin.read()
fin.close()
if "raspberry" in appmdl.lower():
return "RaspberryPi"
elif "wandboard" in appmdl.lower():
return "Wandboard"
elif "pine64" in appmdl.lower() or "rock64" in appmdl.lower():
return "Pine64"
except:
None
return None
def get_system_info(self):
hmcpu={}
f = utils.file_open("/proc/cpuinfo", "r")
try:
for line in f:
if line.startswith("model name"):
ar = line.split(":")
n = ar[1].strip()
if n not in hmcpu:
hmcpu[n]=1
else:
hmcpu[n]=hmcpu[n]+1
finally:
f.close()
cpuName=""
for k in hmcpu:
if cpuName!="":
cpuName+= ", "
cpuName+=k
return {"osName":platform.platform(), "osUpdate":"", "osBuild":platform.version(), "pcName":platform.node() , "cpuName":cpuName, "cpuArchitecture":platform.machine()}
def open(self, name):
self.ftype = name[0]
self.fname = name[1:]
if self.ftype == "F":
self.fpath = sharedmem_manager.getPath(self.fname)
if not utils.path_exists(self.fpath):
raise Exception("Shared file not found.")
self.file = utils.file_open(self.fpath, "r+b")
elif self.ftype == "M":
if not utils.is_windows():
if load_semaphore_lib():
self.fd = _sharememmap["libbase"].sharedMemoryOpen(
self.fname, os.O_RDWR, 0o666)
if self.fd != -1:
#print "open fd: " + str(self.fd) + " " + self.fname
stats = os.fstat(self.fd)
if stats.st_size != MapFile._SIZE:
raise Exception("Invalid map size.")
else:
raise Exception("Invalid fd.")
else:
raise Exception("Library not loaded.")
self._prepare_map()
def getStreamFile(self, size):
fname = None
self._semaphore.acquire()
try:
while True:
ar = []
for x in range(8):
if x == 0:
ar.append(random.choice(string.ascii_lowercase))
else:
ar.append(
random.choice(string.ascii_lowercase +
string.digits))
fname = "stream_" + ''.join(ar)
fpath = SHAREDMEM_PATH + utils.path_sep + fname + ".shm"
if not utils.path_exists(fpath):
with utils.file_open(fpath, "wb") as f:
f.write(" " * size)
break
finally:
self._semaphore.release()
return fname
def start(self, bgui=True):
confjson = {}
try:
f = utils.file_open('config.json')
confjson = json.loads(f.read())
f.close()
except Exception:
None
prmsui = {}
if "name" in confjson:
self._name = unicode(confjson["name"])
prmsui["title"] = self._get_message('configureTitle')
if "topinfo" in confjson:
prmsui["topinfo"] = confjson["topinfo"]
if "topimage" in confjson:
prmsui["topimage"] = confjson["topimage"]
if "logo" in confjson:
prmsui["logo"] = confjson["logo"]
if "leftcolor" in confjson:
prmsui["leftcolor"] = confjson["leftcolor"]
self._uinterface = ui.UI(prmsui, self.step_init)
self._uinterface.start(bgui)
self.close_req()
def _init_process(self):
if self._bdestroy:
raise Exception("Process destroyed.")
iretry=0;
while True:
try:
self._appconsoleid=None
iretry+=1
if agent.is_windows():
self._appconsoleid=self._get_osmodule().consoleSessionId();
if (self._get_osmodule().isWinXP()==1 or self._get_osmodule().isWin2003Server()==1) and self._appconsoleid>0:
self._get_osmodule().winStationConnectW()
time.sleep(1)
self._destroy_internal()
elif self._currentconsoleid!=None and self._appconsoleid!=self._currentconsoleid:
self._destroy_internal()
elif agent.is_mac():
self._appconsoleid=self._get_osmodule().consoleUserId();
if self._currentconsoleid!=None and self._appconsoleid!=self._currentconsoleid:
self._destroy_internal()
time.sleep(1)
if self._sharedmem==None:
self._sharedmem=sharedmem.Stream()
def fix_perm(fn):
if agent.is_mac() and self._appconsoleid!=None:
utils.path_change_owner(fn, self._appconsoleid, -1)
utils.path_change_permissions(fn, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP)
fname = self._sharedmem.create(fixperm=fix_perm)
#RUN PROCESS
#if utils.path_exists("apps" + utils.path_sep + "desktop.py"): ##MI SERVE IN SVILUPPO
# import compileall
# compileall.compile_file("apps" + utils.path_sep + "desktop.py")
if agent.is_windows():
runaselevatore=u"False"
if self._get_osmodule().isUserInAdminGroup()==1:
if self._get_osmodule().isRunAsAdmin()==1:
if self._get_osmodule().isProcessElevated()==1:
runaselevatore=u"True"
#Gestito cosi perche' sys.executable creave problemi con percorsi unicode
exep=sys.executable
pyhome=u""
appth="native\\service.properties"
if (utils.path_exists(appth)):
f = utils.file_open(appth, 'r', encoding='utf-8')
sprop = f.read()
f.close()
lns = sprop.splitlines()
for line in lns:
if line.startswith("pythonPath="):
exep=line[11:]
elif line.startswith("pythonHome="):
pyhome=line[11:]
appcmd=u"\"" + exep + u"\" -S -m agent app=desktop " + unicode(fname) + u" " + unicode(str(self._agent_main._agent_debug_mode)) + u" windows " + runaselevatore
self._ppid = self._get_osmodule().startProcessAsUser(appcmd,pyhome)
self._currentconsoleid=self._get_osmodule().consoleSessionId();
elif agent.is_linux():
libenv = os.environ
if utils.path_exists("runtime"):
libenv["LD_LIBRARY_PATH"]=utils.path_absname("runtime/lib")
#for some distro linux command below don't works because missing runpy
#self._process=subprocess.Popen([sys.executable, u'-S', u'-m', u'agent' , u'app=desktop', unicode(fname), unicode(str(self._agent_main._agent_debug_mode)),u'linux'], env=libenv)
self._process=subprocess.Popen([sys.executable, u'agent.pyc', u'app=desktop', fname, str(self._agent_main._agent_debug_mode),u'linux'], env=libenv)
'''
stat -c%U /dev/tty2
if my_args is None: my_args = sys.argv[1:]
user_name, cwd = my_args[:2]
args = my_args[2:]
pw_record = pwd.getpwnam(user_name)
user_name = pw_record.pw_name
user_home_dir = pw_record.pw_dir
user_uid = pw_record.pw_uid
user_gid = pw_record.pw_gid
env = os.environ.copy()
env[ 'HOME' ] = user_home_dir
env[ 'LOGNAME' ] = user_name
env[ 'PWD' ] = cwd
env[ 'USER' ] = user_name
self._process=subprocess.Popen([sys.executable, u'agent.pyc', u'app=desktop', fname, str(self._agent_main._agent_debug_mode),u'linux'], env=libenv, preexec_fn=self._init_process_demote(1000, 1000))
'''
#GESTIRE IL RENICE
elif agent.is_mac():
self._ppid = self._agent_main.get_osmodule().exec_guilnc(self._appconsoleid,"desktop",[fname, str(self._agent_main._agent_debug_mode),u'mac'])
if self._ppid is not None:
self._currentconsoleid=self._appconsoleid
self._process = None
else:
self._currentconsoleid=None
libenv = os.environ
if utils.path_exists("runtime"):
libenv["DYLD_LIBRARY_PATH"]=utils.path_absname("runtime/lib")
#self._process=subprocess.Popen([sys.executable, u'agent.pyc', u'app=desktop', fname, str(self._agent_main._agent_debug_mode),u'mac'], env=libenv)
self._process=subprocess.Popen([sys.executable, u'-S', u'-m', u'agent' , u'app=desktop', unicode(fname), unicode(str(self._agent_main._agent_debug_mode)),u'mac'], env=libenv)
#GESTIRE IL RENICE
self._appconsoleid=None
#Attende che il processo si attiva
bok=False
for i in range(10):
time.sleep(0.5)
if self._process!=None:
if self._process.poll() == None:
bok=True
break
elif self._ppid!=None:
if self._agent_main.get_osmodule().is_task_running(self._ppid):
bok=True
break
else:
break
if bok:
break
else:
raise Exception("Process not started.")
else:
break
except Exception as e:
time.sleep(1)
self._destroy_internal()
if iretry>=3:
raise e
def _set_config_base_path(self, pth):
self._config_base_path = pth
f = utils.file_open(self._config_base_path + os.sep + 'config.json')
self._properties = json.loads(f.read())
f.close()
def add_show_file(self):
showfilename = self._homedir + utils.path_sep + "monitor.show"
if not utils.path_exists(showfilename):
f = utils.file_open(showfilename, "w")
f.write("\x00")
f.close()
def get_performance_info(self):
ret = {}
cpuUsagePerc=0
#Legge info cpu
f = utils.file_open('/proc/stat', 'rb')
try:
arline = f.readline().split()
finally:
f.close()
cputime = {}
cputime['user'] = float(arline[1]) / self._CLOCKTICKS
cputime['nice'] = float(arline[2]) / self._CLOCKTICKS
cputime['system'] = float(arline[3]) / self._CLOCKTICKS
cputime['idle'] = float(arline[4]) / self._CLOCKTICKS
cputime['iowait'] = float(arline[5]) / self._CLOCKTICKS
cputime['irq'] = float(arline[6]) / self._CLOCKTICKS
cputime['softirq'] = float(arline[7]) / self._CLOCKTICKS
timer = lambda: self._timer() * self._cpu_logical_count
cputime['timer']=timer()
if self._oldcputime is not None:
try:
delta_proc = (cputime['user'] - self._oldcputime['user']) + (cputime['system'] - self._oldcputime['system'])
delta_time = cputime['timer'] - self._oldcputime['timer']
cpuUsagePerc = int(((delta_proc / delta_time) * 100) * self._cpu_logical_count)
if cpuUsagePerc>100:
cpuUsagePerc=100
except ZeroDivisionError:
None
self._oldcputime = cputime
ret["cpuUsagePerc"]=cpuUsagePerc
#Legge la memoria
f = utils.file_open('/proc/meminfo', 'rb')
memoryPhysicalTotal=0
memoryPhysicalAvailable=-1
memoryFree=0
memoryVirtualTotal=0
memoryVirtualAvailable=0
try:
for line in f:
if line.startswith("MemTotal:"):
memoryPhysicalTotal = long(line.split()[1]) * 1024
elif line.startswith("MemFree:"):
memoryFree = long(line.split()[1]) * 1024
elif line.startswith("MemAvailable:"):
memoryPhysicalAvailable = long(line.split()[1]) * 1024
elif line.startswith("SwapTotal:"):
memoryVirtualTotal = long(line.split()[1]) * 1024
elif line.startswith("SwapFree:"):
memoryVirtualAvailable = long(line.split()[1]) * 1024
finally:
f.close()
ret["memoryPhysicalTotal"]=memoryPhysicalTotal
if memoryPhysicalAvailable==-1:
memoryPhysicalAvailable=memoryFree
ret["memoryPhysicalAvailable"]=memoryPhysicalAvailable
ret["memoryVirtualTotal"]=memoryVirtualTotal
ret["memoryVirtualAvailable"]=memoryVirtualAvailable
ret["memoryTotal"]=ret["memoryPhysicalTotal"]+ret["memoryVirtualTotal"]
ret["memoryAvailable"]=ret["memoryPhysicalAvailable"]+ret["memoryVirtualAvailable"]
return ret
