import rpc
import time
from context import lab_logging
lab_logging.setup()
cl = rpc.Client()
cl.run()
base_list = rpc.DBList({'foo'})
result_list = cl.append('bar', base_list)
print("Result: {}".format(result_list.value))
cl.stop()
- peers compete for some critical section
- peers run in separate processes
- multiprocessing should work on unix and windows
- terminates a random process to simulate a crash fault
"""
import sys
import time
import logging
import random
import multiprocessing as mp
from process import Process
from context import lab_channel, lab_logging
lab_logging.setup(stream_level=logging.INFO, file_level=logging.DEBUG)
logger = logging.getLogger("vs2lab.lab5.mutex.doit")
def create_and_run(num_bits, proc_class, enter_bar, run_bar):
"""
Create and run a peer
:param num_bits: address range of the channel
:param node_class: class of peer
:param enter_bar: barrier syncing channel population
:param run_bar: barrier syncing bootstrap
"""
chan = lab_channel.Channel(n_bits=num_bits)
proc = proc_class(chan)
enter_bar.wait() # wait for all peers to join the channel
import os
import rpc
import logging
from context import lab_logging
import time
os.system('cls')
lab_logging.setup(stream_level=logging.INFO)
def callback():
str_res = ""
print('Call-back Function')
print(" 3. Message received from server!")
str_res = str_res + " from callback-function "
return str_res
def main_fkt():
print('The main program continues to run in foreground.')
for i in range(15):
time.sleep(1)
print("-" + str(i) + "-")
cl = rpc.Client()
cl.run()
base_list = rpc.DBList({'foo'})
result_list = cl.append('bar', base_list)
print("Result: {}".format(result_list))
cl.stop()
import logging
import socket
import constCS
from context import lab_logging
lab_logging.setup(
stream_level=logging.INFO) # init loging channels for the lab
class Server:
_logger = logging.getLogger("vs2lab.lab1.clientserver.Server")
_serving = True
def __init__(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind((constCS.HOST, constCS.PORT))
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1) # prevents errors due to "addresses in use"
self.sock.settimeout(3) # time out in order not to block forever
self._logger.info("Server bound to socket " + str(self.sock))
def serve(self):
self.sock.listen(1)
while self._serving: # as long as _serving (checked after connections or socket timeouts)
try:
(connection, address) = self.sock.accept(
) # returns new socket and address of client
while True: # forever
data = connection.recv(1024) # receive data from client
if not data:
import logging
import channel
from context import lab_channel, lab_logging
lab_logging.setup(stream_level=logging.DEBUG)
logger = logging.getLogger('vs2lab.lab2.channel.runsrv')
chan = lab_channel.Channel()
chan.channel.flushall()
logger.info('Flushed all redis keys.')
server = channel.Server()
server.run()
import logging
import socket
import json
import constCS
from context import lab_logging
lab_logging.setup() # init loging channels for the lab
class Server:
_logger = logging.getLogger("vs2lab.lab1.clientserver.Server")
_serving = True
dict1 = {'Luke': "12345672", "Sky": "124576437", 'Walker': "67", 'Peter': "1267"}
def __init__(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind((constCS.HOST, constCS.PORT))
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # prevents errors due to "addresses in use"
self.sock.settimeout(3) # time out in order not to block forever
self._logger.info("Server bound to socket " + str(self.sock))
def dictionary(self, name):
dictData = self.dict1[name]
return str(dictData)
def dictionaryALL(self):
return json.dumps(self.dict1)
