Implement fetching, caching and retrieval of external policy data

chrome/app/policy/syntax_check_policy_template_json.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 '''
 Checks a policy_templates.json file for conformity to its syntax specification.
 '''
 
 import json
@@ skipping 10 matching lines @@
 
 # Convert a 'type' to its corresponding schema type.
 TYPE_TO_SCHEMA = {
   'int': 'integer',
   'list': 'array',
   'dict': 'object',
   'main': 'boolean',
   'string': 'string',
   'int-enum': 'integer',
   'string-enum': 'string',
+  'external': 'object',
 }
 
 # List of boolean policies that have been introduced with negative polarity in
 # the past and should not trigger the negative polarity check.
 LEGACY_INVERTED_POLARITY_WHITELIST = [
     'DeveloperToolsDisabled',
     'DeviceAutoUpdateDisabled',
     'Disable3DAPIs',
     'DisableAuthNegotiateCnameLookup',
     'DisablePluginFinder',
@@ skipping 125 matching lines @@
   def _CheckPolicy(self, policy, is_in_group, policy_ids):
     if not isinstance(policy, dict):
       self._Error('Each policy must be a dictionary.', 'policy', None, policy)
       return
 
     # There should not be any unknown keys in |policy|.
     for key in policy:
       if key not in ('name', 'type', 'caption', 'desc', 'device_only',
                      'supported_on', 'label', 'policies', 'items',
                      'example_value', 'features', 'deprecated', 'future',
-                     'id', 'schema'):
+                     'id', 'schema', 'max_size'):
         self.warning_count += 1
         print ('In policy %s: Warning: Unknown key: %s' %
                (policy.get('name'), key))
 
     # Each policy must have a name.
     self._CheckContains(policy, 'name', str, regexp_check=NO_WHITESPACE)
 
     # Each policy must have a type.
+    policy_types = ('group', 'main', 'string', 'int', 'list', 'int-enum',
+                    'string-enum', 'dict', 'external')
     policy_type = self._CheckContains(policy, 'type', str)
-    if policy_type not in ('group', 'main', 'string', 'int', 'list', 'int-enum',
-                           'string-enum', 'dict'):
-      self._Error('Policy type must be either of: group, main, string, int, '
-                  'list, int-enum, string-enum, dict',
-                  'policy', policy, policy_type)
+    if policy_type not in policy_types:
+      self._Error('Policy type must be one of: ' + ', '.join(policy_types),
+                  'policy', policy.get('name'), policy_type)
       return  # Can't continue for unsupported type.
 
     # Each policy must have a caption message.
     self._CheckContains(policy, 'caption', str)
 
     # Each policy must have a description message.
     self._CheckContains(policy, 'desc', str)
 
     # If 'label' is present, it must be a string.
     self._CheckContains(policy, 'label', str, True)
 
     # If 'deprecated' is present, it must be a bool.
     self._CheckContains(policy, 'deprecated', bool, True)
 
     # If 'future' is present, it must be a bool.
     self._CheckContains(policy, 'future', bool, True)
 
     if policy_type == 'group':
-
       # Groups must not be nested.
       if is_in_group:
         self._Error('Policy groups must not be nested.', 'policy', policy)
 
       # Each policy group must have a list of policies.
       policies = self._CheckContains(policy, 'policies', list)
 
       # Check sub-policies.
       if policies is not None:
         for nested_policy in policies:
           self._CheckPolicy(nested_policy, True, policy_ids)
 
       # Groups must not have an |id|.
       if 'id' in policy:
         self._Error('Policies of type "group" must not have an "id" field.',
                     'policy', policy)
 
       # Statistics.
       self.num_groups += 1
+
     else:  # policy_type != group
-
       # Each policy must have a protobuf ID.
       id = self._CheckContains(policy, 'id', int)
       self._AddPolicyID(id, policy_ids, policy)
 
       # 'schema' is the new 'type'.
       # TODO(joaodasilva): remove the 'type' checks once 'schema' is used
       # everywhere.
       self._CheckPolicySchema(policy, policy_type)
 
       # Each policy must have a supported_on list.
@@ skipping 30 matching lines @@
 
       # Each policy must have an 'example_value' of appropriate type.
       if policy_type == 'main':
         value_type = bool
       elif policy_type in ('string', 'string-enum'):
         value_type = str
       elif policy_type in ('int', 'int-enum'):
         value_type = int
       elif policy_type == 'list':
         value_type = list
-      elif policy_type == 'dict':
+      elif policy_type in ('dict', 'external'):
         value_type = dict
       else:
         raise NotImplementedError('Unimplemented policy type: %s' % policy_type)
       self._CheckContains(policy, 'example_value', value_type)
 
       # Statistics.
       self.num_policies += 1
       if is_in_group:
         self.num_policies_in_groups += 1
 
     if policy_type in ('int-enum', 'string-enum'):
-
       # Enums must contain a list of items.
       items = self._CheckContains(policy, 'items', list)
       if items is not None:
         if len(items) < 1:
           self._Error('"items" must not be empty.', 'policy', policy, items)
         for item in items:
           # Each item must have a name.
           # Note: |policy.get('name')| is used instead of |policy['name']|
           # because it returns None rather than failing when no key called
           # 'name' exists.
           self._CheckContains(item, 'name', str, container_name='item',
                               identifier=policy.get('name'),
                               regexp_check=NO_WHITESPACE)
 
           # Each item must have a value of the correct type.
           self._CheckContains(item, 'value', value_type, container_name='item',
                               identifier=policy.get('name'))
 
           # Each item must have a caption.
           self._CheckContains(item, 'caption', str, container_name='item',
                               identifier=policy.get('name'))
 
+    if policy_type == 'external':
+      # Each policy referencing external data must specify a maximum data size.
+      self._CheckContains(policy, 'max_size', int)
+
   def _CheckMessage(self, key, value):
     # |key| must be a string, |value| a dict.
     if not isinstance(key, str):
       self._Error('Each message key must be a string.', 'message', key, key)
       return
 
     if not isinstance(value, dict):
       self._Error('Each message must be a dictionary.', 'message', key, value)
       return
 
@@ skipping 163 matching lines @@
     if filename is None:
       if len(args) != 2:
         parser.print_help()
         sys.exit(1)
       filename = args[1]
     return self.Main(filename, options)
 
 
 if __name__ == '__main__':
   sys.exit(PolicyTemplateChecker().Run(sys.argv))