def test_message_integrity_and_if_nebpublisher_reads_from_the_queue(self): mq = MessageQueue(123456) with patch.object(ConnectionAdapter, '__init__') as mock_method: message = "Everything is Dust in the Wind" mq.send(message) mock_method.return_value = None mock_sender = ConnectionAdapter([('127.0.0.1', 61613)], 0) mock_sender.send = MagicMock() mock_sender.__connect = MagicMock(return_value=True) ipc2activemq.main() time.sleep(0.1) mock_sender.send.assert_called_with(message, None, None) assertEqual(0, mq.current_messages)
def datetime_request(queue, pid): """ Handles a time request asynchronously :param queue: the queue to send the date back into :param pid: the request client pid """ time = asctime().encode() queue.send(time, type=(int(pid) + 3)) print(f"date {time} sent to client {pid}") if __name__ == "__main__": # Create IPC with key 0x80 if it doesn't exist KEY = 0x80 message_q = MessageQueue(KEY, IPC_CREX) with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool: while True: message, message_type = message_q.receive() # 1 : date request if message_type == 1: # Do it async pool.submit(datetime_request, message_q, message) # 2 : stop request elif message_type == 2: print("terminating") message_q.remove() break
""" IPC client """ # pylint: disable=no-name-in-module import sys from sysv_ipc import MessageQueue, ExistentialError if __name__ == "__main__": KEY = 128 try: mq = MessageQueue(KEY) except ExistentialError: print("IPC queue doesn't exist") sys.exit(1) while True: message_type = input("1 for time 2 to stop : ") if message_type.isdigit() and message_type in ["1", "2"]: mq.send("", type=int(message_type)) print(f"send type {message_type}") if message_type == "1": message_type, t = mq.receive(type=3) print(message_type) else: print("server stopped") break else: print("bad input")
from psutil import Process from os import getpid import psutil def eprint(*args, **kwargs): print(*args, file=stderr, **kwargs) # slice msg msg = input() msg1 = msg[0:int(len(msg) / 2)] msg2 = msg[int(len(msg) / 2):len(msg)] # args queue = MessageQueue(int(argv[1])) master_name = argv[2] # master process must be the nearest parent with the exact given name master_proc = Process(getpid()) while master_proc.name() != master_name: master_proc = master_proc.parent() with Semaphore(int(argv[1])): try: # send-receive echo # type=1 : from me to other # type=2 : to me from other queue.send(msg1, type=1) # will block until a process claims the rest of the message (echo1, echo_type) = queue.receive(type=2)
def market(weatherAttributes, prices, exitFlag): print("[%d] Market (main) : Init" % getpid()) # create handler with a closure, reroute signals, and launch external process externalEvents = [0, 0] def market_handler(sig, frame): if sig == SIGUSR1: externalEvents[0] = 1 elif sig == SIGUSR2: externalEvents[1] = 1 signal(SIGUSR1, market_handler) signal(SIGUSR2, market_handler) externalProcess = Process(target=external, args=(getpid(), exitFlag)) externalProcess.start() # create lock that will be passed to many threads to treat each request sharedLock = Lock() # create message queues to Homes queueToHome = MessageQueue(marketKey, IPC_CREAT) # if queue was not properly deleted, it's still there and we have to do it ourselves if queueToHome.current_messages > 0: queueToHome.remove() queueToHome = MessageQueue(marketKey, IPC_CREAT) print("[%d] Market (main) : messageQueue created" % getpid()) buying = [] selling = [] idx = 0 price = -1 gamma = 0.90 # long-term attenuation coefficient alpha = [ -0.052, 0.075, 0.23, -0.07 ] # modulating coefficient for internal factors: Temperature, Rain, bought, sold internalEvents = [0, 0, 0, 0] beta = [-7, 30 ] # modulating coefficient for external factors: SIGUSR1, SIGUSR2 # print("[%d] Market (main) : all external processes launched" % getpid()) while not exitFlag.value: sleep(period) # upon receiving a buying message, we launch a thread try: while queueToHome.current_messages > 0: message, _ = queueToHome.receive(block=False, type=1) (Thread(target=marketThread, args=( message, buying, sharedLock, ))).start() except (NotAttachedError, BusyError): pass # upon receiving a selling message, we launch a thread try: while queueToHome.current_messages > 0: message, _ = queueToHome.receive(block=False, type=2) (Thread(target=marketThread, args=( message, selling, sharedLock, ))).start() except (NotAttachedError, BusyError): pass print( "[%d] external = %s \tweather = [ %.2f, %.2f ]\tbuying = %s\tselling = %s" % (getpid(), externalEvents, weatherAttributes[0], weatherAttributes[1], buying, selling)) internalEvents = [ weatherAttributes[0], weatherAttributes[1], sum(buying), sum(selling) ] if price == -1: print("[%d] Initiating energy price" % getpid()) price = sum([ alpha[k] * internalEvents[k] for k in range(len(internalEvents)) ]) + sum([ beta[k] * externalEvents[k] for k in range(len(externalEvents)) ]) else: price = gamma * price + sum([ alpha[k] * internalEvents[k] for k in range(len(internalEvents)) ]) + sum([ beta[k] * externalEvents[k] for k in range(len(externalEvents)) ]) if price <= 0: price = 0.05 prices[idx] = price idx = (idx + 1) % 500 #print("In market : "+str(prices[0:20])) print("[%d] Energy price = %.2f €/kWh" % (getpid(), price)) externalEvents = [0, 0] buying = [] selling = [] queueToHome.remove() print("[%d] Market (main) : messageQueue removed" % getpid()) print("[%d] Market (main) : Exit" % getpid())
#!/usr/bin/env python3 """ Create a new private System-V IPC queue. Return key + id The IPC object should be available only to the creating process or its child processes (e.g. those created with fork()). """ from __future__ import print_function from sys import stderr, stdout from sysv_ipc import MessageQueue, Semaphore, IPC_CREX def eprint(*args, **kwargs): print(*args, file=stderr, **kwargs) # create queue and semaphore queue = MessageQueue(None, IPC_CREX) sema1 = Semaphore(queue.key, IPC_CREX, initial_value=1) sema2 = Semaphore(queue.key + 1, IPC_CREX, initial_value=1) print( str(queue.key) + " " + str(queue.id) + " " + str(sema1.id) + " " + str(sema2.id))
def home(exitFlag, CR=int(130 * random()), PR=int(70 * random()), ETP=int(3 * random())): print("[%d] Home : Init" % getpid()) print("[%d] Home : CR = %d\tPR = %d\tETP = %d" % (getpid(), CR, PR, ETP)) try: queueToMarket = MessageQueue(marketKey) print("[%d] Home : connected to messageQueue" % getpid()) except ExistentialError: print( "[%d] Home : can't connect to messageQueue, try launching Market before Home" % getpid()) exitFlag.value = 1 while not exitFlag.value: sleep(period) # besoin d'énergie: il en cherche auprès des maisons, sinon il achète au marché if CR > PR: energyNeeded = CR - PR sleep( timeDelay ) # petit délai pour que les receive() arrivent après les send() while energyNeeded > 0: try: message, _ = queueToMarket.receive(block=False, type=3) pid, quantity = message.decode().split(':') energyNeeded -= int(quantity) print("[%d] Home : received %d of energy" % (getpid(), int(quantity))) response = str(getpid()) + ":ACK" queueToMarket.send(response.encode(), type=int(pid)) print("[%d] Home : ACK sent to %s" % (getpid(), pid)) except (NotAttachedError, BusyError): break if energyNeeded > 0: message = str(getpid()) + ':' + str(energyNeeded) queueToMarket.send(message.encode(), type=1) print("[%d] Home : bought %d of energy to the market" % (getpid(), energyNeeded)) else: print("[%d] Home : got %d of free energy" % (getpid(), -energyNeeded)) # trop d'énergie : il fait selon ETP elif PR > CR: energyBonus = PR - CR if ETP == 0: message = str(getpid()) + ':' + str(energyBonus) queueToMarket.send(message.encode(), type=3) print("[%d] Home : gave %d of energy" % (getpid(), energyBonus)) elif ETP == 1: message = str(getpid()) + ':' + str(energyBonus) queueToMarket.send(message.encode(), type=2) print("[%d] Home : sold %d of energy to the market" % (getpid(), energyBonus)) else: try: message = str(getpid()) + ':' + str(energyBonus) queueToMarket.send(message.encode(), type=3) print( "[%d] Home : gave %d of energy, waiting for response" % (getpid(), energyBonus)) sleep(2 * timeDelay) message, t = queueToMarket.receive(block=False, type=getpid()) print("[%d] Home : response received" % getpid()) except (NotAttachedError, BusyError): message = str(getpid()) + ':' + str(energyBonus) queueToMarket.send(message.encode(), type=2) print( "[%d] Home : no response, sold %d of energy to the market" % (getpid(), energyBonus)) else: print("[%d] Home : i'm autonomous !" % getpid()) print("[%d] Home : Exit" % getpid())
def __init__( self, shared_variables: SharedVariables, politics: int, economy: int, nb_houses: int, ipc_house: int, time_interval: int, ): super().__init__(shared_variables) # Political climate, rated from 0 to 100 self.politics = Value("i") with self.politics.get_lock(): self.politics.value = politics # Economics climate, rated from 0 to 100 self.economy = Value("i") with self.economy.get_lock(): self.economy.value = economy self.nb_houses = nb_houses # Number of houses self.mq_house = MessageQueue( ipc_house) # Message queue to communicate with houses self.daily_consumption = Value( "d") # Total consumption of the houses on this day self.surplus = Value("d") # Surplus of production self.waiting_houses = collections.deque() # Free energy waiting queue self.waiting_lock = multiprocessing.Lock() # Lock to access this queue # Set default values with self.daily_consumption.get_lock(): self.daily_consumption.value = 0 with self.surplus.get_lock(): self.surplus.value = 0 self.workers = 5 # Coefficients for energy price self.gamma = 0.98 self.alpha = [0.0001, 0.0001, 0.000001] self.beta = [0.025, 0.025, 0.025] # Politics : score between 0 and 100. # SIGUSR1 : politics situation deteriorates # SIGUSR2 : economics situation deteriorates self.market_pid = os.getpid() self.politics_process = ExternalFactor( ppid=self.market_pid, name="politics", signal_code=signal.SIGUSR1, delay=time_interval * 6, ) self.economics_process = ExternalFactor( ppid=self.market_pid, name="economics", signal_code=signal.SIGUSR2, delay=time_interval * 7, ) self.economics_process.start() self.politics_process.start() # Listen for signals signal.signal(signal.SIGUSR1, self.signal_handler) signal.signal(signal.SIGUSR2, self.signal_handler)