Revision 24c09d5e

b/lib/rpc/client.py
47 47
  try:
48 48
    request = serializer.LoadJson(msg)
49 49
  except ValueError, err:
50
    raise ProtocolError("Invalid LUXI request (parsing error): %s" % err)
50
    raise ProtocolError("Invalid RPC request (parsing error): %s" % err)
51 51

  
52
  logging.debug("LUXI request: %s", request)
52
  logging.debug("RPC request: %s", request)
53 53

  
54 54
  if not isinstance(request, dict):
55
    logging.error("LUXI request not a dict: %r", msg)
56
    raise ProtocolError("Invalid LUXI request (not a dict)")
55
    logging.error("RPC request not a dict: %r", msg)
56
    raise ProtocolError("Invalid RPC request (not a dict)")
57 57

  
58 58
  method = request.get(KEY_METHOD, None) # pylint: disable=E1103
59 59
  args = request.get(KEY_ARGS, None) # pylint: disable=E1103
60 60
  version = request.get(KEY_VERSION, None) # pylint: disable=E1103
61 61

  
62 62
  if method is None or args is None:
63
    logging.error("LUXI request missing method or arguments: %r", msg)
64
    raise ProtocolError(("Invalid LUXI request (no method or arguments"
63
    logging.error("RPC request missing method or arguments: %r", msg)
64
    raise ProtocolError(("Invalid RPC request (no method or arguments"
65 65
                         " in request): %r") % msg)
66 66

  
67 67
  return (method, args, version)
......
101 101
  if version is not None:
102 102
    response[KEY_VERSION] = version
103 103

  
104
  logging.debug("LUXI response: %s", response)
104
  logging.debug("RPC response: %s", response)
105 105

  
106 106
  return serializer.DumpJson(response)
107 107

  
......
123 123
  return serializer.DumpJson(request)
124 124

  
125 125

  
126
def CallLuxiMethod(transport_cb, method, args, version=None):
127
  """Send a LUXI request via a transport and return the response.
126
def CallRPCMethod(transport_cb, method, args, version=None):
127
  """Send a RPC request via a transport and return the response.
128 128

  
129 129
  """
130 130
  assert callable(transport_cb)
......
138 138

  
139 139
  # Verify version if there was one in the response
140 140
  if resp_version is not None and resp_version != version:
141
    raise LuxiError("LUXI version mismatch, client %s, response %s" %
141
    raise LuxiError("RPC version mismatch, client %s, response %s" %
142 142
                    (version, resp_version))
143 143

  
144 144
  if success:
......
227 227
    if not isinstance(args, (list, tuple)):
228 228
      raise errors.ProgrammerError("Invalid parameter passed to CallMethod:"
229 229
                                   " expected list, got %s" % type(args))
230
    return CallLuxiMethod(self._SendMethodCall, method, args,
231
                          version=constants.LUXI_VERSION)
230
    return CallRPCMethod(self._SendMethodCall, method, args,
231
                         version=constants.LUXI_VERSION)
b/test/py/ganeti.rpc.client_unittest.py
26 26

  
27 27
from ganeti import constants
28 28
from ganeti import errors
29
import ganeti.rpc.client as luxi
30 29
from ganeti import serializer
30
from ganeti.rpc import client
31 31

  
32 32
import testutils
33 33

  
34 34

  
35
class TestLuxiParsing(testutils.GanetiTestCase):
35
class TextRPCParsing(testutils.GanetiTestCase):
36 36
  def testParseRequest(self):
37 37
    msg = serializer.DumpJson({
38
      luxi.KEY_METHOD: "foo",
39
      luxi.KEY_ARGS: ("bar", "baz", 123),
38
      client.KEY_METHOD: "foo",
39
      client.KEY_ARGS: ("bar", "baz", 123),
40 40
      })
41 41

  
42
    self.assertEqualValues(luxi.ParseRequest(msg),
42
    self.assertEqualValues(client.ParseRequest(msg),
43 43
                           ("foo", ["bar", "baz", 123], None))
44 44

  
45
    self.assertRaises(luxi.ProtocolError, luxi.ParseRequest,
45
    self.assertRaises(client.ProtocolError, client.ParseRequest,
46 46
                      "this\"is {invalid, ]json data")
47 47

  
48 48
    # No dict
49
    self.assertRaises(luxi.ProtocolError, luxi.ParseRequest,
49
    self.assertRaises(client.ProtocolError, client.ParseRequest,
50 50
                      serializer.DumpJson(123))
51 51

  
52 52
    # Empty dict
53
    self.assertRaises(luxi.ProtocolError, luxi.ParseRequest,
53
    self.assertRaises(client.ProtocolError, client.ParseRequest,
54 54
                      serializer.DumpJson({ }))
55 55

  
56 56
    # No arguments
57
    self.assertRaises(luxi.ProtocolError, luxi.ParseRequest,
58
                      serializer.DumpJson({ luxi.KEY_METHOD: "foo", }))
57
    self.assertRaises(client.ProtocolError, client.ParseRequest,
58
                      serializer.DumpJson({ client.KEY_METHOD: "foo", }))
59 59

  
60 60
    # No method
61
    self.assertRaises(luxi.ProtocolError, luxi.ParseRequest,
62
                      serializer.DumpJson({ luxi.KEY_ARGS: [], }))
61
    self.assertRaises(client.ProtocolError, client.ParseRequest,
62
                      serializer.DumpJson({ client.KEY_ARGS: [], }))
63 63

  
64 64
    # No method or arguments
65
    self.assertRaises(luxi.ProtocolError, luxi.ParseRequest,
66
                      serializer.DumpJson({ luxi.KEY_VERSION: 1, }))
65
    self.assertRaises(client.ProtocolError, client.ParseRequest,
66
                      serializer.DumpJson({ client.KEY_VERSION: 1, }))
67 67

  
68 68
  def testParseRequestWithVersion(self):
69 69
    msg = serializer.DumpJson({
70
      luxi.KEY_METHOD: "version",
71
      luxi.KEY_ARGS: (["some"], "args", 0, "here"),
72
      luxi.KEY_VERSION: 20100101,
70
      client.KEY_METHOD: "version",
71
      client.KEY_ARGS: (["some"], "args", 0, "here"),
72
      client.KEY_VERSION: 20100101,
73 73
      })
74 74

  
75
    self.assertEqualValues(luxi.ParseRequest(msg),
75
    self.assertEqualValues(client.ParseRequest(msg),
76 76
                           ("version", [["some"], "args", 0, "here"], 20100101))
77 77

  
78 78
  def testParseResponse(self):
79 79
    msg = serializer.DumpJson({
80
      luxi.KEY_SUCCESS: True,
81
      luxi.KEY_RESULT: None,
80
      client.KEY_SUCCESS: True,
81
      client.KEY_RESULT: None,
82 82
      })
83 83

  
84
    self.assertEqual(luxi.ParseResponse(msg), (True, None, None))
84
    self.assertEqual(client.ParseResponse(msg), (True, None, None))
85 85

  
86
    self.assertRaises(luxi.ProtocolError, luxi.ParseResponse,
86
    self.assertRaises(client.ProtocolError, client.ParseResponse,
87 87
                      "this\"is {invalid, ]json data")
88 88

  
89 89
    # No dict
90
    self.assertRaises(luxi.ProtocolError, luxi.ParseResponse,
90
    self.assertRaises(client.ProtocolError, client.ParseResponse,
91 91
                      serializer.DumpJson(123))
92 92

  
93 93
    # Empty dict
94
    self.assertRaises(luxi.ProtocolError, luxi.ParseResponse,
94
    self.assertRaises(client.ProtocolError, client.ParseResponse,
95 95
                      serializer.DumpJson({ }))
96 96

  
97 97
    # No success
98
    self.assertRaises(luxi.ProtocolError, luxi.ParseResponse,
99
                      serializer.DumpJson({ luxi.KEY_RESULT: True, }))
98
    self.assertRaises(client.ProtocolError, client.ParseResponse,
99
                      serializer.DumpJson({ client.KEY_RESULT: True, }))
100 100

  
101 101
    # No result
102
    self.assertRaises(luxi.ProtocolError, luxi.ParseResponse,
103
                      serializer.DumpJson({ luxi.KEY_SUCCESS: True, }))
102
    self.assertRaises(client.ProtocolError, client.ParseResponse,
103
                      serializer.DumpJson({ client.KEY_SUCCESS: True, }))
104 104

  
105 105
    # No result or success
106
    self.assertRaises(luxi.ProtocolError, luxi.ParseResponse,
107
                      serializer.DumpJson({ luxi.KEY_VERSION: 123, }))
106
    self.assertRaises(client.ProtocolError, client.ParseResponse,
107
                      serializer.DumpJson({ client.KEY_VERSION: 123, }))
108 108

  
109 109
  def testParseResponseWithVersion(self):
110 110
    msg = serializer.DumpJson({
111
      luxi.KEY_SUCCESS: True,
112
      luxi.KEY_RESULT: "Hello World",
113
      luxi.KEY_VERSION: 19991234,
111
      client.KEY_SUCCESS: True,
112
      client.KEY_RESULT: "Hello World",
113
      client.KEY_VERSION: 19991234,
114 114
      })
115 115

  
116
    self.assertEqual(luxi.ParseResponse(msg), (True, "Hello World", 19991234))
116
    self.assertEqual(client.ParseResponse(msg), (True, "Hello World", 19991234))
117 117

  
118 118
  def testFormatResponse(self):
119 119
    for success, result in [(False, "error"), (True, "abc"),
120 120
                            (True, { "a": 123, "b": None, })]:
121
      msg = luxi.FormatResponse(success, result)
121
      msg = client.FormatResponse(success, result)
122 122
      msgdata = serializer.LoadJson(msg)
123
      self.assert_(luxi.KEY_SUCCESS in msgdata)
124
      self.assert_(luxi.KEY_RESULT in msgdata)
125
      self.assert_(luxi.KEY_VERSION not in msgdata)
123
      self.assert_(client.KEY_SUCCESS in msgdata)
124
      self.assert_(client.KEY_RESULT in msgdata)
125
      self.assert_(client.KEY_VERSION not in msgdata)
126 126
      self.assertEqualValues(msgdata,
127
                             { luxi.KEY_SUCCESS: success,
128
                               luxi.KEY_RESULT: result,
127
                             { client.KEY_SUCCESS: success,
128
                               client.KEY_RESULT: result,
129 129
                             })
130 130

  
131 131
  def testFormatResponseWithVersion(self):
132 132
    for success, result, version in [(False, "error", 123), (True, "abc", 999),
133 133
                                     (True, { "a": 123, "b": None, }, 2010)]:
134
      msg = luxi.FormatResponse(success, result, version=version)
134
      msg = client.FormatResponse(success, result, version=version)
135 135
      msgdata = serializer.LoadJson(msg)
136
      self.assert_(luxi.KEY_SUCCESS in msgdata)
137
      self.assert_(luxi.KEY_RESULT in msgdata)
138
      self.assert_(luxi.KEY_VERSION in msgdata)
136
      self.assert_(client.KEY_SUCCESS in msgdata)
137
      self.assert_(client.KEY_RESULT in msgdata)
138
      self.assert_(client.KEY_VERSION in msgdata)
139 139
      self.assertEqualValues(msgdata,
140
                             { luxi.KEY_SUCCESS: success,
141
                               luxi.KEY_RESULT: result,
142
                               luxi.KEY_VERSION: version,
140
                             { client.KEY_SUCCESS: success,
141
                               client.KEY_RESULT: result,
142
                               client.KEY_VERSION: version,
143 143
                             })
144 144

  
145 145
  def testFormatRequest(self):
146 146
    for method, args in [("a", []), ("b", [1, 2, 3])]:
147
      msg = luxi.FormatRequest(method, args)
147
      msg = client.FormatRequest(method, args)
148 148
      msgdata = serializer.LoadJson(msg)
149
      self.assert_(luxi.KEY_METHOD in msgdata)
150
      self.assert_(luxi.KEY_ARGS in msgdata)
151
      self.assert_(luxi.KEY_VERSION not in msgdata)
149
      self.assert_(client.KEY_METHOD in msgdata)
150
      self.assert_(client.KEY_ARGS in msgdata)
151
      self.assert_(client.KEY_VERSION not in msgdata)
152 152
      self.assertEqualValues(msgdata,
153
                             { luxi.KEY_METHOD: method,
154
                               luxi.KEY_ARGS: args,
153
                             { client.KEY_METHOD: method,
154
                               client.KEY_ARGS: args,
155 155
                             })
156 156

  
157 157
  def testFormatRequestWithVersion(self):
158 158
    for method, args, version in [("fn1", [], 123), ("fn2", [1, 2, 3], 999)]:
159
      msg = luxi.FormatRequest(method, args, version=version)
159
      msg = client.FormatRequest(method, args, version=version)
160 160
      msgdata = serializer.LoadJson(msg)
161
      self.assert_(luxi.KEY_METHOD in msgdata)
162
      self.assert_(luxi.KEY_ARGS in msgdata)
163
      self.assert_(luxi.KEY_VERSION in msgdata)
161
      self.assert_(client.KEY_METHOD in msgdata)
162
      self.assert_(client.KEY_ARGS in msgdata)
163
      self.assert_(client.KEY_VERSION in msgdata)
164 164
      self.assertEqualValues(msgdata,
165
                             { luxi.KEY_METHOD: method,
166
                               luxi.KEY_ARGS: args,
167
                               luxi.KEY_VERSION: version,
165
                             { client.KEY_METHOD: method,
166
                               client.KEY_ARGS: args,
167
                               client.KEY_VERSION: version,
168 168
                             })
169 169

  
170 170

  
171
class TestCallLuxiMethod(unittest.TestCase):
171
class TestCallRPCMethod(unittest.TestCase):
172 172
  MY_LUXI_VERSION = 1234
173 173
  assert constants.LUXI_VERSION != MY_LUXI_VERSION
174 174

  
175 175
  def testSuccessNoVersion(self):
176 176
    def _Cb(msg):
177
      (method, args, version) = luxi.ParseRequest(msg)
177
      (method, args, version) = client.ParseRequest(msg)
178 178
      self.assertEqual(method, "fn1")
179 179
      self.assertEqual(args, "Hello World")
180
      return luxi.FormatResponse(True, "x")
180
      return client.FormatResponse(True, "x")
181 181

  
182
    result = luxi.CallLuxiMethod(_Cb, "fn1", "Hello World")
182
    result = client.CallRPCMethod(_Cb, "fn1", "Hello World")
183 183

  
184 184
  def testServerVersionOnly(self):
185 185
    def _Cb(msg):
186
      (method, args, version) = luxi.ParseRequest(msg)
186
      (method, args, version) = client.ParseRequest(msg)
187 187
      self.assertEqual(method, "fn1")
188 188
      self.assertEqual(args, "Hello World")
189
      return luxi.FormatResponse(True, "x", version=self.MY_LUXI_VERSION)
189
      return client.FormatResponse(True, "x", version=self.MY_LUXI_VERSION)
190 190

  
191
    self.assertRaises(errors.LuxiError, luxi.CallLuxiMethod,
191
    self.assertRaises(errors.LuxiError, client.CallRPCMethod,
192 192
                      _Cb, "fn1", "Hello World")
193 193

  
194 194
  def testWithVersion(self):
195 195
    def _Cb(msg):
196
      (method, args, version) = luxi.ParseRequest(msg)
196
      (method, args, version) = client.ParseRequest(msg)
197 197
      self.assertEqual(method, "fn99")
198 198
      self.assertEqual(args, "xyz")
199
      return luxi.FormatResponse(True, "y", version=self.MY_LUXI_VERSION)
199
      return client.FormatResponse(True, "y", version=self.MY_LUXI_VERSION)
200 200

  
201
    self.assertEqual("y", luxi.CallLuxiMethod(_Cb, "fn99", "xyz",
201
    self.assertEqual("y", client.CallRPCMethod(_Cb, "fn99", "xyz",
202 202
                                              version=self.MY_LUXI_VERSION))
203 203

  
204 204
  def testVersionMismatch(self):
205 205
    def _Cb(msg):
206
      (method, args, version) = luxi.ParseRequest(msg)
206
      (method, args, version) = client.ParseRequest(msg)
207 207
      self.assertEqual(method, "fn5")
208 208
      self.assertEqual(args, "xyz")
209
      return luxi.FormatResponse(True, "F", version=self.MY_LUXI_VERSION * 2)
209
      return client.FormatResponse(True, "F", version=self.MY_LUXI_VERSION * 2)
210 210

  
211
    self.assertRaises(errors.LuxiError, luxi.CallLuxiMethod,
211
    self.assertRaises(errors.LuxiError, client.CallRPCMethod,
212 212
                      _Cb, "fn5", "xyz", version=self.MY_LUXI_VERSION)
213 213

  
214 214
  def testError(self):
215 215
    def _Cb(msg):
216
      (method, args, version) = luxi.ParseRequest(msg)
216
      (method, args, version) = client.ParseRequest(msg)
217 217
      self.assertEqual(method, "fnErr")
218 218
      self.assertEqual(args, [])
219 219
      err = errors.OpPrereqError("Test")
220
      return luxi.FormatResponse(False, errors.EncodeException(err))
220
      return client.FormatResponse(False, errors.EncodeException(err))
221 221

  
222
    self.assertRaises(errors.OpPrereqError, luxi.CallLuxiMethod,
222
    self.assertRaises(errors.OpPrereqError, client.CallRPCMethod,
223 223
                      _Cb, "fnErr", [])
224 224

  
225 225
  def testErrorWithVersionMismatch(self):
226 226
    def _Cb(msg):
227
      (method, args, version) = luxi.ParseRequest(msg)
227
      (method, args, version) = client.ParseRequest(msg)
228 228
      self.assertEqual(method, "fnErr")
229 229
      self.assertEqual(args, [])
230 230
      err = errors.OpPrereqError("TestVer")
231
      return luxi.FormatResponse(False, errors.EncodeException(err),
231
      return client.FormatResponse(False, errors.EncodeException(err),
232 232
                                 version=self.MY_LUXI_VERSION * 2)
233 233

  
234
    self.assertRaises(errors.LuxiError, luxi.CallLuxiMethod,
234
    self.assertRaises(errors.LuxiError, client.CallRPCMethod,
235 235
                      _Cb, "fnErr", [],
236 236
                      version=self.MY_LUXI_VERSION)
237 237

  
238 238
  def testErrorWithVersion(self):
239 239
    def _Cb(msg):
240
      (method, args, version) = luxi.ParseRequest(msg)
240
      (method, args, version) = client.ParseRequest(msg)
241 241
      self.assertEqual(method, "fn9")
242 242
      self.assertEqual(args, [])
243 243
      err = errors.OpPrereqError("TestVer")
244
      return luxi.FormatResponse(False, errors.EncodeException(err),
244
      return client.FormatResponse(False, errors.EncodeException(err),
245 245
                                 version=self.MY_LUXI_VERSION)
246 246

  
247
    self.assertRaises(errors.OpPrereqError, luxi.CallLuxiMethod,
247
    self.assertRaises(errors.OpPrereqError, client.CallRPCMethod,
248 248
                      _Cb, "fn9", [],
249 249
                      version=self.MY_LUXI_VERSION)
250 250

  

Also available in: Unified diff