New policy protobuf protocol.

chrome/app/policy/syntax_check_policy_template_json.py

 #!/usr/bin/python2
 # Copyright (c) 2011 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 63 matching lines @@
                     (container_name.title(), value_type.__name__, key),
                     container_name, identifier, offending)
       return None
     value = container[key]
     if not isinstance(value, value_type):
       self._Error('Value of "%s" must be a %s.' %
                   (key, value_type.__name__),
                   container_name, identifier, value)
     return value
 
-  def _CheckPolicy(self, policy, may_contain_groups):
+  def _AddPolicyID(self, id, policy_ids, policy):
+    '''
+    Adds |id| to |policy_ids|. Generates an error message if the
+    |id| exists already; |policy| is needed for this message.
+    '''
+    if id in policy_ids:
+      self._Error('Duplicate id', 'policy', policy.get('name'),
+                  id)
+    else:
+      policy_ids.add(id)
+
+  def _CheckPolicyIDs(self, policy_ids):
+    '''
+    Checks a set of policy_ids to make sure it contains a continuous range
+    of entries (i.e. no holes).
+    Holes would not be a technical problem, but we want to ensure that nobody
+    accidentally omits IDs.
+    '''
+    for i in range(len(policy_ids)):
+      if (i + 1) not in policy_ids:
+        self._Error('No policy with id: %s' % (i + 1))
+
+  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', 'supported_on',
                      'label', 'policies', 'items', 'example_value', 'features',
-                     'deprecated', 'future'):
+                     'deprecated', 'future', 'id'):
         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)
 
     # Each policy must have a type.
     policy_type = self._CheckContains(policy, 'type', str)
     if policy_type not in ('group', 'main', 'string', 'int', 'list', 'int-enum',
@@ skipping 13 matching lines @@
 
     # 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 not may_contain_groups:
+      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, False)
+          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)
+
       # Each policy must have a supported_on list.
       supported_on = self._CheckContains(policy, 'supported_on', list)
       if supported_on is not None:
         for s in supported_on:
           if not isinstance(s, str):
             self._Error('Entries in "supported_on" must be strings.', 'policy',
-                              policy, supported_on)
+                        policy, supported_on)
 
       # Each policy must have a 'features' dict.
       self._CheckContains(policy, 'features', dict)
 
       # 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
       else:
         raise NotImplementedError('Unimplemented policy type: %s' % policy_type)
       self._CheckContains(policy, 'example_value', value_type)
 
       # Statistics.
       self.num_policies += 1
-      if not may_contain_groups:
+      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:
@@ skipping 152 matching lines @@
     self.options = options
 
     # First part: check JSON structure.
 
     # Check policy definitions.
     policy_definitions = self._CheckContains(data, 'policy_definitions', list,
                                              parent_element=None,
                                              container_name='The root element',
                                              offending=None)
     if policy_definitions is not None:
+      policy_ids = set()
       for policy in policy_definitions:
-        self._CheckPolicy(policy, True)
+        self._CheckPolicy(policy, False, policy_ids)
+      self._CheckPolicyIDs(policy_ids)
 
     # Check (non-policy-specific) message definitions.
     messages = self._CheckContains(data, 'messages', dict,
                                    parent_element=None,
                                    container_name='The root element',
                                    offending=None)
     if messages is not None:
       for message in messages:
         self._CheckMessage(message, messages[message])
 
     # Check placeholders.
     placeholders = self._CheckContains(data, 'placeholders', list,
                                        parent_element=None,
                                        container_name='The root element',
                                        offending=None)
     if placeholders is not None:
       for placeholder in placeholders:
         self._CheckPlaceholder(placeholder)
 
     # Second part: check formatting.
     self._CheckFormat(filename)
 
     # Third part: summary and exit.
-    print ('Finished. %d errors, %d warnings.' %
-        (self.error_count, self.warning_count))
+    print ('Finished checking %s. %d errors, %d warnings.' %
+        (filename, self.error_count, self.warning_count))
     if self.options.stats:
       if self.num_groups > 0:
         print ('%d policies, %d of those in %d groups (containing on '
                'average %.1f policies).' %
                (self.num_policies, self.num_policies_in_groups, self.num_groups,
                  (1.0 * self.num_policies_in_groups / self.num_groups)))
       else:
         print self.num_policies, 'policies, 0 policy groups.'
     if self.error_count > 0:
       return 1
@@ skipping 14 matching lines @@
       if len(args) != 2:
         parser.print_help()
         sys.exit(1)
       filename = args[1]
     return self.Main(filename, options)
 
 
 if __name__ == '__main__':
   checker = PolicyTemplateChecker()
   sys.exit(checker.Run(sys.argv))