def __receive_login(peer: Peer, command: bytes, message: bytes):
if command == Protocol.Flags.LOGIN:
username = message.split(bytes([Protocol.Flags.SEPARATOR
]))[0].decode()
passwd = message.split(bytes([Protocol.Flags.SEPARATOR
]))[1].decode()
hashed = str(
hashpw(passwd.encode("utf-8"), b"$2a$12$" +
b"SZ4R4Z3G3SZ4DJ4LS0RT..")).split("..")[1][:-1]
logging.info("LOGIN from \"" + username + "\"")
peer_id = SQLModule.PeersSQLModule.get_id(username)
if peer_id == -1 or hashed == SQLModule.PeersSQLModule.get_hashed_pwd(
username):
if peer_id == -1:
SQLModule.PeersSQLModule.add_peer(username, hashed)
logging.info("Account created for \"" + username + "\"")
peer.send(
Protocol.server_message(
Protocol.ServerFlags.ACK,
"Account created for \"" + username + "\""))
peer.name = username
peer.logged_in = True
logging.info("\"" + username + "\" has logged in succesfully")
peer.send(
Protocol.server_message(Protocol.ServerFlags.ACK,
"Successful login"))
else:
logging.warning("\"" + username + "\" failed to log in")
peer.send(
Protocol.server_message(Protocol.ServerFlags.NAK,
"Wrong password for this user"))
peer.logged_in = False
def __init__(self):
threading.Thread.__init__(self)
self.address = ("192.168.1.107", 1237)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect(self.address)
self.thread_owner = ""
self.protocol = Protocol(self)
def onBtnProtocol(self):
proto = Protocol(self.currentTest)
proto.exec()
if proto.ret:
self.ticket.data = self.currentTest
dispatcher.send(self.signals.WB_UPDATE_TEST, dispatcher.Anonymous,self.ticket)
self.fillDialog()
def decodeCommandData(self, msg):
protocol = msg['protocol']
model = msg['model']
method = msg['method']
methods = Protocol.methodsForProtocol(protocol, model)
if not method & methods:
return
for device in self.devices:
params = device.params()
if params['protocol'] != protocol:
continue
if not method & device.methods():
continue
deviceParams = params['protocolParams']
thisDevice = True
for parameter in Protocol.parametersForProtocol(protocol, model):
if parameter not in msg:
thisDevice = False
break
if parameter not in deviceParams:
thisDevice = False
break
if msg[parameter] != deviceParams[parameter]:
thisDevice = False
break
if thisDevice:
device.setState(method, None)
def handle_req_file_request(self):
file_name_str = self.get_sized_payload().decode("UTF-8")
file_path = self.shared_dir_path.joinpath(file_name_str)
if file_path.exists():
self.client_connection.sendall(Protocol.ack_file_bytes(file_path))
else:
self.client_connection.sendall(
Protocol.rej_file_bytes(file_path.name))
def onBtnReport(self):
proto = Protocol(self.currentTest,self.currentProject)
proto.exec()
if proto.ret:
self.ticket.data = self.currentProject
dispatcher.send(self.signals.WB_UPDATE_PROJECT, dispatcher.Anonymous,self.ticket)
self.ticket.data = self.currentTest
dispatcher.send(self.signals.WB_UPDATE_TEST, dispatcher.Anonymous,self.ticket)
def run(self):
self.protocol = Protocol(self)
self.sendBySocket(
self.protocol.sendLogin(self.id_center, self.password))
while True:
chunk = self.socket.recv(1024)
fromClient = str(chunk)
print("recibo -->", fromClient)
self.proccessMsg(fromClient)
def send(cls, data, ctype=2, img=False):
"""发送数据
:param cls:
:param data: 数据
:param ctype: 类型
:param img: 表示本次接收的数据是否为图片
"""
assert cls._socket != None
cls._socket.sendall(Protocol.pack(data, ctype))
Protocol.increase()
return cls.recv(img)
def join_network(self, connection_addr):
# """Protocol utlized for each peer to join a network given one or more nodes initialized in
# P2P network."""
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(connection_addr)
self.audit.sending_data(Protocol.req_join_bytes())
client_socket.sendall(Protocol.req_join_bytes(self.listening_addr))
new_client_connection_thread = ClientConnectionThread(
self, self.shared_dir_path, client_socket)
new_client_connection_thread.start()
self.connections.append(new_client_connection_thread)
class Network(asyncio.Protocol):
def __init__(self, app, name):
self.application = app
self.botName = name
self.players = self.application.GetPlayers()
Debug("Network initialisation")
def connection_made(self, transport):
""" call when the connection with the server is done """
self.transport = transport
# Cnx ok, create the Protocol object
Debug("Connexion ok")
self.protocol = Protocol(self.application, transport)
self.protocol.setStateLogin()
# start the dialog
self.protocol.Out('handshake', protocol_version=5,
server_adress='localhost', server_port=25565, next_state=2)
self.protocol.Out('login_start', name=self.botName)
def data_received(self, data):
"""
incoming data are ready
"""
# compute all packets
while (len(data) > 0):
packet = Packet(data)
size = packet.getVarint()
offset = packet.getVarintSize()
packet = Packet(data[offset:offset+size])
# compute the packet
self.protocol.Receive(packet)
# remove the packet
data = data[offset+size:]
def connection_lost(self, exc):
"""
the connection is closed
"""
Debug('Server closed the connection')
# stop the infinite loop
asyncio.get_event_loop().stop()
def connect(cls, host, port, pwd):
"""连接服务器
:param cls:
:param host: 地址
:param port: 端口
:param pwd: 密码
"""
Protocol.init(pwd)
cls._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cls._socket.settimeout(10) # 10s 超时
try:
cls._socket.connect((host, port))
except Exception as e:
cls._socket = None
raise e
def __init__(self, dataObject):
Protocol.__init__(self, dataObject)
self.states = {
self.INVALID : self.invalid,
self.STARTTOKEN : self.starttoken,
self.VALIDATIONTYPE : self.validationtype,
self.PACKETNUMBER : self.packetnumber,
self.PACKETID : self.packetid,
self.ADDRSPEC : self.addrspec,
self.ADDRFIELD : self.addrfield,
self.DATALEN : self.datalen
self.DATAFIELD : self.datafield
self.WAITCRC : self.waitcrc
self.CRC : self.crc
}
def list_files(self):
addrs_arr = Protocol.parse_config_file_to_arr(self.addr_config_path)
for addr in addrs_arr:
if not (addr == self.listening_addr):
client_socket = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
client_socket.connect(addr)
self.audit.sending_data(Protocol.req_list_bytes())
client_socket.sendall(Protocol.req_list_bytes())
new_client_connection_thread = ClientConnectionThread(
self, self.shared_dir_path, client_socket)
new_client_connection_thread.start()
self.connections.append(new_client_connection_thread)
def logout(self) -> None:
if self.__room_joined:
self.leave_room()
if self.__logged_in:
self.__network_module.send(Protocol.logout_message())
self.__logged_in = False
self.__username = ''
def connect_to_server(self, address: str, port: int) -> None:
if self.__connected:
self.disconnect()
self.__network_module.connect_to_host(address, port)
self.__network_module.send(Protocol.hello_message()) # first message
self.__connected = True
def leave_room(self) -> None:
if self.__room_joined:
self.__network_module.send(Protocol.leave_message())
self.__room_joined = False
self.__room_name = ''
self.__window_module.display_special_message('You left the room!')
def __init__(self, status_code, headers=None, payload=None):
"""
Creates as new http response.
:param status_code: Status code: 200, 404, 302, 400, ...
:param headers: Headers of the response as a dictionary object
:param payload: Payload as Protocol object
"""
Protocol.__init__(self)
self.status_code = int(status_code)
if HttpStatusCodes.has_key(self.status_code):
self.status_msg = HttpStatusCodes[self.status_code]
else:
raise ValueError("Status code " + str(self.status_code) + " is not recognised as a valid http status code")
self.headers = headers
self.payload = payload
def decodeDataSelflearning(data):
value = int(data['data'], 16)
house = (value & 0xFFFFFFC0) >> 6
group = (value & 0x20) >> 5
methodCode = (value & 0x10) >> 4
unit = (value & 0xF)
unit = unit+1
if house < 1 or house > 67108863 or unit < 1 or unit > 16:
# not arctech selflearning
return None
method = 0
if Protocol.checkBit(value, 4):
method = Device.TURNON
else:
method = Device.TURNOFF
retval = {}
retval['class'] = 'command'
retval['protocol'] = 'arctech'
retval['model'] = 'selflearning'
retval['house'] = str(house)
retval['unit'] = str(unit)
retval['group'] = group
retval['method'] = method
return retval
def _command(self, action, value, success, failure, **kwargs):
protocol = Protocol.protocolInstance(self._protocol)
if not protocol:
logging.warning("Unknown protocol %s", self._protocol)
failure(0)
return
protocol.setModel(self._model)
protocol.setParameters(self._protocolParams)
msg = protocol.stringForMethod(action, value)
if msg is None:
failure(0)
logging.error("Could not encode rf-data for %s:%s %s",
self._protocol, self._model, action)
return
def s(params):
success()
def f():
failure(Device.FAILED_STATUS_NO_REPLY)
prefixes = {}
if 'P' in msg:
prefixes['P'] = msg['P']
if 'R' in msg:
prefixes['R'] = msg['R']
if 'S' in msg:
self.controller.queue(
RF433Msg('S', msg['S'], prefixes, success=s, failure=f))
def recv(cls, img=False):
"""接收数据
:param img: 表示本次接收的数据是否为图片
"""
assert cls._socket != None
try:
# 数据长度
header = cls._socket.recv(4)
totalSize, = struct.unpack('>i', header)
recvSize = 0
totalData = header
while recvSize < totalSize:
recvData = cls._socket.recv(1024)
recvSize += len(recvData)
totalData += recvData
if img:
# 获取图片的代码后面会有其它字符串(其实是两个包)
try: # 如果是超时则不管它
totalData += cls._socket.recv(1024)
except:
pass
except:
totalData = None
message = Protocol.unpack(totalData)
return message
def __init__(self, method="GET", url="/", headers=ExampleHttpHeaders["default"], payload=None):
"""
Initiates a new http request object.
:param method: HTTP method: GET, POST, PUT, ...
:param url: The request url
:param headers: a dictionary with header values. See the SampleHttpHeaders variable for an example
:param payload: The http payload as a Protocol object
"""
Protocol.__init__(self)
if method not in HttpRequestMethods:
raise ValueError("The method " + method + " is not recognised as a valid http method")
self.method = method
self.url = url
self.headers = headers
self.payload = payload
def makePackets(fileName): #Creates a Packet Dictionary object, where the keys are Packet objects and the values are Protocol objects. Furthermore, the Protocol Dictionary that is also returned contains the protocols as keys and a list of fields as a value.
myFile = open(fileName, 'r')
PacketNumber = {}
i = 0
# create element tree object
tree = ET.parse(myFile)
# get root element
root = tree.getroot()
# create empty list for objects
Packets = {}
ProtocolsList = {}
for item in root.findall('packet'):
TemporaryPacket = Packet(item.attrib)
Packets[TemporaryPacket] = None
PacketNumber[i]= TemporaryPacket
Protocols = {}
for child in item:
# Packets[item] = child
TemporaryProtocol = Protocol(child.attrib)
FieldValues = []
for fields in child.findall('field'):
FieldValues.append(Field(fields.attrib))
Protocols[TemporaryProtocol] = FieldValues
ProtocolsList[TemporaryProtocol] = FieldValues
Packets[TemporaryPacket] = Protocols
i +=1
ListMe = [PacketNumber,Packets,ProtocolsList]
return ListMe
def decodeSensor(self, msg):
protocol = Protocol.protocolInstance(msg['protocol'])
if not protocol:
logging.error("No known protocol for %s", msg['protocol'])
return
data = protocol.decodeData(msg)
if not data:
return
p = data['protocol']
m = data['model']
sensorId = data['id']
sensorData = data['values']
sensor = None
for s in self.sensors:
if s.compare(p, m, sensorId):
sensor = s
break
if sensor is None:
sensor = SensorNode()
sensor.setParams({'protocol': p, 'model': m, 'sensorId': sensorId})
sensor.setManager(self.deviceManager)
self.sensors.append(sensor)
if 'battery' in data:
sensor.batteryLevel = data['battery']
sensor.updateValues(sensorData)
def decodeDataSelflearning(data):
value = int(data['data'], 16)
house = (value & 0xFFFFFFC0) >> 6
group = (value & 0x20) >> 5
methodCode = (value & 0x10) >> 4
unit = (value & 0xF)
unit = unit+1
if house < 1 or house > 67108863 or unit < 1 or unit > 16:
# not arctech selflearning
return None
method = 0
if Protocol.checkBit(value, 4):
method = Device.TURNON
else:
method = Device.TURNOFF
retval = {}
retval['class'] = 'command'
retval['protocol'] = 'arctech'
retval['model'] = 'selflearning'
retval['house'] = str(house)
retval['unit'] = str(unit)
retval['group'] = group
retval['method'] = method
return retval
def handle_join_network_request(self):
addr_str = self.get_sized_payload().decode("utf-8")
new_ip, new_port = self.find_ip_and_port_addr(addr_str)
ack_join_bytes = Protocol.ack_join_bytes(self.address_file)
self.client_connection.sendall(ack_join_bytes)
self.add_to_addresses_file((new_ip, new_port))
def handle_ack_join_network_request(self):
# The loop needs to call join network for each of the other ones.
new_addr_file_bytes = self.get_sized_payload()
tmp_file_path = self.shared_dir_path.joinpath(".tmp")
open(tmp_file_path, 'wb').write(new_addr_file_bytes)
new_addr_array = Protocol.parse_config_file_to_arr(tmp_file_path)
my_addr_array = Protocol.parse_config_file_to_arr(self.address_file)
for addr in new_addr_array:
if not addr in my_addr_array:
self.add_to_addresses_file(addr)
# TODO: add code here that will make new connections with these folk
if self.shared_dir_path.joinpath(".tmp").is_file():
self.shared_dir_path.joinpath(".tmp").unlink()
def __init__(self, status_code, headers=None, payload=None):
"""
Creates as new http response.
:param status_code: Status code: 200, 404, 302, 400, ...
:param headers: Headers of the response as a dictionary object
:param payload: Payload as Protocol object
"""
Protocol.__init__(self)
self.status_code = int(status_code)
if HttpStatusCodes.has_key(self.status_code):
self.status_msg = HttpStatusCodes[self.status_code]
else:
raise ValueError('Status code ' + str(self.status_code) +
' is not recognised as a valid http status code')
self.headers = headers
self.payload = payload
def main():
try:
board = Board(7, 7)
mySide = Side.SOUTH
n = 1
while (True):
recvmsg = recvMsg()
try:
protocol = Protocol()
messType = protocol.getMessageType(recvmsg)
if messType == MsgType.START:
interpretStartMsg = protocol.interpretStartMsg(recvmsg)
mySide = Side.SOUTH if interpretStartMsg else Side.NORTH
if interpretStartMsg:
n = 0
move = calculateNextBestMove(board, mySide)
sendMsg(protocol.createMoveMsg(move))
continue
continue
elif messType == MsgType.STATE:
interpretStateMsg = protocol.interpretStateMsg(
recvmsg, board)
if interpretStateMsg.again and interpretStateMsg.move == -1: # if opponent does swap
mySide = Side.opposite(mySide)
move = calculateNextBestMove(board, mySide)
sendMsg(protocol.createMoveMsg(move))
elif interpretStateMsg.again and n != 0: # if we swap
if interpretStateMsg.move <= 2:
mySide = Side.opposite(mySide)
sendMsg(protocol.createSwapMsg()) # Stab
else:
move = calculateNextBestMove(board, mySide)
sendMsg(protocol.createMoveMsg(move))
elif interpretStateMsg.again:
move = calculateNextBestMove(board, mySide)
sendMsg(protocol.createMoveMsg(move))
n = 0
continue
else:
break
except InvalidMessageException:
invalidMessage = InvalidMessageException("Invalid move")
print(invalidMessage.getMessage())
except IOException:
ioExceptionMessage = IOException("IOException")
print(ioExceptionMessage.getMessage())
def run(self):
while (1):
data = self.client_connection.recv(8)
if not data:
self.audit.connection_closed(
self.client_connection.getsockname(),
self.client_connection.getpeername())
break
data_str = data.decode("UTF-8")
self.audit.data_recieved(data_str)
if data_str == Protocol.req_join_string():
self.handle_join_network_request()
elif data_str == Protocol.ack_join_string():
self.handle_ack_join_network_request()
elif data_str == Protocol.req_list_string():
self.handle_list_request()
elif data_str == Protocol.ack_list_string():
self.handle_ack_list_request()
elif data_str == Protocol.req_file_string():
self.handle_req_file_request()
elif data_str == Protocol.ack_file_string():
self.handle_ack_file_request()
elif data_str == Protocol.rej_file_string():
pass
def login(self, username: str, password: str) -> None:
if self.__logged_in:
self.logout()
self.__network_module.send(Protocol.login_message(username, password))
self.__logged_in = True
self.__username = username
self.__window_module.add_title_text(self.__username)
def receive_message(self, data: bytes) -> None:
messages: List[bytes] = data.split(bytes([Protocol.Flags.TERMINATOR]))
if len(messages) > 0:
for i in range(0, len(messages) - 1):
flag: Protocol.Flags = messages[i][0]
body: str = ''
if len(messages[i]) > 1:
body = messages[i][1:]
self.__process_message(Protocol.Message(flag, body))
def main():
# Define IP header (Task 3.)
ip = IP(src=src_ip, dst=dst_ip)
# Define customized header (Task 3.)
my_id = '0616225'
my_dept = 'cs'
my_gender = '2'
student = Protocol(id=my_id, dept=my_dept, gender=my_gender)
# Read file and store into list
count = 0
secret = []
tmp = ''.join(reversed(my_id))
with open('./data/secret.txt', 'r') as file:
for line in file:
line = tmp[count % 7] + line
secret.append(line)
count += 1
# Send packets
for i in range(0, len(secret)):
# TCP connection - SYN / SYN-ACK
tcp_syn = TCP(sport=src_port, dport=dst_port, flags='S', seq=0)
packet = ip / tcp_syn
tcp_syn_ack = sr1(packet)
print '[INFO] Send SYN and receive SYN-ACK'
tcp_syn_ack.show()
# TCP connection - ACK (Task 3.)
ack = tcp_syn_ack.seq + 1
tcp_ack = TCP(sport=src_port,
dport=dst_port,
flags='A',
seq=1,
ack=ack)
packet = ip / tcp_ack
send(packet)
print '[INFO] Send ACK'
# Send packet with customized header (Task 3.)
ack = tcp_ack.seq + 1
tcp = TCP(sport=src_port, dport=dst_port, flags='', seq=2, ack=ack)
packet = ip / tcp / student
send(packet)
print '[INFO] Send packet with customized header'
# Send packet with secret payload (Task 3.)
ack = tcp.seq + 1
tcp = TCP(sport=src_port, dport=dst_port, flags='', seq=3, ack=ack)
payload = Raw(secret[i])
packet = ip / tcp / payload
send(packet)
print '[INFO] Send packet with secret payload'
def __init__(self,
player_1,
player_2,
_log_board_state=False,
create_protocol=True):
global log_board_state
log_board_state = _log_board_state
# board_logger.debug("#" * 200)
self.player_1: Player = player_1
self.player_2: Player = player_2
self.players: [Player] = [player_1, player_2]
random.shuffle(self.players)
self.players = cycle(self.players)
self.current_player: Player = next(self.players)
self.board: Board = Board(player_1, player_2)
if create_protocol:
self.protocol = Protocol()
else:
self.protocol = None
def set_game_in_server(self):
self.send_data(Protocol.new_game(self.username, self.game_type))
_expected_answer = self.receive_data()
if _expected_answer == "GAME_SET":
pass
else:
ClientUI.print_detail("Huge error. Server sent back >>> " + _expected_answer)
def flushCurrentQRCode(self):
new = Protocol.produce(self.current_raw_image_obj["flag"],
self.current_raw_image_obj["id"],
self.current_raw_image_obj["data"])
self.image = ImageTk.PhotoImage(
image=self.resize(new, (self.canvas_size, self.canvas_size)))
self.canvas.create_image(self.canvas_size / 2,
self.canvas_size / 2,
image=self.image,
anchor="center")
def __receive_hello(peer: Peer, command: bytes):
"""
Tries to receives HELLO, if the message is not HELLO, terminates the peer
:param peer:
:param command:
:return:
"""
if command == Protocol.Flags.HELLO:
logging.info("HELLO message received")
peer.send(Protocol.hello_message())
peer.send(
Protocol.server_message(Protocol.ServerFlags.ACK,
"Welcome to the server"))
peer.hello_done = True
else:
logging.warning("No HELLO received, closing connection")
peer.terminate()
peer.hello_done = False
def main():
# Define IP header
ip = IP(src=src_ip, dst=dst_ip)
# Define customized header
# [TODO] Add 'id' field in customized header here (Task 2.)
# And fill in your department
student = Protocol(dept='cs', id='0716030')
msg = [
'This lab is a little hard.', 'I am just kidding.',
'It is so damn difficult.'
]
# [TODO] Fill in the message payload (Task 2.)
msg = [
"Anything you want to say (less than 60 charaters)",
"Computer Networks is interesting.", "I agree XD"
]
# Send packets
for i in range(0, len(msg)):
# TCP connection - SYN / SYN-ACK
tcp_syn = TCP(sport=src_port, dport=dst_port, flags='S', seq=0)
packet = ip / tcp_syn
tcp_syn_ack = sr1(packet)
print '[INFO] Send SYN and receive SYN-ACK'
#tcp_syn_ack.show()
# TCP connection - ACK
ack = tcp_syn_ack.seq + 1
tcp_ack = TCP(sport=src_port,
dport=dst_port,
flags='A',
seq=1,
ack=ack)
packet = ip / tcp_ack
send(packet)
print '[INFO] Send ACK'
# Send packet with customized header
ack = tcp_ack.seq + 1
tcp = TCP(sport=src_port, dport=dst_port, flags='', seq=2, ack=ack)
packet = ip / tcp / student
send(packet)
print '[INFO] Send packet with customized header'
# Send packet with payload
ack = tcp.seq + 1
tcp = TCP(sport=src_port, dport=dst_port, flags='', seq=3, ack=ack)
payload = Raw(msg[i])
packet = ip / tcp / payload
send(packet)
print '[INFO] Send packet with payload'
def connection_made(self, transport):
""" call when the connection with the server is done """
self.transport = transport
# Cnx ok, create the Protocol object
Debug("Connexion ok")
self.protocol = Protocol(self.application, transport)
self.protocol.setStateLogin()
# start the dialog
self.protocol.Out('handshake', protocol_version=5,
server_adress='localhost', server_port=25565, next_state=2)
self.protocol.Out('login_start', name=self.botName)
def select_player(self):
user_input = ClientUI.select_player()
if user_input.upper() == "A":
self.set_game_in_server()
self.send_data(Protocol.auto_player(self.username))
else:
# self.set_game_in_server()
while True:
self.send_data(Protocol.send_list(self.username, self.game_type))
data = self.receive_data().strip()
while "MATCH_LIST" not in data:
data = self.receive_data().strip()
player_list = data.split('@')
del player_list[0]
if len(player_list) != 0:
print("\nPlease insert the username that you would like to play with:")
print("------------------------------------------------------------")
for index in range(len(player_list)):
ClientUI.print_detail(str(index + 1) + " -> " + player_list[index])
print("----------------------------------------------------------")
player_name = ClientUI.get_user_input("\nEnter the username: "******"\nThere is no player. Please try it again!!!\n")
self.select_player()
break
def __init__(self, **kwargs):
Thread.__init__(self)
# Serial thread
self.serialthread = SerialPort()
# Controller Read/Write variables over serial
self.controller = DistantIO()
# Serial protocol
self.protocol = Protocol()
# Variable manager
self.variable_manager = VariableManager(self)
self.variable_manager.start()
self.running = True;
# Data logger
self.logger = DataLogger()
def new_account(self):
while True:
self.username = input("Enter your Username: "******"VALID_USERNAME":
break
elif _expected_answer == "":
print("Huge error. Server sent back >>> ", _expected_answer)
else:
print("Someone already has that username. Try another? [CANNOT CONTAIN '@' OR '_']")
def login(self):
self.username = ClientUI.get_user_input("Enter your Username: "******"VALID_USERNAME":
pass
elif _expected_answer == "":
ClientUI.print_detail("Huge error. Server sent back >>> " + _expected_answer)
else:
ClientUI.print_detail("\nInvalid username. Please try it again.\n")
self.welcome()
def _rebind_slow(self):
try:
self.parseFiles()
except:
self.error(traceback.format_exc())
try:
self.dispatcher.rebind()
for channel in dict(self.channels): # hack, but I guess reloading is all a hack :P
chan = self.channels[channel].copy()
del chan['chan'] # 'cause we're passing it ourselves
self.channels[channel] = sys.modules['Protocol'].Channel(self, channel, **chan)
self.protocol = Protocol(self, None)
except:
self.error(traceback.format_exc())
self.admin_broadcast('Done reloading.')
self.console_write('Done reloading.')
class DataHandler:
def __init__(self):
self.local_ip = None
self.online_ip = None
self.session_id = 0
self.dispatcher = None
self.console_buffer = []
self.port = 8200
self.natport = self.port+1
self.dbtype = 'lan'
self.lanadmin = {'username':'', 'password':''}
self.latestspringversion = '*'
self.log = False
self.server = 'TASServer'
self.server_version = 0.35
self.sighup = False
self.chanserv = None
self.userdb = None
self.engine = None
self.tsbanurl = None
self.channelfile = None
self.protocol = None
self.updatefile = None
self.trusted_proxyfile = None
self.max_threads = 25
self.sqlurl = 'sqlite:///sqlite.txt'
self.randomflags = False
self.nextbattle = 0
self.SayHooks = __import__('SayHooks')
self.censor = True
self.motd = None
self.updates = {}
self.running = True
self.output = None
self.trusted_proxies = []
self.start_time = time.time()
self.channels = {}
self.chan_alias = {}
self.usernames = {}
self.clients = {}
self.db_ids = {}
self.battles = {}
thread.start_new_thread(self.event_loop, ())
def parseArgv(self, argv):
'parses command-line options'
args = {'ignoreme':[]}
mainarg = 'ignoreme'
tempargv = list(argv)
while tempargv:
arg = tempargv.pop(0)
if arg.startswith('-'):
mainarg = arg.lstrip('-').lower()
if mainarg in ['g', 'loadargs']:
try:
name = tempargv[0]
if name.startswith('-'): raise Exception
f = file(name, 'r')
lines = f.read().split('\n')
f.close()
tempargv += ' '.join(lines).split(' ')
except:
pass
args[mainarg] = []
else:
args[mainarg].append(arg)
del args['ignoreme']
for arg in args:
argp = args[arg]
if arg in ['h', 'help']:
print 'Usage: server.py [OPTIONS]...'
print 'Starts uberserver.'
print
print 'Options:'
print ' -h, --help'
print ' { Displays this screen then exits }'
print ' -p, --port number'
print ' { Server will host on this port (default is 8200) }'
print ' -n, --natport number'
print ' { Server will use this port for NAT transversal (default is 8201) }'
print ' -l, --lan'
print ' { Users do not need to be registered to login - breaks rudimentary features like channel ops/founders, channel/battle bans, etc. }'
print ' -a, --lanadmin username password [hash] }'
print ' { Hardcoded admin account for LAN. If third arg reads "hash" it will apply the standard hash algorithm to the supplied password }'
print ' -g, --loadargs filename'
print ' { Reads additional command-line arguments from file }'
print ' -r --randomflags'
print ' { Randomizes country codes (flags) }'
print ' -o, --output /path/to/file.log'
print ' { Writes console output to file (for logging) }'
print ' -u, --sighup'
print ' { Reload the server on SIGHUP (if SIGHUP is supported by OS) }'
print ' -v, --latestspringversion version'
print ' { Sets latest Spring version to this string. Defaults to "*" }'
print ' -m, --maxthreads number'
print ' { Uses the specified number of threads for handling clients }'
print ' -s, --sqlurl SQLURL'
print ' { Uses SQL database at the specified sqlurl for user, channel, and ban storage. }'
print ' -c, --no-censor'
print ' { Disables censoring of #main, #newbies, and usernames (default is to censor) }'
print ' --accounts /path/to/accounts.txt'
print ' { Path to accounts.txt. For using the legacy TASServer account database. }'
print ' --tsbans SQLURL'
print ' { Uses SQL database at the specified sqlurl as a legacy TASServer ban database. } '
print ' --channels /path/to/settings.xml'
print ' { Path to ChanServ settings.xml, for using the legacy ChanServ channel database. }'
print ' --updates /path/to/updates.txt'
print ' { Path to updates.txt, for using Spring update system. }'
print ' --proxies /path/to/proxies.txt'
print ' { Path to proxies.txt, for trusting proxies to pass real IP through local IP }'
print 'SQLURL Examples:'
#print ' "sqlite:///:memory:" or "sqlite:///"'
#print ' { both make a temporary database in memory }'
print ' "sqlite:////absolute/path/to/database.txt"'
print ' { uses a database in the file specified }'
print ' "sqlite:///relative/path/to/database.txt"'
print ' { note sqlite is slower than a real SQL server }'
print ' "mysql://*****:*****@server:port/database"'
print ' { requires the MySQLdb module }'
print ' "oracle://*****:*****@server:port/database"'
print ' { requires the cx_Oracle module }'
print ' "postgres://*****:*****@server:port/database"'
print ' { requires the psycopg2 module }'
print ' "mssql://*****:*****@server:port/database"'
print ' { requires pyodbc (recommended) or adodbapi or pymssql }'
print ' "firebird://*****:*****@server:port/database"'
print ' { requires the kinterbasdb module }'
print
print 'Usage example (this is what the test server uses at the moment):'
print ' server.py -p 8300 -n 8301'
print
exit()
if arg in ['p', 'port']:
try: self.port = int(argp[0])
except: print 'Invalid port specification'
elif arg in ['n', 'natport']:
try: self.natport = int(argp[0])
except: print 'Invalid NAT port specification'
elif arg in ['l', 'lan']:
self.dbtype = 'lan'
elif arg in ['a', 'lanadmin']:
try:
if len(argp) > 2:
if argp[2] == 'hash':
m = md5(argp[1])
argp[1] = base64.b64encode(m.digest())
self.lanadmin = {'username':argp[0], 'password':argp[1]}
except: print 'Invalid LAN admin specified'
elif arg in ['r', 'randomcc']:
try: self.randomflags = True
except: print 'Error enabling random flags. (weird)'
elif arg in ['o', 'output']:
try:
self.output = file(argp[0], 'w')
print 'Logging enabled at: %s' % argp[0]
self.log = True
except: print 'Error specifying log location'
elif arg in ['u', 'sighup']:
self.sighup = True
elif arg in ['v', 'latestspringversion']:
try: self.latestspringversion = argp[0] # ' '.join(argp) # shouldn't have spaces
except: print 'Error specifying latest spring version'
elif arg in ['m', 'maxthreads']:
try: self.max_threads = int(argp[0])
except: print 'Error specifing max threads'
elif arg in ['s', 'sqlurl']:
try:
self.sqlurl = argp[0]
self.dbtype = 'sql'
except:
print 'Error specifying SQL URL'
elif arg in ['c', 'no-censor']:
self.censor = False
elif arg == 'accounts':
try:
self.engine = argp[0]
open(self.engine, 'r').close()
self.dbtype = 'legacy'
except:
print 'Error opening legacy accounts.txt database.'
elif arg == 'tsbans':
self.tsbanurl = argp[0]
elif arg == 'channels':
try:
self.channelfile = argp[0]
open(self.channelfile, 'r').close()
except:
print 'Error opening ChanServ settings.xml.'
self.channelfile = None
elif arg == 'updates':
try:
self.updatefile = argp[0]
open(self.updatefile, 'r').close()
except:
print 'Error opening updates.txt.'
self.updatefile = None
elif arg == 'proxies':
try:
self.trusted_proxyfile = argp[0]
open(self.trusted_proxyfile, 'r').close()
except:
print 'Error opening trusted proxy file.'
self.trusted_proxyfile = None
if self.dbtype == 'sql':
if self.sqlurl == 'sqlite:///:memory:' or self.sqlurl == 'sqlite:///':
print 'In-memory sqlite databases are not supported.'
print 'Falling back to LAN mode.'
print
self.dbtype = 'lan'
else:
try:
sqlalchemy = __import__('sqlalchemy')
self.engine = sqlalchemy.create_engine(self.sqlurl, pool_recycle=300) # hopefully no thread will open more than two sql connections :/
if self.sqlurl.startswith('sqlite'):
print 'Multiple threads are not supported with sqlite, forcing a single thread'
print 'Please note the server performance will not be optimal'
print 'You might want to install a real database server or use LAN mode'
print
self.max_threads = 1
except ImportError:
print 'sqlalchemy not found or invalid SQL URL, falling back to LAN mode.'
self.dbtype = 'lan'
if self.dbtype == 'legacy':
try:
self.userdb = LegacyUsers.UsersHandler(self, self.engine)
self.userdb.readAccounts()
except:
print traceback.format_exc()
print 'Error loading accounts.txt database, falling back to LAN mode.'
self.dbtype = 'lan'
elif self.dbtype == 'sql':
try:
self.userdb = __import__('SQLUsers').UsersHandler
self.userdb(self, self.engine)
except:
self.dbtype = 'lan'
print traceback.format_exc()
print 'Error importing SQL - falling back to LAN mode.'
if self.dbtype == 'lan':
self.userdb = __import__('LANUsers').UsersHandler(self)
print 'Warning: LAN mode enabled - many user-specific features will be broken.'
if self.channelfile:
parser = LegacyChannels.Parser()
channels = parser.parse(self.channelfile)
userdb = self.getUserDB()
for name in channels:
channel = channels[name]
owner = None
admins = []
client = userdb.clientFromUsername(channel['owner'])
if client and client.id: owner = client.id
for user in channel['admins']:
client = userdb.clientFromUsername(user)
if client and client.id:
admins.append(client.id)
self.channels[name] = Channel(self, name, chanserv=bool(owner), owner=owner, admins=admins, key=channel['key'], antispam=channel['antispam'], topic={'user':'******', 'text':channel['topic'], 'time':int(time.time()*1000)})
if self.chanserv:
for name in channels:
self.chanserv.client._protocol._handle(self.chanserv.client, 'JOIN %s' % name)
if not self.log:
try:
self.output = open('server.log', 'w')
self.log = True
except: pass
self.parseFiles()
self.protocol = Protocol(self, None)
def parseFiles(self):
if os.path.isfile('motd.txt'):
motd = []
f = open('motd.txt', 'r')
data = f.read()
f.close()
if data:
for line in data.split('\n'):
motd.append(line.strip())
self.motd = motd
if self.updatefile:
self.updates = {}
f = open(self.updatefile, 'r')
data = f.read()
f.close()
if data:
for line in data.split('\n'):
if not ':' in line: continue
left, right = line.split(':', 1)
left = left.lower()
if ' ' in left:
name, version = left.rsplit(' ',1)
else:
name, version = left, 'default'
if not name in self.updates:
self.updates[name] = {}
if not version in self.updates[name]:
self.updates[name][version] = {}
self.updates[name][version] = right
if self.trusted_proxyfile:
self.trusted_proxies = set([])
f = open(self.trusted_proxyfile, 'r')
data = f.read()
f.close()
if data:
for line in data.split('\n'):
proxy = line.strip()
if not proxy.replace('.', '', 3).isdigit():
proxy = socket.gethostbyname(proxy)
if proxy:
self.trusted_proxies.add(proxy)
def getUserDB(self):
if self.dbtype in ('legacy', 'lan'):
return self.userdb
elif self.dbtype == 'sql':
return self.userdb(self, self.engine)
def clientFromID(self, db_id):
if db_id in self.db_ids: return self.db_ids[db_id]
def clientFromUsername(self, username):
if username in self.usernames: return self.usernames[username]
def event_loop(self):
start = time.time()
lastsave = lastmute = lastidle = start
while self.running:
now = time.time()
try:
if now - lastsave >= 1800: # save every 30 minutes
lastsave = now
if self.dbtype == 'legacy' and self.userdb:
print 'Writing account database to file.',
start = time.time()
self.userdb.writeAccounts()
if self.channelfile:
writer = LegacyChannels.Writer()
writer.dump(self.channels, self.getUserDB().clientFromID)
print '..took %0.2f seconds.' % (time.time() - start)
if now - lastmute >= 1:
lastmute = now
self.mute_timeout_step()
if now - lastidle >= 90:
lastidle = now
self.idle_timeout_step()
self.console_print_step()
except:
self.error(traceback.format_exc())
time.sleep(max(0.1, 1 - (time.time() - start)))
def mute_timeout_step(self):
try:
now = time.time()
channels = dict(self.channels)
for chan in channels:
channel = channels[chan]
mutelist = dict(channel.mutelist)
for db_id in mutelist:
expiretime = mutelist[db_id]['expires']
if 0 < expiretime and expiretime < now:
del channel.mutelist[db_id]
channel.channelMessage('<%s> has been unmuted (mute expired).' % self.protocol.clientFromID(db_id).username)
except:
self.error(traceback.format_exc())
def idle_timeout_step(self):
now = time.time()
for client in self.clients.values():
if not client.logged_in and client.last_login < now - 90:
client.Remove()
def console_print_step(self):
try:
while self.console_buffer:
line = self.console_buffer.pop(0)
print line
if self.log:
self.output.write(line+'\n')
if self.output:
self.output.flush()
except:
print separator
print traceback.format_exc()
print separator
def error(self, error):
error = '%s\n%s\n%s'%(separator,error,separator)
self.console_write(error)
for user in dict(self.usernames):
try:
if self.usernames[user].debug:
for line in error.split('\n'):
if line:
self.usernames[user].Send('SERVERMSG %s'%line)
except KeyError: pass # the user was removed
def console_write(self, lines=''):
if type(lines) in(str, unicode):
lines = lines.split('\n')
elif not type(lines) in (list, tuple, set):
try: lines = [lines.__repr__()]
except: lines = ['Failed to print lines of type %s'%type(lines)]
self.console_buffer += lines
def multicast(self, clients, msg, ignore=()):
if type(ignore) in (str, unicode): ignore = [ignore]
static = []
for client in clients:
if client and not client.username in ignore:
if client.static: static.append(client)
else: client.Send(msg)
# this is so static clients don't respond before other people even receive the message
for client in static:
client.Send(msg)
def broadcast(self, msg, chan=None, ignore=()):
if type(ignore) in (str, unicode): ignore = [ignore]
try:
if chan in self.channels:
channel = self.channels[chan]
if len(channel.users) > 0:
clients = [self.clientFromUsername(user) for user in list(channel.users)]
self.multicast(clients, msg, ignore)
else:
clients = [self.clientFromUsername(user) for user in list(self.usernames)]
self.multicast(clients, msg, ignore)
except: self.error(traceback.format_exc())
def broadcast_battle(self, msg, battle_id, ignore=[]):
if type(ignore) in (str, unicode): ignore = [ignore]
if battle_id in self.battles:
battle = self.battles[battle_id]
clients = [self.clientFromUsername(user) for user in list(battle.users)]
self.multicast(clients, msg, ignore)
def admin_broadcast(self, msg):
for user in dict(self.usernames):
client = self.usernames[user]
if 'admin' in client.accesslevels:
client.Send('SERVERMSG Admin broadcast: %s'%msg)
def _rebind_slow(self):
try:
self.parseFiles()
except:
self.error(traceback.format_exc())
try:
self.dispatcher.rebind()
for channel in dict(self.channels): # hack, but I guess reloading is all a hack :P
chan = self.channels[channel].copy()
del chan['chan'] # 'cause we're passing it ourselves
self.channels[channel] = sys.modules['Protocol'].Channel(self, channel, **chan)
self.protocol = Protocol(self, None)
except:
self.error(traceback.format_exc())
self.admin_broadcast('Done reloading.')
self.console_write('Done reloading.')
def reload(self):
self.admin_broadcast('Reloading...')
self.console_write('Reloading...')
reload(sys.modules['SayHooks'])
reload(sys.modules['Protocol'])
reload(sys.modules['ChanServ'])
reload(sys.modules['Client'])
if 'SQLUsers' in sys.modules: reload(sys.modules['SQLUsers'])
elif 'LANUsers' in sys.modules: reload(sys.modules['LANUsers'])
elif 'tasserver.LegacyUsers' in sys.modules: reload(sys.modules['tasserver.LegacyUsers'])
self.SayHooks = __import__('SayHooks')
thread.start_new_thread(self._rebind_slow, ()) # why should reloading block the thread? :)
def play_game(self):
if self.game_type == "Battleship":
if self.battleship_setup:
self.game_ui.setUp(self.game_board)
states = ""
for row in range(self.game_board.get_num_rows()):
for col in range(self.game_board.get_num_columns()):
states += "@" + self.game_board.get_game_state()[row][col]
states += "@"
self.send_data(Protocol.set_ship(self.game_id, str(states)))
self.battleship_setup = False
if self.player_key == self.game_board.get_player_turn():
if self.game_type == "Battleship":
print("\nIt's your turn. Please make your move!!!\n")
else:
print("\nIt's your turn. Please make your move!!!\nYour game annotation is: ", self.player_key, "\n")
move = self.game_ui.make_move(self.game_board)
self.send_data(Protocol.play_game(self.game_id, str(move[0]) + "@" + str(move[1])))
else:
print("\nIt is not your turn. Please wait for the next player to make his/her move.")
_expected_answer = self.receive_data()
while _expected_answer == "":
_expected_answer = self.receive_data()
while _expected_answer != "GAME_OVER":
if "BS_PRIMARY" in _expected_answer: # for Battleship Primary Grid
count = 0
temp = _expected_answer.split('@')
del temp[0]
for row in range(self.game_board.get_num_rows()):
for col in range(self.game_board.get_num_columns()):
self.game_board.primaryGrid1[row][col] = temp[count]
count += 1
if "BS_TRACKING" in _expected_answer: # for Battleship Tracking Grid
count = 0
temp = _expected_answer.split('@')
del temp[0]
for row in range(self.game_board.get_num_rows()):
for col in range(self.game_board.get_num_columns()):
self.game_board.trackingGrid1[col][row] = temp[count]
count += 1
if "UPDATE" in _expected_answer:
count = 0
temp = _expected_answer.split('@')
del temp[0]
for row in range(self.game_board.get_num_rows()):
for col in range(self.game_board.get_num_columns()):
self.game_board.get_game_state()[row][col] = temp[count]
count += 1
elif "READY" in _expected_answer:
self.game_ui.print_scores(self.game_board)
self.game_ui.print_board(self.game_board)
print("\nIt's your turn. Please make your move!!!\nYour game annotation is: ", self.player_key)
move = self.game_ui.make_move(self.game_board)
self.send_data(Protocol.play_game(self.game_id, str(move[0]) + "@" + str(move[1])))
elif _expected_answer == "SWITCH_PLAYER":
self.game_board.switch_Turn()
elif "WAIT" in _expected_answer:
print("WAIT from client")
self.game_ui.print_scores(self.game_board)
self.game_ui.print_board(self.game_board)
print("\nIt is not your turn. Please wait for the next player to make his/her move.")
elif "NO_MOVE_FOR_YOU" in _expected_answer:
print("\nThere is no move for you. Changing the turn.")
elif _expected_answer == "INVALID_MOVE":
print("\nInvalid move. Please try it again !!!")
move = self.game_ui.make_move(self.game_board)
self.send_data(Protocol.play_game(self.game_id, str(move[0]) + "@" + str(move[1])))
else:
pass
_expected_answer = self.receive_data()
self.game_ui.print_scores(self.game_board)
self.game_ui.print_board(self.game_board)
print(self.game_board.winning_player())
def __init__(self, my_bytes):
Protocol.__init__(self)
self._bytes = my_bytes
class ProtocolTest (unittest.TestCase):
def setUp(self):
self.protocol = Protocol(True)
def tearDown(self):
os.remove("test.u1db")
os.remove("test1.u1db")
"""
method: protocol
when: called
with: typeInsertAndList
should: insertCorrect
"""
def test_protocol_called_typeInsertAndList_insertCorrect(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type":"insert","lista":[{"cloud":"Stacksync", "user_eyeos":"eyeID_EyeosUser_2","status": "NEW", "is_root": false, "version": 1, "filename": "clients", "parent_id": "null", "server_modified": "2013-03-08 10:36:41.997", "path": "/documents/clients", "client_modified": "2013-03-08 10:36:41.997", "id": 9873615, "user": "******","is_folder":true}]}'
else:
params = '{"type":"insert","lista":[{"user_eyeos":"eyeID_EyeosUser_2","status": "NEW", "is_root": false, "version": 1, "filename": "clients", "parent_id": "null", "server_modified": "2013-03-08 10:36:41.997", "path": "/documents/clients", "client_modified": "2013-03-08 10:36:41.997", "id": 9873615, "user": "******","is_folder":true}]}'
aux = json.loads(params)
self.protocol.insert = Mock()
self.protocol.insert.return_value = True
result = self.protocol.protocol(params)
self.protocol.insert.assert_called_once_with(aux['lista'])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeSelectAndList
should: returnArray
"""
def test_protocol_called_typeSelectAndList_returnArray(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type":"select","lista":[{"id":"124568", "user_eyeos":"eyeID_EyeosUser_2", "cloud":"Stacksync", "path":"/documents/clients"}]}'
else:
params = '{"type":"select","lista":[{"id":"124568", "user_eyeos":"eyeID_EyeosUser_2", "path":"/documents/clients"}]}'
aux = json.loads(params)
self.protocol.select = Mock()
self.protocol.select.return_value = []
result = self.protocol.protocol(params)
self.protocol.select.assert_called_once_with(aux['lista'][0])
self.assertEquals('[]',result)
"""
method: protocol
when: called
with: typeUpdateAndList
should: updateCorrect
"""
def test_protocol_called_typeUpdateAndList_updateCorrect(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type":"update","lista":[{"parent_old":"null"},{"cloud": "Stacksync", "user_eyeos": "eyeID_EyeosUser_2", "status": "NEW", "is_root": false, "version": 1, "filename": "clients", "parent_id": "null", "server_modified": "2013-03-08 10:36:41.997", "path": "/documents/clients", "client_modified": "2013-03-08 10:36:41.997", "id": "9873615", "user": "******","is_folder":true}]}'
else:
params = '{"type":"update","lista":[{"parent_old":"null"},{"user_eyeos":"eyeID_EyeosUser_2","status": "NEW", "is_root": false, "version": 1, "filename": "clients", "parent_id": "null", "server_modified": "2013-03-08 10:36:41.997", "path": "/documents/clients", "client_modified": "2013-03-08 10:36:41.997", "id": "9873615", "user": "******","is_folder":true}]}'
aux = json.loads(params)
self.protocol.update = Mock()
self.protocol.update.return_value = True
result = self.protocol.protocol(params)
self.protocol.update.assert_called_once_with(aux['lista'])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeDeleteAndList
should: deleteCorrect
"""
def test_protocol_called_typeDeleteAndList_deleteCorrect(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type":"delete","lista":[{"id":1234, "user_eyeos":"eyeID_EyeosUser_2", "cloud": "Stacksync", "parent_id":"3456"},{"id":"8907", "user_eyeos":"eyeID_EyeosUser_2", "cloud": "Stacksync", "parent_id":"3456"}]}'
else:
params = '{"type":"delete","lista":[{"id":1234,"user_eyeos":"eyeID_EyeosUser_2","parent_id":"3456"},{"id":"8907","user_eyeos":"eyeID_EyeosUser_2","parent_id":"3456"}]}'
aux = json.loads(params)
self.protocol.delete = Mock()
self.protocol.delete.return_value = True
result = self.protocol.protocol(params)
self.protocol.delete.assert_called_once_with(aux['lista'])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeGetParentAndPath
should: returnArray
"""
def test_protocol_called_typeGetParentAndList_returnArray(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type":"parent", "lista":[{"cloud": "Stacksync", "path":"/Documents/", "filename":"prueba", "user_eyeos":"eyeID_EyeosUser_2"}]}'
else:
params = '{"type":"parent", "lista":[{"path":"/Documents/", "filename":"prueba", "user_eyeos":"eyeID_EyeosUser_2"}]}'
aux = json.loads(params)
self.protocol.getParent = Mock()
self.protocol.getParent.return_value = []
result = self.protocol.protocol(params)
self.protocol.getParent.assert_called_once_with(aux[ 'lista' ][0])
self.assertEquals('[]',result)
"""
method: protocol
when: called
with: typeDeleteFolderAndList
should: deleteCorrect
"""
def test_protocol_called_typeDeleteFolderAndList_deleteCorrect(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type":"deleteFolder","lista":[{"id":"1234","user_eyeos":"eyeID_EyeosUser_2", "cloud":"Stacksync", "path":"/documents/clients"}]}'
else:
params = '{"type":"deleteFolder","lista":[{"id":"1234","user_eyeos":"eyeID_EyeosUser_2","path":"/documents/clients"}]}'
aux = json.loads(params)
self.protocol.deleteFolder = Mock()
self.protocol.deleteFolder.return_value = True
result = self.protocol.protocol(params)
self.protocol.deleteFolder.assert_called_once_with(aux[ 'lista' ][0])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeDeleteMetadataUserAndListUser
should: deleteCorrect
"""
def test_protocol_called_typeDeleteMetadataUserAndListUser_deleteCorrect(self):
params = '{"type":"deleteMetadataUser","lista":[{"user_eyeos":"eyeID_EyeosUser_2"}]}'
self.protocol.deleteMetadataUser = Mock()
self.protocol.deleteMetadataUser.return_value = True
result = self.protocol.protocol(params)
self.protocol.deleteMetadataUser.assert_called_once_with(json.loads(params)['lista'])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeDeleteMetadataUserAndListUserAndCloud
should: deleteCorrect
"""
def test_protocol_called_typeDeleteMetadataUserAndListUserAndCloud_deleteCorrect(self):
params = '{"type":"deleteMetadataUser","lista":[{"user_eyeos":"eyeID_EyeosUser_2", "cloud":"Stacksync"}]}'
self.protocol.deleteMetadataUser = Mock()
self.protocol.deleteMetadataUser.return_value = True
result = self.protocol.protocol(params)
self.protocol.deleteMetadataUser.assert_called_once_with(json.loads(params)['lista'])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeSelectMetatadataUserAndList
should: returnArray
"""
def test_protocol_called_typeSelectMetadataUserAndList_returnArray(self):
params = '{"type":"selectMetadataUser","lista":[{"user_eyeos":"eyeID_EyeosUser_2"}]}'
self.protocol.selectMetadataUser = Mock()
self.protocol.selectMetadataUser.return_value = []
result = self.protocol.protocol(params)
self.protocol.selectMetadataUser.assert_called_once_with("eyeID_EyeosUser_2")
self.assertEquals('[]',result)
"""
method: protocol
when: called
with: typeRenameMetadataAndUserAndList
"""
def test_protocol_called_typeRenameMetadataAndUserAndList_renameCorrect(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type": "rename", "lista": [{"user_eyeos": "eyeID_EyeosUser_2", "cloud": "Stacksync", "status": "NEW", "version": 1, "filename": "prueba.txt", "parent_id": "null", "server_modified": "2013-03-08 10:36:41.997", "path": "/", "client_modified": "2013-03-08 10:36:41.997", "id": "9873615", "user": "******","is_folder":false}]}'
else:
params = '{"type": "rename", "lista": [{"user_eyeos": "eyeID_EyeosUser_2", "status": "NEW", "version": 1, "filename": "prueba.txt", "parent_id": "null", "server_modified": "2013-03-08 10:36:41.997", "path": "/", "client_modified": "2013-03-08 10:36:41.997", "id": "9873615", "user": "******","is_folder":false}]}'
aux = json.loads(params)
self.protocol.renameMetadata = Mock()
self.protocol.renameMetadata.return_value = True
result = self.protocol.protocol(params)
self.protocol.renameMetadata.assert_called_once_with(aux[ 'lista' ][0])
self.assertEquals('true',result)
"""
##################################################################################################################################################
TEST DOWNLOAD FILES
##################################################################################################################################################
"""
"""
method: protocol
when: called
with: typeInsertDownloadVersionAndList
should: insertCorrect
"""
def test_protocol_called_typeInsertDownloadVersionAndList_insertCorrect(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type": "insertDownloadVersion", "lista": [{"id": "9873615", "cloud": "Stacksync", "user_eyeos": "eyeID_EyeosUser_2", "version": "2", "recover": false}]}'
else:
params = '{"type": "insertDownloadVersion", "lista": [{"id": "9873615", "user_eyeos": "eyeID_EyeosUser_2", "version": "2", "recover": false}]}'
aux = json.loads(params)
self.protocol.insertDownloadVersion = Mock()
self.protocol.insertDownloadVersion.return_value = True
result = self.protocol.protocol(params)
self.protocol.insertDownloadVersion.assert_called_once_with(aux[ 'lista' ][0])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeUpdateDownloadVersionAndList
should: updateCorrect
"""
def test_protocol_called_typeUpdateDownloadVersionAndList_updateCorrect(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type": "updateDownloadVersion", "lista": [{"id": "9873615", "cloud": "Stacksync", "user_eyeos": "eyeID_EyeosUser_2", "version": "3", "recover": false}]}'
else:
params = '{"type": "updateDownloadVersion", "lista": [{"id": "9873615", "user_eyeos": "eyeID_EyeosUser_2", "version": "3", "recover": false}]}'
aux = json.loads(params)
self.protocol.updateDownloadVersion = Mock()
self.protocol.updateDownloadVersion.return_value = True
result = self.protocol.protocol(params)
self.protocol.updateDownloadVersion.assert_called_once_with(aux[ 'lista' ][0])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeDeleteDownloadVersionAndList
should: deleteCorrect
"""
def test_protocol_called_typeDeleteDownloadVersionAndList_deleteCorrect(self):
params = '{"type":"deleteDownloadVersion","lista":[{"id":"9873615","user_eyeos":"eyeID_EyeosUser_2"}]}'
self.protocol.deleteDownloadVersion = Mock()
self.protocol.deleteDownloadVersion.return_value = True
result = self.protocol.protocol(params)
self.protocol.deleteDownloadVersion.assert_called_once_with("9873615","eyeID_EyeosUser_2")
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeGetDownloadVersionAndList
should: returnMetadata
"""
def test_protocol_called_typeGetDownloadVersionAndList_returnMetadata(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type":"getDownloadVersion","lista":[{"id": "9873615", "user_eyeos": "eyeID_EyeosUser_2", "cloud": "Stacksync"}]}'
expected = {"id": "9873615", "cloud": "Stacksync", "user_eyeos": "eyeID_EyeosUser_2", "version": "3", "recover": False}
else:
params = '{"type":"getDownloadVersion","lista":[{"id": "9873615", "user_eyeos": "eyeID_EyeosUser_2"}]}'
expected = {"id": "9873615", "user_eyeos": "eyeID_EyeosUser_2", "version": "3", "recover": False}
aux = json.loads(params)
self.protocol.getDownloadVersion = Mock()
self.protocol.getDownloadVersion.return_value = expected
result = self.protocol.protocol(params)
self.protocol.getDownloadVersion.assert_called_once_with(aux[ 'lista' ][0])
self.assertEquals(json.dumps(expected), result)
"""
method: protocol
when: called
with: typeRecursiveDeleteVersionAndList
should: deleteCorrect
"""
def test_protocol_called_typeRecursiveDeleteVersionAndList_deleteCorrect(self):
if settings[ 'NEW_CODE' ] == "true":
params = '{"type":"recursiveDeleteVersion","lista":[{"cloud":"Stacksync","id":"9873615","user_eyeos":"eyeID_EyeosUser_2"}]}'
else:
params = '{"type":"recursiveDeleteVersion","lista":[{"id":"9873615","user_eyeos":"eyeID_EyeosUser_2"}]}'
aux = json.loads(params)
self.protocol.recursiveDeleteVersion = Mock()
self.protocol.recursiveDeleteVersion.return_value = True
result = self.protocol.protocol(params)
self.protocol.recursiveDeleteVersion.assert_called_once_with(aux['lista'][0])
self.assertEquals('true',result)
"""
##################################################################################################################################################
TEST CALENDAR
##################################################################################################################################################
"""
"""
method: protocol
when: called
with: typeDeleteEventAndList
should: deleteCorrect
"""
def test_protocol_called_typeDeleteEventAndList_deleteCorrect(self):
params = '{"type":"deleteEvent" , "lista":[{"type":"event","user_eyeos": "eyeos","calendar": "personal", "status":"DELETED" ,"isallday":"0", "timestart": "201419160000", "timeend":"201419170000", "repetition": "None", "finaltype": "1", "finalvalue": "0", "subject": "Visita Médico", "location": "Barcelona", "description": "Llevar justificante"},{"type":"event","user_eyeos": "eyeos","calendarid": "eyeID_Calendar_2b", "isallday": "1", "timestart": "201420160000", "timeend":"201420170000", "repetition": "None", "finaltype": "1", "finalvalue": "0", "subject": "Excursión", "location": "Girona", "description": "Mochila"}]}'
aux = json.loads(params)
self.protocol.deleteEvent = Mock()
self.protocol.deleteEvent.return_value = True
result = self.protocol.protocol(params)
self.protocol.deleteEvent.assert_called_once_with(aux['lista'])
self.assertEquals("true",result)
"""
method: protocol
when: called
with: typeUpdateEventAndList
should: updateCorrect
"""
def test_protocol_called_typeUpdateEventAndList_updateCorrect(self):
params = '{"type":"updateEvent" , "lista":[{"type":"event","user_eyeos": "eyeos","calendar": "personal", "status":"CHANGED", "isallday":"0", "timestart": "201419160000", "timeend":"201419170000", "repetition": "None", "finaltype": "1", "finalvalue": "0", "subject": "Visita Médico", "location": "Barcelona", "description": "Llevar justificante"},{"type":"event","user_eyeos": "eyeos","calendarid": "eyeID_Calendar_2b", "isallday": "1", "timestart": "201420160000", "timeend":"201420170000", "repetition": "None", "finaltype": "1", "finalvalue": "0", "subject": "Excursión", "location": "Girona", "description": "Mochila"}]}'
aux = json.loads(params)
self.protocol.updateEvent = Mock()
self.protocol.updateEvent.return_value = True
result = self.protocol.protocol(params)
self.protocol.updateEvent.assert_called_once_with(aux['lista'])
self.assertEquals("true",result)
"""
method: protocol
when: called
with: typeSelectEventAndList
should: return Array
"""
def test_protocol_called_typeSelectEventAndList_returnArray(self):
params = '{"type":"selectEvent","lista":[{"type":"event","user_eyeos":"eyeos","calendar":"personal"}]}'
aux = json.loads(params)
self.protocol.selectEvent = Mock()
self.protocol.selectEvent.return_value = []
result = self.protocol.protocol(params)
self.protocol.selectEvent.assert_called_once_with("event","eyeos","personal")
self.assertEquals("[]",result)
"""
method: protocol
when: called
with: typeInsertEventAndList
should: insertCorrect
"""
def test_protocol_called_typeInsertEventAndList_insertCorrect(self):
params = '{"type":"insertEvent" , "lista":[{"type":"event","user_eyeos": "eyeos","calendar": "personal", "status":"NEW", "isallday":"0", "timestart": "201419160000", "timeend":"201419170000", "repetition": "None", "finaltype": "1", "finalvalue": "0", "subject": "Visita Médico", "location": "Barcelona", "description": "Llevar justificante"},{"type":"event","user_eyeos": "eyeos","calendarid": "eyeID_Calendar_2b", "isallday": "1", "timestart": "201420160000", "timeend":"201420170000", "repetition": "None", "finaltype": "1", "finalvalue": "0", "subject": "Excursión", "location": "Girona", "description": "Mochila"}]}'
aux = json.loads(params)
self.protocol.insertEvent = Mock()
self.protocol.insertEvent.return_value = True
result = self.protocol.protocol(params)
self.protocol.insertEvent.assert_called_once_with(aux['lista'])
self.assertEquals("true",result)
"""
method: protocol
when: called
with: typeInsertCalendarAndList
should: insertCorrect
"""
def test_protocol_called_typeInsertCalendarAndList_insertCorrect(self):
params = '{"type":"insertCalendar" , "lista":[{"type":"calendar","user_eyeos": "eyeos","name": "personal", "status":"NEW","description":"personal calendar","timezone":0}]}'
aux = json.loads(params)
self.protocol.insertCalendar = Mock()
self.protocol.insertCalendar.return_value = True
result = self.protocol.protocol(params)
self.protocol.insertCalendar.assert_called_once_with(aux['lista'])
self.assertEquals("true",result)
"""
method: protocol
when: called
with: typeDeleteCalendarAndList
should: deleteCorrect
"""
def test_protocol_called_typeDeleteCalendarAndList_deleteCorrect(self):
params = '{"type":"deleteCalendar" , "lista":[{"type":"calendar","user_eyeos": "eyeos","name": "personal"}]}'
aux = json.loads(params)
self.protocol.deleteCalendar = Mock()
self.protocol.deleteCalendar.return_value = True
result = self.protocol.protocol(params)
self.protocol.deleteCalendar.assert_called_once_with(aux['lista'])
self.assertEquals("true",result)
"""
method: protocol
when: called
with: typeSelectCalendarAndList
should: returnArray
"""
def test_protocol_called_typeSelectCalendarAndList_returnArray(self):
params = '{"type":"selectCalendar" , "lista":[{"type":"calendar","user_eyeos": "eyeos"}]}'
aux = json.loads(params)
self.protocol.selectCalendar = Mock()
self.protocol.selectCalendar.return_value = []
result = self.protocol.protocol(params)
self.protocol.selectCalendar.assert_called_once_with(aux['lista'][0])
self.assertEquals("[]",result)
"""
method: protocol
when: called
with: typeUpdateCalendarAndList
should: updateCorrect
"""
def test_protocol_called_typeUpdateCalendarAndList_updateCorrect(self):
params = '{"type":"updateCalendar" , "lista":[{"type":"calendar","user_eyeos": "eyeos","name":"personal","description":"personal calendar","timezone":0,"status":"CHANGED"}]}'
aux = json.loads(params)
self.protocol.updateCalendar = Mock()
self.protocol.updateCalendar.return_value = True
result = self.protocol.protocol(params)
self.protocol.updateCalendar.assert_called_once_with(aux['lista'])
self.assertEquals("true",result)
"""
method: protocol
when: called
with: typeDeleteCalendarUserAndList
should: deleteCorrect
"""
def test_protocol_called_typeDeleteCalendarUserAndList_deleteCorrect(self):
params = '{"type":"deleteCalendarUser","lista":[{"user_eyeos":"eyeos"}]}'
self.protocol.deleteCalendarUser = Mock()
self.protocol.deleteCalendarUser.return_value = True
result = self.protocol.protocol(params)
self.protocol.deleteCalendarUser.assert_called_once_with("eyeos")
self.assertEquals('true',result)
"""
method: protocol
when: called
with: selectCalendarsAndEventsAndList
should: returnArray
"""
def test_protocol_called_selectCalendarsAndEventsAndList_returnArray(self):
params = '{"type":"selectCalendarsAndEvents","lista":[{"user_eyeos":"eyeos"}]}'
self.protocol.selectCalendarsAndEvents = Mock()
self.protocol.selectCalendarsAndEvents.return_value = []
result = self.protocol.protocol(params)
self.protocol.selectCalendarsAndEvents.assert_called_once_with("eyeos")
self.assertEquals('[]',result)
"""
##################################################################################################################################################
TEST LOCK FILE
##################################################################################################################################################
"""
"""
method: protocol
when: called
with: typeGetMetadataFileAndList
should: returnArray
"""
def test_protocol_called_typeGetMetadataFileAndList_returnArray(self):
params = '{"type":"getMetadataFile","lista":[{"id":"124568","cloud":"Stacksync"}]}'
self.protocol.getMetadataFile = Mock()
self.protocol.getMetadataFile.return_value = []
result = self.protocol.protocol(params)
self.protocol.getMetadataFile.assert_called_once_with("124568","Stacksync")
self.assertEquals('[]',result)
"""
method: protocol
when: called
with: typeLockFileAndList
should: correctBlock
"""
def test_protocol_called_typeLockFileAndList_returnCorrectBlock(self):
params = '{"type":"lockFile","lista":[{"id":"124568","cloud":"Stacksync","username":"******","IpServer":"192.168.56.101","datetime":"2015-05-12 10:50:00","status":"open","timeLimit":10}]}'
aux = json.loads(params)
self.protocol.lockFile = Mock()
self.protocol.lockFile.return_value = True
result = self.protocol.protocol(params)
self.protocol.lockFile.assert_called_once_with(aux['lista'][0])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeUpdateDateTimeAndList
should: updateCorrect
"""
def test_protocol_called_typeUpdateDateTimeAndList_returnCorrectBlock(self):
params = '{"type":"updateDateTime","lista":[{"id":"124568","cloud":"Stacksync","username":"******","IpServer":"192.168.56.101","datetime":"2015-05-12 10:50:00","status":"open"}]}'
aux = json.loads(params)
self.protocol.updateDateTime = Mock()
self.protocol.updateDateTime.return_value = True
result = self.protocol.protocol(params)
self.protocol.updateDateTime.assert_called_once_with(aux['lista'][0])
self.assertEquals('true',result)
"""
method: protocol
when: called
with: typeUnLockFileAndList
should: returnCorrectUnBlock
"""
def test_protocol_called_typeUnLockFileAndList_returnCorrectUnBlock(self):
params = '{"type":"unLockFile","lista":[{"id":"124568","cloud":"Stacksync","username":"******","IpServer":"192.168.56.101","datetime":"2015-05-12 10:50:00","status":"close"}]}'
aux = json.loads(params)
self.protocol.unLockFile = Mock()
self.protocol.unLockFile.return_value = True
result = self.protocol.protocol(params)
self.protocol.unLockFile.assert_called_once_with(aux['lista'][0])
self.assertEquals('true',result)
def setUp(self):
self.protocol = Protocol(True)
class Model(Thread):
def __init__(self, **kwargs):
Thread.__init__(self)
# Serial thread
self.serialthread = SerialPort()
# Controller Read/Write variables over serial
self.controller = DistantIO()
# Serial protocol
self.protocol = Protocol()
# Variable manager
self.variable_manager = VariableManager(self)
self.variable_manager.start()
self.running = True;
# Data logger
self.logger = DataLogger()
def get_ports(self):
return self.serialthread.get_ports()
def connect_com(self,COM_port):
# Start serial thread (can run without COM port connected)
if not self.serialthread.isAlive():
self.serialthread.start()
self.serialthread.connect(COM_port,115200)
#Model update running in a thread
def run(self):
while self.running:
if self.serialthread.char_available():
c = self.serialthread.get_char()
if not c is None:
self.protocol.process_rx(c)
if self.protocol.available():
p = self.protocol.get()
# Dump payload if controller is in heavy load ?
pub.sendMessage('new_rx_payload',rxpayload=p)#USED ?
if not p is None:
self.controller.decode(p)
def disconnect_com(self):
self.serialthread.disconnect()
def stop(self):
self.running = False
self.serialthread.stop()
self.variable_manager.stop()
if self.serialthread.isAlive():
self.serialthread.join(0.1)
if self.serialthread.isAlive():
self.serialthread.join(1)
if self.serialthread.isAlive():
print("--- Serial thread not properly joined.")
if self.variable_manager.isAlive():
self.variable_manager.join(0.1)
if self.variable_manager.isAlive():
self.variable_manager.join(1)
self.stop_controller()
def start_controller(self):
#Get command for querying variable table MCU side
cmd = self.controller.encode(cmd='table')
#Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
#Send command
self.serialthread.write(frame)
def stop_controller(self):
#TODO : Tell MCU to stop sending all data
pass
def start_log(self):
self.logger.start()
def stop_log(self):
self.logger.record_all()
def read_var(self, varid):
# Get command
cmd = self.controller.encode(cmd='read',var_id=varid)
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def write_var(self,varid,value):
# Get command
cmd = self.controller.encode(cmd='write',var_id=varid,value=value)
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def stop_read_var(self,varid):
# Get command
cmd = self.controller.encode(cmd='stop',var_id=varid)
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def stop_read_all_vars():
# Get command
cmd = self.controller.encode(cmd='stopall')
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def get_var_info(self,varid):
return self.controller.get_var_info(varid)
def parseArgv(self, argv):
'parses command-line options'
args = {'ignoreme':[]}
mainarg = 'ignoreme'
tempargv = list(argv)
while tempargv:
arg = tempargv.pop(0)
if arg.startswith('-'):
mainarg = arg.lstrip('-').lower()
if mainarg in ['g', 'loadargs']:
try:
name = tempargv[0]
if name.startswith('-'): raise Exception
f = file(name, 'r')
lines = f.read().split('\n')
f.close()
tempargv += ' '.join(lines).split(' ')
except:
pass
args[mainarg] = []
else:
args[mainarg].append(arg)
del args['ignoreme']
for arg in args:
argp = args[arg]
if arg in ['h', 'help']:
print 'Usage: server.py [OPTIONS]...'
print 'Starts uberserver.'
print
print 'Options:'
print ' -h, --help'
print ' { Displays this screen then exits }'
print ' -p, --port number'
print ' { Server will host on this port (default is 8200) }'
print ' -n, --natport number'
print ' { Server will use this port for NAT transversal (default is 8201) }'
print ' -l, --lan'
print ' { Users do not need to be registered to login - breaks rudimentary features like channel ops/founders, channel/battle bans, etc. }'
print ' -a, --lanadmin username password [hash] }'
print ' { Hardcoded admin account for LAN. If third arg reads "hash" it will apply the standard hash algorithm to the supplied password }'
print ' -g, --loadargs filename'
print ' { Reads additional command-line arguments from file }'
print ' -r --randomflags'
print ' { Randomizes country codes (flags) }'
print ' -o, --output /path/to/file.log'
print ' { Writes console output to file (for logging) }'
print ' -u, --sighup'
print ' { Reload the server on SIGHUP (if SIGHUP is supported by OS) }'
print ' -v, --latestspringversion version'
print ' { Sets latest Spring version to this string. Defaults to "*" }'
print ' -m, --maxthreads number'
print ' { Uses the specified number of threads for handling clients }'
print ' -s, --sqlurl SQLURL'
print ' { Uses SQL database at the specified sqlurl for user, channel, and ban storage. }'
print ' -c, --no-censor'
print ' { Disables censoring of #main, #newbies, and usernames (default is to censor) }'
print ' --accounts /path/to/accounts.txt'
print ' { Path to accounts.txt. For using the legacy TASServer account database. }'
print ' --tsbans SQLURL'
print ' { Uses SQL database at the specified sqlurl as a legacy TASServer ban database. } '
print ' --channels /path/to/settings.xml'
print ' { Path to ChanServ settings.xml, for using the legacy ChanServ channel database. }'
print ' --updates /path/to/updates.txt'
print ' { Path to updates.txt, for using Spring update system. }'
print ' --proxies /path/to/proxies.txt'
print ' { Path to proxies.txt, for trusting proxies to pass real IP through local IP }'
print 'SQLURL Examples:'
#print ' "sqlite:///:memory:" or "sqlite:///"'
#print ' { both make a temporary database in memory }'
print ' "sqlite:////absolute/path/to/database.txt"'
print ' { uses a database in the file specified }'
print ' "sqlite:///relative/path/to/database.txt"'
print ' { note sqlite is slower than a real SQL server }'
print ' "mysql://*****:*****@server:port/database"'
print ' { requires the MySQLdb module }'
print ' "oracle://*****:*****@server:port/database"'
print ' { requires the cx_Oracle module }'
print ' "postgres://*****:*****@server:port/database"'
print ' { requires the psycopg2 module }'
print ' "mssql://*****:*****@server:port/database"'
print ' { requires pyodbc (recommended) or adodbapi or pymssql }'
print ' "firebird://*****:*****@server:port/database"'
print ' { requires the kinterbasdb module }'
print
print 'Usage example (this is what the test server uses at the moment):'
print ' server.py -p 8300 -n 8301'
print
exit()
if arg in ['p', 'port']:
try: self.port = int(argp[0])
except: print 'Invalid port specification'
elif arg in ['n', 'natport']:
try: self.natport = int(argp[0])
except: print 'Invalid NAT port specification'
elif arg in ['l', 'lan']:
self.dbtype = 'lan'
elif arg in ['a', 'lanadmin']:
try:
if len(argp) > 2:
if argp[2] == 'hash':
m = md5(argp[1])
argp[1] = base64.b64encode(m.digest())
self.lanadmin = {'username':argp[0], 'password':argp[1]}
except: print 'Invalid LAN admin specified'
elif arg in ['r', 'randomcc']:
try: self.randomflags = True
except: print 'Error enabling random flags. (weird)'
elif arg in ['o', 'output']:
try:
self.output = file(argp[0], 'w')
print 'Logging enabled at: %s' % argp[0]
self.log = True
except: print 'Error specifying log location'
elif arg in ['u', 'sighup']:
self.sighup = True
elif arg in ['v', 'latestspringversion']:
try: self.latestspringversion = argp[0] # ' '.join(argp) # shouldn't have spaces
except: print 'Error specifying latest spring version'
elif arg in ['m', 'maxthreads']:
try: self.max_threads = int(argp[0])
except: print 'Error specifing max threads'
elif arg in ['s', 'sqlurl']:
try:
self.sqlurl = argp[0]
self.dbtype = 'sql'
except:
print 'Error specifying SQL URL'
elif arg in ['c', 'no-censor']:
self.censor = False
elif arg == 'accounts':
try:
self.engine = argp[0]
open(self.engine, 'r').close()
self.dbtype = 'legacy'
except:
print 'Error opening legacy accounts.txt database.'
elif arg == 'tsbans':
self.tsbanurl = argp[0]
elif arg == 'channels':
try:
self.channelfile = argp[0]
open(self.channelfile, 'r').close()
except:
print 'Error opening ChanServ settings.xml.'
self.channelfile = None
elif arg == 'updates':
try:
self.updatefile = argp[0]
open(self.updatefile, 'r').close()
except:
print 'Error opening updates.txt.'
self.updatefile = None
elif arg == 'proxies':
try:
self.trusted_proxyfile = argp[0]
open(self.trusted_proxyfile, 'r').close()
except:
print 'Error opening trusted proxy file.'
self.trusted_proxyfile = None
if self.dbtype == 'sql':
if self.sqlurl == 'sqlite:///:memory:' or self.sqlurl == 'sqlite:///':
print 'In-memory sqlite databases are not supported.'
print 'Falling back to LAN mode.'
print
self.dbtype = 'lan'
else:
try:
sqlalchemy = __import__('sqlalchemy')
self.engine = sqlalchemy.create_engine(self.sqlurl, pool_recycle=300) # hopefully no thread will open more than two sql connections :/
if self.sqlurl.startswith('sqlite'):
print 'Multiple threads are not supported with sqlite, forcing a single thread'
print 'Please note the server performance will not be optimal'
print 'You might want to install a real database server or use LAN mode'
print
self.max_threads = 1
except ImportError:
print 'sqlalchemy not found or invalid SQL URL, falling back to LAN mode.'
self.dbtype = 'lan'
if self.dbtype == 'legacy':
try:
self.userdb = LegacyUsers.UsersHandler(self, self.engine)
self.userdb.readAccounts()
except:
print traceback.format_exc()
print 'Error loading accounts.txt database, falling back to LAN mode.'
self.dbtype = 'lan'
elif self.dbtype == 'sql':
try:
self.userdb = __import__('SQLUsers').UsersHandler
self.userdb(self, self.engine)
except:
self.dbtype = 'lan'
print traceback.format_exc()
print 'Error importing SQL - falling back to LAN mode.'
if self.dbtype == 'lan':
self.userdb = __import__('LANUsers').UsersHandler(self)
print 'Warning: LAN mode enabled - many user-specific features will be broken.'
if self.channelfile:
parser = LegacyChannels.Parser()
channels = parser.parse(self.channelfile)
userdb = self.getUserDB()
for name in channels:
channel = channels[name]
owner = None
admins = []
client = userdb.clientFromUsername(channel['owner'])
if client and client.id: owner = client.id
for user in channel['admins']:
client = userdb.clientFromUsername(user)
if client and client.id:
admins.append(client.id)
self.channels[name] = Channel(self, name, chanserv=bool(owner), owner=owner, admins=admins, key=channel['key'], antispam=channel['antispam'], topic={'user':'******', 'text':channel['topic'], 'time':int(time.time()*1000)})
if self.chanserv:
for name in channels:
self.chanserv.client._protocol._handle(self.chanserv.client, 'JOIN %s' % name)
if not self.log:
try:
self.output = open('server.log', 'w')
self.log = True
except: pass
self.parseFiles()
self.protocol = Protocol(self, None)
