PK!nginx_conf_parser/__init__.pyPK!&^^nginx_conf_parser/context.py# coding=utf-8 class Context: content = '' def __init__(self, content): self.content = content self._parse() def _parse(self): if self.content is None: raise ValueError('Content not initialized') def _extract_values(self, directive_name): more = True while more: try: directive_begin_index = self.content.index(directive_name) directive_end_index = self.content.index(';', directive_begin_index) directive_name_value = self.content[directive_begin_index:directive_end_index + 1] directive_value = directive_name_value[len(directive_name):-1].strip() if isinstance(self.__getattribute__(directive_name), list): self.__getattribute__(directive_name).append(directive_value) else: self.__setattr__(directive_name, directive_value) self.content = self.content[:directive_begin_index] + self.content[directive_end_index + 1:] except ValueError: more = False PK! \\#nginx_conf_parser/events_context.py# coding=utf-8 import re class EventContext: accept_mutex_delay = None accept_mutex = None debug_connection = [] multi_accept = 'off' use = None worker_aio_requests = 32 worker_connections = 512 error_log = dict(file='logs/error.log', level='error') def __init__(self, content): # accept_mutex_delay delay = re.search(r'accept_mutex_delay\s*([^;]*)', content) self.accept_mutex_delay = delay.group(1) if delay else '500ms' # accept_mutex mutex = re.search(r'accept_mutex\s*(on|off);', content) self.accept_mutex = mutex.group(1) if mutex else 'off' # debug_connection debug = re.findall(r'debug_connection\s*([^;]*)', content) self.debug_connection = debug # multi_accept accept = re.search(r'multi_accept\s*(on|off);', content) self.multi_accept = accept.group(1) if accept else 'off' # use use = re.search(r'use\s+(select|poll|kqueue|epoll|/dev/poll|eventport);', content) self.use = use.group(1) if use else self.use # worker_aio_requests aio = re.search(r'worker_aio_requests\s*(\d+);', content) self.worker_aio_requests = int(aio.group(1)) if aio else 32 # worker_connections conn = re.search(r'worker_connections\s*(\d+);', content) self.worker_connections = int(conn.group(1)) if conn else 512 # error_log error_log = re.search( r'error_log\s*([^\s]*)\s*(debug|info|notice|warn|error|crit|alert|emerg)?;', content) if error_log: self.error_log = dict( file=error_log.group(1), level=error_log.group(2) if error_log.group(2) else 'error' ) else: self.error_log = dict( file='logs/error.log', level='error' ) PK!g!nginx_conf_parser/http_context.py# coding=utf-8 import re class HttpContext: servers = [] absolute_redirect = None def __init__(self, content): pass PK!!nginx_conf_parser/main_context.py# coding=utf-8 import re class MainContext: daemon = 'on' debug_points = None env = [] error_log = dict(file='logs/error.log', level='error') load_module = None lock_file = 'logs/nginx.lock' master_process = 'on' pcre_jit = 'off' pid = 'logs/nginx.pid' ssl_engine = None thread_pool = dict(name='default', threads=32, max_queue=65536) timer_resolution = None working_directory = None user = dict(user='nobody', group='nobody') worker_cpu_affinity = None worker_priority = 0 worker_processes = 1 worker_rlimit_core = None worker_rlimit_nofile = None worker_shutdown_timeout = None google_perftools_profiles = None def load(self, content): # daemon daemon = re.search(r'daemon\s+(on|off);', content) self.daemon = daemon.group(1) if daemon else self.daemon # debug_points dp = re.search(r'debug_points\s+(stop|abort);', content) self.debug_points = dp.group(1) if dp else self.debug_points # env env = re.findall(r'env\s+([a-zA-Z0-9=_]+);', content) self.env = env # error_log error_log = re.search( r'error_log\s+(([a-zA-Z0-9./\\\-]+)(\s+)?(debug|info|notice|warn|error|crit|alert|emerg)?);', content) if error_log: self.error_log['file'] = error_log.group(2) self.error_log['level'] = error_log.group(4) if error_log.group(4) else 'error' # load_module load_module = re.search(r'load_module\s+([a-zA-Z0-9\\/.\s]+);', content) self.load_module = load_module.group(1) if load_module else self.load_module # lock_file lock_file = re.search(r'lock_file\s+([a-zA-Z0-9\\/.\s\-]+);', content) self.lock_file = lock_file.group(1) if lock_file else self.lock_file # master_process master_process = re.search(r'master_process\s+(on|off);', content) self.master_process = master_process.group(1) if master_process else self.master_process # pcre_jit pcre = re.search(r'pcre_jit\s+(on|off);', content) self.pcre_jit = pcre.group(1) if pcre else self.pcre_jit # pid pid = re.search(r'pid\s+([a-zA-Z0-9\\/.\s\-]+);', content) self.pid = pid.group(1) if pid else self.pid # ssl_engine engine = re.search(r'ssl_engine\s+([a-zA-Z0-9\\/.\s\-]+);', content) self.ssl_engine = engine.group(1) if engine else self.ssl_engine # thread_pool pool = re.search(r'thread_pool\s+(([a-zA-Z0-9]+)\s+threads=([0-9]+)[\s+]?(max_queue=)?([0-9]+)?);', content) if pool: self.thread_pool['name'] = pool.group(2) self.thread_pool['threads'] = int(pool.group(3)) self.thread_pool['max_queue'] = int(pool.group(5)) if pool.group(5) else self.thread_pool.get('max_queue') # timer_resolution timer = re.search(r'timer_resolution\s+([0-9a-zA-Z]+);', content) self.timer_resolution = timer.group(1) if timer else self.timer_resolution # working_directory directory = re.search(r'working_directory\s+([a-zA-Z0-9/.\\_-]+);', content) self.working_directory = directory.group(1) if directory else self.working_directory # user user = re.search(r'user\s+([a-zA-Z0-9_\-]+)(\s+)?([a-zA-Z0-9_\-]+)?;', content) if user: self.user['user'] = user.group(1) self.user['group'] = user.group(3) if user.group(3) else user.group(1) # worker_cpu_affinity affinity = re.search(r'worker_cpu_affinity\s+([0-9a-zA-Z\s]+);', content) self.worker_cpu_affinity = affinity.group(1) if affinity else self.worker_cpu_affinity # worker_priority priority = re.search(r'worker_priority\s+([0-9]+);', content) self.worker_priority = int(priority.group(1)) if priority else self.worker_priority # worker_processes processes = re.search(r'worker_processes\s+([0-9]+);', content) self.worker_processes = int(processes.group(1)) if processes else self.worker_processes # worker_rlimit_core rlimit_core = re.search(r'worker_rlimit_core\s+([0-9a-zA-Z]+);', content) self.worker_rlimit_core = rlimit_core.group(1) if rlimit_core else self.worker_rlimit_core # worker_rlimit_nofile rlimit_nofile = re.search(r'worker_rlimit_nofile\s+([0-9]+);', content) self.worker_rlimit_nofile = int(rlimit_nofile.group(1)) if rlimit_nofile else self.worker_rlimit_nofile # worker_shutdown_timeout timemout = re.search(r'worker_shutdown_timeout\s+([a-zA-Z0-9]+);', content) self.worker_shutdown_timeout = timemout.group(1) if timemout else self.worker_shutdown_timeout # google_perftools_profiles pertools = re.search(r'google_perftools_profiles\s+([a-zA-Z0-9_.\-\\/]+);', content) self.google_perftools_profiles = pertools.group(1) if pertools else self.google_perftools_profiles PK!rrq[q[#nginx_conf_parser/server_context.py# coding=utf-8 import re class ServerContext: absolute_redirect = None aio = None aio_write = None chunked_transfer_encoding = None client_body_buffer_size = None client_body_in_file_only = None client_body_in_single_buffer = None client_body_temp_path = None client_body_timeout = None client_header_buffer_size = None client_header_timeout = None client_max_body_size = None connection_pool_size = None default_type = None directio = None directio_alignment = None disable_symlinks = None error_page = None etag = None if_modified_since = None ignore_invalid_headers = None keepalive_disable = None keepalive_requests = None keepalive_timeout = None large_client_header_buffers = None limit_rate = None limit_rate_after = None lingering_close = None lingering_time = None lingering_timeout = None listen = [] location = [] log_not_found = None log_subrequest = None max_ranges = None merge_slashes = None msie_padding = None msie_refresh = None open_file_cache = None open_file_cache_errors = None open_file_cache_min_uses = None open_file_cache_valid = None output_buffers = None port_in_redirect = None postpone_output = None read_ahead = None recursive_error_pages = None request_pool_size = None reset_timedout_connection = None resolver = None resolver_timeout = None root = None satisfy = None send_lowat = None send_timeout = None sendfile = None sendfile_max_chunk = None server_name_in_redirect = None server_tokens = None subrequest_output_buffer_size = None tcp_nodelay = None tcp_nopush = None try_files = None types = None types_hash_bucket_size = None types_hash_max_size = None underscores_in_headers = None variables_hash_bucket_size = None variables_hash_max_size = None def __init__(self, content): # extracting location directive self.location = [_ + '}' for _ in re.findall(r'(location[^}]*)', content)] self._content = content for loc in self.location: # TODO: parse directly location from here self._content = self._content.replace(loc, '') # absolute_redirect directive abs_redirect = re.search(r'absolute_redirect\s+(on|off);', self._content) self.absolute_redirect = abs_redirect.group(1) if abs_redirect else 'off' # aio directive aio = re.search(r'aio\s+(on|off|threads=?(.*)?);', self._content) self.aio = 'off' if aio: if aio.group(1) == 'on' or aio.group(1) == 'off': self.aio = aio.group(1) else: self.aio = dict(threads=True, pool=aio.group(2) if aio.group(2) else None) # aio_write directive awrite = re.search(r'aio_write\s+(on|off);', self._content) self.aio_write = awrite.group(1) if awrite else 'off' # chunked_transfer_encoding directive cte = re.search(r'chunked_transfer_encoding\s+(on|off);', self._content) self.chunked_transfer_encoding = cte.group(1) if cte else 'on' # client_body_buffer_size directive cbbs = re.search(r'client_body_buffer_size\s+([^;]*)', self._content) self.client_body_buffer_size = cbbs.group(1) if cbbs else '8k|16k' # client_body_in_file_only directive cbif = re.search(r'client_body_in_file_only\s+(on|off|clean);', self._content) self.client_body_in_file_only = cbif.group(1) if cbif else 'off' # client_body_in_single_buffer directive cbisb = re.search(r'client_body_in_single_buffer\s+(on|off);', self._content) self.client_body_in_single_buffer = cbisb.group(1) if cbisb else 'off' # client_body_temp_path directive cbtp = re.search(r'client_body_temp_path\s*([\w/_]*)\s*([^;]*)', self._content) if cbtp: self.client_body_temp_path = dict( path=cbtp.group(1), level1=None, level2=None, level3=None ) levels = re.findall(r'(\w*\s*)', cbtp.group(2)) if cbtp.group(2) else None if levels: for i in range(0, len(levels)): if levels[i]: self.client_body_temp_path.__setitem__('level{0}'.format(str(i + 1)), levels[i].strip()) else: self.client_body_temp_path = dict( path='client_body_temp', level1=None, level2=None, level3=None ) # client_body_timeout directive timeout = re.search(r'client_body_timeout\s+([^;]*)', self._content) self.client_body_timeout = timeout.group(1) if timeout else '60s' # client_header_buffer_size directive chbs = re.search(r'client_header_buffer_size\s+([^;]*)', self._content) self.client_header_buffer_size = chbs.group(1) if chbs else '1k' # client_header_timeout directive cht = re.search(r'client_header_timeout\s+([^;]*)', self._content) self.client_header_timeout = cht.group(1) if cht else '60s' # client_max_body_size directive cmbs = re.search(r'client_max_body_size\s+([^;]*)', self._content) self.client_max_body_size = cmbs.group(1) if cmbs else '1m' # connection_pool_size directive cps = re.search(r'connection_pool_size\s+([^;]*)', self._content) self.connection_pool_size = cps.group(1) if cps else '256|512' # default_type directive default_type = re.search(r'default_type\s+([^;]*)', self._content) self.default_type = default_type.group(1) if default_type else 'text/plain' # directio directive directio = re.search(r'directio\s+([^;]*)', self._content) self.directio = directio.group(1) if directio else 'off' # directio_alignment directive directio_alignment = re.search(r'directio_alignment\s+([^;]*)', self._content) self.directio_alignment = directio_alignment.group(1) if directio_alignment else '512' # disable_symlinks directive disable_symlinks = re.search(r'disable_symlinks\s+(off|on|if_not_owner)\s*([^;]*)', self._content) if disable_symlinks: self.disable_symlinks = dict( value=disable_symlinks.group(1), _from=disable_symlinks.group(2).split('from=')[1] if disable_symlinks.group(2) else None, ) if disable_symlinks.group(1) != 'off' else 'off' else: self.disable_symlinks = 'off' # error_page directive error_page = re.search(r'error_page\s+([^;]*)', self._content) if error_page: self.error_page = dict(codes='', uri=re.search(r'([^\s]*)$', error_page.group(1)).group(1)) self.error_page.__setitem__('codes', error_page.group(1).replace(self.error_page.get('uri'), '').strip()) else: self.error_page = None # etag directive etag = re.search(r'etag\s+(on|off);', self._content) self.etag = etag.group(1) if etag else 'on' # if_modified_since directive if_modified_since = re.search(r'if_modified_since\s+(off|exact|before);', self._content) self.if_modified_since = if_modified_since.group(1) if if_modified_since else 'exact' # ignore_invalid_headers directive ignore_invalid_headers = re.search(r'ignore_invalid_headers\s+(on|off)', self._content) self.ignore_invalid_headers = ignore_invalid_headers.group(1) if ignore_invalid_headers else 'on' # keepalive_disable directive keepalive_disable = re.search(r'keepalive_disable\s+([^;]*)', self._content) self.keepalive_disable = keepalive_disable.group(1) if keepalive_disable else 'msie6' # keepalive_requests directive keepalive_requests = re.search(r'keepalive_requests\s+(\d+);', self._content) self.keepalive_requests = int(keepalive_requests.group(1)) if keepalive_requests else 100 # keepalive_timeout directive keepalive_timeout = re.search(r'keepalive_timeout\s+([^;]*)', self._content) if keepalive_timeout: timeouts = re.findall(r'(\w+)', keepalive_timeout.group(1)) self.keepalive_timeout = dict( timeout=timeouts[0], header_timeout=timeouts[1] if len(timeouts) != 1 else None ) else: self.keepalive_timeout = dict( timeout='75s', header_timeout=None ) # large_client_header_buffers directive large_client_header_buffers = re.search(r'large_client_header_buffers\s+(\d+)\s+([^;]*)', self._content) self.large_client_header_buffers = dict( number=int(large_client_header_buffers.group(1)), size=large_client_header_buffers.group(2) ) if large_client_header_buffers else dict( number=4, size='8k' ) # limit_rate directive limit_rate = re.search(r'limit_rate\s+([^;]*)', self._content) self.limit_rate = limit_rate.group(1) if limit_rate else '0' # limit_rate_after directive limit_rate_after = re.search(r'limit_rate_after\s+([^;]*)', self._content) self.limit_rate_after = limit_rate_after.group(1) if limit_rate_after else '0' # lingering_close directive lingering_close = re.search(r'lingering_close\s+(on|off|always);', self._content) self.lingering_close = lingering_close.group(1) if lingering_close else 'on' # lingering_time directive lingering_time = re.search(r'lingering_time\s+([^;]*)', self._content) self.lingering_time = lingering_time.group(1) if lingering_time else '30s' # lingering_timeout directive lingering_timeout = re.search(r'lingering_timeout\s+([^;]*)', self._content) self.lingering_timeout = lingering_timeout.group(1) if lingering_timeout else '5s' # listen directive listens = re.findall(r'listen\s([^\s^;]*)([^;]*)', self._content) self.listen = [] if len(listens) == 0: self.listen.append(dict( value='*:80 | *:8000', default_server=False, )) else: for listen in listens: self.listen.append(dict( value=listen[0], default_server='default_server' in listen[1] if len(listen) == 2 else False, ssl='ssl' in listen[1] if len(listen) == 2 else False, http2='http2' in listen[1] if len(listen) == 2 else False, spdy='spdy' in listen[1] if len(listen) == 2 else False, proxy_protocol='proxy_protocol' in listen[1] if len(listen) == 2 else False, setfib=int(re.search(r'setfib=([^\s]*)', listen[1]).group(1)) if len(listen) == 2 and 'setfib' in listen[1] else None, fastopen=int(re.search(r'fastopen=([^\s]*)', listen[1]).group(1)) if len( listen) == 2 and 'fastopen' in listen[1] else None, backlog=int(re.search(r'backlog=([^\s]*)', listen[1]).group(1)) if len(listen) == 2 and 'backlog' in listen[1] else None, rcvbuf=re.search(r'rcvbuf=([^\s]*)', listen[1]).group(1) if len(listen) == 2 and 'rcvbuf' in listen[ 1] else None, sndbuf=re.search(r'sndbuf=([^\s]*)', listen[1]).group(1) if len(listen) == 2 and 'sndbuf' in listen[ 1] else None, accept_filter=re.search(r'accept_filter=([^\s]*)', listen[1]).group(1) if len( listen) == 2 and 'accept_filter' in listen[1] else None, deferred='deferred' in listen[1] if len(listen) == 2 else False, bind='bind' in listen[1] if len(listen) == 2 else False, ipv6only=re.search(r'ipv6only=(on|off)', listen[1]).group(1) if len(listen) == 2 and 'ipv6only' in listen[1] else 'on', reuseport='reuseport' in listen[1] if len(listen) == 2 else False, so_keepalive=re.search(r'so_keepalive=([^\s]*)', listen[1]).group(1) if len( listen) == 2 and 'so_keepalive' in listen[1] else None )) # log_not_found directive log_not_found = re.search(r'log_not_found\s+(on|off);', self._content) self.log_not_found = log_not_found.group(1) if log_not_found else 'on' # log_subrequest directive log_subrequest = re.search(r'log_subrequest\s+(on|off);', self._content) self.log_subrequest = log_subrequest.group(1) if log_subrequest else 'off' # max_ranges directive max_ranges = re.search(r'max_ranges\s+(\d+);', self._content) self.max_ranges = int(max_ranges.group(1)) if max_ranges else None # merge_slashes directive merge_slashes = re.search(r'merge_slashes\s+(on|off);', self._content) self.merge_slashes = merge_slashes.group(1) if merge_slashes else 'on' # msie_padding directive msie_padding = re.search(r'msie_padding\s+(on|off);', self._content) self.msie_padding = msie_padding.group(1) if msie_padding else 'on' # msie_refresh directive msie_refresh = re.search(r'msie_refresh\s+(on|off);', self._content) self.msie_refresh = msie_refresh.group(1) if msie_refresh else 'off' # open_file_cache directive open_file_cache = re.search(r'open_file_cache\s+(off|max=(\d+)\s*(inactive=(\w+))?)', self._content) if open_file_cache: if open_file_cache.group(2): self.open_file_cache = dict( max=int(open_file_cache.group(2)), inactive=open_file_cache.group(4) if open_file_cache.group(4) else None ) else: self.open_file_cache = 'off' else: self.open_file_cache = 'off' # open_file_cache_errors directive open_file_cache_errors = re.search(r'open_file_cache_errors\s+(on|off);', self._content) self.open_file_cache_errors = open_file_cache_errors.group(1) if open_file_cache_errors else 'off' # open_file_cache_min_uses directive open_file_cache_min_uses = re.search(r'open_file_cache_min_uses\s+(\d+);', self._content) self.open_file_cache_min_uses = int( open_file_cache_min_uses.group(1)) if open_file_cache_min_uses else 1 # open_file_cache_valid directive open_file_cache_valid = re.search(r'open_file_cache_valid\s+([^;]*)', self._content) self.open_file_cache_valid = open_file_cache_valid.group(1) if open_file_cache_valid else '60s' # output_buffers directive output_buffers = re.search(r'output_buffers\s+(\d+)\s+([^;]*)', self._content) self.output_buffers = dict( number=int(output_buffers.group(1)), size=output_buffers.group(2) ) if output_buffers else dict( number=2, size='32k' ) # port_in_redirect directive port_in_redirect = re.search(r'port_in_redirect\s+(on|off);', self._content) self.port_in_redirect = port_in_redirect.group(1) if port_in_redirect else 'on' # postpone_output directive postpone_output = re.search(r'postpone_output\s+([^;]*)', self._content) self.postpone_output = postpone_output.group(1) if postpone_output else '1460' # read_ahead directive read_ahead = re.search(r'read_ahead\s+([^;]*)', self._content) self.read_ahead = read_ahead.group(1) if read_ahead else '0' # recursive_error_pages directive recursive_error_pages = re.search(r'recursive_error_pages\s+(on|off);', self._content) self.recursive_error_pages = recursive_error_pages.group(1) if recursive_error_pages else 'off' # request_pool_size directive request_pool_size = re.search(r'request_pool_size\s+([^;]*)', self._content) self.request_pool_size = request_pool_size.group(1) if request_pool_size else '4k' # reset_timedout_connection directive reset_timedout_connection = re.search(r'reset_timedout_connection\s+(on|off);', self._content) self.reset_timedout_connection = reset_timedout_connection.group( 1) if reset_timedout_connection else 'off' # resolver directive resolver = re.search(r'resolver\s+([^;]*)', self._content) if resolver: valid = re.search(r'valid=(\w+)', resolver.group(1)) ipv6 = re.search(r'ipv6=(on|off)', resolver.group(1)) new_resolver = re.sub(r'valid=(\w+)', '', resolver.group(1)) new_resolver = re.sub(r'ipv6=(on|off)', '', new_resolver) self.resolver = dict( address=re.findall(r'([^\s]*)', new_resolver), valid=valid.group(1) if valid else None, ipv6=ipv6.group(1) if ipv6 else None ) else: self.resolver = None # resolver_timeout directive resolver_timeout = re.search(r'resolver_timeout\s+([^;]*)', self._content) self.resolver_timeout = resolver_timeout.group(1) if resolver_timeout else '30s' # root directive root = re.search(r'root\s+([^;]*)', self._content) self.root = root.group(1) if root else 'html' # satisfy directive satisfy = re.search(r'satisfy\s+(all|any);', self._content) self.satisfy = satisfy.group(1) if satisfy else 'all' # send_lowat directive send_lowat = re.search(r'send_lowat\s+([^;]*)', self._content) self.send_lowat = send_lowat.group(1) if send_lowat else '0' # send_timeout directive send_timeout = re.search(r'send_timeout\s+([^;]*)', self._content) self.send_timeout = send_timeout.group(1) if send_timeout else '60s' # sendfile directive sendfile = re.search(r'sendfile\s+(on|off);', self._content) self.sendfile = sendfile.group(1) if sendfile else 'off' # sendfile_max_chunk directive sendfile_max_chunk = re.search(r'sendfile_max_chunk\s+([^;]*)', self._content) self.sendfile_max_chunk = sendfile_max_chunk.group(1) if sendfile_max_chunk else '0' # server_name directive server_name = re.search(r'server_name\s+([^;]*)', self._content) self.server_name = re.findall(r'([^\s]+)', server_name.group(1)) if server_name else '' self.server_name = self.server_name[0] if len(self.server_name) == 1 else self.server_name # server_name_in_redirect directive server_name_in_redirect = re.search(r'server_name_in_redirect\s+(on|off);', self._content) self.server_name_in_redirect = server_name_in_redirect.group(1) if server_name_in_redirect else 'off' # server_tokens directive server_tokens = re.search(r'server_tokens\s+(on|off|build|[^;]*)', self._content) self.server_tokens = server_tokens.group(1) if server_tokens else 'on' # subrequest_output_buffer_size directive subrequest_output_buffer_size = re.search(r'subrequest_output_buffer_size\s+([^;]*)', self._content) self.subrequest_output_buffer_size = subrequest_output_buffer_size.group( 1) if subrequest_output_buffer_size else '4k|8k' # tcp_nodelay directive tcp_nodelay = re.search(r'tcp_nodelay\s+(on|off);', self._content) self.tcp_nodelay = tcp_nodelay.group(1) if tcp_nodelay else 'on' # tcp_nopush directive tcp_nopush = re.search(r'tcp_nopush\s+(on|off);', self._content) self.tcp_nopush = tcp_nopush.group(1) if tcp_nopush else 'off' # try_files directive try_files = re.search(r'try_files\s+([^;]*)', self._content) if try_files: self.try_files = re.findall(r'([^\s]+)', try_files.group(1)) if try_files else None self.try_files = self.try_files[0] if len(self.try_files) == 1 else self.try_files # types directive types = re.search(r'types\s+{([^}]*)', self._content) if types: self.types = dict() subdirectives = [_.strip() for _ in re.findall(r'([^;]+)', types.group(1)) if _.strip()] for subdirective in subdirectives: _ = re.findall(r'([^\s]+)', subdirective) for extension in _[1:]: self.types[extension] = _[0] # types_hash_bucket_size directive types_hash_bucket_size = re.search(r'types_hash_bucket_size\s+([^;]*)', self._content) self.types_hash_bucket_size = types_hash_bucket_size.group(1) if types_hash_bucket_size else '64' # types_hash_max_size directive types_hash_max_size = re.search(r'types_hash_max_size\s+([^;]*)', self._content) self.types_hash_max_size = types_hash_max_size.group(1) if types_hash_max_size else '1024' # underscores_in_headers directive underscores_in_headers = re.search(r'underscores_in_headers\s+(on|off);', self._content) self.underscores_in_headers = underscores_in_headers.group(1) if underscores_in_headers else 'off' # variables_hash_bucket_size directive variables_hash_bucket_size = re.search(r'variables_hash_bucket_size\s+([^;]*)', self._content) self.variables_hash_bucket_size = variables_hash_bucket_size.group( 1) if variables_hash_bucket_size else '64' # variables_hash_max_size directive variables_hash_max_size = re.search(r'variables_hash_max_size\s+([^;]*)', self._content) self.variables_hash_max_size = variables_hash_max_size.group(1) if variables_hash_max_size else '1024' PK!PP#nginx_conf_parser/stream_context.py# coding=utf-8 import re from .utils import extract_upstream_zone, extract_upstream_server_parameters, extract_context from .upstream_context import UpstreamContext class StreamContext: upstreams = [] servers = [] def load(self, content): # extracting upstreams upstreams = re.findall(r'upstream\s+([a-zA-Z]+)\s+{([^}]*)', content) for upstream in upstreams: self.upstreams.append(UpstreamContext(name=upstream[0], content=upstream[1])) to_append = dict(name=upstream[0], servers=[], zone=extract_upstream_zone(upstream[1])) # server directives servers = re.findall(r'server\s+([^;]*)', upstream[1]) for server in servers: to_append.get('servers').append( dict(address=re.search(r'^([0-9a-zA-Z.:/]+)', server).group(1), parameters=extract_upstream_server_parameters(server))) # state directive state = re.search(r'state\s+([^;]*)', upstream[1]) to_append['state'] = state.group(1) if state else None # hash directive hash = re.search(r'hash\s+([^;]*)', upstream[1]) if hash: consistent = 'consistent' in hash.group(1) to_append['hash'] = dict(consistent=consistent, key=hash.group(1).split('consistent')[0].strip()) # ip_hash to_append['ip_hash'] = 'ip_hash' in upstream[1] # keep_alive connections; keep_alive = re.search(r'keep_alive\s+([^;]*)', upstreams[1]) to_append['keep_alive'] = keep_alive.group(1) if keep_alive else None self.upstreams.append(to_append) # extracting servers servers = re.findall(r'server\s+{([^}]*)', content) if __name__ == '__main__': from os.path import dirname from core.utils import extract_context with open('{0}/../tests/features/nginx_stream_sample.conf'.format(dirname(__file__))) as f: stream_string = extract_context(f, 'stream') stream_context = StreamContext() stream_context.load(stream_string) PK!YU %nginx_conf_parser/upstream_context.py# coding=utf-8 import re from .utils import extract_upstream_zone class UpstreamContext: name = None servers = [] zone = None state = None hash = None ip_hash = False keepalive = None keepalive_requests = 100 keepalive_timeout = '60s' ntlm = False least_conn = False least_time = None queue = None random = None sticky = None def __init__(self, name, content): self.name = name # zone directive self.zone = extract_upstream_zone(content) # server directive self.servers = [] servers = re.findall(r'server\s+([^\s]*)\s*([^;]*)', content) for server in servers: self.servers.append({ 'address': server[0], 'parameters': {_[0]: _[1] if _[1] != '' else True for _ in re.findall(r'(\w*)=*(\w*)', server[1]) if _[0] != ''} }) # state directive state = re.search(r'state\s+([^;]*)', content) self.state = state.group(1) if state else self.state # hash directive hash_ = re.search(r'hash\s+([^\s]*)\s*(consistent)*;', content) self.hash = dict(key=hash_.group(1), consistent=True if hash_.group(2) else False) if hash_ else self.hash # ip_hash directive self.ip_hash = 'ip_hash;' in content # keepalive directive keepalive = re.search(r'keepalive\s+(\d+);', content) self.keepalive = int(keepalive.group(1)) if keepalive else None # keekpalive_requests directive keepalive_requests = re.search(r'keepalive_requests\s+(\d+);', content) self.keepalive_timeout = int(keepalive_requests.group(1)) if keepalive_requests else 100 # keepalive_timeout directive keepalive_timeout = re.search(r'keepalive_timeout\s+(\w);', content) self.keepalive_timeout = keepalive_timeout.group(1) if keepalive_timeout else '60s' # ntlm directive self.ntlm = 'ntlm;' in content # least_conn directive self.least_conn = 'least_conn;' in content # least_time self.least_time = None least_time = re.search(r'least_time\s+([^;]*)', content) self.least_time = dict(header='header' in least_time.group(1), last_byte='last_byte' in least_time.group(1), inflight='inflight' in least_time.group(1)) \ if least_time else self.least_time # queue directive queue = re.search(r'queue\s+(\d+)\s*(timeout=(\w+))?;', content) self.queue = dict(value=int(queue.group(1)), timeout=queue.group(3) if queue.group(3) else '60s') if queue else None # random directive random = re.search(r'random\s*(two)?\s*([^;]*)', content) self.random = dict(two=True if random.group(1) else False, method=random.group(2) if random.group(2) else None) if random else None # sticky directive sticky = re.search(r'sticky\s*(cookie|route|learn)\s*([^;]*)', content) if sticky: # sticky cookie if 'cookie' == sticky.group(1): self.sticky = dict( type='cookie', name=re.search(r'^([^\s]*)', sticky.group(2)).group(1), expires=re.search(r'expires=([^\s]*)', sticky.group(2)).group(1) if 'expires' in sticky.group( 2) else None, domain=re.search(r'domain=([^\s]*)', sticky.group(2)).group(1) if 'domain' in sticky.group( 2) else None, httponly='httponly' in sticky.group(2), secure='secure' in sticky.group(2), path=re.search(r'path=([^\s]*)', sticky.group(2)).group(1) if 'path' in sticky.group(2) else None ) elif 'route' == sticky.group(1): self.sticky = dict( type='route', variables=re.findall(r'(\$\w+)', sticky.group(2)) ) elif 'learn' == sticky.group(1): zone = re.search(r'zone=([^\s]*)', sticky.group(2)).group(1) self.sticky = dict( type='learn', create=re.search(r'create=([^\s]*)', sticky.group(2)).group(1), zone=dict(name=zone.split(':')[0], size=zone.split(':')[1]), lookup=re.search(r'lookup=([^\s]*)', sticky.group(2)).group(1), timeout=re.search(r'timeout=([^\s]*)', sticky.group(2)).group(1) if 'timeout' in sticky.group( 2) else None, header='header' in sticky.group(2), sync='sync' in sticky.group(2) ) PK!?z nginx_conf_parser/utils.py# coding=utf-8 import re from _io import TextIOWrapper def extract_context(conffile, context_name): if not isinstance(conffile, TextIOWrapper) and not isinstance(conffile, str): raise TypeError('Invalid configuration file given, must be a file stream or a string') if isinstance(conffile, TextIOWrapper): content = conffile.read().replace('\n', ' ') else: content = conffile.replace('\n', ' ') try: context_begin_index = re.search(context_name + '\s+{', content).start() context_string = '' depth = 0 for c in content[context_begin_index:]: if c == '{': depth += 1 context_string += c continue if c == '}': depth -= 1 context_string += c if depth == 0: break else: continue context_string += c return context_string except AttributeError: return '' def extract_upstream_server_parameters(to_parse): parameters = {} # weight=number weight = re.search(r'weight=([0-9]+)', to_parse) parameters['weight'] = int(weight.group(1)) if weight else None # max_conns=number max_conns = re.search(r'max_conns=([0-9]+)', to_parse) parameters['max_conns'] = int(max_conns.group(1)) if max_conns else None # max_fails=number max_fails = re.search(r'max_fails=([0-9]+)', to_parse) parameters['max_fails'] = int(max_fails.group(1)) if max_conns else None # fail_timeout=time fail_timeout = re.search(r'fail_timeout=([0-9a-zA-Z]+)', to_parse) parameters['fail_timeout'] = fail_timeout.group(1) if fail_timeout else None # backup, down, resolve, drain parameters['backup'] = 'backup' in to_parse parameters['down'] = 'down' in to_parse parameters['resolve'] = 'resolve' in to_parse parameters['drain'] = 'drain' in to_parse # route=string route = re.search(r'route=([a-zA-Z0-9.-_\\/]+)', to_parse) parameters['route'] = route.group(1) if route else None # service=string service = re.search(r'service=([a-zA-Z0-9.-_\\/]+)', to_parse) parameters['service'] = service.group(1) if service else None # slow_start=time slow_start = re.search(r'slow_start=([a-zA-Z0-9]+)', to_parse) parameters['slow_start'] = slow_start.group(1) if slow_start else None return parameters def extract_upstream_zone(to_parse): zone = re.search(r'zone\s+([a-zA-Z0-9_\-.]+)\s*?([a-z0-9]+)?;', to_parse) return dict(name=zone.group(1), size=zone.group(2)) if zone and zone.group(2) else \ dict(name=zone.group(1), size=None) if zone else None PK!J7;11)nginx_conf_parser-0.1.1.dist-info/LICENSECopyright (c) 2018 The Python Packaging Authority Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.PK!HnHTU'nginx_conf_parser-0.1.1.dist-info/WHEEL A н#Z;/"d&F[xzw@Zpy3Fv]\fi4WZ^EgM_-]#0(q7PK!H7d*nginx_conf_parser-0.1.1.dist-info/METADATASKo0Wq!Rct RDTJ۲l 8xcڛ-=xV3o`Ъ/d P7yUfXwű2HP96oX8a2H#xG܈Zh G{ JmؒJK%X l `?ؗsLt>5 8{c* ,|Eߞ9DgsN4^\.DtN@VsˤLbx4?*d6q2j25S?ͪ0 p0mUV<ƃ`=xBM2p]?DW3܏vepy%iG]SɜMȒJP/)oQ4n´tjZ6ogf= vH$fx5) PK!HMu[jo(nginx_conf_parser-0.1.1.dist-info/RECORDˎP}? tEhD@E؜pӏt"t*U.`ܢ vOo |fC])hnHöHNSlNp;ӽ`.^ yH/[àn SL 0m$< :m@V-AӴc;ԉq$^A|Yoy7uE֖]ad*njr!X^\-CQ?HFpνNX¨͵fsE$wYIdk+;W>:{I% !^yݸp]"hg~i}s,'ҵFL6n-vhz Hmu nIҿAֶSBE>)S9 ^'fI%u %QeQ/PK!nginx_conf_parser/__init__.pyPK!&^^;nginx_conf_parser/context.pyPK! \\#nginx_conf_parser/events_context.pyPK!g!p nginx_conf_parser/http_context.pyPK!!: nginx_conf_parser/main_context.pyPK!rrq[q[#!nginx_conf_parser/server_context.pyPK!PP#|nginx_conf_parser/stream_context.pyPK!YU %Cnginx_conf_parser/upstream_context.pyPK!?z Bnginx_conf_parser/utils.pyPK!J7;11)!nginx_conf_parser-0.1.1.dist-info/LICENSEPK!HnHTU'nginx_conf_parser-0.1.1.dist-info/WHEELPK!H7d*2nginx_conf_parser-0.1.1.dist-info/METADATAPK!HMu[jo(?nginx_conf_parser-0.1.1.dist-info/RECORDPK