class Emmer(object):
"""This is the wrapping class for the Emmer framework. It initializes
running services and also offers the client level interface.
"""
def __init__(self):
self.host = config.HOST
self.port = config.PORT
self.response_router = ResponseRouter()
self.conversation_table = ConversationTable()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.reactor = Reactor(self.sock, self.response_router,
self.conversation_table)
self.performer = Performer(self.sock, self.conversation_table,
config.RESEND_TIMEOUT,
config.RETRIES_BEFORE_GIVEUP)
def route_read(self, filename_pattern):
"""Adds a function with a filename pattern to the Emmer server. Upon a
read request, Emmer will run the action corresponding to the first
filename pattern to match the request's filename.
Use this function as a decorator on a function to add that function
as an action with which to handle a tftp conversation.
Args:
filename_pattern: a regex pattern to match filenames against.
"""
def decorator(action):
self.response_router.append_read_rule(filename_pattern, action)
return decorator
def route_write(self, filename_pattern):
"""Adds a function with a filename pattern to the Emmer server. Upon a
write request, Emmer will run the action corresponding to the first
filename pattern to match the request's filename.
Use this function as a decorator on a function to add that function
as an action with which to handle a tftp conversation.
Args:
filename_pattern: a regex pattern to match filenames against.
"""
def decorator(action):
self.response_router.append_write_rule(filename_pattern, action)
return decorator
def run(self):
"""Initiates the Emmer server. This includes:
* Listening on the given UDP host and port.
* Sending messages through the given port to reach out on timed out
tftp conversations.
"""
self.sock.bind((self.host, self.port))
print "TFTP Server running at %s:%s" % (self.host, self.port)
thread.start_new_thread(self.performer.run,
(config.PERFORMER_THREAD_INTERVAL, ))
self.reactor.run()
class Emmer(object):
"""This is the wrapping class for the Emmer framework. It initializes
running services and also offers the client level interface.
"""
def __init__(self):
self.host = config.HOST
self.port = config.PORT
self.response_router = ResponseRouter()
self.conversation_table = ConversationTable()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.reactor = Reactor(self.sock, self.response_router,
self.conversation_table)
self.performer = Performer(self.sock, self.conversation_table,
config.RESEND_TIMEOUT,
config.RETRIES_BEFORE_GIVEUP)
def route_read(self, filename_pattern):
"""Adds a function with a filename pattern to the Emmer server. Upon a
read request, Emmer will run the action corresponding to the first
filename pattern to match the request's filename.
Use this function as a decorator on a function to add that function
as an action with which to handle a tftp conversation.
Args:
filename_pattern: a regex pattern to match filenames against.
"""
def decorator(action):
self.response_router.append_read_rule(filename_pattern, action)
return decorator
def route_write(self, filename_pattern):
"""Adds a function with a filename pattern to the Emmer server. Upon a
write request, Emmer will run the action corresponding to the first
filename pattern to match the request's filename.
Use this function as a decorator on a function to add that function
as an action with which to handle a tftp conversation.
Args:
filename_pattern: a regex pattern to match filenames against.
"""
def decorator(action):
self.response_router.append_write_rule(filename_pattern, action)
return decorator
def run(self):
"""Initiates the Emmer server. This includes:
* Listening on the given UDP host and port.
* Sending messages through the given port to reach out on timed out
tftp conversations.
"""
self.sock.bind((self.host, self.port))
print "TFTP Server running at %s:%s" % (self.host, self.port)
thread.start_new_thread(self.performer.run,
(config.PERFORMER_THREAD_INTERVAL,))
self.reactor.run()
def __init__(self):
self.host = config.HOST
self.port = config.PORT
self.response_router = ResponseRouter()
self.conversation_table = ConversationTable()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.reactor = Reactor(self.sock, self.response_router,
self.conversation_table)
self.performer = Performer(self.sock, self.conversation_table,
config.RESEND_TIMEOUT,
config.RETRIES_BEFORE_GIVEUP)
def setUp(self):
self.router = ResponseRouter()
# These lambda functions simulate user actions
self.router.append_read_rule("test1", lambda x, y, z: "1")
self.router.append_read_rule("test2", lambda x, y, z: "2")
self.router.append_read_rule("test3.*", lambda x, y, z: "3")
# These lambda functions simulate user actions
self.write_action_one = lambda x, y, z, data: "%s_4" % data
self.write_action_two = lambda x, y, z, data: "%s_5" % data
self.write_action_three = lambda x, y, z, data: "%s_6" % data
self.router.append_write_rule("test1", self.write_action_one)
self.router.append_write_rule("test2", self.write_action_two)
self.router.append_write_rule("test3.*", self.write_action_three)
def __init__(self):
self.host = config.HOST
self.port = config.PORT
self.response_router = ResponseRouter()
self.conversation_table = ConversationTable()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.reactor = Reactor(self.sock, self.response_router,
self.conversation_table)
self.performer = Performer(self.sock, self.conversation_table,
config.RESEND_TIMEOUT,
config.RETRIES_BEFORE_GIVEUP)
def setUp(self):
self.router = ResponseRouter()
# These lambda functions simulate user actions
self.router.append_read_rule("test1", lambda x, y, z: "1")
self.router.append_read_rule("test2", lambda x, y, z: "2")
self.router.append_read_rule("test3.*", lambda x, y, z: "3")
# These lambda functions simulate user actions
self.write_action_one = lambda x, y, z, data: "%s_4" % data
self.write_action_two = lambda x, y, z, data: "%s_5" % data
self.write_action_three = lambda x, y, z, data: "%s_6" % data
self.router.append_write_rule("test1", self.write_action_one)
self.router.append_write_rule("test2", self.write_action_two)
self.router.append_write_rule("test3.*", self.write_action_three)
class TestResponseRouter(unittest.TestCase):
def setUp(self):
self.router = ResponseRouter()
# These lambda functions simulate user actions
self.router.append_read_rule("test1", lambda x, y, z: "1")
self.router.append_read_rule("test2", lambda x, y, z: "2")
self.router.append_read_rule("test3.*", lambda x, y, z: "3")
# These lambda functions simulate user actions
self.write_action_one = lambda x, y, z, data: "%s_4" % data
self.write_action_two = lambda x, y, z, data: "%s_5" % data
self.write_action_three = lambda x, y, z, data: "%s_6" % data
self.router.append_write_rule("test1", self.write_action_one)
self.router.append_write_rule("test2", self.write_action_two)
self.router.append_write_rule("test3.*", self.write_action_three)
def test_initialize_read(self):
read_buffer = self.router.initialize_read("test1", "127.0.0.1", 3942)
self.assertEqual(read_buffer.data, "1")
read_buffer = self.router.initialize_read("test2", "127.0.0.1", 3942)
self.assertEqual(read_buffer.data, "2")
read_buffer = self.router.initialize_read("test3", "127.0.0.1", 3942)
self.assertEqual(read_buffer.data, "3")
read_buffer = self.router.initialize_read("test3if", "127.0.0.1", 3942)
self.assertEqual(read_buffer.data, "3")
def test_initialize_read_for_no_action(self):
read_buffer = self.router.initialize_read("test4", "127.0.0.1", 3942)
self.assertEqual(read_buffer, None)
def test_initialize_write(self):
write_action = self.router.initialize_write("test1", "127.0.0.1", 3942)
self.assertEqual(write_action("a", "b", "c", "d"), "d_4")
write_action = self.router.initialize_write("test2", "127.0.0.1", 3942)
self.assertEqual(write_action("a", "b", "c", "d"), "d_5")
write_action = self.router.initialize_write("test3", "127.0.0.1", 3942)
self.assertEqual(write_action("a", "b", "c", "d"), "d_6")
def test_initialize_write_for_no_action(self):
write_action = self.router.initialize_write("test4", "127.0.0.1", 3942)
self.assertEqual(write_action, None)
class TestResponseRouter(unittest.TestCase):
def setUp(self):
self.router = ResponseRouter()
# These lambda functions simulate user actions
self.router.append_read_rule("test1", lambda x, y, z: "1")
self.router.append_read_rule("test2", lambda x, y, z: "2")
self.router.append_read_rule("test3.*", lambda x, y, z: "3")
# These lambda functions simulate user actions
self.write_action_one = lambda x, y, z, data: "%s_4" % data
self.write_action_two = lambda x, y, z, data: "%s_5" % data
self.write_action_three = lambda x, y, z, data: "%s_6" % data
self.router.append_write_rule("test1", self.write_action_one)
self.router.append_write_rule("test2", self.write_action_two)
self.router.append_write_rule("test3.*", self.write_action_three)
def test_initialize_read(self):
read_buffer = self.router.initialize_read("test1", "127.0.0.1", 3942)
self.assertEqual(read_buffer.data, "1")
read_buffer = self.router.initialize_read("test2", "127.0.0.1", 3942)
self.assertEqual(read_buffer.data, "2")
read_buffer = self.router.initialize_read("test3", "127.0.0.1", 3942)
self.assertEqual(read_buffer.data, "3")
read_buffer = self.router.initialize_read("test3if", "127.0.0.1", 3942)
self.assertEqual(read_buffer.data, "3")
def test_initialize_read_for_no_action(self):
read_buffer = self.router.initialize_read("test4", "127.0.0.1", 3942)
self.assertEqual(read_buffer, None)
def test_initialize_write(self):
write_action = self.router.initialize_write("test1", "127.0.0.1", 3942)
self.assertEqual(write_action("a", "b", "c", "d"), "d_4")
write_action = self.router.initialize_write("test2", "127.0.0.1", 3942)
self.assertEqual(write_action("a", "b", "c", "d"), "d_5")
write_action = self.router.initialize_write("test3", "127.0.0.1", 3942)
self.assertEqual(write_action("a", "b", "c", "d"), "d_6")
def test_initialize_write_for_no_action(self):
write_action = self.router.initialize_write("test4", "127.0.0.1", 3942)
self.assertEqual(write_action, None)
