def thread_P2(nom):
global RC
tprint('{nom} : Debut du thread nom={nom}'.format(
nom=nom,
pid=multiprocessing.current_process().pid,
tid=threading.get_ident()))
for i in range(NbCoups):
time.sleep(random.randint(0, 3))
#P()
S1.acquire()
# Debut de section critique
tprint('{nom} : Debut de section critique'.format(nom=nom))
b = RC
time.sleep(random.randint(0, 3))
RC = b + 2
tprint('{nom} : \t (i={i}) RC={RC}'.format(nom=nom, i=i, RC=RC))
tprint('{nom} : Fin de section critique'.format(nom=nom))
# fin de section critique
# V()
S1.release()
tprint('{nom} : Fin du thread'.format(nom=nom))
def avion():
for i in range(nbAvions):
SA2.acquire()
time.sleep(random.randint(0, 3))
nbProduction["avion"] += 1
tprint('Un avion est achevé ({})'.format(i + 1))
SAv.release()
def thread_ping_pong(nom) :
global chaine_ping_pong
tprint( '{nom} : Debut du thread nom={nom}, pid={pid}, tid={tid}'.format(nom=nom, pid=multiprocessing.current_process().pid, tid=threading.get_ident()))
for i in range(NbCoups):
time.sleep(random.randint(0, 3))
# A completer ...
if nom is "PING" :
SPI.acquire()
else :
SPO.acquire()
# Debut de section critique
tprint( '{nom} : Debut de section critique'.format(nom=nom))
time.sleep(random.randint(0, 3))
chaine_ping_pong = chaine_ping_pong + nom + ' '
tprint( '{nom} : \t (i={i}) chaine_ping_pong={chaine_ping_pong}'.format(nom=nom, i=i, chaine_ping_pong=chaine_ping_pong) )
tprint( '{nom} : Fin de section critique'.format(nom=nom))
# fin de section critique
# A completer ...
if nom is "PING" :
SPO.release()
else :
SPI.release()
tprint( '{nom} : Fin du thread'.format(nom=nom))
def thread_P2(nom):
global RC
tprint('{nom} : Debut du thread nom={nom}'.format(
nom=nom,
pid=multiprocessing.current_process().pid,
tid=threading.get_ident()))
for i in range(NbCoups):
# A completer...
semaphore.acquire()
# Debut de section critique
tprint('{nom} : Debut de section critique'.format(nom=nom))
b = RC
RC = b + 2
tprint('{nom} : \t (i={i}) RC={RC}'.format(nom=nom, i=i, RC=RC))
tprint('{nom} : Fin de section critique'.format(nom=nom))
# fin de section critique
semaphore.release()
# A completer...
tprint('{nom} : Fin du thread'.format(nom=nom))
def tampon_retirer ( tampon ) :
if tampon_est_vide( tampon ) :
tprint("Erreur Tampon Vide")
return
element=tampon.fifo[0]
tampon.fifo=tampon.fifo[1:]
return element
def tampon_retirer(tampon):
if tampon_est_vide(tampon):
tprint("Erreur Tampon Vide")
return
time.sleep(random.randint(0, tampon.dureeMax))
element = tampon.fifo[0]
tampon.fifo = tampon.fifo[1:]
return element
def aeroplane():
for i in range(nbAvionsPrevus):
moniteur_retirer(usine.tamponMoteur,"moteur")
moniteur_retirer(usine.tamponCarlingueAileRoue,"carlingueAileRoue")
moniteur_retirer(usine.tamponMoteur,"moteur")
# A completer: retirer 1 carlingue1Ailes2Roues3 et 2 moteurs des tampons
tprint( 'Un aeroplane est achevé ({})'.format(i+1))
# A completer: deposer dans le tampon des aeroplane
moniteur_deposer(usine.tamponAeroplne,"avion","1")
def carlingue1Ailes2():
for i in range(nbAvionsPrevus):
# A completer: retirer 1 carlingue et 2 ailes des tampons
moniteur_retirer(usine.tamponAile,"aile")
moniteur_retirer(usine.tamponCarlingue,"carlingue")
moniteur_retirer(usine.tamponAile,"aile")
tprint( 'Un assemblage 1 carlingue avec 2 ailes est achevé ({})'.format(i+1))
# A completer: deposer dans le tampon des carlingue1Ailes2
moniteur_deposer(usine.tamponCarlingueAile,"carlingueAile","1")
def avion():
for i in range(nbAvions):
# A Compléter...
carlingueAileRoue.acquire()
moteurs.acquire()
moteurs.acquire()
time.sleep(random.randint(0, 3))
nbProduction["avion"] += 1
tprint('Un avion est achevé ({})'.format(i + 1))
avions.release()
def exit_test(self, error=None):
for p in self.processes:
p.terminate()
for p in self.processes:
p.join()
if error != None:
tprint("EXITED - " + str(error), "FAIL")
else:
tprint("ALL TESTS PASSED", "OKGREEN")
return
def all_alive(self):
ok = True
for i, p in enumerate(self.processes):
if not p.is_alive():
ok = False
tprint(
"ERROR : " + self.processesnames[i] + "PROCESS IS DEAD...", "FAIL")
if not ok:
self.exit_test("DEAD PROCESS")
return ok
def carlingue1Ailes2():
for i in range(nbAvions):
SC.acquire()
SA.acquire()
SA.acquire()
time.sleep(random.randint(0, 3))
nbProduction["carlingue1Ailes2"] += 1
tprint(
'Un assemblage 1 carlingue avec 2 ailes est achevé ({})'.format(i +
1))
SA1.release()
def carlingue1Ailes2Roues3():
for i in range(nbAvions):
SR.acquire()
SR.acquire()
SR.acquire()
SA1.acquire()
time.sleep(random.randint(0, 3))
nbProduction["carlingue1Ailes2Roues3"] += 1
tprint(
'Un assemblage 1 carlingue et 2 ailes avec 3 roue est achevé ({})'.
format(i + 1))
SA2.release()
def _rpc(self, method, *args):
data = {'id': self.id, 'method': method, 'params': args }
request = json.dumps(data)
self.client.write(request + '\n')
self.client.flush()
response = self.client.readline()
self.id += 1
result = json.loads(response)
if result['error'] is not None:
tprint(result['error'])
# namedtuple doesn't work with unicode keys.
return Result(id=result['id'], result=result['result'], error=result['error'],)
def carlingue1Ailes2Roues3():
for i in range(nbAvions):
# A Compléter...
carlingueAile.acquire()
roues.acquire()
roues.acquire()
roues.acquire()
time.sleep(random.randint(0, 3))
nbProduction["carlingue1Ailes2Roues3"] += 1
tprint(
'Un assemblage 1 carlingue et 2 ailes avec 3 roue est achevé ({})'.
format(i + 1))
carlingueAileRoue.release()
def test_prod_cons_avec_semaphores():
# Fonction principales de création et de démarrage des threads
nomsThreads = ["c1", "p1", "p2", "p3", "p4", "c2", "c3", "c4 "]
threads = []
for nomT in nomsThreads:
if nomT[0] == 'p':
thread_main = producteur
else:
thread_main = consommateur
threads.append(
threading.Thread(target=thread_main, name=nomT, args=(nomT, )))
tprint("Debut du test")
for t in threads:
t.start()
tprint("{name} demarre".format(name=t.name))
for t in threads:
t.join()
tprint("{name} est terminé".format(name=t.name))
tprint("Fin du test")
def producteur(nom):
element = nom[1:]
Sp.acquire()
S.acquire()
# code en E.M. sur mutex
tprint(" {nom} depose \"{element}\" dans le tampon...".format(
nom=nom, element=element))
tampon_lifo.tampon_deposer(tampon, element)
tprint(" {nom} a fini de deposee \"{element}\" dans le tampon...".
format(nom=nom, element=element))
#tprint(" {nom} tampon = {tampon}".format(nom=nom, tampon=tampon.lifo))
# fin d'E.M.
Sc.release()
S.release()
def consommateur(nom):
Sc.acquire()
S.acquire()
# code en E.M. sur mutex
tprint(" {nom} retire un element du tampon...".format(nom=nom))
element = tampon_lifo.tampon_retirer(tampon)
tprint(" {nom} a fini de retirer \"{element}\" du tampon...".format(
nom=nom, element=element))
#tprint(" {nom} tampon = {tampon}".format(nom=nom, tampon=tampon.lifo))
# fin d'E.M.
Sp.release()
S.release()
return element
def consommateur(nom):
# A completer
produits.acquire()
mutex.acquire()
# code en E.M. sur mutex
tprint(" {nom} retire un element du tampon...".format(nom=nom))
element = tampon_lifo.tampon_retirer(tampon)
tprint(" {nom} a fini de retirer \"{element}\" du tampon...".format(
nom=nom, element=element))
#tprint(" {nom} tampon = {tampon}".format(nom=nom, tampon=tampon.lifo))
# fin d'E.M.
# A completer
mutex.release()
placeVide.release()
return element
def producteur(nom):
element = nom[1:]
# A completer
placeVide.acquire()
mutex.acquire()
# code en E.M. sur mutex
tprint(" {nom} depose \"{element}\" dans le tampon...".format(
nom=nom, element=element))
tampon_lifo.tampon_deposer(tampon, element)
tprint(" {nom} a fini de deposee \"{element}\" dans le tampon...".
format(nom=nom, element=element))
#tprint(" {nom} tampon = {tampon}".format(nom=nom, tampon=tampon.lifo))
# fin d'E.M.
# A completer
mutex.release()
produits.release()
def __init__(self, yml_rules="", verbosity=0):
self._p = p.tprint()
self.verbosity = verbosity
self.load_cfg()
if yml_rules:
self.rules = rulebook.RuleBook()
self.rules.load_rules(yml_rules)
#self.rules.print_rules()
# TODO: If no module path, set it to git repository
self.list_all_modules(self.cfg_module_root)
def __init__(self, addr=None):
if addr is None:
addr = HOST, PORT
tprint("connect to addr: ", addr)
self.conn = socket.create_connection(addr)
tprint("create file pointer: ", self.conn)
self.client = self.conn.makefile(mode='rw', encoding='utf-8')
tprint("created file pointer: ", self.client)
self.id = 0
def test_moniteur_prod_cons():
# Ressource Critique
tailleMax = 5
tampon = Tampon_fifo(tailleMax)
moniteur = MoniteurProdCons(tampon)
# Fonction principales des threads "producteurs"
def producteur(nom, moniteur):
element = nom[1:]
moniteur_deposer(moniteur, nom, element)
# Fonction principales des threads "consommateurs"
def consommateur(nom, moniteur):
elt = moniteur_retirer(moniteur, nom)
# Fonction principales de création et de démarrage des threads
nomsThreads = [
"c1", "p1", "p2", "p3", "p4", "c2", "c3", "c4", "p5", "p6", "c5"
]
threads = []
for nomT in nomsThreads:
if nomT[0] == 'p':
thread_main = producteur
else:
thread_main = consommateur
threads.append(
threading.Thread(target=thread_main,
name=nomT,
args=(nomT, moniteur)))
tprint("Debut du test")
for t in threads:
t.start()
tprint("{name} demarre".format(name=t.name))
for t in threads:
t.join()
tprint("{name} est terminé".format(name=t.name))
tprint("Fin du test")
def moniteur_retirer(moniteur, nom):
tprint("{nom} debute moniteur_retirer".format(nom=nom))
# a compléter: EM
moniteur.mutex.acquire()
# a compléter : attendre (=wait) si tampon vide (tampon_est_vide( moniteur.tampon )....)
while (tampon_est_vide(moniteur.tampon)):
moniteur.CC.wait()
tprint(" {nom} retire un element du tampon...".format(nom=nom))
element = tampon_retirer(moniteur.tampon)
tprint(" {nom} a fini de retirer \"{element}\" du tampon".format(
nom=nom, element=element))
assert (not tampon_est_plein(moniteur.tampon))
# a compléter : réveiller (=signal) un processus producteur endormi en attente de tampon plein
moniteur.CP.notify()
tprint("{nom} termine moniteur_retirer".format(nom=nom))
# a compléter: EM
moniteur.mutex.release()
return element
def moniteur_deposer(moniteur, nom, element):
tprint("{nom} debute moniteur_deposer".format(nom=nom))
# a compléter: EM
moniteur.mutex.acquire()
# a compléter : attendre (=wait) si tampon plein (tampon_est_plein( moniteur.tampon )....)
while (tampon_est_plein(moniteur.tampon)):
moniteur.CP.wait()
tprint(" {nom} depose \"{element}\" dans le tampon...".format(
nom=nom, element=element))
tampon_deposer(moniteur.tampon, element)
tprint(
" {nom} a fini de deposee \"{element}\" dans le tampon".format(
nom=nom, element=element))
assert (not tampon_est_vide(moniteur.tampon))
# a compléter : réveiller (=signal) un processus consommateur endormi en attente de tampon vide
moniteur.CC.notify()
tprint("{nom} termine moniteur_deposer".format(nom=nom))
# a compléter: EM
moniteur.mutex.release()
tprint( 'T2 : dessine...')
# restitution d'un jeton dans le semaphore crayon
tprint( 'T2 : v(feuille)' )
feuille.release()
# restitution d'un jeton dans le semaphore feuille
tprint( 'T2 : V(crayon})')
crayon.release()
# Création des Thread
t1=threading.Thread(target=thread_T1)
t2=threading.Thread(target=thread_T2)
tprint('Debut du test')
# Démarrage des threads
for t in [t1,t2]:
t.start()
# Attente de terminaison des threads
for t in [t1,t2]:
t.join()
tprint('Fin du test')
input_dir = input('Enter folder path: ')
if isinstance(input_dir, str):
work_dir = input_dir
break
else:
pass
# work_dir = 'D:\\共享区'
for parent, dirnames, filenames in os.walk(work_dir, followlinks=True):
for filename in filenames:
file_path = os.path.join(parent, filename)
file_attr = stat(file_path)
attr_list = [
file_attr.st_mode, file_attr.st_uid, file_attr.st_gid,
file_attr.st_size, file_attr.st_atime, file_attr.st_mtime,
file_attr.st_ctime
]
name, ext = os.path.splitext(filename)
sql = '''INSERT OR IGNORE INTO `files` (name, ext, filename, dirpath, filepath, md5, sha1, mode,
uid, gid, size, astime, mstime, cstime, uptime, atime, mtime, ctime, remark)
VALUES('{0}','{1}','{2}','{3}','{4}','{5}','{6}',{7},{8},{9},{10},
'{11}','{12}','{13}','{14}',{15},{16},{17},'{18}')'''.format(
name, ext, filename, parent, file_path, get_md5(file_path),
get_sha1(file_path),
attr_list[0], attr_list[1], attr_list[2], attr_list[3],
mts(attr_list[4]), mts(attr_list[5]), mts(attr_list[6]),
currentTs(), attr_list[4], attr_list[5], attr_list[6], '')
tprint('write_successfully', filename)
sqlite.insert(sql)
# print(attr_list)
import socket
from _socket import SHUT_RDWR
class AndroidProxy(android.Android):
def __init__(self, addr=None):
android.Android.__init__(self, addr)
def call(self, request):
self.conn.sendall(request)
response = self.conn.recv(10240)
self.id += 1
return response
droid = AndroidProxy()
tprint("Handshake is %s" % (android.HANDSHAKE))
tprint("Server host is %s" % (android.HOST))
tprint("Server port is %s" % (android.PORT))
addr = ("", 9999)
serverSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serverSock.bind(addr)
serverSock.listen(1)
while True:
tprint("Connection waiting at %s" % (serverSock))
sock, addr = serverSock.accept()
tprint("Connection accepted %s" % (sock))
while True:
def aile() :
for i in range(nbAvionsPrevus*2):
tprint( 'Une Aile est achevée ({})'.format(i+1))
# A completer: deposer dans le tampon des ailes
moniteur_deposer(usine.tamponAile,"aile","1")
def thread_T2() :
tprint( 'Debut du thread T2')
time.sleep(random.randint(0, 3))
# prise d'un jeton dans le semaphore crayon
tprint( 'T2 : Demande P(feuille)' )
feuille.acquire()
tprint( 'T2 : Obtient P(feuille})')
# prise d'un jeton dans le semaphore feuille
tprint( 'T2 : Demande P(crayon})')
crayon.acquire()
tprint( 'T2 : Obtient P(crayon})')
# Debut de section critique
tprint( 'T2 : feuille et crayon obtenus')
tprint( 'T2 : dessine...')
# restitution d'un jeton dans le semaphore crayon
tprint( 'T2 : v(feuille)' )
feuille.release()
# restitution d'un jeton dans le semaphore feuille
tprint( 'T2 : V(crayon})')
crayon.release()
def roue():
for i in range(nbAvionsPrevus*3):
tprint( 'Une roue est achevée ({})'.format(i+1))
# A completer: deposer dans le tampon des roues
moniteur_deposer(usine.tamponRoue,"roue","1")
from tprint import tprint
import sys
tprint("Current platform is %s." % (sys.platform))
if sys.platform.startswith('linux-armv'):
tprint("This device is android")
from android import Android
else:
tprint("This device is not android")
import collections
import json
import socket
PORT = 9999
HOST = "127.0.0.1"
Result = collections.namedtuple('Result', 'id,result,error')
class Android(object):
def __init__(self, addr=None):
if addr is None:
addr = HOST, PORT
tprint("connect to addr: ", addr)
self.conn = socket.create_connection(addr)
tprint("create file pointer: ", self.conn)
self.client = self.conn.makefile(mode='rw', encoding='utf-8')
tprint("created file pointer: ", self.client)
self.id = 0
def _rpc(self, method, *args):
def __init__(self,db_path):
self.conn = sqlite3.connect(db_path)
tprint("Opened database successfully")
self.curs = self.conn.cursor()
def moteur():
for i in range(nbAvionsPrevus*2):
tprint( 'Un moteur est achevé ({})'.format(i+1))
# A completer: deposer dans le tampon des moteurs
moniteur_deposer(usine.tamponMoteur,"moteur","1")