/ - Diff - snf-ganeti - Greek Research and Technology Network's projects

     from ganeti import constants
     from ganeti import errors
     from ganeti import netutils
     from cStringIO import StringIO
     #: default list of field for L{ListNodes}
-...
       result = cl.QueryNodes(fields=["name", "pip", "sip",
                                      "pinst_list", "sinst_list",
                                      "master_candidate", "drained", "offline",
                                      "master_capable", "vm_capable", "powered"],
                                      "master_capable", "vm_capable", "powered",
                                      "ndparams", "custom_ndparams"],
                              names=args, use_locking=False)
       for (name, primary_ip, secondary_ip, pinst, sinst,
            is_mc, drained, offline, master_capable, vm_capable, powered) in result:
       for (name, primary_ip, secondary_ip, pinst, sinst, is_mc, drained, offline,
            master_capable, vm_capable, powered, ndparams,
            ndparams_custom) in result:
         ToStdout("Node name: %s", name)
         ToStdout("  primary ip: %s", primary_ip)
         ToStdout("  secondary ip: %s", secondary_ip)
-...
               ToStdout("    - %s", iname)
           else:
             ToStdout("  secondary for no instances")
         ToStdout("  node parameters:")
         buf = StringIO()
         FormatParameterDict(buf, ndparams_custom, ndparams, level=2)
         ToStdout(buf.getvalue().rstrip("\n"))
       return 0

         return query.NodeQueryData([all_info[name] for name in nodenames],
                                    live_data, lu.cfg.GetMasterNode(),
                                    node_to_primary, node_to_secondary, groups,
                                    oob_support)
                                    oob_support, lu.cfg.GetClusterInfo())
     class LUQueryNodes(NoHooksLU):

       """
       def __init__(self, nodes, live_data, master_name, node_to_primary,
                    node_to_secondary, groups, oob_support):
                    node_to_secondary, groups, oob_support, cluster):
         """Initializes this class.
         """
-...
         self.node_to_secondary = node_to_secondary
         self.groups = groups
         self.oob_support = oob_support
         self.cluster = cluster
         # Used for individual rows
         self.curlive_data = None
-...
+      }
     def _GetNodeGroup(ctx, node):
     def _GetGroup(cb):
       """Build function for calling another function with an node group.
       @param cb: The callback to be called with the nodegroup
       """
       def fn(ctx, node):
         """Get group data for a node.
         @type ctx: L{NodeQueryData}
         @type inst: L{objects.Node}
         @param inst: Node object
         """
         ng = ctx.groups.get(node.group, None)
         if ng is None:
           # Nodes always have a group, or the configuration is corrupt
           return (constants.QRFS_UNAVAIL, None)
         return cb(ctx, node, ng)
       return fn
     def _GetNodeGroup(ctx, node, ng): # pylint: disable-msg=W0613
       """Returns the name of a node's group.
       @type ctx: L{NodeQueryData}
       @type node: L{objects.Node}
       @param node: Node object
       @type ng: L{objects.NodeGroup}
       @param ng: The node group this node belongs to
       """
       ng = ctx.groups.get(node.group, None)
       if ng is None:
         # Nodes always have a group, or the configuration is corrupt
         return (constants.QRFS_UNAVAIL, None)
       return (constants.QRFS_NORMAL, ng.name)
-...
       return (constants.QRFS_UNAVAIL, None)
     def _GetNdParams(ctx, node, ng):
       """Returns the ndparams for this node.
       @type ctx: L{NodeQueryData}
       @type node: L{objects.Node}
       @param node: Node object
       @type ng: L{objects.NodeGroup}
       @param ng: The node group this node belongs to
       """
       return (constants.QRFS_NORMAL, ctx.cluster.SimpleFillND(ng.FillND(node)))
     def _GetLiveNodeField(field, kind, ctx, node):
       """Gets the value of a "live" field from L{NodeQueryData}.
-...
         (_MakeField("role", "Role", constants.QFT_TEXT), NQ_CONFIG,
          lambda ctx, node: (constants.QRFS_NORMAL,
                             _GetNodeRole(node, ctx.master_name))),
         (_MakeField("group", "Group", constants.QFT_TEXT), NQ_GROUP, _GetNodeGroup),
         (_MakeField("group", "Group", constants.QFT_TEXT), NQ_GROUP,
          _GetGroup(_GetNodeGroup)),
         (_MakeField("group.uuid", "GroupUUID", constants.QFT_TEXT),
          NQ_CONFIG, lambda ctx, node: (constants.QRFS_NORMAL, node.group)),
         (_MakeField("powered", "Powered", constants.QFT_BOOL), NQ_OOB,
           _GetNodePower),
         (_MakeField("ndparams", "NodeParameters", constants.QFT_OTHER), NQ_GROUP,
           _GetGroup(_GetNdParams)),
         (_MakeField("custom_ndparams", "CustomNodeParameters", constants.QFT_OTHER),
           NQ_GROUP, lambda ctx, node: (constants.QRFS_NORMAL, node.ndparams)),
+        ]
       def _GetLength(getter):

           objects.Node(name="node3", drained=False),
+          ]
         for live_data in [None, dict.fromkeys([node.name for node in nodes], {})]:
           nqd = query.NodeQueryData(nodes, live_data, None, None, None, None, None)
           nqd = query.NodeQueryData(nodes, live_data, None, None, None, None, None,
                                     None)
           q = self._Create(["name", "drained"])
           self.assertEqual(q.RequestedData(), set([query.NQ_CONFIG]))
-...
                          set([query.NQ_CONFIG, query.NQ_LIVE, query.NQ_INST,
                               query.NQ_GROUP, query.NQ_OOB]))
         cluster = objects.Cluster(cluster_name="testcluster",
           hvparams=constants.HVC_DEFAULTS,
           beparams={
             constants.PP_DEFAULT: constants.BEC_DEFAULTS,
             },
           nicparams={
             constants.PP_DEFAULT: constants.NICC_DEFAULTS,
             },
           ndparams=constants.NDC_DEFAULTS,
+            )
         node_names = ["node%s" % i for i in range(20)]
         master_name = node_names[3]
         nodes = [
-...
                        drained=False,
                        vm_capable=False,
                        master_capable=False,
                        ndparams={},
                        group="default",
                        ctime=1290006900,
                        mtime=1290006913,
-...
         ng_uuid = "492b4b74-8670-478a-b98d-4c53a76238e6"
         groups = {
           ng_uuid: objects.NodeGroup(name="ng1", uuid=ng_uuid),
           ng_uuid: objects.NodeGroup(name="ng1", uuid=ng_uuid, ndparams={}),
+          }
         oob_support = dict((name, False) for name in node_names)
-...
         nqd = query.NodeQueryData(nodes, live_data, master_name,
                                   node_to_primary, node_to_secondary, groups,
                                   oob_support)
                                   oob_support, cluster)
         result = q.Query(nqd)
         self.assert_(compat.all(len(row) == len(selected) for row in result))
         self.assertEqual([row[field_index["name"]] for row in result],
-...
         live_data = dict.fromkeys([node.name for node in nodes], {})
         # No data
         nqd = query.NodeQueryData(None, None, None, None, None, None, None)
         nqd = query.NodeQueryData(None, None, None, None, None, None, None, None)
         self.assertEqual(query._GetLiveNodeField("hello", constants.QFT_NUMBER,
                                                  nqd, nodes[0]),
                          (constants.QRFS_NODATA, None))

Synnefo » snf-ganeti

Revision 8572f1fe