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.OpcodeResource):
 957   """/2/instances/[instance_name]/activate-disks resource.
 958
 959   """
 960   PUT_OPCODE = opcodes.OpInstanceActivateDisks
 961
 962   def GetPutOpInput(self):
 963     """Activate disks for an instance.
 964
 965     The URI might contain ignore_size to ignore current recorded size.
 966
 967     """
 968     return ({}, {
 969       "instance_name": self.items[0],
 970       "ignore_size": bool(self._checkIntVariable("ignore_size")),
 971       })
 972
 973
 974 class R_2_instances_name_deactivate_disks(baserlib.ResourceBase):
 975   """/2/instances/[instance_name]/deactivate-disks resource.
 976
 977   """
 978   def PUT(self):
 979     """Deactivate disks for an instance.
 980
 981     """
 982     instance_name = self.items[0]
 983
 984     op = opcodes.OpInstanceDeactivateDisks(instance_name=instance_name)
 985
 986     return self.SubmitJob([op])
 987
 988
 989 class R_2_instances_name_prepare_export(baserlib.ResourceBase):
 990   """/2/instances/[instance_name]/prepare-export resource.
 991
 992   """
 993   def PUT(self):
 994     """Prepares an export for an instance.
 995
 996     @return: a job id
 997
 998     """
 999     instance_name = self.items[0]
1000     mode = self._checkStringVariable("mode")
1001
1002     op = opcodes.OpBackupPrepare(instance_name=instance_name,
1003                                  mode=mode)
1004
1005     return self.SubmitJob([op])
1006
1007
1008 def _ParseExportInstanceRequest(name, data):
1009   """Parses a request for an instance export.
1010
1011   @rtype: L{opcodes.OpBackupExport}
1012   @return: Instance export opcode
1013
1014   """
1015   # Rename "destination" to "target_node"
1016   try:
1017     data["target_node"] = data.pop("destination")
1018   except KeyError:
1019     pass
1020
1021   return baserlib.FillOpcode(opcodes.OpBackupExport, data, {
1022     "instance_name": name,
1023     })
1024
1025
1026 class R_2_instances_name_export(baserlib.ResourceBase):
1027   """/2/instances/[instance_name]/export resource.
1028
1029   """
1030   def PUT(self):
1031     """Exports an instance.
1032
1033     @return: a job id
1034
1035     """
1036     if not isinstance(self.request_body, dict):
1037       raise http.HttpBadRequest("Invalid body contents, not a dictionary")
1038
1039     op = _ParseExportInstanceRequest(self.items[0], self.request_body)
1040
1041     return self.SubmitJob([op])
1042
1043
1044 def _ParseMigrateInstanceRequest(name, data):
1045   """Parses a request for an instance migration.
1046
1047   @rtype: L{opcodes.OpInstanceMigrate}
1048   @return: Instance migration opcode
1049
1050   """
1051   return baserlib.FillOpcode(opcodes.OpInstanceMigrate, data, {
1052     "instance_name": name,
1053     })
1054
1055
1056 class R_2_instances_name_migrate(baserlib.ResourceBase):
1057   """/2/instances/[instance_name]/migrate resource.
1058
1059   """
1060   def PUT(self):
1061     """Migrates an instance.
1062
1063     @return: a job id
1064
1065     """
1066     baserlib.CheckType(self.request_body, dict, "Body contents")
1067
1068     op = _ParseMigrateInstanceRequest(self.items[0], self.request_body)
1069
1070     return self.SubmitJob([op])
1071
1072
1073 class R_2_instances_name_failover(baserlib.ResourceBase):
1074   """/2/instances/[instance_name]/failover resource.
1075
1076   """
1077   def PUT(self):
1078     """Does a failover of an instance.
1079
1080     @return: a job id
1081
1082     """
1083     baserlib.CheckType(self.request_body, dict, "Body contents")
1084
1085     op = baserlib.FillOpcode(opcodes.OpInstanceFailover, self.request_body, {
1086       "instance_name": self.items[0],
1087       })
1088
1089     return self.SubmitJob([op])
1090
1091
1092 def _ParseRenameInstanceRequest(name, data):
1093   """Parses a request for renaming an instance.
1094
1095   @rtype: L{opcodes.OpInstanceRename}
1096   @return: Instance rename opcode
1097
1098   """
1099   return baserlib.FillOpcode(opcodes.OpInstanceRename, data, {
1100     "instance_name": name,
1101     })
1102
1103
1104 class R_2_instances_name_rename(baserlib.ResourceBase):
1105   """/2/instances/[instance_name]/rename resource.
1106
1107   """
1108   def PUT(self):
1109     """Changes the name of an instance.
1110
1111     @return: a job id
1112
1113     """
1114     baserlib.CheckType(self.request_body, dict, "Body contents")
1115
1116     op = _ParseRenameInstanceRequest(self.items[0], self.request_body)
1117
1118     return self.SubmitJob([op])
1119
1120
1121 def _ParseModifyInstanceRequest(name, data):
1122   """Parses a request for modifying an instance.
1123
1124   @rtype: L{opcodes.OpInstanceSetParams}
1125   @return: Instance modify opcode
1126
1127   """
1128   return baserlib.FillOpcode(opcodes.OpInstanceSetParams, data, {
1129     "instance_name": name,
1130     })
1131
1132
1133 class R_2_instances_name_modify(baserlib.ResourceBase):
1134   """/2/instances/[instance_name]/modify resource.
1135
1136   """
1137   def PUT(self):
1138     """Changes some parameters of an instance.
1139
1140     @return: a job id
1141
1142     """
1143     baserlib.CheckType(self.request_body, dict, "Body contents")
1144
1145     op = _ParseModifyInstanceRequest(self.items[0], self.request_body)
1146
1147     return self.SubmitJob([op])
1148
1149
1150 class R_2_instances_name_disk_grow(baserlib.ResourceBase):
1151   """/2/instances/[instance_name]/disk/[disk_index]/grow resource.
1152
1153   """
1154   def POST(self):
1155     """Increases the size of an instance disk.
1156
1157     @return: a job id
1158
1159     """
1160     op = baserlib.FillOpcode(opcodes.OpInstanceGrowDisk, self.request_body, {
1161       "instance_name": self.items[0],
1162       "disk": int(self.items[1]),
1163       })
1164
1165     return self.SubmitJob([op])
1166
1167
1168 class R_2_instances_name_console(baserlib.ResourceBase):
1169   """/2/instances/[instance_name]/console resource.
1170
1171   """
1172   GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
1173
1174   def GET(self):
1175     """Request information for connecting to instance's console.
1176
1177     @return: Serialized instance console description, see
1178              L{objects.InstanceConsole}
1179
1180     """
1181     client = self.GetClient()
1182
1183     ((console, ), ) = client.QueryInstances([self.items[0]], ["console"], False)
1184
1185     if console is None:
1186       raise http.HttpServiceUnavailable("Instance console unavailable")
1187
1188     assert isinstance(console, dict)
1189     return console
1190
1191
1192 def _GetQueryFields(args):
1193   """
1194
1195   """
1196   try:
1197     fields = args["fields"]
1198   except KeyError:
1199     raise http.HttpBadRequest("Missing 'fields' query argument")
1200
1201   return _SplitQueryFields(fields[0])
1202
1203
1204 def _SplitQueryFields(fields):
1205   """
1206
1207   """
1208   return [i.strip() for i in fields.split(",")]
1209
1210
1211 class R_2_query(baserlib.ResourceBase):
1212   """/2/query/[resource] resource.
1213
1214   """
1215   # Results might contain sensitive information
1216   GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
1217
1218   def _Query(self, fields, filter_):
1219     return self.GetClient().Query(self.items[0], fields, filter_).ToDict()
1220
1221   def GET(self):
1222     """Returns resource information.
1223
1224     @return: Query result, see L{objects.QueryResponse}
1225
1226     """
1227     return self._Query(_GetQueryFields(self.queryargs), None)
1228
1229   def PUT(self):
1230     """Submits job querying for resources.
1231
1232     @return: Query result, see L{objects.QueryResponse}
1233
1234     """
1235     body = self.request_body
1236
1237     baserlib.CheckType(body, dict, "Body contents")
1238
1239     try:
1240       fields = body["fields"]
1241     except KeyError:
1242       fields = _GetQueryFields(self.queryargs)
1243
1244     return self._Query(fields, self.request_body.get("filter", None))
1245
1246
1247 class R_2_query_fields(baserlib.ResourceBase):
1248   """/2/query/[resource]/fields resource.
1249
1250   """
1251   def GET(self):
1252     """Retrieves list of available fields for a resource.
1253
1254     @return: List of serialized L{objects.QueryFieldDefinition}
1255
1256     """
1257     try:
1258       raw_fields = self.queryargs["fields"]
1259     except KeyError:
1260       fields = None
1261     else:
1262       fields = _SplitQueryFields(raw_fields[0])
1263
1264     return self.GetClient().QueryFields(self.items[0], fields).ToDict()
1265
1266
1267 class _R_Tags(baserlib.ResourceBase):
1268   """ Quasiclass for tagging resources
1269
1270   Manages tags. When inheriting this class you must define the
1271   TAG_LEVEL for it.
1272
1273   """
1274   TAG_LEVEL = None
1275
1276   def __init__(self, items, queryargs, req):
1277     """A tag resource constructor.
1278
1279     We have to override the default to sort out cluster naming case.
1280
1281     """
1282     baserlib.ResourceBase.__init__(self, items, queryargs, req)
1283
1284     if self.TAG_LEVEL == constants.TAG_CLUSTER:
1285       self.name = None
1286     else:
1287       self.name = items[0]
1288
1289   def GET(self):
1290     """Returns a list of tags.
1291
1292     Example: ["tag1", "tag2", "tag3"]
1293
1294     """
1295     kind = self.TAG_LEVEL
1296
1297     if kind in (constants.TAG_INSTANCE,
1298                 constants.TAG_NODEGROUP,
1299                 constants.TAG_NODE):
1300       if not self.name:
1301         raise http.HttpBadRequest("Missing name on tag request")
1302
1303       cl = self.GetClient()
1304       if kind == constants.TAG_INSTANCE:
1305         fn = cl.QueryInstances
1306       elif kind == constants.TAG_NODEGROUP:
1307         fn = cl.QueryGroups
1308       else:
1309         fn = cl.QueryNodes
1310       result = fn(names=[self.name], fields=["tags"], use_locking=False)
1311       if not result or not result[0]:
1312         raise http.HttpBadGateway("Invalid response from tag query")
1313       tags = result[0][0]
1314
1315     elif kind == constants.TAG_CLUSTER:
1316       assert not self.name
1317       # TODO: Use query API?
1318       ssc = ssconf.SimpleStore()
1319       tags = ssc.GetClusterTags()
1320
1321     return list(tags)
1322
1323   def PUT(self):
1324     """Add a set of tags.
1325
1326     The request as a list of strings should be PUT to this URI. And
1327     you'll have back a job id.
1328
1329     """
1330     # pylint: disable-msg=W0212
1331     if "tag" not in self.queryargs:
1332       raise http.HttpBadRequest("Please specify tag(s) to add using the"
1333                                 " the 'tag' parameter")
1334     op = opcodes.OpTagsSet(kind=self.TAG_LEVEL, name=self.name,
1335                            tags=self.queryargs["tag"], dry_run=self.dryRun())
1336     return self.SubmitJob([op])
1337
1338   def DELETE(self):
1339     """Delete a tag.
1340
1341     In order to delete a set of tags, the DELETE
1342     request should be addressed to URI like:
1343     /tags?tag=[tag]&tag=[tag]
1344
1345     """
1346     # pylint: disable-msg=W0212
1347     if "tag" not in self.queryargs:
1348       # no we not gonna delete all tags
1349       raise http.HttpBadRequest("Cannot delete all tags - please specify"
1350                                 " tag(s) using the 'tag' parameter")
1351     op = opcodes.OpTagsDel(kind=self.TAG_LEVEL, name=self.name,
1352                            tags=self.queryargs["tag"], dry_run=self.dryRun())
1353     return self.SubmitJob([op])
1354
1355
1356 class R_2_instances_name_tags(_R_Tags):
1357   """ /2/instances/[instance_name]/tags resource.
1358
1359   Manages per-instance tags.
1360
1361   """
1362   TAG_LEVEL = constants.TAG_INSTANCE
1363
1364
1365 class R_2_nodes_name_tags(_R_Tags):
1366   """ /2/nodes/[node_name]/tags resource.
1367
1368   Manages per-node tags.
1369
1370   """
1371   TAG_LEVEL = constants.TAG_NODE
1372
1373
1374 class R_2_groups_name_tags(_R_Tags):
1375   """ /2/groups/[group_name]/tags resource.
1376
1377   Manages per-nodegroup tags.
1378
1379   """
1380   TAG_LEVEL = constants.TAG_NODEGROUP
1381
1382
1383 class R_2_tags(_R_Tags):
1384   """ /2/tags resource.
1385
1386   Manages cluster tags.
1387
1388   """
1389   TAG_LEVEL = constants.TAG_CLUSTER