Merge pull request #15 from CreatCodeBuild/dev

Dev

Author: CreatCodeBuild

app.py

@@ -2,13 +2,19 @@
 
 if __name__ == '__main__':
 
+	app = app.App()
+
 	# A basic callback style API is provided
-	async def get_name(http, stream):
+	async def post_name(http, stream, parameters):
 		# this route essentially echo the data received back to client
 		print('data received:')
 		print(str(stream.data, encoding='utf8'))
 		await http.send_and_end(stream, stream.data)
+	app.post('name', post_name)
+
+	async def get_user(http, stream, parameters):
+		print(parameters)
+		await http.send_error(stream, 200)
+	app.get('user/{userId}', get_user)
 
-	app = app.App(static_file_handle='auto', root_route='index.html')
-	app.post('name', get_name)
 	app.up()

hyper2web/abstract.py

@@ -7,9 +7,6 @@ class AbstractApp:
     def up(self):
         raise NotImplementedError
 
-    def register_route(self, method: str, route: str, handler):
-        raise NotImplementedError
-
     def get(self, route: str, handler):
         raise NotImplementedError
 
@@ -18,3 +15,25 @@ def post(self, route: str, handler):
 
     async def handle_route(self, http, stream):
         raise NotImplementedError
+
+
+class AbstractRouter:
+    def register(self, method: str, route: str, handler):
+        raise NotImplementedError
+
+    async def handle_route(self, http, stream):
+        raise NotImplementedError
+
+
+class AbstractHTTP:
+    async def handle_event(self, event):
+        raise NotImplementedError
+
+    async def send_and_end(self, stream, data):
+        raise NotImplementedError
+
+    async def send_file(self, stream, file_path):
+        raise NotImplementedError
+
+    async def send_error(self, stream, error):
+        raise NotImplementedError

hyper2web/app.py

@@ -4,20 +4,42 @@
 
 from . import server, abstract
 from .http import HTTP, Stream
+from .router import Router
 
 AbstractApp = abstract.AbstractApp
 h2_server = server.h2_server
 
 
 class App(AbstractApp):
-	def __init__(self, port=5000, root='./public', static_file_handle='auto', root_route='index.html'):
+	def __init__(self, port=5000, root='./public',
+				 auto_serve_static_file=True,
+				 default_file='index.html', router=Router):
+		"""
+		:param port: TCP port 
+		:param root: root directory to serve
+		:param serve_static_file: automatically serve static files without manually register routes
+		:param default_file: default static file to serve 
+		:param router: the router class to use
+		"""
 		self.port = port
 		self.root = os.path.abspath(root)
-		self.routes = {'GET': {}, 'POST': {}}
 
 		# todo: implement static_file_handle and root_route
-		self.static_file_handle = static_file_handle
-		self.root_route = root_route
+		self.default_file = default_file
+
+		if auto_serve_static_file:
+			async def default_get(http, stream, parameters):
+				print('default_get')
+				route = stream.headers[':path'].lstrip('/')
+				full_path = os.path.join(self.root, route)
+				if os.path.exists(full_path):
+					await http.send_file(stream, full_path)
+				else:
+					await http.send_error(stream, 404)
+
+			self._router = router(default_get)
+		else:
+			self._router = router(None)
 
 	def up(self):
 		kernel = Kernel()
@@ -27,27 +49,12 @@ def up(self):
 							 app=self),
 				   shutdown=True)
 
-	def register_route(self, method: str, route: str, handler):
-		assert method in ['GET', 'POST']
-		self.routes[method][route] = handler
-
 	def get(self, route: str, handler):
-		self.register_route('GET', route, handler)
+		self._router.register('GET', route, handler)
 
 	def post(self, route: str, handler):
-		self.register_route('POST', route, handler)
+		self._router.register('POST', route, handler)
 
 	# async
 	async def handle_route(self, http: HTTP, stream: Stream):
-		print('app.App.handle_route')
-    
-		route = stream.headers[':path'].lstrip('/')
-		if route in self.routes['GET'] or route in self.routes['POST']:
-			await self.routes[stream.headers[':method']][route](http, stream)
-		else:
-			# if route is not registered, assume it is requesting files
-			full_path = os.path.join(self.root, route)
-			if os.path.exists(full_path):
-				await http.send_file(stream, full_path)
-			else:
-				await http.send_error(stream, 404)
+		await self._router.handle_route(http, stream)

hyper2web/http.py

@@ -12,7 +12,7 @@
 from h2 import events
 from h2.connection import H2Connection
 
-from .abstract import AbstractApp
+from .abstract import AbstractApp, AbstractHTTP
 
 READ_CHUNK_SIZE = 8192
 
@@ -60,7 +60,7 @@ def finalize(self):
 		self.buffered_data = None
 
 
-class HTTP:
+class HTTP(AbstractHTTP):
 	"""
 	This class further implements complete HTTP2 on top of h2
 	"""

hyper2web/router.py

@@ -0,0 +1,86 @@
+import os
+
+from .abstract import AbstractRouter
+from .http import HTTP, Stream
+
+
+class Router(AbstractRouter):
+	"""User should never construct Router"""
+
+	# todo: I may want to change the constructor
+	def __init__(self, default_get):
+		self._routes = {
+			'GET': {},
+			'POST': {}
+		}
+		self.default_get = default_get
+
+	def register(self, method: str, route: str, handler):
+		assert method in ['GET', 'POST']  # 这只是目前为了测试而加的限制
+		self._routes[method][route] = handler
+
+	def find_match(self, path: str):
+		"""
+		'user/{userId}' should match 'user/abc'
+		userId = abc
+		return a tuple (matched, parameters)
+		matched is the route which matches the incoming path
+		parameters is a dict of parameters and their values
+		"""
+		# todo: now the problem is how to implement it
+		# todo: pattern matching should be independent from :method,
+		# todo: but the current implementation doesn't support it. Should improve it later.
+		print(self._routes.values())
+		for routes_of_this_method in self._routes.values():
+			print(routes_of_this_method)
+			for route in routes_of_this_method:
+				matched, parameters = self._match(route, path)
+				if matched:
+					return route, parameters
+		return None, None
+
+	@classmethod
+	def _match(cls, route, path):
+		# todo: it seems like that regular expression is not necessary
+		# note: Could it be simpler? Could regex help?
+		route = route.split('/')
+		path = path.split('/')
+		if len(route) != len(path):
+			return False, None
+		else:
+			# todo: implement it
+			parameters = {}
+			for r, p in zip(route, path):
+				if r[0] == '{' and r[-1] == '}':
+					parameters[r[1:-1]] = p
+				elif r != p:
+					return False, None
+			return True, parameters
+
+	# async
+	async def handle_route(self, http: HTTP, stream: Stream):
+		print('app.App.handle_route')
+
+		path = stream.headers[':path'].lstrip('/')
+		method = stream.headers[':method']
+
+		route, parameters = self.find_match(path)
+		print('app.App.handle_route', route)
+
+		# 如果没有任何匹配，就默认为静态文件读取
+		if route is None:
+			if method == 'GET':
+				print('GET')
+				handler = self.default_get
+			else:
+				handler = None
+		else:
+			handler = self._routes[method].get(route, None)
+
+		if handler is not None:
+			print('handle')
+			print(handler)
+			await handler(http, stream, parameters)
+		else:
+			# maybe raise an error?
+			raise Exception(path, 'is not a valid request path')

hyper2web/server.py

@@ -9,7 +9,7 @@
 Requires Python 3.5+.
 """
 
-from curio import spawn
+from curio import spawn, socket
 
 import h2.config
 import h2.connection

test/test_Stream.py renamed to test/test_http.py

@@ -0,0 +1,66 @@
+import unittest
+
+from curio import Kernel
+
+from hyper2web.http import Stream
+from hyper2web.router import Router
+
+
+k = Kernel()
+
+class TestRouter(unittest.TestCase):
+
+	def test_raise_error_on_non_existing_route(self):
+		"""If a route doesn't exist, should raise error"""
+		router = Router(None, None)
+		stream = Stream(1, {':path': 'x', ':method': 'GET'})
+
+		# should raise a more specific error in the future
+		with self.assertRaises(Exception):
+			coroutine = router.handle_route(None, stream)
+			k.run(coroutine)
+
+	def test_get_existing_route(self):
+		router = Router(None, None)
+		stream = Stream(1, {':path': 'x', ':method': 'GET'})
+
+		async def f(http, stream):
+			assert http is None
+			assert stream.headers[':path'] == 'x'
+		router.get('x', f)
+		coroutine = router.handle_route(None, stream)
+		k.run(coroutine)
+
+	def test_post_existing_route(self):
+		router = Router(None, None)
+		stream = Stream(1, {':path': 'x', ':method': 'POST'})
+
+		async def f(http, stream):
+			assert http is None
+			assert stream.headers[':path'] == 'x'
+		router.post('x', f)
+		coroutine = router.handle_route(None, stream)
+		k.run(coroutine)
+
+	def test_match(self):
+		# match true
+		matched, parameters = Router._match('user/{userId}/name/{name}', 'user/123/name/John')
+		self.assertTrue(matched)
+		self.assertEqual(parameters['userId'], '123')
+		self.assertEqual(parameters['name'], 'John')
+
+		# match false
+		matched, parameters = Router._match('user/{userId}/name/{name}', 'user/123/nam/John')
+		self.assertFalse(matched)
+
+	def test_parameterized_route(self):
+		router = Router(None, None)
+		async def f(http, stream, parameters):
+			self.assertIsNone(http)
+			self.assertEqual(parameters['userId'], '123')
+			self.assertEqual(parameters['name'], 'John')
+		router.get('user/{userId}/name/{name}', f)
+		c = router.handle_route(None, Stream(1, {':path': 'user/123/name/John', ':method': 'GET'}))
+		k.run(c)
+
+	# will want to test with unicode