| #!/usr/bin/env python |
| # |
| # Copyright 2007 Google Inc. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| """Contains logic for writing handlers to app.yaml. |
| |
| Information about handlers comes from static file paths, appengine-web.xml, |
| and web.xml. This information is packaged into Handler objects which specify |
| paths and properties about how they are handled. |
| |
| In this module: |
| GenerateYamlHandlers: Returns Yaml string with handlers. |
| HandlerGenerator: Ancestor class for creating handler lists. |
| DynamicHandlerGenerator: Creates handlers from web-xml servlet and filter |
| mappings. |
| StaticHandlerGenerator: Creates handlers from static file includes and |
| static files. |
| """ |
| |
| from google.appengine.api import appinfo |
| from google.appengine.tools import handler |
| from google.appengine.tools.app_engine_config_exception import AppEngineConfigException |
| |
| API_ENDPOINT_REGEX = '/_ah/spi/*' |
| |
| |
| def GenerateYamlHandlersList(app_engine_web_xml, web_xml, static_files): |
| """Produces a list of Yaml strings for dynamic and static handlers.""" |
| welcome_properties = _MakeWelcomeProperties(web_xml, static_files) |
| static_handler_generator = StaticHandlerGenerator( |
| app_engine_web_xml, web_xml, welcome_properties) |
| dynamic_handler_generator = DynamicHandlerGenerator( |
| app_engine_web_xml, web_xml) |
| |
| handler_length = len(dynamic_handler_generator.GenerateOrderedHandlerList()) |
| if static_files: |
| handler_length += len(static_handler_generator.GenerateOrderedHandlerList()) |
| if handler_length > appinfo.MAX_URL_MAPS: |
| |
| |
| |
| |
| dynamic_handler_generator.fall_through = True |
| dynamic_handler_generator.welcome_properties = {} |
| |
| yaml_statements = ['handlers:'] |
| if static_files: |
| yaml_statements += static_handler_generator.GetHandlerYaml() |
| yaml_statements += dynamic_handler_generator.GetHandlerYaml() |
| |
| return yaml_statements |
| |
| |
| def GenerateYamlHandlersListForDevAppServer( |
| app_engine_web_xml, web_xml, static_urls): |
| r"""Produces a list of Yaml strings for dynamic and static handlers. |
| |
| This variant of GenerateYamlHandlersList is for the Dev App Server case. |
| The key difference there is that we serve files directly from the war |
| directory rather than constructing a parallel hierarchy with a special |
| __static__ directory. Since app.yaml doesn't support excluding URL patterns |
| and appengine-web.xml does, this means that we have to define patterns that |
| cover exactly the set of static files we want without pulling in any files |
| that are not supposed to be served as static files. |
| |
| Args: |
| app_engine_web_xml: an app_engine_web_xml_parser.AppEngineWebXml object. |
| web_xml: a web_xml_parser.WebXml object. |
| static_urls: a list of two-item tuples where the first item is a URL pattern |
| string for a static file, such as '/stylesheets/main\.css', and the |
| second item is the app_engine_web_xml_parser.StaticFileInclude |
| representing the <static-files><include> XML element that caused that URL |
| pattern to be included in the list. |
| |
| Returns: |
| A list of strings that together make up the lines of the generated app.yaml |
| file. |
| """ |
| |
| |
| |
| |
| |
| |
| |
| appinfo.MAX_URL_MAPS = 10000 |
| static_handler_generator = StaticHandlerGeneratorForDevAppServer( |
| app_engine_web_xml, web_xml, static_urls) |
| dynamic_handler_generator = DynamicHandlerGenerator( |
| app_engine_web_xml, web_xml) |
| return (['handlers:'] + |
| static_handler_generator.GetHandlerYaml() + |
| dynamic_handler_generator.GetHandlerYaml()) |
| |
| |
| def _MakeWelcomeProperties(web_xml, static_files): |
| """Makes the welcome_properties dict given web_xml and the static files. |
| |
| Args: |
| web_xml: a parsed web.xml that may contain a <welcome-file-list> clause. |
| static_files: the list of all static files found in the app. |
| |
| Returns: |
| A dict with a single entry where the key is 'welcome' and the value is |
| either None or a tuple of the file names in all the <welcome-file> clauses |
| that were retained. A <welcome-file> clause is retained if its file name |
| matches at least one actual file in static_files. |
| |
| For example, if the input looked like this: |
| <welcome-file-list> |
| <welcome-file>index.jsp</welcome-file> |
| <welcome-file>index.html</welcome-file> |
| </welcome-file-list> |
| and if there was a file /foo/bar/index.html but no file called index.jsp |
| anywhere in static_files, the result would be {'welcome': ('index.html',)}. |
| """ |
| static_welcome_files = [] |
| for welcome_file in web_xml.welcome_files: |
| if any(f.endswith('/' + welcome_file) for f in static_files): |
| static_welcome_files.append(welcome_file) |
| |
| welcome_value = tuple(static_welcome_files) or None |
| return {'welcome': welcome_value} |
| |
| |
| class HandlerGenerator(object): |
| """Ancestor class for StaticHandlerGenerator and DynamicHandlerGenerator. |
| |
| Contains shared functionality. Both static and dynamic handler generators |
| work in a similar way. Both obtain a list of patterns, static includes and |
| web.xml servlet url patterns, respectively, add security constraint info to |
| those lists, sort them, and then generate Yaml statements for each entry. |
| """ |
| |
| def __init__(self, app_engine_web_xml, web_xml): |
| self.app_engine_web_xml = app_engine_web_xml |
| self.web_xml = web_xml |
| |
| def GetHandlerYaml(self): |
| handler_yaml = [] |
| for h in self.GenerateOrderedHandlerList(): |
| handler_yaml += self.TranslateHandler(h) |
| return handler_yaml |
| |
| def GenerateSecurityConstraintHandlers(self): |
| """Creates Handlers for security constraint information.""" |
| handler_list = [] |
| for constraint in self.web_xml.security_constraints: |
| props = {'transport_guarantee': constraint.transport_guarantee, |
| 'required_role': constraint.required_role} |
| for pattern in constraint.patterns: |
| security_handler = handler.SimpleHandler(pattern, props) |
| handler_list.append(security_handler) |
| handler_list += self.CreateHandlerWithoutTrailingStar(security_handler) |
| return handler_list |
| |
| def GenerateWelcomeFileHandlers(self): |
| """Creates handlers for welcome files.""" |
| if not self.welcome_properties: |
| return [] |
| |
| |
| |
| return [handler.SimpleHandler('/', self.welcome_properties), |
| handler.SimpleHandler('/*/', self.welcome_properties)] |
| |
| def TranslateAdditionalOptions(self, h): |
| """Generates Yaml statements from security constraint information.""" |
| additional_statements = [] |
| |
| required_role = h.GetProperty('required_role', default='none') |
| required_role_translation = {'none': 'optional', |
| '*': 'required', |
| 'admin': 'admin'} |
| additional_statements.append( |
| ' login: %s' % required_role_translation[required_role]) |
| |
| transport_guarantee = h.GetProperty('transport_guarantee', default='none') |
| |
| if transport_guarantee == 'none': |
| if self.app_engine_web_xml.ssl_enabled: |
| additional_statements.append(' secure: optional') |
| else: |
| additional_statements.append(' secure: never') |
| else: |
| if self.app_engine_web_xml.ssl_enabled: |
| additional_statements.append(' secure: always') |
| else: |
| raise AppEngineConfigException( |
| 'SSL must be enabled in appengine-web.xml to use ' |
| 'transport-guarantee') |
| |
| handler_id = self.web_xml.pattern_to_id.get(h.pattern) |
| if handler_id and handler_id in self.app_engine_web_xml.api_endpoints: |
| additional_statements.append(' api_endpoint: True') |
| return additional_statements |
| |
| def CreateHandlerWithoutTrailingStar(self, h): |
| """Creates identical handler without trailing star in pattern. |
| |
| According to servlet spec, baz/* should match baz. |
| |
| Args: |
| h: a Handler. |
| Returns: |
| If h.pattern is of form "baz/*", returns a singleton list with a |
| SimpleHandler with pattern "baz" and the properties of h. Otherwise, |
| returns an empty list. |
| """ |
| if len(h.pattern) <= 2 or h.pattern[-2:] != '/*': |
| return [] |
| return [handler.SimpleHandler(h.pattern[:-2], h.properties)] |
| |
| |
| class DynamicHandlerGenerator(HandlerGenerator): |
| """Generates dynamic handler yaml entries for app.yaml.""" |
| |
| def __init__(self, app_engine_web_xml, web_xml): |
| super(DynamicHandlerGenerator, self).__init__(app_engine_web_xml, web_xml) |
| if any([self.web_xml.fall_through_to_runtime, |
| '/' in self.web_xml.patterns, |
| '/*' in self.web_xml.patterns]): |
| self.fall_through = True |
| self.welcome_properties = {} |
| else: |
| self.fall_through = False |
| self.welcome_properties = {'type': 'dynamic'} |
| |
| self.has_api_endpoint = API_ENDPOINT_REGEX in self.web_xml.patterns |
| self.patterns = [pattern for pattern in self.web_xml.patterns if |
| pattern not in ('/', '/*', API_ENDPOINT_REGEX)] |
| self.has_jsps = web_xml.has_jsps |
| |
| def MakeServletPatternsIntoHandlers(self): |
| """Creates SimpleHandlers from servlet and filter mappings in web.xml.""" |
| handler_patterns = [] |
| has_jsps = self.has_jsps |
| if self.fall_through: |
| return [handler.SimpleHandler('/*', {'type': 'dynamic'})] |
| |
| for pattern in self.patterns: |
| if pattern.endswith('.jsp'): |
| has_jsps = True |
| else: |
| new_handler = handler.SimpleHandler(pattern, {'type': 'dynamic'}) |
| handler_patterns.append(new_handler) |
| handler_patterns += self.CreateHandlerWithoutTrailingStar(new_handler) |
| |
| if has_jsps or self.app_engine_web_xml.vm: |
| handler_patterns.append( |
| handler.SimpleHandler('*.jsp', {'type': 'dynamic'})) |
| |
| handler_patterns.append( |
| handler.SimpleHandler('/_ah/*', {'type': 'dynamic'})) |
| return handler_patterns |
| |
| def GenerateOrderedHandlerList(self): |
| handler_patterns = (self.MakeServletPatternsIntoHandlers() |
| + self.GenerateSecurityConstraintHandlers() |
| + self.GenerateWelcomeFileHandlers()) |
| ordered_handlers = handler.GetOrderedIntersection(handler_patterns) |
| if self.has_api_endpoint: |
| ordered_handlers.append( |
| handler.SimpleHandler(API_ENDPOINT_REGEX, {'type': 'dynamic'})) |
| return ordered_handlers |
| |
| def TranslateHandler(self, the_handler): |
| """Converts a dynamic handler object to Yaml.""" |
| if the_handler.GetProperty('type') != 'dynamic': |
| return [] |
| statements = ['- url: %s' % the_handler.Regexify(), |
| ' script: unused'] |
| return statements + self.TranslateAdditionalOptions(the_handler) |
| |
| |
| class StaticHandlerGenerator(HandlerGenerator): |
| """Generates static handler yaml entries for app.yaml.""" |
| |
| def __init__(self, app_engine_web_xml, web_xml, welcome_properties): |
| super(StaticHandlerGenerator, self).__init__(app_engine_web_xml, web_xml) |
| self.static_file_includes = self.app_engine_web_xml.static_file_includes |
| self.welcome_properties = welcome_properties |
| |
| def MakeStaticFilePatternsIntoHandlers(self): |
| """Creates SimpleHandlers out of XML-specified static file includes.""" |
| includes = self.static_file_includes |
| if not includes: |
| return [handler.SimpleHandler('/*', {'type': 'static'})] |
| |
| handler_patterns = [] |
| |
| for include in includes: |
| pattern = include.pattern.replace('**', '*') |
| if pattern[0] != '/': |
| pattern = '/' + pattern |
| properties = {'type': 'static'} |
| if include.expiration: |
| properties['expiration'] = include.expiration |
| if include.http_headers: |
| |
| properties['http_headers'] = tuple(sorted(include.http_headers.items())) |
| handler_patterns.append(handler.SimpleHandler(pattern, properties)) |
| return handler_patterns |
| |
| def GenerateOrderedHandlerList(self): |
| handler_patterns = (self.MakeStaticFilePatternsIntoHandlers() |
| + self.GenerateSecurityConstraintHandlers() |
| + self.GenerateWelcomeFileHandlers()) |
| return handler.GetOrderedIntersection(handler_patterns) |
| |
| def TranslateHandler(self, h): |
| """Translates SimpleHandler to static handler yaml statements.""" |
| root = self.app_engine_web_xml.public_root |
| regex_string = h.Regexify() |
| if regex_string.startswith(root): |
| regex_string = regex_string[len(root):] |
| |
| welcome_files = h.GetProperty('welcome') |
| |
| if welcome_files: |
| statements = [] |
| for welcome_file in welcome_files: |
| statements += ['- url: (%s)' % regex_string, |
| ' static_files: __static__%s\\1%s' % |
| (root, welcome_file), |
| ' upload: __NOT_USED__', |
| ' require_matching_file: True'] |
| statements += self.TranslateAdditionalOptions(h) |
| statements += self.TranslateAdditionalStaticOptions(h) |
| return statements |
| |
| if h.GetProperty('type') != 'static': |
| return [] |
| |
| statements = ['- url: (%s)' % regex_string, |
| ' static_files: __static__%s\\1' % root, |
| ' upload: __NOT_USED__', |
| ' require_matching_file: True'] |
| |
| return (statements + |
| self.TranslateAdditionalOptions(h) + |
| self.TranslateAdditionalStaticOptions(h)) |
| |
| def TranslateAdditionalStaticOptions(self, h): |
| statements = [] |
| expiration = h.GetProperty('expiration') |
| if expiration: |
| statements.append(' expiration: %s' % expiration) |
| http_headers = h.GetProperty('http_headers') |
| if http_headers: |
| statements.append(' http_headers:') |
| statements += [' %s: %s' % pair for pair in http_headers] |
| return statements |
| |
| |
| class StaticHandlerGeneratorForDevAppServer(StaticHandlerGenerator): |
| """Generates static handler yaml entries for app.yaml in Dev App Server. |
| |
| This class overrides the GenerateOrderedHanderList and TranslateHandler |
| methods from its parent to work with the Dev App Server environment. |
| See the GenerateYamlHandlersListForDevAppServer method above for further |
| details. |
| """ |
| |
| def __init__(self, app_engine_web_xml, web_xml, static_urls): |
| super(StaticHandlerGeneratorForDevAppServer, self).__init__( |
| app_engine_web_xml, web_xml, {}) |
| self.static_urls = static_urls |
| |
| def GenerateOrderedHandlerList(self): |
| handler_patterns = self.MakeStaticUrlsIntoHandlers() |
| |
| |
| |
| |
| return handler.GetOrderedIntersection(handler_patterns) |
| |
| def MakeStaticUrlsIntoHandlers(self): |
| handler_patterns = [] |
| for url, include in self.static_urls: |
| properties = {'type': 'static'} |
| if include.expiration: |
| properties['expiration'] = include.expiration |
| if include.http_headers: |
| properties['http_headers'] = tuple(sorted(include.http_headers.items())) |
| handler_patterns.append(handler.SimpleHandler(url, properties)) |
| return handler_patterns |
| |
| def TranslateHandler(self, h): |
| """Translates SimpleHandler to static handler yaml statements.""" |
| |
| root = self.app_engine_web_xml.public_root |
| |
| |
| regex = h.Regexify() |
| |
| |
| |
| split = 1 if regex.startswith('/') else 0 |
| |
| statements = ['- url: /(%s)' % regex[split:], |
| ' static_files: %s\\1' % root, |
| ' upload: __NOT_USED__', |
| ' require_matching_file: True'] |
| |
| return (statements + |
| self.TranslateAdditionalOptions(h) + |
| self.TranslateAdditionalStaticOptions(h)) |
