Miko/Hippolyzer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

builder nearly done. Tests all pass, but need more tests.

Browse Source
This commit is contained in:
locklainn.linden
2008-07-23 19:25:46 +00:00
committed by Salad Dais
parent 81b556d67d
commit 455310f7bc
5 changed files with 101 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
pyogp/lib/base/message_template.py
View File

@@ -43,15 +43,14 @@ class MsgData():
serialized and sent. """
def __init__(self, name):
self.name = name
self.total_size = 0
self.size = 0
self.blocks = {}
def add_block(self, block):
self.blocks[block.get_name()] = []
self.blocks[block.get_name()].append(block)
def get_blocks(self):
return self.blocks
if block.name not in self.blocks:
self.blocks[block.name] = []
self.blocks[block.name].append(block)
def get_block(self, block_name):
return self.blocks[block_name]
@@ -67,21 +66,16 @@ class MsgBlockData():
self.name = name
self.size = 0
self.variables = {}
self.block_number = 0
def get_name(self):
return self.name
def add_variable(self, var):
self.variables[var.get_name()] = var
def get_variables(self):
return self.variables
def get_variable(self, var_name):
return self.variables[var_name]
def add_variable(self, var):
self.variables[var.name] = var
def add_data(self, var_name, data, data_size):
get_variable[var_name].add_data(data, data_size)
self.get_variable(var_name).add_data(data, data_size)
class MsgVariableData():
""" Used as a Message Block variable that is being created that will be
@@ -92,75 +86,39 @@ class MsgVariableData():
#MVT_VARIABLE
self.data_size = 0
self.size = -1
self.lltype = tp
self.type = tp
self.data = None
def get_name(self):
return self.name
#how DO we add data? What format will it be in?
def add_data(self, data, data_size):
self.data = data
def get_data(self):
return self.data
def get_size(self):
return self.total_size
def get_type(self):
return self.lltype
self.size = data_size
class MessageTemplateVariable():
def __init__(self, name, tp, size):
self.name = name
self.lltype = tp
self.type = tp
self.size = size
def get_size(self):
return self.size
def get_name(self):
return self.name
def get_type(self):
return self.lltype
class MessageTemplateBlock():
def __init__(self, name):
self.variables = {}
self.variable_map = {}
self.name = name
self.block_type = None
self.number = 0
def get_block_type(self):
return self.block_type
def get_block_number(self):
return self.number
def get_name(self):
return self.name
def add_variable(self, var):
self.variables[var.get_name()] = var
self.variable_map[var.name] = var
def get_variables(self):
return self.variables.values()
return self.variable_map.values()
def get_variable(self, name):
return self.variables[name]
def set_type(self, tp):
self.block_type = tp
def set_number(self, num):
self.number = num
return self.variable_map[name]
class MessageTemplate():
def __init__(self, name):
self.blocks = {}
self.block_map = {}
#this is the function or object that will handle this type of message
self.handler = None
self.name = name
@@ -170,60 +128,18 @@ class MessageTemplate():
self.msg_trust = None
self.msg_deprecation = None
def get_handler(self):
return self.handler
#this probably needs more arguments to pass to the func or object
def set_handler(self, handler):
self.handler = handler
def get_frequency(self):
return self.frequency
def get_message_number(self):
return self.msg_num
def get_message_hex_num(self):
return self.msg_num_hex
def get_trust(self):
return self.msg_trust
def get_encoding(self):
return self.msg_encoding
def get_deprecation(self):
return self.msg_deprecation
def get_name(self):
return self.name
def add_block(self, block):
self.blocks[block.get_name()] = block
self.block_map[block.name] = block
def get_blocks(self):
return self.blocks.values()
return self.block_map.values()
def get_block(self, name):
return self.blocks[name]
def set_frequency(self, freq):
self.frequency = freq
def set_message_number(self, num):
self.msg_num = num
def set_message_hex_num(self, num):
self.msg_num_hex = num
def set_trust(self, trust):
self.msg_trust = trust
def set_encoding(self, enc):
self.msg_encoding = enc
def set_deprecation(self, dep):
self.msg_deprecation = dep
return self.block_map[name]
#these remain unformatted (by standard) because they are going to be moved
def decodeHeaderPair(frequency, num):

73
pyogp/lib/base/message_template_builder.py
View File

@@ -4,8 +4,8 @@ import struct
#pyogp libs
from pyogp.lib.base.message_template import MsgData, MsgBlockData, \
MsgVariableData
import pyogp.lib.base.message_types
#from pyogp.lib.base.message_types import MsgType, MsgBlockType, MsgFrequency
#import pyogp.lib.base.message_types
from pyogp.lib.base.message_types import MsgType, MsgBlockType, MsgFrequency, sizeof
from pyogp.lib.base.data_packer import DataPacker
class MessageTemplateBuilder():
@@ -67,7 +67,7 @@ class MessageTemplateBuilder():
block_buffer = ''
bytes = 0
block_list = message_data.get_block(template_block.get_name())
block_list = message_data.get_block(template_block.name)
block_count = len(block_list)
message_block = block_list[0]
@@ -78,7 +78,7 @@ class MessageTemplateBuilder():
#receieve this know how many to read automatically
if template_block.get_type() == MsgBlockType.MBT_MULTIPLE:
if template_block.get_block_number() != message_block.get_block_number():
raise Exception('Block ' + template_block.get_name() + ' is type MBT_MULTIPLE \
raise Exception('Block ' + template_block.name + ' is type MBT_MULTIPLE \
but only has data stored for ' + str(block_count) + ' out of its ' + \
template_block.get_block_number() + ' blocks')
@@ -94,8 +94,8 @@ class MessageTemplateBuilder():
var_size = variable.get_size()
if var_size == -1:
raise Exception('Variable ' + variable.get_name() + ' in block ' + \
message_block.get_name() + ' of message ' + message_data.get_name() + \
raise Exception('Variable ' + variable.name + ' in block ' + \
message_block.name + ' of message ' + message_data.name + \
' wasn"t set prior to buildMessage call')
data_size = variable.get_data_size()
@@ -124,37 +124,72 @@ class MessageTemplateBuilder():
""" Creates a new packet where data can be added to it. Note, the variables
are added when they are used, or data added to them, so to make sure
no bad data is sent over the network. """
self.current_template = self.template_list[message_name]
#error check
self.current_template = self.template_list[message_name]
self.current_msg = MsgData(message_name)
self.cur_msg_name = message_name
for block in self.current_template.get_blocks():
block_data = MsgBlockData(block.get_name())
block_data = MsgBlockData(block.name)
self.current_msg.add_block(block_data)
def next_block(self, block_name):
self.current_block = self.current_template.get_block(block_name)
#if it doesn't exist, create a new block (may be a VARIABLE or MULTIPLE type
#block
if block_name not in self.current_template.block_map:
#error:
print 'ERROR: template doesn"t have the block'
return
self.cur_block_name = block_name
for variable in self.current_block.get_variables():
var_data = MsgVariableData(variable.get_name(), variable.get_type())
self.current_block.add_variable(var_data)
template_block = self.current_template.get_block(block_name)
block_data = self.current_msg.get_block(block_name)[0]
#if the block's number is 0, then we haven't set up this block yet
if block_data.block_number == 0:
block_data.block_number = 1
self.current_block = block_data
self.cur_block_name = block_name
for variable in template_block.get_variables():
var_data = MsgVariableData(variable.name, variable.type)
self.current_block.add_variable(var_data)
return
#although we may have a block already, there are some cases where we can have
#more than one block of the same name (when type is MULTIPLE or VARIABLE)
else:
#make sure it isn't SINGLE
if self.template_block.type == MsgBlockType.MBT_SINGLE:
#error: can't have more than 1 block when its supposed to be 1
print 'ERROR: can"t have more than 1 block when its supposed to be 1'
return
elif self.template_block.type == MsgBlockType.MBT_MULTIPLE and \
self.template_block.block_number == block_data.block_number:
#error: we are about to exceed block total
print 'ERROR: we are about to exceed block total'
return
block_data.block_number += 1
self.current_block = MsgBlockData(block.name)
self.current_msg.add_block(self.current_block)
self.cur_block_name = block_name
for variable in self.current_block.variables:
var_data = MsgVariableData(variable.name, variable.type)
self.current_block.add_variable(var_data)
def add_data(self, var_name, data, data_type):
""" the data type is passed in to make sure that the programmer is aware of
what type (and therefore size) of the data that is being passed in. """
self.__check_size(var_name, data_type)
self.__check_size(var_name, data, data_type)
self.current_block.add_data(var_name, data, data_type)
def __check_size(self, var_name, data, data_type):
block = self.template_list[cur_msg_name].get_block(self.cur_block_name)
data_size = MsgType.sizeof(data_type)
size = block.get_variable(var_name).get_size()
block = self.template_list[self.cur_msg_name].get_block(self.cur_block_name)
data_size = sizeof(data_type)
size = block.get_variable(var_name).size
if size != data_size:
#warning
#for now, exception

12
pyogp/lib/base/message_template_dict.py
View File

@@ -14,21 +14,21 @@ class TemplateDictionary():
def buildDictionaries(self, template_list):
for template in template_list:
self.message_templates[template.get_name()] = template
self.message_templates[template.name] = template
#do a mapping of type to a string for easier reference
frequency_str = ''
if template.get_frequency() == MsgFrequency.FIXED_FREQUENCY_MESSAGE:
if template.frequency == MsgFrequency.FIXED_FREQUENCY_MESSAGE:
frequency_str = "Fixed"
elif template.get_frequency() == MsgFrequency.LOW_FREQUENCY_MESSAGE:
elif template.frequency == MsgFrequency.LOW_FREQUENCY_MESSAGE:
frequency_str = "Low"
elif template.get_frequency() == MsgFrequency.MEDIUM_FREQUENCY_MESSAGE:
elif template.frequency == MsgFrequency.MEDIUM_FREQUENCY_MESSAGE:
frequency_str = "Medium"
elif template.get_frequency() == MsgFrequency.HIGH_FREQUENCY_MESSAGE:
elif template.frequency == MsgFrequency.HIGH_FREQUENCY_MESSAGE:
frequency_str = "High"
self.message_dict[(frequency_str, \
template.get_message_number())] = template
template.msg_num)] = template
def get_template(self, template_name):
return self.message_templates[template_name]

25
pyogp/lib/base/message_template_parser.py
View File

@@ -21,15 +21,6 @@ class MessageTemplateParser():
self.count = 0
self.__parse_template_file()
def get_version(self):
return self.version
def get_template_list(self):
return self.message_templates
def get_count(self):
return self.count
def __add_template(self, new_template):
self.count += 1
#self.message_templates[new_template.get_name()] = new_template
@@ -80,7 +71,7 @@ class MessageTemplateParser():
elif parts[1] == 'Fixed':
frequency = MsgFrequency.FIXED_FREQUENCY_MESSAGE
current_template.set_frequency(frequency)
current_template.frequency = frequency
msg_num = string.atoi(parts[2],0)
if frequency == MsgFrequency.FIXED_FREQUENCY_MESSAGE:
@@ -95,8 +86,8 @@ class MessageTemplateParser():
elif frequency == MsgFrequency.HIGH_FREQUENCY_MESSAGE:
msg_num_hex = struct.pack('>B', msg_num)
current_template.set_message_number(msg_num)
current_template.set_message_hex_num(msg_num_hex)
current_template.msg_num = msg_num
current_template.msg_num_hex = msg_num_hex
msg_trust = None
if parts[3] == 'Trusted':
@@ -104,7 +95,7 @@ class MessageTemplateParser():
elif parts[3] == 'NotTrusted':
msg_trust = MsgTrust.LL_NOTRUST
current_template.set_trust(msg_trust)
current_template.msg_trust = msg_trust
msg_encoding = None
if parts[4] == 'Unencoded':
@@ -112,7 +103,7 @@ class MessageTemplateParser():
elif parts[4] == 'Zerocoded':
msg_encoding = MsgEncoding.LL_ZEROCODED
current_template.set_encoding(msg_encoding)
current_template.msg_encoding = msg_encoding
msg_dep = None
if len(parts) > 5:
@@ -125,7 +116,7 @@ class MessageTemplateParser():
else:
msg_dep = MsgDeprecation.LL_NOTDEPRECATED
current_template.set_deprecation(msg_dep)
current_template.msg_deprecation = msg_dep
self.__add_template(current_template)
@@ -146,8 +137,8 @@ class MessageTemplateParser():
elif parts[1] == 'Variable':
block_type = MsgBlockType.MBT_VARIABLE
current_block.set_type(block_type)
current_block.set_number(block_num)
current_block.type = block_type
current_block.block_number = block_num
current_template.add_block(current_block)

24
pyogp/lib/base/tests/test_template_builder.py
View File

@@ -8,7 +8,7 @@ from pyogp.lib.base.message_template_parser import MessageTemplateParser
from pyogp.lib.base.message_template_builder import MessageTemplateBuilder
from pyogp.lib.base.message_template_dict import TemplateDictionary
from pyogp.lib.base.message_types import MsgType
from indra.base.lluuid import UUID
class TestTemplateBuilder(unittest.TestCase):
@@ -18,7 +18,7 @@ class TestTemplateBuilder(unittest.TestCase):
def setUp(self):
self.template_file = msg_tmpl
parser = MessageTemplateParser(self.template_file)
self.template_list = parser.get_template_list()
self.template_list = parser.message_templates
self.template_dict = TemplateDictionary(self.template_list)
def test_builder(self):
@@ -73,7 +73,7 @@ class TestTemplateBuilder(unittest.TestCase):
assert builder.get_current_block() == None, "Message block exists before it was created"
builder.next_block('AgentData')
assert builder.get_current_block() != None, "Setting next block failed"
assert builder.get_current_block().get_name() == 'AgentData', "Wrong block set"
assert builder.get_current_block().name == 'AgentData', "Wrong block set"
def test_next_block_fail(self):
builder = MessageTemplateBuilder(self.template_dict)
@@ -91,21 +91,21 @@ class TestTemplateBuilder(unittest.TestCase):
builder.new_message('AvatarTextureUpdate')
builder.next_block('AgentData')
variables = builder.get_current_block().variables
assert len(variables) == 2, "Variables not added to the block"
try:
t_var = variables['AgentID']
assert t_var != None,"Block doesn't have AgentID variable"
assert t_var.get_name() == 'AgentID', "AgentID name incorrect"
assert t_var.get_type() == MsgType.MVT_LLUUID, "AgentID type incorrect"
assert t_var.name == 'AgentID', "AgentID name incorrect"
assert t_var.type == MsgType.MVT_LLUUID, "AgentID type incorrect"
except KeyError:
assert False, "Block doesn't have AgentID variable"
try:
t_var = variables['TexturesChanged']
assert t_var != None,"Block doesn't have TexturesChanged variable"
assert t_var.get_name() == 'TexturesChanged', "Name incorrect"
assert t_var.get_type() == MsgType.MVT_BOOL, "Type incorrect"
assert t_var.name == 'TexturesChanged', "Name incorrect"
assert t_var.type == MsgType.MVT_BOOL, "Type incorrect"
except KeyError:
assert False, "Block doesn't have TexturesChanged variable"
@@ -113,17 +113,17 @@ class TestTemplateBuilder(unittest.TestCase):
builder = MessageTemplateBuilder(self.template_dict)
builder.new_message('AvatarTextureUpdate')
builder.next_block('AgentData')
builder.add_bool('TexturesChanged', True)
builder.add_data('TexturesChanged', True, MsgType.MVT_BOOL)
#need a way to determine the right variable data is sent compared to the type
assert builder.get_current_block().variables['TexturesChanged'].get_data() == True,\
assert builder.get_current_block().variables['TexturesChanged'].data == True,\
"Data not set correctly"
def test_add_lluuid(self):
builder = MessageTemplateBuilder(self.template_dict)
builder.new_message('AvatarTextureUpdate')
builder.next_block('AgentData')
builder.add_lluuid('AgentID', "4baff.afef.1234.1241fvbaf")
assert builder.get_current_block().variables['AgentID'].get_data() == "4baff.afef.1234.1241fvbaf",\
builder.add_data('AgentID', UUID("550e8400-e29b-41d4-a716-446655440000"), MsgType.MVT_LLUUID)
assert builder.get_current_block().variables['AgentID'].data == UUID("550e8400-e29b-41d4-a716-446655440000"),\
"Data not set correctly"
#assert builder.get_current_block().variables['AgentID'].get_size() == ?