Revision bdf7d8c0

b/lib/rpc.py
49 49
  individual call.
50 50

  
51 51
  """
52
  def __init__(self, parent, node):
52
  def __init__(self, parent, node, address=None):
53
    """Constructor for the node controller.
54

  
55
    @type parent: L{Client}
56
    @param parent: the C{Client} instance which holds global parameters for
57
        the call
58
    @type node: str
59
    @param node: the name of the node we connect to; it is used for error
60
        messages and in cases we the address paramater is not passed
61
    @type address: str
62
    @keyword address: the node's address, in case we know it, so that we
63
        don't need to resolve it; testing shows that httplib has high
64
        overhead in resolving addresses (even when speficied in /etc/hosts)
65

  
66
    """
53 67
    self.parent = parent
54 68
    self.node = node
69
    if address is None:
70
      address = node
55 71
    self.failed = False
56 72

  
57
    self.http_conn = hc = httplib.HTTPConnection(node, self.parent.port)
73
    self.http_conn = hc = httplib.HTTPConnection(address, parent.port)
58 74
    try:
59 75
      hc.connect()
60
      hc.putrequest('PUT', "/%s" % self.parent.procedure,
76
      hc.putrequest('PUT', "/%s" % parent.procedure,
61 77
                    skip_accept_encoding=True)
62
      hc.putheader('Content-Length', str(len(parent.body)))
78
      hc.putheader('Content-Length', parent.body_length)
63 79
      hc.endheaders()
64 80
      hc.send(parent.body)
65
    except socket.error, err:
81
    except socket.error:
66 82
      logging.exception("Error connecting to node %s", node)
67 83
      self.failed = True
68 84

  
......
99 115
  'False' result, which is not good. This overloading of values can
100 116
  cause bugs.
101 117

  
118
  @var body_length: cached string value of the length of the body (so that
119
      individual C{NodeController} instances don't have to recompute it)
120

  
102 121
  """
103 122
  result_set = False
104 123
  result = False
......
112 131
    self.procedure = procedure
113 132
    self.args = args
114 133
    self.body = simplejson.dumps(args)
134
    self.body_length = str(len(self.body))
115 135

  
116 136
  #--- generic connector -------------
117 137

  
118
  def ConnectList(self, node_list):
138
  def ConnectList(self, node_list, address_list=None):
119 139
    """Add a list of nodes to the target nodes.
120 140

  
121 141
    @type node_list: list
122 142
    @param node_list: the list of node names to connect
143
    @type address_list: list or None
144
    @keyword address_list: either None or a list with node addresses,
145
        which must have the same length as the node list
123 146

  
124 147
    """
125
    for node in node_list:
126
      self.ConnectNode(node)
148
    if address_list is None:
149
      address_list = [None for _ in node_list]
150
    else:
151
      assert len(node_list) == len(address_list), \
152
             "Name and address lists should have the same length"
153
    for node, address in zip(node_list, address_list):
154
      self.ConnectNode(node, address)
127 155

  
128
  def ConnectNode(self, connect_node):
156
  def ConnectNode(self, name, address=None):
129 157
    """Add a node to the target list.
130 158

  
159
    @type name: str
160
    @param name: the node name
161
    @type address: str
162
    @keyword address: the node address, if known
163

  
131 164
    """
132
    self.nc[connect_node] = nc = NodeController(self, connect_node)
165
    self.nc[name] = NodeController(self, name, address)
133 166

  
134 167
  def GetResults(self):
135 168
    """Return the results of the call.

Also available in: Unified diff