pbesa 2.1__py3-none-any.whl → 4.0.0__py3-none-any.whl

pbesa/kernel/system/Adm.py

@@ -1,189 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import sys
-import json
-import socket
-from time import sleep
-from ...kernel.util.HashTable import HashTable
-from ...kernel.system.Directory import Directory
-from ...kernel.adapter.FileAdapter import FileAdapter
-from ...middleware.remote.RemoteAdm import RemoteAdm
-from ...middleware.remote.AdmListener import AdmListener
-
-class Adm(object):
-    class __Adm:
-        def __init__(self):
-            self.val = None
-            self.conf = None
-            self.adapters = HashTable()
-            self.agentsTable = {}
-            self.containerList = []
-            
-        def __str__(self):
-            return repr(self) + self.val
-
-        def start(self):
-            self.startByConf('')
-
-        def startByConf(self, conf):            
-            
-            if conf == '':
-                self.conf = {
-                    "user" : "local",
-                    "ip" : "localhost",
-                    "port" : 8080,
-                    "remote" : None     
-                }
-            else:
-                CONF_DIR = conf
-                fa = FileAdapter({'alias':'JsonAdapter', 'type': 'JSON', 'path': CONF_DIR})
-                fa.setUp()
-                param = fa.request()
-                self.conf = param['conf']
-
-            if self.conf['remote']:
-                remote = self.conf['remote']                
-                if remote['mode'] == 'MASTER':
-                    self.remoteAdm = RemoteAdm(remote['ip'], remote['port'])
-                    self.remoteAdm.start()    
-                else:
-                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)                        
-                    attempts = remote['attempts']
-                    master = remote['master']
-                    data = '{"command": "REGISTER", "alias":"' + remote['container_alias'] + '", "ip":"' + remote['ip'] + '", "port":"'+ str(remote['port']) +'"}'
-                    for x in range(1, attempts):                        
-                        try:                            
-                            sock.connect((master['master_ip'], master['master_port']))                            
-                            sock.sendall(bytes(data + "\n", "utf-8"))
-                            received = str(sock.recv(1024), "utf-8")
-                            print("Received: {}".format(received))                                                            
-                            if received == 'ACK' + "\n":
-                                break
-                        except:
-                            sleep(1) # 1 second.
-                        finally:
-                            sock.close()
-
-                    admListener = AdmListener(remote['ip'], remote['port'])
-                    admListener.start()
-            
-        def addAgent(self, agent):
-            self.agentsTable[agent.id] = agent
-            ip = ''
-            port = ''
-            if self.conf['remote']:
-                remote = self.conf['remote'] 
-                ip = remote['ip']
-                port = remote['port']
-            directory = Directory()
-            directory.addAgent({'agent': agent.id, 'ip': ip, 'port' : port})
-            if self.conf['remote']:
-                remote = self.conf['remote']
-                agents = directory.getAgents()
-                dto = '{"command":"UPDATE", "agents" : ' + json.dumps(agents, ensure_ascii=False) + '}'                
-                if remote['mode'] == 'MASTER':
-                    containers = directory.getContainers()                    
-                    for ctn in containers:
-                        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                        try:                            
-                            sock.connect( (ctn['ip'], int(ctn['port'])) )                            
-                            sock.sendall(bytes(dto + "\n", "utf-8"))
-                        except:
-                            pass
-                            
-                        finally:
-                            sock.close()
-                else:
-                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)                        
-                    attempts = remote['attempts']
-                    master = remote['master']                                              
-                    try:                            
-                        sock.connect((master['master_ip'], master['master_port']))                            
-                        sock.sendall(bytes(dto + "\n", "utf-8"))
-                    except:
-                        sleep(1) # 1 second.
-                    finally:
-                        sock.close()
-            
-        def sendEvent(self, agentID, event, data):
-            try:
-                ag = self.agentsTable[agentID]
-                if (ag):
-                    ag.sendEvent(event, data)
-                    return True
-                else:
-                    remote = self.conf['remote'] 
-                    attempts = remote['attempts']
-                    agents = Directory().getAgents()
-                    for agent in agents:
-                        if agentID == agent['agent']:
-                            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                            aux = str(data)
-                            aux = aux.replace("\'", "\"")                                                
-                            dto = '{"command": "SENDEVENT", "alias":"' + agentID + '", "event":"' + event + '", "data":'+ aux +'}'
-                            print('Send::')
-                            print(dto)                               
-                            for x in range(1, attempts):                        
-                                try:                            
-                                    sock.connect((agent['ip'], agent['port']))                            
-                                    sock.sendall(bytes(dto + "\n", "utf-8"))
-                                    received = str(sock.recv(1024), "utf-8")
-                                    print("Received: {}".format(received))                                                            
-                                    if received == 'ACK' + "\n":
-                                        break
-                                except:
-                                    sleep(1) # 1 second.
-                                finally:
-                                    sock.close()
-                    return True
-
-            except Exception as inst:
-                print('Controled ecxeption in Adm: ')
-                print(inst)
-                return False
-
-        def addAdapter(self, id, adapter):
-            self.adapters[id] = adapter
-
-        def getAdapter(self, id):
-            return self.adapters[id]
-
-        def getConf(self):
-            return self.conf
-
-        def addContainer(self, container):
-            self.containerList.append(container)
-
-        def moveAgent(self, agentID, container):
-            ag = self.agentsTable[agentID]
-            ag.finalize()
-            dto = ag.toDTO()
-            print (dto)
-            containers = Directory().getContainers()
-            for ctn in containers:
-                if container == ctn['alias']:
-                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                    try:                            
-                        sock.connect( (ctn['ip'], int(ctn['port'])) )                            
-                        sock.sendall(bytes(dto + "\n", "utf-8"))
-                    except:
-                        pass
-                    finally:
-                        sock.close()
-                    break    
-            self.agentsTable[agentID] = None
-            Directory().removeAgent(agentID)
-
-        def setEndPoint(self, agID, socket):
-            ag = self.agentsTable[agID]
-            ag.setSocket(socket)
-        
-    instance = None
-    def __new__(cls):
-        if not Adm.instance:
-            Adm.instance = Adm.__Adm()
-        return Adm.instance
-    def __getattr__(self, name):
-        return getattr(self.instance, name)
-    def __setattr__(self, name):
-        return setattr(self.instance, name)

pbesa/kernel/system/Directory.py

@@ -1,36 +0,0 @@
-class Directory(object):
-    class __Directory:
-        
-        def __init__(self):
-            self.containerList = []
-            self.agentList = []
-                    
-        def addContainer(self, container):
-            self.containerList.append(container)
-
-        def addAgent(self, agent):
-            self.agentList.append(agent)
-
-        def getContainers(self):
-        	return self.containerList
-
-        def getAgents(self):
-        	return self.agentList
-
-        def resetAgentList(self):
-        	self.agentList = []
-
-        def removeAgent(self, agent): 
-            for ag in self.agentList:
-                if ag['agent'] == agent:
-                    self.agentList.remove(ag)
-                    
-    instance = None
-    def __new__(cls):
-        if not Directory.instance:
-            Directory.instance = Directory.__Directory()
-        return Directory.instance
-    def __getattr__(self, name):
-        return getattr(self.instance, name)
-    def __setattr__(self, name):
-        return setattr(self.instance, name)

pbesa/kernel/system/__init__.py

@@ -1,2 +0,0 @@
-from .Adm import Adm
-from .Directory import Directory

pbesa/kernel/util/HashTable.py

@@ -1,62 +0,0 @@
-class HashTable:
-    def __init__(self):
-        self.size = 11
-        self.slots = [None] * self.size
-        self.data = [None] * self.size
-
-    def put(self,key,data):
-      hashvalue = self.hashfunction(key,len(self.slots))
-
-      if self.slots[hashvalue] == None:
-        self.slots[hashvalue] = key
-        self.data[hashvalue] = data
-      else:
-        if self.slots[hashvalue] == key:
-          self.data[hashvalue] = data  #replace
-        else:
-          nextslot = self.rehash(hashvalue,len(self.slots))
-          while self.slots[nextslot] != None and \
-                          self.slots[nextslot] != key:
-            nextslot = self.rehash(nextslot,len(self.slots))
-
-          if self.slots[nextslot] == None:
-            self.slots[nextslot]=key
-            self.data[nextslot]=data
-          else:
-            self.data[nextslot] = data #replace
-
-    def hashfunction(self,key,size):
-         return self.hasht(key,size)#key%size
-
-    def hasht(self,astring, tablesize):
-         sum = 0
-         for pos in range(len(astring)):
-            sum = sum + ord(astring[pos])
-         return sum%tablesize
-
-    def rehash(self,oldhash,size):
-        return (oldhash+1)%size
-
-    def get(self,key):
-      startslot = self.hashfunction(key,len(self.slots))
-
-      data = None
-      stop = False
-      found = False
-      position = startslot
-      while self.slots[position] != None and  \
-                           not found and not stop:
-         if self.slots[position] == key:
-           found = True
-           data = self.data[position]
-         else:
-           position=self.rehash(position,len(self.slots))
-           if position == startslot:
-               stop = True
-      return data
-
-    def __getitem__(self,key):
-        return self.get(key)
-
-    def __setitem__(self,key,data):
-        self.put(key,data)

pbesa/kernel/util/Queue.py

@@ -1,231 +0,0 @@
-from time import time as _time
-try:
-    import threading as _threading
-except ImportError:
-    import dummy_threading as _threading
-from collections import deque
-import heapq
-
-__all__ = ['Empty', 'Full', 'Queue', 'PriorityQueue', 'LifoQueue']
-
-class Empty(Exception):
-    "Exception raised by Queue.get(block=0)/get_nowait()."
-    pass
-
-class Full(Exception):
-    "Exception raised by Queue.put(block=0)/put_nowait()."
-    pass
-
-class Queue:
-    """Create a queue object with a given maximum size.
-    If maxsize is <= 0, the queue size is infinite.
-    """
-    def __init__(self, maxsize=0):
-        self.maxsize = maxsize
-        self._init(maxsize)
-        # mutex must be held whenever the queue is mutating.  All methods
-        # that acquire mutex must release it before returning.  mutex
-        # is shared between the three conditions, so acquiring and
-        # releasing the conditions also acquires and releases mutex.
-        self.mutex = _threading.Lock()
-        # Notify not_empty whenever an item is added to the queue; a
-        # thread waiting to get is notified then.
-        self.not_empty = _threading.Condition(self.mutex)
-        # Notify not_full whenever an item is removed from the queue;
-        # a thread waiting to put is notified then.
-        self.not_full = _threading.Condition(self.mutex)
-        # Notify all_tasks_done whenever the number of unfinished tasks
-        # drops to zero; thread waiting to join() is notified to resume
-        self.all_tasks_done = _threading.Condition(self.mutex)
-        self.unfinished_tasks = 0
-
-    def task_done(self):
-        """Indicate that a formerly enqueued task is complete.
-        Used by Queue consumer threads.  For each get() used to fetch a task,
-        a subsequent call to task_done() tells the queue that the processing
-        on the task is complete.
-        If a join() is currently blocking, it will resume when all items
-        have been processed (meaning that a task_done() call was received
-        for every item that had been put() into the queue).
-        Raises a ValueError if called more times than there were items
-        placed in the queue.
-        """
-        self.all_tasks_done.acquire()
-        try:
-            unfinished = self.unfinished_tasks - 1
-            if unfinished <= 0:
-                if unfinished < 0:
-                    raise ValueError('task_done() called too many times')
-                self.all_tasks_done.notify_all()
-            self.unfinished_tasks = unfinished
-        finally:
-            self.all_tasks_done.release()
-
-    def join(self):
-        """Blocks until all items in the Queue have been gotten and processed.
-        The count of unfinished tasks goes up whenever an item is added to the
-        queue. The count goes down whenever a consumer thread calls task_done()
-        to indicate the item was retrieved and all work on it is complete.
-        When the count of unfinished tasks drops to zero, join() unblocks.
-        """
-        self.all_tasks_done.acquire()
-        try:
-            while self.unfinished_tasks:
-                self.all_tasks_done.wait()
-        finally:
-            self.all_tasks_done.release()
-
-    def qsize(self):
-        """Return the approximate size of the queue (not reliable!)."""
-        self.mutex.acquire()
-        n = self._qsize()
-        self.mutex.release()
-        return n
-
-    def empty(self):
-        """Return True if the queue is empty, False otherwise (not reliable!)."""
-        self.mutex.acquire()
-        n = not self._qsize()
-        self.mutex.release()
-        return n
-
-    def full(self):
-        """Return True if the queue is full, False otherwise (not reliable!)."""
-        self.mutex.acquire()
-        n = 0 < self.maxsize == self._qsize()
-        self.mutex.release()
-        return n
-
-    def put(self, item, block=True, timeout=None):
-        """Put an item into the queue.
-        If optional args 'block' is true and 'timeout' is None (the default),
-        block if necessary until a free slot is available. If 'timeout' is
-        a non-negative number, it blocks at most 'timeout' seconds and raises
-        the Full exception if no free slot was available within that time.
-        Otherwise ('block' is false), put an item on the queue if a free slot
-        is immediately available, else raise the Full exception ('timeout'
-        is ignored in that case).
-        """
-        self.not_full.acquire()
-        try:
-            if self.maxsize > 0:
-                if not block:
-                    if self._qsize() == self.maxsize:
-                        raise Full
-                elif timeout is None:
-                    while self._qsize() == self.maxsize:
-                        self.not_full.wait()
-                elif timeout < 0:
-                    raise ValueError("'timeout' must be a non-negative number")
-                else:
-                    endtime = _time() + timeout
-                    while self._qsize() == self.maxsize:
-                        remaining = endtime - _time()
-                        if remaining <= 0.0:
-                            raise Full
-                        self.not_full.wait(remaining)
-            self._put(item)
-            self.unfinished_tasks += 1
-            self.not_empty.notify()
-        finally:
-            self.not_full.release()
-
-    def put_nowait(self, item):
-        """Put an item into the queue without blocking.
-        Only enqueue the item if a free slot is immediately available.
-        Otherwise raise the Full exception.
-        """
-        return self.put(item, False)
-
-    def get(self, block=True, timeout=None):
-        """Remove and return an item from the queue.
-        If optional args 'block' is true and 'timeout' is None (the default),
-        block if necessary until an item is available. If 'timeout' is
-        a non-negative number, it blocks at most 'timeout' seconds and raises
-        the Empty exception if no item was available within that time.
-        Otherwise ('block' is false), return an item if one is immediately
-        available, else raise the Empty exception ('timeout' is ignored
-        in that case).
-        """
-        self.not_empty.acquire()
-        try:
-            if not block:
-                if not self._qsize():
-                    raise Empty
-            elif timeout is None:
-                while not self._qsize():
-                    self.not_empty.wait()
-            elif timeout < 0:
-                raise ValueError("'timeout' must be a non-negative number")
-            else:
-                endtime = _time() + timeout
-                while not self._qsize():
-                    remaining = endtime - _time()
-                    if remaining <= 0.0:
-                        raise Empty
-                    self.not_empty.wait(remaining)
-            item = self._get()
-            self.not_full.notify()
-            return item
-        finally:
-            self.not_empty.release()
-
-    def get_nowait(self):
-        """Remove and return an item from the queue without blocking.
-        Only get an item if one is immediately available. Otherwise
-        raise the Empty exception.
-        """
-        return self.get(False)
-
-    # Override these methods to implement other queue organizations
-    # (e.g. stack or priority queue).
-    # These will only be called with appropriate locks held
-
-    # Initialize the queue representation
-    def _init(self, maxsize):
-        self.queue = deque()
-
-    def _qsize(self, len=len):
-        return len(self.queue)
-
-    # Put a new item in the queue
-    def _put(self, item):
-        self.queue.append(item)
-
-    # Get an item from the queue
-    def _get(self):
-        return self.queue.popleft()
-
-
-class PriorityQueue(Queue):
-    '''Variant of Queue that retrieves open entries in priority order (lowest first).
-    Entries are typically tuples of the form:  (priority number, data).
-    '''
-
-    def _init(self, maxsize):
-        self.queue = []
-
-    def _qsize(self, len=len):
-        return len(self.queue)
-
-    def _put(self, item, heappush=heapq.heappush):
-        heappush(self.queue, item)
-
-    def _get(self, heappop=heapq.heappop):
-        return heappop(self.queue)
-
-
-class LifoQueue(Queue):
-    '''Variant of Queue that retrieves most recently added entries first.'''
-
-    def _init(self, maxsize):
-        self.queue = []
-
-    def _qsize(self, len=len):
-        return len(self.queue)
-
-    def _put(self, item):
-        self.queue.append(item)
-
-    def _get(self):
-        return self.queue.pop()

pbesa/kernel/util/__init__.py

@@ -1,2 +0,0 @@
-from .HashTable import HashTable
-from .Queue import Queue

pbesa/middleware/__init__.py

@@ -1,3 +0,0 @@
-from .adapter import *
-from .remote import *
-from .web import *

pbesa/middleware/adapter/GameAdapter.py

@@ -1,64 +0,0 @@
-from threading import Thread
-from abc import ABC, abstractmethod
-#from ...kernel.system.Adm import Adm
-from ...kernel.adapter.Adapter import Adapter
-
-import os
-import random
-import pygame
-import math
-import sys
-
-class GameAdapter(Adapter, Thread):
-
-    adm = None
-    conf = None
-    clock = None
-    screen = None
-    agentList = None
-
-    def __init__(self, conf):        
-        self.conf = conf
-        self.agentList = []
-        self.adm = None #Adm()
-        super().__init__()
-
-    def setUp(self):
-        os.environ["SDL_VIDEO_CENTERED"] = "1"
-        self.screen = pygame.display.set_mode((self.conf['width'], self.conf['height']))
-        pygame.display.set_caption(self.conf['title'])
-        self.clock = pygame.time.Clock()
-        pygame.init()
-        self.clock = pygame.time.Clock()
-
-    def response(self):
-        pass
-    
-    def request(self):
-        return self.data
-
-    def finalize(self):
-        pass
-
-    def addAgent(self, ag):
-        self.agentList.append(ag)
-
-    def run(self):
-        running = True       
-        while running:
-            for event in pygame.event.get():
-                if event.type == pygame.QUIT:
-                    running = False
-            self.frame()
-            pygame.display.update()
-            self.clock.tick(40)
-
-    def updateWorlds(self, event, data):
-        for ag in self.agentList:
-            self.adm.sendEvent(ag.id, event, data)
-
-    def getPygame(self):
-        return pygame
-
-    def frame(self):
-        pass

pbesa/middleware/adapter/MongoAdapter.py

@@ -1,47 +0,0 @@
-import pymongo
-
-from pymongo import MongoClient
-from ...kernel.adapter.Adapter import Adapter
-
-class MongoAdapter(Adapter):
-
-    db = None
-    conf = None
-    client = None
-
-    def __init__(self, conf):
-        self.conf = conf
-        super().__init__()
-
-    def setUp(self):
-        self.client = MongoClient()
-        self.db = self.client[self.conf['database']]
-
-    def response(self, response):
-        pass
-    
-    def request(self):
-        pass
-        
-    def finalize(self):
-        pass
-
-    def getAll(self, collection):
-        coll = self.db[collection]
-        return coll.find()
-
-    def getObject(self, collection, query):
-        coll = self.db[collection]
-        return coll.find_one(query)
-
-    def getObjectByID(self, collection, id):
-        coll = self.db[collection]
-        return coll.find_one({"_id": id})
-
-    def insertObject(self, collection, dto):
-        coll = self.db[collection]
-        return coll.insert_one(dto).inserted_id
-
-    def updateObject(self, collection, id, dto):
-        coll = self.db[collection]
-        return coll.replace_one({"_id": id}, dto, True)

pbesa/middleware/adapter/RESTAdapter.py

@@ -1,52 +0,0 @@
-from threading import Thread
-#from ...kernel.system.Adm import Adm
-from ...kernel.util.Queue import Queue
-from ...kernel.adapter.Adapter import Adapter
-
-#import web
-import json
-
-class RESTAdapter(Adapter, Thread):
-
-    app = None
-    adm = None
-    conf = None
-    
-    def __init__(self):
-        self.adm = None #Adm()
-        super().__init__()
-
-    def setUp(self):
-        urls = ('/(.*)', 'RESTAdapter')
-        self.app = web.application(urls, globals())
-        
-    def response(self, response):
-        pass
-    
-    def request(self):
-        pass
-
-    def finalize(self):
-        pass
-
-    def run(self):
-        self.app.run()
-
-    def GET(self, name):
-        if not name:
-            name = 'World'
-        return 'Hello, ' + name + '!'
-
-    def POST(self, rqst):
-        data = json.loads(web.data().decode('utf-8'))                        
-        queue = Queue(10)        
-        dto = {'queue': queue,'url': rqst, 'data': data}
-        self.adm.sendEvent('front_controller', 'request', dto)
-        response = queue.get()
-        queue.task_done()
-        web.header('Access-Control-Allow-Origin',      '*')
-        web.header('Access-Control-Allow-Credentials', 'true')        
-        return str(response).replace("'", "\"")
-
-
-