def test_set_data(self):
""" Test XplMessage.set_data() method.
"""
self.__xpl_message.set_data({
"command": "dim",
"device": "a1",
"level": "75"
})
self.assertEqual(
self.__xpl_message.data,
OrderedDict({
"command": "dim",
"device": "a1",
"level": "75"
}))
# Check if correctly remove previous data
self.__xpl_message.set_data({
"command2": "dim",
"device2": "a1",
"level2": "75"
})
self.assertEqual(
self.__xpl_message.data,
OrderedDict({
"command2": "dim",
"device2": "a1",
"level2": "75"
}))
def fragment_message(message, uid):
""" Fill the instance with fragments from the message
@param message: XplMessage instance to split
@param uid : the unique ID that should identify this message
@return an OrderedDict which contains all the fragments
"""
#we use an OrderedDict to store messages until we know the total number of messages
message_list = OrderedDict()
msg = FragmentedXplMessage.__init_fragment(message, uid)
base_len = len(msg.to_packet())
f_id = 1
for k in message.data:
if type(message.data[k]) == list:
for l in message.data[k]:
if not FragmentedXplMessage.__try_add_item_to_message(
msg, k, l):
message_list[f_id] = msg
msg = FragmentedXplMessage.__init_fragment(
message, uid)
FragmentedXplMessage.__try_add_item_to_message(
msg, k, l)
f_id = f_id + 1
else:
if not FragmentedXplMessage.__try_add_item_to_message(
msg, k, message.data[k]):
message_list[f_id] = msg
msg = FragmentedXplMessage.__init_fragment(message, uid)
FragmentedXplMessage.__try_add_item_to_message(
msg, k, message.data[k])
f_id = f_id + 1
message_list[f_id] = msg
return FragmentedXplMessage.__update_fragments_ids(message_list, uid)
def __init__(self, packet=None):
""" Message object.
Create Message instance from a message string and check if the
structure is correct. Raise exception if it is not
The message can be None (to allow building a message)
@param packet : message packet, as sent on the network
@type packet: str
"""
super(XplMessage, self).__init__()
self.type = ""
self.hop_count = 1
self.source = ""
self.source_vendor_id = ""
self.source_device_id = ""
self.source_instance_id = ""
self.target = ""
self.target_vendor_id = ""
self.target_device_id = ""
self.target_instance_id = ""
self.schema = ""
self.schema_class = ""
self.schema_type = ""
self.data = OrderedDict()
if packet is not None:
self.from_packet(packet)
def test_from_packet(self):
""" Test the XplMessage.from_packet() method.
"""
wrong_packet = \
"""xpl-cmnd
{
target=acme-cm12.server
}
{
command=dim
device=a1
level=75
}
"""
self.assertRaises(XplMessageError, self.__xpl_message.from_packet,
wrong_packet)
packet = \
"""xpl-cmnd
{
hop=1
source=xpl-xplhal.myhouse
target=acme-cm12.server
}
x10.basic
{
command=dim
device=a1
level=75
}
"""
self.__xpl_message.from_packet(packet)
self.assertEqual(self.__xpl_message.type, 'xpl-cmnd')
self.assertEqual(self.__xpl_message.hop_count, 1)
self.assertEqual(self.__xpl_message.source, "xpl-xplhal.myhouse")
self.assertEqual(self.__xpl_message.source_vendor_id, "xpl")
self.assertEqual(self.__xpl_message.source_device_id, "xplhal")
self.assertEqual(self.__xpl_message.source_instance_id, "myhouse")
self.assertEqual(self.__xpl_message.target, "acme-cm12.server")
self.assertEqual(self.__xpl_message.target_vendor_id, "acme")
self.assertEqual(self.__xpl_message.target_device_id, "cm12")
self.assertEqual(self.__xpl_message.target_instance_id, "server")
self.assertEqual(self.__xpl_message.schema, "x10.basic")
self.assertEqual(self.__xpl_message.schema_class, "x10")
self.assertEqual(self.__xpl_message.schema_type, "basic")
self.assertEqual(
self.__xpl_message.data,
OrderedDict({
"command": "dim",
"device": "a1",
"level": "75"
}))
def set_data(self, data):
""" Set message data, replacing previous ones. ???
First build data as str, to be parsed by the regexp.
@param data: message data, as name/value pairs
@type data: dict or L{OrderedDict}
"""
data_backup = copy.deepcopy(self.data)
try:
self.data = OrderedDict()
self.add_data(data)
except XplMessageError:
self.data = copy.deepcopy(data_backup)
raise
def from_packet(self, packet):
""" Decode message from given packet.
@param packet: message packet, as sent on the network
@type packet: str
@raise XplMessageError: the message packet is incorrect
@raise XplMessageError: invalid message packet
"""
match_global = XplMessage.__regexp_global.match(packet)
if match_global is None:
raise XplMessageError("Invalid message packet")
else:
match_global_dict = match_global.groupdict()
self.set_type(match_global_dict['type_'])
self.set_hop_count(match_global_dict['hop_count'])
self.set_source(match_global_dict['source'])
self.set_target(match_global_dict['target'])
self.set_schema(match_global_dict['schema'])
self.data = OrderedDict()
data = match_global_dict[
'data'] + '\n' # The global match remove the last '\n'
self.__parse_data(data)
class HeyuManager:
"""
This class manages the heyu configuration file
"""
ITEMS_SECTION = OrderedDict()
ITEMS_SECTION['general'] = [
'TTY', 'TTY_AUX', 'LOG_DIR', 'HOUSECODE', 'REPORT_PATH',
'DEFAULT_MODULE', 'START_ENGINE', 'DATE_FORMAT', 'LOGDATE_YEAR',
'TAILPATH', 'HEYU_UMASK', 'STATUS_TIMEOUT', 'SPF_TIMEOUT',
'TRANS_DIMLEVEL'
]
ITEMS_SECTION['aliases'] = ['ALIAS']
ITEMS_SECTION['scenes'] = ['SCENE', 'USERSYN', 'MAX_PPARMS']
ITEMS_SECTION['scripts'] = ['SCRIPT', 'SCRIPT_MODE', 'SCRIPT_CTRL']
ITEMS_SECTION['scheduler'] = [
'SCHEDULE_FILE', 'MODE', 'PROGRAM_DAYS', 'COMBINE_EVENTS',
'COMPRESS_MACROS', 'REPL_DELAYED_MACROS', 'WRITE_CHECK_FILES'
]
ITEMS_SECTION['dawnduk'] = [
'LONGITUDE', 'LATITUDE', 'DAWN_OPTION', 'DUSK_OPTION', 'MIN_DAWN',
'MAX_DAWN', 'MIN_DUSK', 'MAX_DUSK'
]
def __init__(self, path):
"""
@param path = The heyu config file path, must be absolute
"""
self._file = "%s" % path
def load(self):
"""
Load the file and parse it
@return a list containing all the *uncommented* lines of config file
"""
f = open(self._file, "r")
lines = f.readlines()
f.close()
result = []
for line in lines:
if not line.startswith("#") and line.strip() != "":
result.append(line.strip())
return result
def write(self, data):
"""
Write config datas in the config file
@param data : list of config lines
@Warning : it will erease the previous config file
@raise IOError if the file can'"t be opened
"""
f = open(self._file, "w")
for section in self.ITEMS_SECTION:
f.write("##### %s #####\n\n" % section)
for item in self.ITEMS_SECTION[section]:
for d in data:
if d.startswith("%s " % item) or d.startswith(
"%s\t" % item):
f.write("%s\n" % d)
f.write("\n")
f.close()
def restart(self):
"""
Restart heyu process, needed to reload config
@return the output of heyu restart command on stderr,
should be empty if everything goes well
"""
return ""
def clear_data(self):
""" Clear the message data.
"""
self.data = OrderedDict()
