def dist_metainfo_dict(dist):
"""Convert an Egg's PKG-INFO into a dict"""
from rfc822 import Message
from cStringIO import StringIO
distmetadata = dist.get_metadata('PKG-INFO')
msg = Message(StringIO(distmetadata))
return dict(msg.items())
def dist_metainfo_dict(dist):
"""Convert an Egg's PKG-INFO into a dict"""
if sys.version_info > (3, 0):
from email.parser import Parser
from email.policy import default
distmetadata = dist.get_metadata('PKG-INFO')
return Parser(policy=default).parsestr(distmetadata)
else:
from rfc822 import Message
from cStringIO import StringIO
distmetadata = dist.get_metadata('PKG-INFO')
msg = Message(StringIO(distmetadata))
return dict(msg.items())
def _load_state_from_file(self, file):
self.attrs = {}
self.message = Message(file)
for k in self.message.keys():
if self.schema is None:
if len(self.message.getheaders(k)) == 1:
self.attrs[k] = self.message.getheader(k)
else:
self.attrs[k] = self.message.getheaders(k)
elif k in self.schema:
if issubclass(self.schema[k], String):
self.attrs[k] = self.message.getheader(k)
elif issubclass(self.schema[k], Tokens):
self.attrs[k] = self.message.getheaders(k)
def iter_plugininfo():
"""
Iterate over the plugins loaded so far
"""
from rfc822 import Message
from cStringIO import StringIO
global plugin_directories
for plugin_dir in plugin_directories:
for dist in find_distributions(plugin_dir):
distmetadata = dist.get_metadata('PKG-INFO')
msg = Message(StringIO(distmetadata))
filtered_keys = ['metadata-version', 'home-page', 'platform']
distinfo = filter(lambda x: x[0] not in filtered_keys, msg.items())
yield dist, dict(distinfo)
def parse_body(self, file, boundary):
total_bytes = 0 # total bytes read from 'file'
done = 0
while not done:
headers = Message(file)
cdisp = headers.get('content-disposition')
if not cdisp:
raise RequestError("expected Content-Disposition header "
"in body sub-part")
(name, filename) = self.parse_content_disposition(cdisp)
if filename:
content_type = headers.get('content-type')
done = self.handle_upload(name, filename, file,
boundary, content_type)
else:
done = self.handle_regular_var(name, file, boundary)
def handle(self):
try:
raw_requestline = self.rfile.readline(self.MAX_REQUEST_LINE)
except SocketError:
# "Connection reset by peer" or other socket errors aren't interesting here
return False
if not raw_requestline:
return False
if len(raw_requestline) >= self.MAX_REQUEST_LINE:
self.socket.sendall(self.REQUEST_TOO_LONG_RESPONSE)
return False
if not self._request_check(raw_requestline):
self.socket.sendall(self.BAD_REQUEST_RESPONSE)
return False
# TODO: move self.rfile to FileObjectThread when available, otherwise is blocking
self.message = Message(self.rfile, 0)
host = self.message.get('Host', '')
if ':' in host:
host, port = host.split(':', 1)
host = host.strip()
proxy_to = self.config.get_vhost(host)
if not proxy_to:
self.socket.sendall(self.NOT_FOUND_RESPONSE)
self.message.fp.close()
return False
ProxyStream(raw_requestline, self.message, self.socket, proxy_to).start()
def get_client_data(self, request):
buflen = 8072
rfile = StringIO()
# get header
buf = request.recv(buflen)
rfile.write(buf)
rfile.seek(0)
headers = Message(rfile,1)
rfile.seek(0, os.SEEK_END)
if headers.get('content_length'):
clen = int(headers.get('content_length'))
buf = request.recv(clen)
rfile.write(buf)
return rfile.getvalue()
def __init__(self, patchfile, signoff_mode):
self.patchfile = patchfile
try:
self.message = Message(file(patchfile))
except IOError:
self.message = None
self.signoff_mode = signoff_mode
self.prepare()
self.read()
def filterMessage(self):
"""Override this.
A trivial example is included.
"""
try:
m = Message(open(self.messageFilename))
self.sendLine('200 Ok')
except:
trace_dump()
self.sendLine('435 %s processing error' % FILTERNAME)
def _load_state_from_file(self, file):
self.attrs = {}
self.message = Message(file)
for k in self.message.keys():
if self.schema is None:
if len(self.message.getheaders(k)) == 1:
self.attrs[k] = self.message.getheader(k)
else:
self.attrs[k] = self.message.getheaders(k)
elif k in self.schema:
if issubclass(self.schema[k], String):
self.attrs[k] = self.message.getheader(k)
elif issubclass(self.schema[k], Tokens):
self.attrs[k] = self.message.getheaders(k)
def iter_plugininfo():
"""
Iterate over the plugins loaded so far
"""
if sys.version_info > (3, 0):
from email.parser import Parser
from email.policy import default
else:
from rfc822 import Message # pylint: disable=import-error
from cStringIO import StringIO # pylint: disable=import-error
for plugin_dir in PLUGIN_DIRECTORIES:
for dist in find_distributions(plugin_dir):
distmetadata = dist.get_metadata('PKG-INFO')
if sys.version_info > (3, 0):
msg = Parser(policy=default).parsestr(distmetadata)
else:
msg = Message(StringIO(distmetadata))
filtered_keys = ['metadata-version', 'home-page', 'platform']
distinfo = [x for x in list(msg.items()) if x[0] not in filtered_keys]
yield dist, dict(distinfo)
def parse(self):
f = open(self.filename, 'r')
headers = Message(f)
c = f.read()
f.close()
if not c.strip():
c = headers.get_payload()
if not headers.keys():
raise Exception("File %s has no headers" % self.filename)
self.description = headers['Description']
self.expect = headers.get('Expect', '')
self.ignore = headers.get('Ignore')
self.options = [
o.strip() for o in headers.get('Options', '').split(',')
if o.strip()
]
parts = bar_re.split(c)
self.input = parts[0].rstrip() + '\n'
if parts[1:]:
self.expect = parts[1].rstrip() + '\n'
else:
self.expect = None
def parse(self):
f = open(self.filename, "r")
headers = Message(f)
c = f.read()
f.close()
if not c.strip():
c = headers.get_payload()
if not headers.keys():
raise Exception("File %s has no headers" % self.filename)
self.description = headers["Description"]
self.expect = headers.get("Expect", "")
self.ignore = headers.get("Ignore")
self.options = [
o.strip() for o in headers.get("Options", "").split(",")
if o.strip()
]
parts = bar_re.split(c)
self.input = parts[0].rstrip() + "\n"
if parts[1:]:
self.expect = parts[1].rstrip() + "\n"
else:
self.expect = None
def parse(self):
f = open(self.filename, 'r')
headers = Message(f)
c = f.read()
f.close()
if not c.strip():
c = headers.get_payload()
if not headers.keys():
raise Exception(
"File %s has no headers" % self.filename)
self.description = headers['Description']
self.expect = headers.get('Expect', '')
self.ignore = headers.get('Ignore')
self.options = [
o.strip() for o in headers.get('Options', '').split(',')
if o.strip()]
parts = bar_re.split(c)
self.input = parts[0].rstrip() + '\n'
if parts[1:]:
self.expect = parts[1].rstrip() + '\n'
else:
self.expect = None
class RFC822File(TextFile):
""" holds a rfc822 Message """
attrs = {}
message = None
list_types = (type([]), type(()))
str_types = (type(''), )
def new(self, **kw):
if 'attrs' in kw.keys():
self.set_attrs(kw['attrs'])
def _load_state_from_file(self, file):
self.attrs = {}
self.message = Message(file)
for k in self.message.keys():
if self.schema is None:
if len(self.message.getheaders(k)) == 1:
self.attrs[k] = self.message.getheader(k)
else:
self.attrs[k] = self.message.getheaders(k)
elif k in self.schema:
if issubclass(self.schema[k], String):
self.attrs[k] = self.message.getheader(k)
elif issubclass(self.schema[k], Tokens):
self.attrs[k] = self.message.getheaders(k)
def to_str(self):
data = ''
list_types = (type([]), type(()))
str_types = (type(''), )
for key, val in self.attrs.items():
if type(val) in str_types:
data += '%s: %s\n' % (key, val)
elif type(val) in list_types:
# a new line for each item of the list
for v in val:
data += '%s: %s\n' % (key, v)
return data
#######################################################################
# API
#######################################################################
def set_attrs(self, attrs):
# Check types of values
type_error_msg = 'One of the given values is not compatible'
for key, val in attrs.items():
if type(val) in self.list_types:
for v in val:
if type(v) not in self.str_types:
raise TypeError, type_error_msg
elif self.schema is not None and key not in self.schema:
del attrs[key]
# Now attrs is sure
self.attrs = attrs
self.set_changed()
def get_attrs(self):
if self.schema is not None:
for key in self.schema:
if key not in self.attrs:
self.attrs[key] = self.schema[key].get_default()
return self.attrs
class RequestRouter(object):
MAX_REQUEST_LINE = 8192
REQUEST_TOO_LONG_RESPONSE = "HTTP/1.0 414 Request URI Too Long\r\nConnection: close\r\nContent-length: 0\r\n\r\n"
BAD_REQUEST_RESPONSE = "HTTP/1.0 400 Bad Request\r\nConnection: close\r\nContent-length: 0\r\n\r\n"
NOT_FOUND_RESPONSE = "HTTP/1.1 404 Not Found\r\n\r\n"
def __init__(self, config, socket):
self.config = config
self.socket = gevent.socket.socket(_sock=socket)
self.rfile = self.socket.makefile('rb', -1)
self.message = None
def close(self):
self.rfile.close()
self.socket.close()
if self.message is not None:
self.message.fp.close()
def handle(self):
try:
raw_requestline = self.rfile.readline(self.MAX_REQUEST_LINE)
except SocketError:
# "Connection reset by peer" or other socket errors aren't interesting here
return False
if not raw_requestline:
return False
if len(raw_requestline) >= self.MAX_REQUEST_LINE:
self.socket.sendall(self.REQUEST_TOO_LONG_RESPONSE)
return False
if not self._request_check(raw_requestline):
self.socket.sendall(self.BAD_REQUEST_RESPONSE)
return False
# TODO: move self.rfile to FileObjectThread when available, otherwise is blocking
self.message = Message(self.rfile, 0)
host = self.message.get('Host', '')
if ':' in host:
host, port = host.split(':', 1)
host = host.strip()
proxy_to = self.config.get_vhost(host)
if not proxy_to:
self.socket.sendall(self.NOT_FOUND_RESPONSE)
self.message.fp.close()
return False
ProxyStream(raw_requestline, self.message, self.socket, proxy_to).start()
def _request_check(self, reqline):
try:
command, path, version = reqline.split()
if version.strip() not in ('HTTP/1.0', 'HTTP/1.1'):
return False
return True
except:
return False
class RFC822File(TextFile):
""" holds a rfc822 Message """
attrs = {}
message = None
list_types = (type([]), type(()))
str_types = (type(''),)
def new(self, **kw):
if 'attrs' in kw.keys():
self.set_attrs(kw['attrs'])
def _load_state_from_file(self, file):
self.attrs = {}
self.message = Message(file)
for k in self.message.keys():
if self.schema is None:
if len(self.message.getheaders(k)) == 1:
self.attrs[k] = self.message.getheader(k)
else:
self.attrs[k] = self.message.getheaders(k)
elif k in self.schema:
if issubclass(self.schema[k], String):
self.attrs[k] = self.message.getheader(k)
elif issubclass(self.schema[k], Tokens):
self.attrs[k] = self.message.getheaders(k)
def to_str(self):
data = ''
list_types = (type([]), type(()))
str_types = (type(''),)
for key, val in self.attrs.items():
if type(val) in str_types:
data += '%s: %s\n' % (key, val)
elif type(val) in list_types:
# a new line for each item of the list
for v in val:
data += '%s: %s\n' % (key, v)
return data
#######################################################################
# API
#######################################################################
def set_attrs(self, attrs):
# Check types of values
type_error_msg = 'One of the given values is not compatible'
for key, val in attrs.items():
if type(val) in self.list_types:
for v in val:
if type(v) not in self.str_types:
raise TypeError, type_error_msg
elif self.schema is not None and key not in self.schema:
del attrs[key]
# Now attrs is sure
self.attrs = attrs
self.set_changed()
def get_attrs(self):
if self.schema is not None:
for key in self.schema:
if key not in self.attrs:
self.attrs[key] = self.schema[key].get_default()
return self.attrs
