####################################
## Readable code versus less code ##
####################################
from web_server.general_api import general_api as api
from web_server.web_api import web_server_api as server_api
import threading
import callme
logger = api.__get_logger('web_core.run')
class MasterServer(threading.Thread):
def __init__(self, sid):
self.sid = sid
super(MasterServer, self).__init__()
def run(self):
## start inspection on inactive clients
server_api._inspect_inactive_children(self.sid)
## checking for timeout and refreshing common key
threading.Timer(api.COMMON_KEY_TIMEOUT,
server_api._refresh_common_key,
[self.sid]).start()
## call for cleaning failed nodes
threading.Timer(api.CLEAN_GARBAGE_NODES,
server_api._clean_failed_garbages, [self.sid]).start()
import json
import callme
import pika
import pickle
import dill
sys.path.append(r'C:\Users\haejong\Documents\distributed_system_2016\Chatchat')
from web_server.general_api import general_api as api
from web_server.general_api.connection_timeout import ConnTimeout
#from web_server.general_api.redis_queue import Queue
from client_model import AppModel, NodeModel, CommentReplicaModel
from shared_res_model import CommentModel#CommentListModel
#q = Queue(db=api.REDIS_ID_NODE)
logger = api.__get_logger('app_client.api.run')
## RTC call
def add_comments(**data): ## [{"by":"nid", "comment":"comment"}, ...]
if not isinstance(data['content'], list):
data['content'] = [data['content']]
if data['permission']:
for ele in data['content']:
# TODO: compare also 'by' to make sure or set primary key for 'created_at'
if not CommentModel.objects(timestamp=ele['created_at']):
CommentModel(
by=ele['by'],
timestamp=ele['created_at'],
comment=ele['comment'],
####################################
## Readable code versus less code ##
####################################
import pika
import threading
import json
import web_server_api as server_api
from web_server.general_api import general_api as api
logger = api.__get_logger("new_clinet_listener.run")
## define exchange name for broadcasting message
## define handshake queue for handshaking with the new node
## listen to new nodes
class NewNodeListener(threading.Thread):
def __init__(self, sid):
self.sid = sid
super(NewNodeListener, self).__init__()
def run(self):
connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost", port=5672))
channel = connection.channel()
channel.exchange_declare(exchange=api.TOPIC_NEW_NODE, type="topic")
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
class Sessions(Document):
created_at = DateTimeField(
default=api._get_current_time(),
required=True)
by = StringField(max_length=128)
ssid = StringField(
required=True,
max_length=128,
default=api._generate_session_id())
user_data = StringField(max_length=500, required=True)
expiration = DateTimeField(required=True)
modified = DateTimeField(required=True,
default=api._get_current_time())
logger = api.__get_logger('MongoSession')
## users' session manager
class MongoSession(CallbackDict, SessionMixin):
def __init__(self,
initial=None,
ssid=None,
modified=None):
CallbackDict.__init__(self, initial)
self.ssid = ssid
self.modified = modified
class MongoSessionInterface(SessionInterface):
####################################
## Readable code versus less code ##
####################################
import threading
from web_server.general_api import general_api as api
logger = api.__get_logger('ConnTimeout.run')
class ConnTimeout(object):
def __init__(self, timeout, function, servers=5, args=[], kwargs=[]):
self.timeout = timeout
self.timer = None #threading.Timer(timeout, pickle.loads(function), args)
self.count = 0
self.f = function
self.servers = servers
self.args = args
self.kwargs = kwargs
super(ConnTimeout, self).__init__()
#def __reduce__(self):
# return (self.__class__, (self.name, self.address))
def start(self):
return self._start()
def _start(self):
####################################
## Readable code versus less code ##
####################################
import pika
import threading
import json
import app_client_api as app_api
import callme
from web_server.general_api import general_api as api
from web_server.general_api.general_api import _ACTION_KEYS
from client_model import AppModel, CommentReplicaModel
logger = api.__get_logger('app_listener.run')
class BroadcastListener(threading.Thread):
def __init__(self, nid):
self.nid = nid
super(BroadcastListener, self).__init__()
def run(self):
connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))
channel = connection.channel()
channel.exchange_declare(exchange=api.EXCHANGE_FOR_ALL,
type='fanout')
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
import callme
import threading
import pika
import json
import redis
import bson
#from itsdangerous import Signer
from web_server.general_api import general_api as api
from web_server.general_api.redis_queue import Queue
from server_model import WebServerModel, ChildrenModel, ServerLogModel, Sessions
from shared_res_model import CommentModel, UserSessions
from mongoengine import *
logger = api.__get_logger('web_server_api.run')
## for queueing turns for node to get the access to shared resource
q = Queue(db=api.REDIS_ID)
q.flush()
def _add_children(client, sid):
s_obj = WebServerModel.objects(sid=sid)
children = ChildrenModel(
nid=client['nid'],
created_at=client['created_at'],
public_key=client['public_key'],
last_access=client['created_at'])
#last_work=api._get_current_time())
