code.grnet.gr Git - ganeti-local/blob - lib/rapi/rlib2.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """Remote API resource implementations.
  23
  24 PUT or POST?
  25 ============
  26
  27 According to RFC2616 the main difference between PUT and POST is that
  28 POST can create new resources but PUT can only create the resource the
  29 URI was pointing to on the PUT request.
  30
  31 In the context of this module POST on ``/2/instances`` to change an existing
  32 entity is legitimate, while PUT would not be. PUT creates a new entity (e.g. a
  33 new instance) with a name specified in the request.
  34
  35 Quoting from RFC2616, section 9.6::
  36
  37   The fundamental difference between the POST and PUT requests is reflected in
  38   the different meaning of the Request-URI. The URI in a POST request
  39   identifies the resource that will handle the enclosed entity. That resource
  40   might be a data-accepting process, a gateway to some other protocol, or a
  41   separate entity that accepts annotations. In contrast, the URI in a PUT
  42   request identifies the entity enclosed with the request -- the user agent
  43   knows what URI is intended and the server MUST NOT attempt to apply the
  44   request to some other resource. If the server desires that the request be
  45   applied to a different URI, it MUST send a 301 (Moved Permanently) response;
  46   the user agent MAY then make its own decision regarding whether or not to
  47   redirect the request.
  48
  49 So when adding new methods, if they are operating on the URI entity itself,
  50 PUT should be prefered over POST.
  51
  52 """
  53
  54 # pylint: disable-msg=C0103
  55
  56 # C0103: Invalid name, since the R_* names are not conforming
  57
  58 from ganeti import opcodes
  59 from ganeti import http
  60 from ganeti import constants
  61 from ganeti import cli
  62 from ganeti import rapi
  63 from ganeti import ht
  64 from ganeti import compat
  65 from ganeti import ssconf
  66 from ganeti.rapi import baserlib
  67
  68
  69 _COMMON_FIELDS = ["ctime", "mtime", "uuid", "serial_no", "tags"]
  70 I_FIELDS = ["name", "admin_state", "os",
  71             "pnode", "snodes",
  72             "disk_template",
  73             "nic.ips", "nic.macs", "nic.modes", "nic.links", "nic.bridges",
  74             "network_port",
  75             "disk.sizes", "disk_usage",
  76             "beparams", "hvparams",
  77             "oper_state", "oper_ram", "oper_vcpus", "status",
  78             "custom_hvparams", "custom_beparams", "custom_nicparams",
  79             ] + _COMMON_FIELDS
  80
  81 N_FIELDS = ["name", "offline", "master_candidate", "drained",
  82             "dtotal", "dfree",
  83             "mtotal", "mnode", "mfree",
  84             "pinst_cnt", "sinst_cnt",
  85             "ctotal", "cnodes", "csockets",
  86             "pip", "sip", "role",
  87             "pinst_list", "sinst_list",
  88             "master_capable", "vm_capable",
  89             "group.uuid",
  90             ] + _COMMON_FIELDS
  91
  92 G_FIELDS = [
  93   "alloc_policy",
  94   "name",
  95   "node_cnt",
  96   "node_list",
  97   ] + _COMMON_FIELDS
  98
  99 J_FIELDS_BULK = [
 100   "id", "ops", "status", "summary",
 101   "opstatus",
 102   "received_ts", "start_ts", "end_ts",
 103   ]
 104
 105 J_FIELDS = J_FIELDS_BULK + [
 106   "oplog",
 107   "opresult",
 108   ]
 109
 110 _NR_DRAINED = "drained"
 111 _NR_MASTER_CANDIATE = "master-candidate"
 112 _NR_MASTER = "master"
 113 _NR_OFFLINE = "offline"
 114 _NR_REGULAR = "regular"
 115
 116 _NR_MAP = {
 117   constants.NR_MASTER: _NR_MASTER,
 118   constants.NR_MCANDIDATE: _NR_MASTER_CANDIATE,
 119   constants.NR_DRAINED: _NR_DRAINED,
 120   constants.NR_OFFLINE: _NR_OFFLINE,
 121   constants.NR_REGULAR: _NR_REGULAR,
 122   }
 123
 124 assert frozenset(_NR_MAP.keys()) == constants.NR_ALL
 125
 126 # Request data version field
 127 _REQ_DATA_VERSION = "__version__"
 128
 129 # Feature string for instance creation request data version 1
 130 _INST_CREATE_REQV1 = "instance-create-reqv1"
 131
 132 # Feature string for instance reinstall request version 1
 133 _INST_REINSTALL_REQV1 = "instance-reinstall-reqv1"
 134
 135 # Feature string for node migration version 1
 136 _NODE_MIGRATE_REQV1 = "node-migrate-reqv1"
 137
 138 # Feature string for node evacuation with LU-generated jobs
 139 _NODE_EVAC_RES1 = "node-evac-res1"
 140
 141 ALL_FEATURES = frozenset([
 142   _INST_CREATE_REQV1,
 143   _INST_REINSTALL_REQV1,
 144   _NODE_MIGRATE_REQV1,
 145   _NODE_EVAC_RES1,
 146   ])
 147
 148 # Timeout for /2/jobs/[job_id]/wait. Gives job up to 10 seconds to change.
 149 _WFJC_TIMEOUT = 10
 150
 151
 152 class R_root(baserlib.ResourceBase):
 153   """/ resource.
 154
 155   """
 156   @staticmethod
 157   def GET():
 158     """Supported for legacy reasons.
 159
 160     """
 161     return None
 162
 163
 164 class R_version(baserlib.ResourceBase):
 165   """/version resource.
 166
 167   This resource should be used to determine the remote API version and
 168   to adapt clients accordingly.
 169
 170   """
 171   @staticmethod
 172   def GET():
 173     """Returns the remote API version.
 174
 175     """
 176     return constants.RAPI_VERSION
 177
 178
 179 class R_2_info(baserlib.ResourceBase):
 180   """/2/info resource.
 181
 182   """
 183   def GET(self):
 184     """Returns cluster information.
 185
 186     """
 187     client = self.GetClient()
 188     return client.QueryClusterInfo()
 189
 190
 191 class R_2_features(baserlib.ResourceBase):
 192   """/2/features resource.
 193
 194   """
 195   @staticmethod
 196   def GET():
 197     """Returns list of optional RAPI features implemented.
 198
 199     """
 200     return list(ALL_FEATURES)
 201
 202
 203 class R_2_os(baserlib.ResourceBase):
 204   """/2/os resource.
 205
 206   """
 207   def GET(self):
 208     """Return a list of all OSes.
 209
 210     Can return error 500 in case of a problem.
 211
 212     Example: ["debian-etch"]
 213
 214     """
 215     cl = self.GetClient()
 216     op = opcodes.OpOsDiagnose(output_fields=["name", "variants"], names=[])
 217     job_id = self.SubmitJob([op], cl=cl)
 218     # we use custom feedback function, instead of print we log the status
 219     result = cli.PollJob(job_id, cl, feedback_fn=baserlib.FeedbackFn)
 220     diagnose_data = result[0]
 221
 222     if not isinstance(diagnose_data, list):
 223       raise http.HttpBadGateway(message="Can't get OS list")
 224
 225     os_names = []
 226     for (name, variants) in diagnose_data:
 227       os_names.extend(cli.CalculateOSNames(name, variants))
 228
 229     return os_names
 230
 231
 232 class R_2_redist_config(baserlib.OpcodeResource):
 233   """/2/redistribute-config resource.
 234
 235   """
 236   PUT_OPCODE = opcodes.OpClusterRedistConf
 237
 238
 239 class R_2_cluster_modify(baserlib.OpcodeResource):
 240   """/2/modify resource.
 241
 242   """
 243   PUT_OPCODE = opcodes.OpClusterSetParams
 244
 245
 246 class R_2_jobs(baserlib.ResourceBase):
 247   """/2/jobs resource.
 248
 249   """
 250   def GET(self):
 251     """Returns a dictionary of jobs.
 252
 253     @return: a dictionary with jobs id and uri.
 254
 255     """
 256     client = self.GetClient()
 257
 258     if self.useBulk():
 259       bulkdata = client.QueryJobs(None, J_FIELDS_BULK)
 260       return baserlib.MapBulkFields(bulkdata, J_FIELDS_BULK)
 261     else:
 262       jobdata = map(compat.fst, client.QueryJobs(None, ["id"]))
 263       return baserlib.BuildUriList(jobdata, "/2/jobs/%s",
 264                                    uri_fields=("id", "uri"))
 265
 266
 267 class R_2_jobs_id(baserlib.ResourceBase):
 268   """/2/jobs/[job_id] resource.
 269
 270   """
 271   def GET(self):
 272     """Returns a job status.
 273
 274     @return: a dictionary with job parameters.
 275         The result includes:
 276             - id: job ID as a number
 277             - status: current job status as a string
 278             - ops: involved OpCodes as a list of dictionaries for each
 279               opcodes in the job
 280             - opstatus: OpCodes status as a list
 281             - opresult: OpCodes results as a list of lists
 282
 283     """
 284     job_id = self.items[0]
 285     result = self.GetClient().QueryJobs([job_id, ], J_FIELDS)[0]
 286     if result is None:
 287       raise http.HttpNotFound()
 288     return baserlib.MapFields(J_FIELDS, result)
 289
 290   def DELETE(self):
 291     """Cancel not-yet-started job.
 292
 293     """
 294     job_id = self.items[0]
 295     result = self.GetClient().CancelJob(job_id)
 296     return result
 297
 298
 299 class R_2_jobs_id_wait(baserlib.ResourceBase):
 300   """/2/jobs/[job_id]/wait resource.
 301
 302   """
 303   # WaitForJobChange provides access to sensitive information and blocks
 304   # machine resources (it's a blocking RAPI call), hence restricting access.
 305   GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
 306
 307   def GET(self):
 308     """Waits for job changes.
 309
 310     """
 311     job_id = self.items[0]
 312
 313     fields = self.getBodyParameter("fields")
 314     prev_job_info = self.getBodyParameter("previous_job_info", None)
 315     prev_log_serial = self.getBodyParameter("previous_log_serial", None)
 316
 317     if not isinstance(fields, list):
 318       raise http.HttpBadRequest("The 'fields' parameter should be a list")
 319
 320     if not (prev_job_info is None or isinstance(prev_job_info, list)):
 321       raise http.HttpBadRequest("The 'previous_job_info' parameter should"
 322                                 " be a list")
 323
 324     if not (prev_log_serial is None or
 325             isinstance(prev_log_serial, (int, long))):
 326       raise http.HttpBadRequest("The 'previous_log_serial' parameter should"
 327                                 " be a number")
 328
 329     client = self.GetClient()
 330     result = client.WaitForJobChangeOnce(job_id, fields,
 331                                          prev_job_info, prev_log_serial,
 332                                          timeout=_WFJC_TIMEOUT)
 333     if not result:
 334       raise http.HttpNotFound()
 335
 336     if result == constants.JOB_NOTCHANGED:
 337       # No changes
 338       return None
 339
 340     (job_info, log_entries) = result
 341
 342     return {
 343       "job_info": job_info,
 344       "log_entries": log_entries,
 345       }
 346
 347
 348 class R_2_nodes(baserlib.ResourceBase):
 349   """/2/nodes resource.
 350
 351   """
 352   def GET(self):
 353     """Returns a list of all nodes.
 354
 355     """
 356     client = self.GetClient()
 357
 358     if self.useBulk():
 359       bulkdata = client.QueryNodes([], N_FIELDS, False)
 360       return baserlib.MapBulkFields(bulkdata, N_FIELDS)
 361     else:
 362       nodesdata = client.QueryNodes([], ["name"], False)
 363       nodeslist = [row[0] for row in nodesdata]
 364       return baserlib.BuildUriList(nodeslist, "/2/nodes/%s",
 365                                    uri_fields=("id", "uri"))
 366
 367
 368 class R_2_nodes_name(baserlib.ResourceBase):
 369   """/2/nodes/[node_name] resource.
 370
 371   """
 372   def GET(self):
 373     """Send information about a node.
 374
 375     """
 376     node_name = self.items[0]
 377     client = self.GetClient()
 378
 379     result = baserlib.HandleItemQueryErrors(client.QueryNodes,
 380                                             names=[node_name], fields=N_FIELDS,
 381                                             use_locking=self.useLocking())
 382
 383     return baserlib.MapFields(N_FIELDS, result[0])
 384
 385
 386 class R_2_nodes_name_role(baserlib.ResourceBase):
 387   """ /2/nodes/[node_name]/role resource.
 388
 389   """
 390   def GET(self):
 391     """Returns the current node role.
 392
 393     @return: Node role
 394
 395     """
 396     node_name = self.items[0]
 397     client = self.GetClient()
 398     result = client.QueryNodes(names=[node_name], fields=["role"],
 399                                use_locking=self.useLocking())
 400
 401     return _NR_MAP[result[0][0]]
 402
 403   def PUT(self):
 404     """Sets the node role.
 405
 406     @return: a job id
 407
 408     """
 409     if not isinstance(self.request_body, basestring):
 410       raise http.HttpBadRequest("Invalid body contents, not a string")
 411
 412     node_name = self.items[0]
 413     role = self.request_body
 414
 415     if role == _NR_REGULAR:
 416       candidate = False
 417       offline = False
 418       drained = False
 419
 420     elif role == _NR_MASTER_CANDIATE:
 421       candidate = True
 422       offline = drained = None
 423
 424     elif role == _NR_DRAINED:
 425       drained = True
 426       candidate = offline = None
 427
 428     elif role == _NR_OFFLINE:
 429       offline = True
 430       candidate = drained = None
 431
 432     else:
 433       raise http.HttpBadRequest("Can't set '%s' role" % role)
 434
 435     op = opcodes.OpNodeSetParams(node_name=node_name,
 436                                  master_candidate=candidate,
 437                                  offline=offline,
 438                                  drained=drained,
 439                                  force=bool(self.useForce()))
 440
 441     return self.SubmitJob([op])
 442
 443
 444 class R_2_nodes_name_evacuate(baserlib.OpcodeResource):
 445   """/2/nodes/[node_name]/evacuate resource.
 446
 447   """
 448   POST_OPCODE = opcodes.OpNodeEvacuate
 449
 450   def GetPostOpInput(self):
 451     """Evacuate all instances off a node.
 452
 453     """
 454     return (self.request_body, {
 455       "node_name": self.items[0],
 456       "dry_run": self.dryRun(),
 457       })
 458
 459
 460 class R_2_nodes_name_migrate(baserlib.OpcodeResource):
 461   """/2/nodes/[node_name]/migrate resource.
 462
 463   """
 464   POST_OPCODE = opcodes.OpNodeMigrate
 465
 466   def GetPostOpInput(self):
 467     """Migrate all primary instances from a node.
 468
 469     """
 470     if self.queryargs:
 471       # Support old-style requests
 472       if "live" in self.queryargs and "mode" in self.queryargs:
 473         raise http.HttpBadRequest("Only one of 'live' and 'mode' should"
 474                                   " be passed")
 475
 476       if "live" in self.queryargs:
 477         if self._checkIntVariable("live", default=1):
 478           mode = constants.HT_MIGRATION_LIVE
 479         else:
 480           mode = constants.HT_MIGRATION_NONLIVE
 481       else:
 482         mode = self._checkStringVariable("mode", default=None)
 483
 484       data = {
 485         "mode": mode,
 486         }
 487     else:
 488       data = self.request_body
 489
 490     return (data, {
 491       "node_name": self.items[0],
 492       })
 493
 494
 495 class R_2_nodes_name_storage(baserlib.ResourceBase):
 496   """/2/nodes/[node_name]/storage resource.
 497
 498   """
 499   # LUNodeQueryStorage acquires locks, hence restricting access to GET
 500   GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
 501
 502   def GET(self):
 503     node_name = self.items[0]
 504
 505     storage_type = self._checkStringVariable("storage_type", None)
 506     if not storage_type:
 507       raise http.HttpBadRequest("Missing the required 'storage_type'"
 508                                 " parameter")
 509
 510     output_fields = self._checkStringVariable("output_fields", None)
 511     if not output_fields:
 512       raise http.HttpBadRequest("Missing the required 'output_fields'"
 513                                 " parameter")
 514
 515     op = opcodes.OpNodeQueryStorage(nodes=[node_name],
 516                                     storage_type=storage_type,
 517                                     output_fields=output_fields.split(","))
 518     return self.SubmitJob([op])
 519
 520
 521 class R_2_nodes_name_storage_modify(baserlib.ResourceBase):
 522   """/2/nodes/[node_name]/storage/modify resource.
 523
 524   """
 525   def PUT(self):
 526     node_name = self.items[0]
 527
 528     storage_type = self._checkStringVariable("storage_type", None)
 529     if not storage_type:
 530       raise http.HttpBadRequest("Missing the required 'storage_type'"
 531                                 " parameter")
 532
 533     name = self._checkStringVariable("name", None)
 534     if not name:
 535       raise http.HttpBadRequest("Missing the required 'name'"
 536                                 " parameter")
 537
 538     changes = {}
 539
 540     if "allocatable" in self.queryargs:
 541       changes[constants.SF_ALLOCATABLE] = \
 542         bool(self._checkIntVariable("allocatable", default=1))
 543
 544     op = opcodes.OpNodeModifyStorage(node_name=node_name,
 545                                      storage_type=storage_type,
 546                                      name=name,
 547                                      changes=changes)
 548     return self.SubmitJob([op])
 549
 550
 551 class R_2_nodes_name_storage_repair(baserlib.ResourceBase):
 552   """/2/nodes/[node_name]/storage/repair resource.
 553
 554   """
 555   def PUT(self):
 556     node_name = self.items[0]
 557
 558     storage_type = self._checkStringVariable("storage_type", None)
 559     if not storage_type:
 560       raise http.HttpBadRequest("Missing the required 'storage_type'"
 561                                 " parameter")
 562
 563     name = self._checkStringVariable("name", None)
 564     if not name:
 565       raise http.HttpBadRequest("Missing the required 'name'"
 566                                 " parameter")
 567
 568     op = opcodes.OpRepairNodeStorage(node_name=node_name,
 569                                      storage_type=storage_type,
 570                                      name=name)
 571     return self.SubmitJob([op])
 572
 573
 574 class R_2_groups(baserlib.OpcodeResource):
 575   """/2/groups resource.
 576
 577   """
 578   POST_OPCODE = opcodes.OpGroupAdd
 579   POST_RENAME = {
 580     "name": "group_name",
 581     }
 582
 583   def GetPostOpInput(self):
 584     """Create a node group.
 585
 586     """
 587     assert not self.items
 588     return (self.request_body, {
 589       "dry_run": self.dryRun(),
 590       })
 591
 592   def GET(self):
 593     """Returns a list of all node groups.
 594
 595     """
 596     client = self.GetClient()
 597
 598     if self.useBulk():
 599       bulkdata = client.QueryGroups([], G_FIELDS, False)
 600       return baserlib.MapBulkFields(bulkdata, G_FIELDS)
 601     else:
 602       data = client.QueryGroups([], ["name"], False)
 603       groupnames = [row[0] for row in data]
 604       return baserlib.BuildUriList(groupnames, "/2/groups/%s",
 605                                    uri_fields=("name", "uri"))
 606
 607
 608 class R_2_groups_name(baserlib.ResourceBase):
 609   """/2/groups/[group_name] resource.
 610
 611   """
 612   def GET(self):
 613     """Send information about a node group.
 614
 615     """
 616     group_name = self.items[0]
 617     client = self.GetClient()
 618
 619     result = baserlib.HandleItemQueryErrors(client.QueryGroups,
 620                                             names=[group_name], fields=G_FIELDS,
 621                                             use_locking=self.useLocking())
 622
 623     return baserlib.MapFields(G_FIELDS, result[0])
 624
 625   def DELETE(self):
 626     """Delete a node group.
 627
 628     """
 629     op = opcodes.OpGroupRemove(group_name=self.items[0],
 630                                dry_run=bool(self.dryRun()))
 631
 632     return self.SubmitJob([op])
 633
 634
 635 class R_2_groups_name_modify(baserlib.OpcodeResource):
 636   """/2/groups/[group_name]/modify resource.
 637
 638   """
 639   PUT_OPCODE = opcodes.OpGroupSetParams
 640
 641   def GetPutOpInput(self):
 642     """Changes some parameters of node group.
 643
 644     """
 645     assert self.items
 646     return (self.request_body, {
 647       "group_name": self.items[0],
 648       })
 649
 650
 651 class R_2_groups_name_rename(baserlib.OpcodeResource):
 652   """/2/groups/[group_name]/rename resource.
 653
 654   """
 655   PUT_OPCODE = opcodes.OpGroupRename
 656
 657   def GetPutOpInput(self):
 658     """Changes the name of a node group.
 659
 660     """
 661     assert len(self.items) == 1
 662     return (self.request_body, {
 663       "group_name": self.items[0],
 664       "dry_run": self.dryRun(),
 665       })
 666
 667
 668 class R_2_groups_name_assign_nodes(baserlib.OpcodeResource):
 669   """/2/groups/[group_name]/assign-nodes resource.
 670
 671   """
 672   PUT_OPCODE = opcodes.OpGroupAssignNodes
 673
 674   def GetPutOpInput(self):
 675     """Assigns nodes to a group.
 676
 677     """
 678     assert len(self.items) == 1
 679     return (self.request_body, {
 680       "group_name": self.items[0],
 681       "dry_run": self.dryRun(),
 682       "force": self.useForce(),
 683       })
 684
 685
 686 def _ParseInstanceCreateRequestVersion1(data, dry_run):
 687   """Parses an instance creation request version 1.
 688
 689   @rtype: L{opcodes.OpInstanceCreate}
 690   @return: Instance creation opcode
 691
 692   """
 693   override = {
 694     "dry_run": dry_run,
 695     }
 696
 697   rename = {
 698     "os": "os_type",
 699     "name": "instance_name",
 700     }
 701
 702   return baserlib.FillOpcode(opcodes.OpInstanceCreate, data, override,
 703                              rename=rename)
 704
 705
 706 class R_2_instances(baserlib.ResourceBase):
 707   """/2/instances resource.
 708
 709   """
 710   def GET(self):
 711     """Returns a list of all available instances.
 712
 713     """
 714     client = self.GetClient()
 715
 716     use_locking = self.useLocking()
 717     if self.useBulk():
 718       bulkdata = client.QueryInstances([], I_FIELDS, use_locking)
 719       return baserlib.MapBulkFields(bulkdata, I_FIELDS)
 720     else:
 721       instancesdata = client.QueryInstances([], ["name"], use_locking)
 722       instanceslist = [row[0] for row in instancesdata]
 723       return baserlib.BuildUriList(instanceslist, "/2/instances/%s",
 724                                    uri_fields=("id", "uri"))
 725
 726   def POST(self):
 727     """Create an instance.
 728
 729     @return: a job id
 730
 731     """
 732     if not isinstance(self.request_body, dict):
 733       raise http.HttpBadRequest("Invalid body contents, not a dictionary")
 734
 735     # Default to request data version 0
 736     data_version = self.getBodyParameter(_REQ_DATA_VERSION, 0)
 737
 738     if data_version == 0:
 739       raise http.HttpBadRequest("Instance creation request version 0 is no"
 740                                 " longer supported")
 741     elif data_version == 1:
 742       data = self.request_body.copy()
 743       # Remove "__version__"
 744       data.pop(_REQ_DATA_VERSION, None)
 745       op = _ParseInstanceCreateRequestVersion1(data, self.dryRun())
 746     else:
 747       raise http.HttpBadRequest("Unsupported request data version %s" %
 748                                 data_version)
 749
 750     return self.SubmitJob([op])
 751
 752
 753 class R_2_instances_name(baserlib.OpcodeResource):
 754   """/2/instances/[instance_name] resource.
 755
 756   """
 757   DELETE_OPCODE = opcodes.OpInstanceRemove
 758
 759   def GET(self):
 760     """Send information about an instance.
 761
 762     """
 763     client = self.GetClient()
 764     instance_name = self.items[0]
 765
 766     result = baserlib.HandleItemQueryErrors(client.QueryInstances,
 767                                             names=[instance_name],
 768                                             fields=I_FIELDS,
 769                                             use_locking=self.useLocking())
 770
 771     return baserlib.MapFields(I_FIELDS, result[0])
 772
 773   def GetDeleteOpInput(self):
 774     """Delete an instance.
 775
 776     """
 777     assert len(self.items) == 1
 778     return ({}, {
 779       "instance_name": self.items[0],
 780       "ignore_failures": False,
 781       "dry_run": self.dryRun(),
 782       })
 783
 784
 785 class R_2_instances_name_info(baserlib.OpcodeResource):
 786   """/2/instances/[instance_name]/info resource.
 787
 788   """
 789   GET_OPCODE = opcodes.OpInstanceQueryData
 790
 791   def GetGetOpInput(self):
 792     """Request detailed instance information.
 793
 794     """
 795     assert len(self.items) == 1
 796     return ({}, {
 797       "instances": [self.items[0]],
 798       "static": bool(self._checkIntVariable("static", default=0)),
 799       })
 800
 801
 802 class R_2_instances_name_reboot(baserlib.OpcodeResource):
 803   """/2/instances/[instance_name]/reboot resource.
 804
 805   Implements an instance reboot.
 806
 807   """
 808   POST_OPCODE = opcodes.OpInstanceReboot
 809
 810   def GetPostOpInput(self):
 811     """Reboot an instance.
 812
 813     The URI takes type=[hard|soft|full] and
 814     ignore_secondaries=[False|True] parameters.
 815
 816     """
 817     return ({}, {
 818       "instance_name": self.items[0],
 819       "reboot_type":
 820         self.queryargs.get("type", [constants.INSTANCE_REBOOT_HARD])[0],
 821       "ignore_secondaries": bool(self._checkIntVariable("ignore_secondaries")),
 822       "dry_run": self.dryRun(),
 823       })
 824
 825
 826 class R_2_instances_name_startup(baserlib.OpcodeResource):
 827   """/2/instances/[instance_name]/startup resource.
 828
 829   Implements an instance startup.
 830
 831   """
 832   PUT_OPCODE = opcodes.OpInstanceStartup
 833
 834   def GetPutOpInput(self):
 835     """Startup an instance.
 836
 837     The URI takes force=[False|True] parameter to start the instance
 838     if even if secondary disks are failing.
 839
 840     """
 841     return ({}, {
 842       "instance_name": self.items[0],
 843       "force": self.useForce(),
 844       "dry_run": self.dryRun(),
 845       "no_remember": bool(self._checkIntVariable("no_remember")),
 846       })
 847
 848
 849 class R_2_instances_name_shutdown(baserlib.OpcodeResource):
 850   """/2/instances/[instance_name]/shutdown resource.
 851
 852   Implements an instance shutdown.
 853
 854   """
 855   PUT_OPCODE = opcodes.OpInstanceShutdown
 856
 857   def GetPutOpInput(self):
 858     """Shutdown an instance.
 859
 860     """
 861     return (self.request_body, {
 862       "instance_name": self.items[0],
 863       "no_remember": bool(self._checkIntVariable("no_remember")),
 864       "dry_run": self.dryRun(),
 865       })
 866
 867
 868 def _ParseInstanceReinstallRequest(name, data):
 869   """Parses a request for reinstalling an instance.
 870
 871   """
 872   if not isinstance(data, dict):
 873     raise http.HttpBadRequest("Invalid body contents, not a dictionary")
 874
 875   ostype = baserlib.CheckParameter(data, "os", default=None)
 876   start = baserlib.CheckParameter(data, "start", exptype=bool,
 877                                   default=True)
 878   osparams = baserlib.CheckParameter(data, "osparams", default=None)
 879
 880   ops = [
 881     opcodes.OpInstanceShutdown(instance_name=name),
 882     opcodes.OpInstanceReinstall(instance_name=name, os_type=ostype,
 883                                 osparams=osparams),
 884     ]
 885
 886   if start:
 887     ops.append(opcodes.OpInstanceStartup(instance_name=name, force=False))
 888
 889   return ops
 890
 891
 892 class R_2_instances_name_reinstall(baserlib.ResourceBase):
 893   """/2/instances/[instance_name]/reinstall resource.
 894
 895   Implements an instance reinstall.
 896
 897   """
 898   def POST(self):
 899     """Reinstall an instance.
 900
 901     The URI takes os=name and nostartup=[0|1] optional
 902     parameters. By default, the instance will be started
 903     automatically.
 904
 905     """
 906     if self.request_body:
 907       if self.queryargs:
 908         raise http.HttpBadRequest("Can't combine query and body parameters")
 909
 910       body = self.request_body
 911     elif self.queryargs:
 912       # Legacy interface, do not modify/extend
 913       body = {
 914         "os": self._checkStringVariable("os"),
 915         "start": not self._checkIntVariable("nostartup"),
 916         }
 917     else:
 918       body = {}
 919
 920     ops = _ParseInstanceReinstallRequest(self.items[0], body)
 921
 922     return self.SubmitJob(ops)
 923
 924
 925 class R_2_instances_name_replace_disks(baserlib.OpcodeResource):
 926   """/2/instances/[instance_name]/replace-disks resource.
 927
 928   """
 929   POST_OPCODE = opcodes.OpInstanceReplaceDisks
 930
 931   def GetPostOpInput(self):
 932     """Replaces disks on an instance.
 933
 934     """
 935     data = self.request_body.copy()
 936     static = {
 937       "instance_name": self.items[0],
 938       }
 939
 940     # Parse disks
 941     try:
 942       raw_disks = data["disks"]
 943     except KeyError:
 944       pass
 945     else:
 946       if not ht.TListOf(ht.TInt)(raw_disks): # pylint: disable-msg=E1102
 947         # Backwards compatibility for strings of the format "1, 2, 3"
 948         try:
 949           data["disks"] = [int(part) for part in raw_disks.split(",")]
 950         except (TypeError, ValueError), err:
 951           raise http.HttpBadRequest("Invalid disk index passed: %s" % err)
 952
 953     return (data, static)
 954
 955
 956 class R_2_instances_name_activate_disks(baserlib.ResourceBase):
 957   """/2/instances/[instance_name]/activate-disks resource.
 958
 959   """
 960   def PUT(self):
 961     """Activate disks for an instance.
 962
 963     The URI might contain ignore_size to ignore current recorded size.
 964
 965     """
 966     instance_name = self.items[0]
 967     ignore_size = bool(self._checkIntVariable("ignore_size"))
 968
 969     op = opcodes.OpInstanceActivateDisks(instance_name=instance_name,
 970                                          ignore_size=ignore_size)
 971
 972     return self.SubmitJob([op])
 973
 974
 975 class R_2_instances_name_deactivate_disks(baserlib.ResourceBase):
 976   """/2/instances/[instance_name]/deactivate-disks resource.
 977
 978   """
 979   def PUT(self):
 980     """Deactivate disks for an instance.
 981
 982     """
 983     instance_name = self.items[0]
 984
 985     op = opcodes.OpInstanceDeactivateDisks(instance_name=instance_name)
 986
 987     return self.SubmitJob([op])
 988
 989
 990 class R_2_instances_name_prepare_export(baserlib.ResourceBase):
 991   """/2/instances/[instance_name]/prepare-export resource.
 992
 993   """
 994   def PUT(self):
 995     """Prepares an export for an instance.
 996
 997     @return: a job id
 998
 999     """
1000     instance_name = self.items[0]
1001     mode = self._checkStringVariable("mode")
1002
1003     op = opcodes.OpBackupPrepare(instance_name=instance_name,
1004                                  mode=mode)
1005
1006     return self.SubmitJob([op])
1007
1008
1009 def _ParseExportInstanceRequest(name, data):
1010   """Parses a request for an instance export.
1011
1012   @rtype: L{opcodes.OpBackupExport}
1013   @return: Instance export opcode
1014
1015   """
1016   # Rename "destination" to "target_node"
1017   try:
1018     data["target_node"] = data.pop("destination")
1019   except KeyError:
1020     pass
1021
1022   return baserlib.FillOpcode(opcodes.OpBackupExport, data, {
1023     "instance_name": name,
1024     })
1025
1026
1027 class R_2_instances_name_export(baserlib.ResourceBase):
1028   """/2/instances/[instance_name]/export resource.
1029
1030   """
1031   def PUT(self):
1032     """Exports an instance.
1033
1034     @return: a job id
1035
1036     """
1037     if not isinstance(self.request_body, dict):
1038       raise http.HttpBadRequest("Invalid body contents, not a dictionary")
1039
1040     op = _ParseExportInstanceRequest(self.items[0], self.request_body)
1041
1042     return self.SubmitJob([op])
1043
1044
1045 def _ParseMigrateInstanceRequest(name, data):
1046   """Parses a request for an instance migration.
1047
1048   @rtype: L{opcodes.OpInstanceMigrate}
1049   @return: Instance migration opcode
1050
1051   """
1052   return baserlib.FillOpcode(opcodes.OpInstanceMigrate, data, {
1053     "instance_name": name,
1054     })
1055
1056
1057 class R_2_instances_name_migrate(baserlib.ResourceBase):
1058   """/2/instances/[instance_name]/migrate resource.
1059
1060   """
1061   def PUT(self):
1062     """Migrates an instance.
1063
1064     @return: a job id
1065
1066     """
1067     baserlib.CheckType(self.request_body, dict, "Body contents")
1068
1069     op = _ParseMigrateInstanceRequest(self.items[0], self.request_body)
1070
1071     return self.SubmitJob([op])
1072
1073
1074 class R_2_instances_name_failover(baserlib.ResourceBase):
1075   """/2/instances/[instance_name]/failover resource.
1076
1077   """
1078   def PUT(self):
1079     """Does a failover of an instance.
1080
1081     @return: a job id
1082
1083     """
1084     baserlib.CheckType(self.request_body, dict, "Body contents")
1085
1086     op = baserlib.FillOpcode(opcodes.OpInstanceFailover, self.request_body, {
1087       "instance_name": self.items[0],
1088       })
1089
1090     return self.SubmitJob([op])
1091
1092
1093 def _ParseRenameInstanceRequest(name, data):
1094   """Parses a request for renaming an instance.
1095
1096   @rtype: L{opcodes.OpInstanceRename}
1097   @return: Instance rename opcode
1098
1099   """
1100   return baserlib.FillOpcode(opcodes.OpInstanceRename, data, {
1101     "instance_name": name,
1102     })
1103
1104
1105 class R_2_instances_name_rename(baserlib.ResourceBase):
1106   """/2/instances/[instance_name]/rename resource.
1107
1108   """
1109   def PUT(self):
1110     """Changes the name of an instance.
1111
1112     @return: a job id
1113
1114     """
1115     baserlib.CheckType(self.request_body, dict, "Body contents")
1116
1117     op = _ParseRenameInstanceRequest(self.items[0], self.request_body)
1118
1119     return self.SubmitJob([op])
1120
1121
1122 def _ParseModifyInstanceRequest(name, data):
1123   """Parses a request for modifying an instance.
1124
1125   @rtype: L{opcodes.OpInstanceSetParams}
1126   @return: Instance modify opcode
1127
1128   """
1129   return baserlib.FillOpcode(opcodes.OpInstanceSetParams, data, {
1130     "instance_name": name,
1131     })
1132
1133
1134 class R_2_instances_name_modify(baserlib.ResourceBase):
1135   """/2/instances/[instance_name]/modify resource.
1136
1137   """
1138   def PUT(self):
1139     """Changes some parameters of an instance.
1140
1141     @return: a job id
1142
1143     """
1144     baserlib.CheckType(self.request_body, dict, "Body contents")
1145
1146     op = _ParseModifyInstanceRequest(self.items[0], self.request_body)
1147
1148     return self.SubmitJob([op])
1149
1150
1151 class R_2_instances_name_disk_grow(baserlib.ResourceBase):
1152   """/2/instances/[instance_name]/disk/[disk_index]/grow resource.
1153
1154   """
1155   def POST(self):
1156     """Increases the size of an instance disk.
1157
1158     @return: a job id
1159
1160     """
1161     op = baserlib.FillOpcode(opcodes.OpInstanceGrowDisk, self.request_body, {
1162       "instance_name": self.items[0],
1163       "disk": int(self.items[1]),
1164       })
1165
1166     return self.SubmitJob([op])
1167
1168
1169 class R_2_instances_name_console(baserlib.ResourceBase):
1170   """/2/instances/[instance_name]/console resource.
1171
1172   """
1173   GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
1174
1175   def GET(self):
1176     """Request information for connecting to instance's console.
1177
1178     @return: Serialized instance console description, see
1179              L{objects.InstanceConsole}
1180
1181     """
1182     client = self.GetClient()
1183
1184     ((console, ), ) = client.QueryInstances([self.items[0]], ["console"], False)
1185
1186     if console is None:
1187       raise http.HttpServiceUnavailable("Instance console unavailable")
1188
1189     assert isinstance(console, dict)
1190     return console
1191
1192
1193 def _GetQueryFields(args):
1194   """
1195
1196   """
1197   try:
1198     fields = args["fields"]
1199   except KeyError:
1200     raise http.HttpBadRequest("Missing 'fields' query argument")
1201
1202   return _SplitQueryFields(fields[0])
1203
1204
1205 def _SplitQueryFields(fields):
1206   """
1207
1208   """
1209   return [i.strip() for i in fields.split(",")]
1210
1211
1212 class R_2_query(baserlib.ResourceBase):
1213   """/2/query/[resource] resource.
1214
1215   """
1216   # Results might contain sensitive information
1217   GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
1218
1219   def _Query(self, fields, filter_):
1220     return self.GetClient().Query(self.items[0], fields, filter_).ToDict()
1221
1222   def GET(self):
1223     """Returns resource information.
1224
1225     @return: Query result, see L{objects.QueryResponse}
1226
1227     """
1228     return self._Query(_GetQueryFields(self.queryargs), None)
1229
1230   def PUT(self):
1231     """Submits job querying for resources.
1232
1233     @return: Query result, see L{objects.QueryResponse}
1234
1235     """
1236     body = self.request_body
1237
1238     baserlib.CheckType(body, dict, "Body contents")
1239
1240     try:
1241       fields = body["fields"]
1242     except KeyError:
1243       fields = _GetQueryFields(self.queryargs)
1244
1245     return self._Query(fields, self.request_body.get("filter", None))
1246
1247
1248 class R_2_query_fields(baserlib.ResourceBase):
1249   """/2/query/[resource]/fields resource.
1250
1251   """
1252   def GET(self):
1253     """Retrieves list of available fields for a resource.
1254
1255     @return: List of serialized L{objects.QueryFieldDefinition}
1256
1257     """
1258     try:
1259       raw_fields = self.queryargs["fields"]
1260     except KeyError:
1261       fields = None
1262     else:
1263       fields = _SplitQueryFields(raw_fields[0])
1264
1265     return self.GetClient().QueryFields(self.items[0], fields).ToDict()
1266
1267
1268 class _R_Tags(baserlib.ResourceBase):
1269   """ Quasiclass for tagging resources
1270
1271   Manages tags. When inheriting this class you must define the
1272   TAG_LEVEL for it.
1273
1274   """
1275   TAG_LEVEL = None
1276
1277   def __init__(self, items, queryargs, req):
1278     """A tag resource constructor.
1279
1280     We have to override the default to sort out cluster naming case.
1281
1282     """
1283     baserlib.ResourceBase.__init__(self, items, queryargs, req)
1284
1285     if self.TAG_LEVEL == constants.TAG_CLUSTER:
1286       self.name = None
1287     else:
1288       self.name = items[0]
1289
1290   def GET(self):
1291     """Returns a list of tags.
1292
1293     Example: ["tag1", "tag2", "tag3"]
1294
1295     """
1296     kind = self.TAG_LEVEL
1297
1298     if kind in (constants.TAG_INSTANCE,
1299                 constants.TAG_NODEGROUP,
1300                 constants.TAG_NODE):
1301       if not self.name:
1302         raise http.HttpBadRequest("Missing name on tag request")
1303
1304       cl = self.GetClient()
1305       if kind == constants.TAG_INSTANCE:
1306         fn = cl.QueryInstances
1307       elif kind == constants.TAG_NODEGROUP:
1308         fn = cl.QueryGroups
1309       else:
1310         fn = cl.QueryNodes
1311       result = fn(names=[self.name], fields=["tags"], use_locking=False)
1312       if not result or not result[0]:
1313         raise http.HttpBadGateway("Invalid response from tag query")
1314       tags = result[0][0]
1315
1316     elif kind == constants.TAG_CLUSTER:
1317       assert not self.name
1318       # TODO: Use query API?
1319       ssc = ssconf.SimpleStore()
1320       tags = ssc.GetClusterTags()
1321
1322     return list(tags)
1323
1324   def PUT(self):
1325     """Add a set of tags.
1326
1327     The request as a list of strings should be PUT to this URI. And
1328     you'll have back a job id.
1329
1330     """
1331     # pylint: disable-msg=W0212
1332     if "tag" not in self.queryargs:
1333       raise http.HttpBadRequest("Please specify tag(s) to add using the"
1334                                 " the 'tag' parameter")
1335     op = opcodes.OpTagsSet(kind=self.TAG_LEVEL, name=self.name,
1336                            tags=self.queryargs["tag"], dry_run=self.dryRun())
1337     return self.SubmitJob([op])
1338
1339   def DELETE(self):
1340     """Delete a tag.
1341
1342     In order to delete a set of tags, the DELETE
1343     request should be addressed to URI like:
1344     /tags?tag=[tag]&tag=[tag]
1345
1346     """
1347     # pylint: disable-msg=W0212
1348     if "tag" not in self.queryargs:
1349       # no we not gonna delete all tags
1350       raise http.HttpBadRequest("Cannot delete all tags - please specify"
1351                                 " tag(s) using the 'tag' parameter")
1352     op = opcodes.OpTagsDel(kind=self.TAG_LEVEL, name=self.name,
1353                            tags=self.queryargs["tag"], dry_run=self.dryRun())
1354     return self.SubmitJob([op])
1355
1356
1357 class R_2_instances_name_tags(_R_Tags):
1358   """ /2/instances/[instance_name]/tags resource.
1359
1360   Manages per-instance tags.
1361
1362   """
1363   TAG_LEVEL = constants.TAG_INSTANCE
1364
1365
1366 class R_2_nodes_name_tags(_R_Tags):
1367   """ /2/nodes/[node_name]/tags resource.
1368
1369   Manages per-node tags.
1370
1371   """
1372   TAG_LEVEL = constants.TAG_NODE
1373
1374
1375 class R_2_groups_name_tags(_R_Tags):
1376   """ /2/groups/[group_name]/tags resource.
1377
1378   Manages per-nodegroup tags.
1379
1380   """
1381   TAG_LEVEL = constants.TAG_NODEGROUP
1382
1383
1384 class R_2_tags(_R_Tags):
1385   """ /2/tags resource.
1386
1387   Manages cluster tags.
1388
1389   """
1390   TAG_LEVEL = constants.TAG_CLUSTER