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 _AddProtobufID(self, protobuf_id, policy, is_in_group):
+    '''
+    Adds |protobuf_id| to either self.protobuf_ids or self.group_protobuf_ids,
+    depending on |is_in_group|. Generates an error message if the protobuf_id
+    exists already; |policy| is needed for this message.
+    '''
+    if is_in_group:
+      if protobuf_id in self.group_protobuf_ids:

[gfeher, 2011/02/02 08:42:45]

How about making |self.group_protobuf_ids| / |is_in_group| a function parameter?
(Both here and in _CheckPolicy())

[Jakob Kummerow, 2011/02/03 14:36:52]

Done. Good idea.

+        self._Error('Duplicate protobuf_id', 'policy', policy.get('name'),
+                    protobuf_id)
+      else:
+        self.group_protobuf_ids.add(protobuf_id)
+    else:
+      if protobuf_id in self.protobuf_ids:
+        self._Error('Duplicate protobuf_id', 'policy', policy.get('name'),
+                    protobuf_id)
+      else:
+        self.protobuf_ids.add(protobuf_id)
+
+  def _CheckProtobufIDs(self, protobuf_ids, group=None):
+    '''
+    Checks a set of protobuf_ids to make sure it contains a continuous range
+    of entries (i.e. no holes).

[gfeher, 2011/02/02 08:42:45]

Isn't it possible that we will have holes later as deprecated policies are
removed?

[Jakob Kummerow, 2011/02/03 14:36:52]

As discussed offline, we don't want to allow holes. Ever. (Or if we do, we'll
change the checker.)

+    '''
+    for i in range(len(protobuf_ids)):
+      if (i + 1) not in protobuf_ids:
+        if group is not None:
+          self._Error('Missing protobuf_id: %s' % (i + 1), 'policy group',
+                      group.get('name'))
+        else:
+          self._Error('No policy with protobuf_id: %s' % (i + 1))
+
+  def _CheckPolicy(self, policy, is_in_group):
     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'):
+                     'deprecated', 'protobuf_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',
                            'string-enum'):
       self._Error('Policy type must be either of: group, main, string, int, '
                   'list, int-enum, string-enum', 'policy', policy, 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)
 
+    # Each policy must have a protobuf ID.
+    protobuf_id = self._CheckContains(policy, 'protobuf_id', int)
+    self._AddProtobufID(protobuf_id, policy, is_in_group)
+
     # If 'deprecated' is present, it must be a bool.
     self._CheckContains(policy, 'deprecated', 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.
+      self.group_protobuf_ids = set()
       if policies is not None:
         for nested_policy in policies:
-          self._CheckPolicy(nested_policy, False)
+          self._CheckPolicy(nested_policy, True)
+      self._CheckProtobufIDs(self.group_protobuf_ids, policy)
 
       # Statistics.
       self.num_groups += 1
     else:  # policy_type != group
 
       # 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:
+      self.protobuf_ids = set()
       for policy in policy_definitions:
-        self._CheckPolicy(policy, True)
+        self._CheckPolicy(policy, False)
+      self._CheckProtobufIDs(self.protobuf_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])
 
@@ skipping 39 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))