1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 try:
18 import json
19 except ImportError:
20 import simplejson as json
21
22 import copy
23 import datetime
24 import time
25
26 __docformat__ = "epytext"
27
28 -class Attr(object):
29 """
30 Encapsulates information about an attribute in the JSON encoding of the
31 object. It identifies properties of the attribute such as whether it's
32 read-only, its type, etc.
33 """
34 DATE_FMT = "%Y-%m-%dT%H:%M:%S.%fZ"
35
36 - def __init__(self, atype=None, rw=True, is_api_list=False):
37 self._atype = atype
38 self._is_api_list = is_api_list
39 self.rw = rw
40
41 - def to_json(self, value, preserve_ro):
42 """
43 Returns the JSON encoding of the given attribute value.
44
45 If the value has a 'to_json_dict' object, that method is called. Otherwise,
46 the following values are returned for each input type:
47 - datetime.datetime: string with the API representation of a date.
48 - dictionary: if 'atype' is ApiConfig, a list of ApiConfig objects.
49 - python list: python list (or ApiList) with JSON encoding of items
50 - the raw value otherwise
51 """
52 if hasattr(value, 'to_json_dict'):
53 return value.to_json_dict(preserve_ro)
54 elif isinstance(value, dict) and self._atype == ApiConfig:
55 return config_to_api_list(value)
56 elif isinstance(value, datetime.datetime):
57 return value.strftime(self.DATE_FMT)
58 elif isinstance(value, list) or isinstance(value, tuple):
59 if self._is_api_list:
60 return ApiList(value).to_json_dict()
61 else:
62 return [ self.to_json(x, preserve_ro) for x in value ]
63 else:
64 return value
65
67 """
68 Parses the given JSON value into an appropriate python object.
69
70 This means:
71 - a datetime.datetime if 'atype' is datetime.datetime
72 - a converted config dictionary or config list if 'atype' is ApiConfig
73 - if the attr is an API list, an ApiList with instances of 'atype'
74 - an instance of 'atype' if it has a 'from_json_dict' method
75 - a python list with decoded versions of the member objects if the input
76 is a python list.
77 - the raw value otherwise
78 """
79 if data is None:
80 return None
81
82 if self._atype == datetime.datetime:
83 return datetime.datetime.strptime(data, self.DATE_FMT)
84 elif self._atype == ApiConfig:
85
86
87
88 if not data['items']:
89 return { }
90 first = data['items'][0]
91 return json_to_config(data, len(first) == 2)
92 elif self._is_api_list:
93 return ApiList.from_json_dict(data, resource_root, self._atype)
94 elif isinstance(data, list):
95 return [ self.from_json(resource_root, x) for x in data ]
96 elif hasattr(self._atype, 'from_json_dict'):
97 return self._atype.from_json_dict(data, resource_root)
98 else:
99 return data
100
102 """
103 Subclass that just defines the attribute as read-only.
104 """
105 - def __init__(self, atype=None, is_api_list=False):
106 Attr.__init__(self, atype=atype, rw=False, is_api_list=is_api_list)
107
110 """
111 Checks if the resource_root's API version it at least the given minimum
112 version.
113 """
114 if resource_root.version < min_version:
115 raise Exception("API version %s is required but %s is in use."
116 % (min_version, resource_root.version))
117
118
119 -def call(method, path, ret_type,
120 ret_is_list=False, data=None, params=None, api_version=1):
121 """
122 Generic function for calling a resource method and automatically dealing with
123 serialization of parameters and deserialization of return values.
124
125 @param method: method to call (must be bound to a resource;
126 e.g., "resource_root.get").
127 @param path: the full path of the API method to call.
128 @param ret_type: return type of the call.
129 @param ret_is_list: whether the return type is an ApiList.
130 @param data: Optional data to send as payload to the call.
131 @param params: Optional query parameters for the call.
132 @param api_version: minimum API version for the call.
133 """
134 check_api_version(method.im_self, api_version)
135 if data is not None:
136 data = json.dumps(Attr(is_api_list=True).to_json(data, False))
137 ret = method(path, data=data, params=params)
138 else:
139 ret = method(path, params=params)
140 if ret_type is None:
141 return
142 elif ret_is_list:
143 return ApiList.from_json_dict(ret, method.im_self, ret_type)
144 elif isinstance(ret, list):
145 return [ ret_type.from_json_dict(x, method.im_self) for x in ret ]
146 else:
147 return ret_type.from_json_dict(ret, method.im_self)
148
150 """
151 The BaseApiObject helps with (de)serialization from/to JSON.
152
153 The derived class has two ways of defining custom attributes:
154 - Overwriting the '_ATTRIBUTES' field with the attribute dictionary
155 - Override the _get_attributes() method, in case static initialization of
156 the above field is not possible.
157
158 It's recommended that the _get_attributes() implementation do caching to
159 avoid computing the dictionary on every invocation.
160
161 The derived class's constructor must call the base class's init() static
162 method. All constructor arguments (aside from self and resource_root) must
163 be keywords arguments with default values (typically None), or
164 from_json_dict() will not work.
165 """
166
167 _ATTRIBUTES = { }
168 _WHITELIST = ( '_resource_root', '_attributes' )
169
170 @classmethod
172 """
173 Returns a map of property names to attr instances (or None for default
174 attribute behavior) describing the properties of the object.
175
176 By default, this method will return the class's _ATTRIBUTES field.
177 Classes can override this method to do custom initialization of the
178 attributes when needed.
179 """
180 return cls._ATTRIBUTES
181
182 @staticmethod
183 - def init(obj, resource_root, attrs=None):
184 """
185 Wraper around the real constructor to avoid issues with the 'self'
186 argument. Call like this, from a subclass's constructor:
187
188 - BaseApiObject.init(self, locals())
189 """
190
191
192 str_attrs = { }
193 if attrs:
194 for k, v in attrs.iteritems():
195 if k not in ('self', 'resource_root'):
196 str_attrs[k] = v
197 BaseApiObject.__init__(obj, resource_root, **str_attrs)
198
199 - def __init__(self, resource_root, **attrs):
200 """
201 Initializes internal state and sets all known writable properties of the
202 object to None. Then initializes the properties given in the provided
203 attributes dictionary.
204
205 @param resource_root: API resource object.
206 @param attrs: optional dictionary of attributes to set. This should only
207 contain r/w attributes.
208 """
209 self._resource_root = resource_root
210
211 for name, attr in self._get_attributes().iteritems():
212 object.__setattr__(self, name, None)
213 if attrs:
214 self._set_attrs(attrs, from_json=False)
215
216 - def _set_attrs(self, attrs, allow_ro=False, from_json=True):
217 """
218 Sets all the attributes in the dictionary. Optionally, allows setting
219 read-only attributes (e.g. when deserializing from JSON) and skipping
220 JSON deserialization of values.
221 """
222 for k, v in attrs.iteritems():
223 attr = self._check_attr(k, allow_ro)
224 if attr and from_json:
225 v = attr.from_json(self._get_resource_root(), v)
226 object.__setattr__(self, k, v)
227
232
234 if name not in self._get_attributes():
235 raise AttributeError('Invalid property %s for class %s.' %
236 (name, self.__class__.__name__))
237 attr = self._get_attributes()[name]
238 if not allow_ro and attr and not attr.rw:
239 raise AttributeError('Attribute %s of class %s is read only.' %
240 (name, self.__class__.__name__))
241 return attr
242
244 return self._resource_root
245
247 """Copy state from api_obj to this object."""
248 if not isinstance(self, api_obj.__class__):
249 raise ValueError(
250 "Class %s does not derive from %s; cannot update attributes." %
251 (self.__class__, api_obj.__class__))
252
253 for name in self._get_attributes().keys():
254 try:
255 val = getattr(api_obj, name)
256 setattr(self, name, val)
257 except AttributeError, ignored:
258 pass
259
261 dic = { }
262 for name, attr in self._get_attributes().iteritems():
263 if not preserve_ro and attr and not attr.rw:
264 continue
265 try:
266 value = getattr(self, name)
267 if value is not None:
268 if attr:
269 dic[name] = attr.to_json(value, preserve_ro)
270 else:
271 dic[name] = value
272 except AttributeError:
273 pass
274 return dic
275
277 """
278 Default implementation of __str__. Uses the type name and the first
279 attribute retrieved from the attribute map to create the string.
280 """
281 name = self._get_attributes().keys()[0]
282 value = getattr(self, name, None)
283 return "<%s>: %s = %s" % (self.__class__.__name__, name, value)
284
285 @classmethod
287 obj = cls(resource_root)
288 obj._set_attrs(dic, allow_ro=True)
289 return obj
290
292 """
293 A specialization of BaseApiObject that provides some utility methods for
294 resources. This class allows easier serialization / deserialization of
295 parameters and return values.
296 """
297
299 """
300 Returns the minimum API version for this resource. Defaults to 1.
301 """
302 return 1
303
305 """
306 Returns the path to the resource.
307
308 e.g., for a service 'foo' in cluster 'bar', this should return
309 '/clusters/bar/services/foo'.
310 """
311 raise NotImplementedError
312
314 """
315 Raise an exception if the version of the api is less than the given version.
316
317 @param version: The minimum required version.
318 """
319 actual_version = self._get_resource_root().version
320 version = max(version, self._api_version())
321 if actual_version < version:
322 raise Exception("API version %s is required but %s is in use."
323 % (version, actual_version))
324
325 - def _cmd(self, command, data=None, params=None, api_version=1):
326 """
327 Invokes a command on the resource. Commands are expected to be under the
328 "commands/" sub-resource.
329 """
330 return self._post("commands/" + command, ApiCommand,
331 data=data, params=params, api_version=api_version)
332
342
348
349 - def _delete(self, rel_path, ret_type, ret_is_list=False, params=None,
350 api_version=1):
351 return self._call('delete', rel_path, ret_type, ret_is_list, None, params,
352 api_version)
353
354 - def _get(self, rel_path, ret_type, ret_is_list=False, params=None,
355 api_version=1):
356 return self._call('get', rel_path, ret_type, ret_is_list, None, params,
357 api_version)
358
359 - def _post(self, rel_path, ret_type, ret_is_list=False, data=None, params=None,
360 api_version=1):
361 return self._call('post', rel_path, ret_type, ret_is_list, data, params,
362 api_version)
363
364 - def _put(self, rel_path, ret_type, ret_is_list=False, data=None, params=None,
365 api_version=1):
366 return self._call('put', rel_path, ret_type, ret_is_list, data, params,
367 api_version)
368
369 - def _call(self, method, rel_path, ret_type, ret_is_list=False, data=None,
370 params=None, api_version=1):
371 path = self._path()
372 if rel_path:
373 path += '/' + rel_path
374 return call(getattr(self._get_resource_root(), method),
375 path,
376 ret_type,
377 ret_is_list,
378 data,
379 params,
380 api_version)
381
383 """A list of some api object"""
384 LIST_KEY = "items"
385
386 - def __init__(self, objects, resource_root=None, **attrs):
390
392 return "<ApiList>(%d): [%s]" % (
393 len(self.objects),
394 ", ".join([str(item) for item in self.objects]))
395
401
404
407
410
412 return self.objects.__getslice__(i, j)
413
414 @classmethod
433
435 _ATTRIBUTES = {
436 'hostId' : None,
437 }
438
439 - def __init__(self, resource_root, hostId=None):
441
443 return "<ApiHostRef>: %s" % (self.hostId)
444
446 _ATTRIBUTES = {
447 'clusterName' : None,
448 'serviceName' : None,
449 'peerName' : None,
450 }
451
452 - def __init__(self, resource_root, serviceName=None, clusterName=None,
453 peerName=None):
455
457 _ATTRIBUTES = {
458 'clusterName' : None,
459 }
460
461 - def __init__(self, resource_root, clusterName = None):
463
465 _ATTRIBUTES = {
466 'clusterName' : None,
467 'serviceName' : None,
468 'roleName' : None,
469 }
470
471 - def __init__(self, resource_root, serviceName=None, roleName=None,
472 clusterName=None):
474
476 _ATTRIBUTES = {
477 'roleConfigGroupName' : None,
478 }
479
480 - def __init__(self, resource_root, roleConfigGroupName=None):
482
484 SYNCHRONOUS_COMMAND_ID = -1
485
486 @classmethod
488 if not cls.__dict__.has_key('_ATTRIBUTES'):
489 cls._ATTRIBUTES = {
490 'id' : ROAttr(),
491 'name' : ROAttr(),
492 'startTime' : ROAttr(datetime.datetime),
493 'endTime' : ROAttr(datetime.datetime),
494 'active' : ROAttr(),
495 'success' : ROAttr(),
496 'resultMessage' : ROAttr(),
497 'clusterRef' : ROAttr(ApiClusterRef),
498 'serviceRef' : ROAttr(ApiServiceRef),
499 'roleRef' : ROAttr(ApiRoleRef),
500 'hostRef' : ROAttr(ApiHostRef),
501 'children' : ROAttr(ApiCommand, is_api_list=True),
502 'parent' : ROAttr(ApiCommand),
503 'resultDataUrl' : ROAttr(),
504 }
505 return cls._ATTRIBUTES
506
508 return "<ApiCommand>: '%s' (id: %s; active: %s; success: %s)" % (
509 self.name, self.id, self.active, self.success)
510
512 return '/commands/%d' % self.id
513
525
526 - def wait(self, timeout=None):
527 """
528 Wait for command to finish.
529
530 @param timeout: (Optional) Max amount of time (in seconds) to wait. Wait
531 forever by default.
532 @return: The final ApiCommand object, containing the last known state.
533 The command may still be running in case of timeout.
534 """
535 if self.id == ApiCommand.SYNCHRONOUS_COMMAND_ID:
536 return self
537
538 SLEEP_SEC = 5
539
540 if timeout is None:
541 deadline = None
542 else:
543 deadline = time.time() + timeout
544
545 while True:
546 cmd = self.fetch()
547 if not cmd.active:
548 return cmd
549
550 if deadline is not None:
551 now = time.time()
552 if deadline < now:
553 return cmd
554 else:
555 time.sleep(min(SLEEP_SEC, deadline - now))
556 else:
557 time.sleep(SLEEP_SEC)
558
559
572
578
590
596 """Metric reading data."""
597
598 _ATTRIBUTES = {
599 'timestamp' : ROAttr(datetime.datetime),
600 'value' : ROAttr(),
601 }
602
605
621
627 _ATTRIBUTES = {
628 'name' : ROAttr(),
629 'type' : ROAttr(),
630 'parent' : ROAttr(),
631 'startTime' : ROAttr(),
632 'finishTime' : ROAttr(),
633 'id' : ROAttr(),
634 'status' : ROAttr(),
635 'user' : ROAttr(),
636 'group' : ROAttr(),
637 'inputDir' : ROAttr(),
638 'outputDir' : ROAttr(),
639 'mapper' : ROAttr(),
640 'combiner' : ROAttr(),
641 'reducer' : ROAttr(),
642 'queueName' : ROAttr(),
643 'schedulerPriority' : ROAttr(),
644 }
645
648
650 return "<ApiActivity>: %s (%s)" % (self.name, self.status)
651
652
653
654
655
656 -class ApiCmPeer(BaseApiObject):
657 _ATTRIBUTES = {
658 'name' : None,
659 'url' : None,
660 'username' : None,
661 'password' : None,
662 }
663
665 return "<ApiPeer>: %s (%s)" % (self.name, self.url)
666
672
674 _ATTRIBUTES = {
675 'sourceService' : Attr(ApiServiceRef),
676 'sourcePath' : None,
677 'destinationPath' : None,
678 'mapreduceServiceName' : None,
679 'userName' : None,
680 'numMaps' : None,
681 'dryRun' : None,
682 'schedulerPoolName' : None,
683 'abortOnError' : None,
684 'preservePermissions' : None,
685 'preserveBlockSize' : None,
686 'preserveReplicationCount' : None,
687 'removeMissingFiles' : None,
688 'skipChecksumChecks' : None,
689 'skipTrash' : None,
690 'replicationStrategy' : None,
691 'preserveXAttrs' : None,
692 }
693
695 _ATTRIBUTES = {
696 'progress' : ROAttr(),
697 'counters' : ROAttr(),
698 'numBytesDryRun' : ROAttr(),
699 'numFilesDryRun' : ROAttr(),
700 'numFilesExpected' : ROAttr(),
701 'numBytesExpected' : ROAttr(),
702 'numFilesCopied' : ROAttr(),
703 'numBytesCopied' : ROAttr(),
704 'numFilesSkipped' : ROAttr(),
705 'numBytesSkipped' : ROAttr(),
706 'numFilesDeleted' : ROAttr(),
707 'numFilesCopyFailed' : ROAttr(),
708 'numBytesCopyFailed' : ROAttr(),
709 'setupError' : ROAttr(),
710 'jobId' : ROAttr(),
711 'jobDetailsUri' : ROAttr(),
712 'dryRun' : ROAttr(),
713 'snapshottedDirs' : ROAttr(),
714 }
715
717 _ATTRIBUTES = {
718 'database' : None,
719 'tableName' : None,
720 }
721
723 return "<ApiHiveTable>: %s, %s" % (self.database, self.tableName)
724
726 _ATTRIBUTES = {
727 'database' : ROAttr(),
728 'signature' : ROAttr(),
729 }
730
732 return "<ApiImpalaUDF>: %s, %s" % (self.database, self.signature)
733
745
758
770
772 _ATTRIBUTES = {
773 'startTime' : Attr(datetime.datetime),
774 'endTime' : Attr(datetime.datetime),
775 'interval' : None,
776 'intervalUnit' : None,
777 'paused' : None,
778 'hdfsArguments' : Attr(ApiHdfsReplicationArguments),
779 'hiveArguments' : Attr(ApiHiveReplicationArguments),
780 'alertOnStart' : None,
781 'alertOnSuccess' : None,
782 'alertOnFail' : None,
783 'alertOnAbort' : None,
784 'id' : ROAttr(),
785 'nextRun' : ROAttr(datetime.datetime),
786 'history' : ROAttr(ApiReplicationCommand),
787 }
788
790 _ATTRIBUTES = {
791 'tableRegExps' : None,
792 'storage' : None,
793 }
794
799
801 _ATTRIBUTES = {
802 'snapshotName' : None,
803 'tableName' : None,
804 'creationTime' : ROAttr(datetime.datetime),
805 'storage' : None,
806 }
807
815
817 _ATTRIBUTES = {
818 'path' : None,
819 'snapshotName' : None,
820 'snapshotPath' : None,
821 'creationTime' : ROAttr(datetime.datetime),
822 }
823
831
833 _ATTRIBUTES = {
834 'processedTableCount' : ROAttr(),
835 'processedTables' : ROAttr(),
836 'unprocessedTableCount' : ROAttr(),
837 'unprocessedTables' : ROAttr(),
838 'createdSnapshotCount' : ROAttr(),
839 'createdSnapshots' : ROAttr(ApiHBaseSnapshot),
840 'deletedSnapshotCount' : ROAttr(),
841 'deletedSnapshots' : ROAttr(ApiHBaseSnapshot),
842 'creationErrorCount' : ROAttr(),
843 'creationErrors' : ROAttr(ApiHBaseSnapshotError),
844 'deletionErrorCount' : ROAttr(),
845 'deletionErrors' : ROAttr(ApiHBaseSnapshotError),
846 }
847
849 _ATTRIBUTES = {
850 'processedPathCount' : ROAttr(),
851 'processedPaths' : ROAttr(),
852 'unprocessedPathCount' : ROAttr(),
853 'unprocessedPaths' : ROAttr(),
854 'createdSnapshotCount' : ROAttr(),
855 'createdSnapshots' : ROAttr(ApiHdfsSnapshot),
856 'deletedSnapshotCount' : ROAttr(),
857 'deletedSnapshots' : ROAttr(ApiHdfsSnapshot),
858 'creationErrorCount' : ROAttr(),
859 'creationErrors' : ROAttr(ApiHdfsSnapshotError),
860 'deletionErrorCount' : ROAttr(),
861 'deletionErrors' : ROAttr(ApiHdfsSnapshotError),
862 }
863
875
877 """
878 @type name: str
879 @ivar name: Name of the snapshot policy.
880 @type description: str
881 @ivar description: Description of the snapshot policy.
882 @type hourly_snapshots: int
883 @ivar hourly_snapshots: Number of hourly snapshots to be retained (default: 0).
884 @type daily_snapshots: int
885 @ivar daily_snapshots: Number of daily snapshots to be retained (default: 0).
886 @type weekly_snapshots: int
887 @ivar weekly_snapshots: Number of weekly snapshots to be retained (default: 0).
888 @type monthly_snapshots: int
889 @ivar monthly_snapshots: Number of monthly snapshots to be retained (default: 0).
890 @type yearly_snapshots: int
891 @ivar yearly_snapshots: Number of yearly snapshots to be retained (default: 0).
892 @type hours_for_hourly_snapshots: list of int
893 @ivar hours_for_hourly_snapshots: Hours of the day that hourly snapshots should be created.
894 Valid values are 0 to 23. If this list is empty, then hourly snapshots are
895 created for every hour.
896 @type minute_of_hour: int
897 @ivar minute_of_hour: Minute in the hour that hourly, daily, weekly, monthly and yearly
898 snapshots should be created. Valid values are 0 to 59 (default: 0).
899 @type hour_of_day: int
900 @ivar hour_of_day: Hour in the day that daily, weekly, monthly and yearly snapshots should be created.
901 Valid values are 0 to 23 (default: 0).
902 @type day_of_week: int
903 @ivar day_of_week: Day of the week that weekly snapshots should be created.
904 Valid values are 1 to 7, 1 representing Sunday (default: 1).
905 @type day_of_month: int
906 @ivar day_of_month: Day of the month that monthly and yearly snapshots should be created.
907 Values from 1 to 31 are allowed. Additionally 0 to -30 can be used to
908 specify offsets from the last day of the month (default: 1).
909 @type month_of_year: int
910 @ivar month_of_year: Month of the year that yearly snapshots should be created.
911 Valid values are 1 to 12, 1 representing January (default: 1).
912 @ivar alert_on_start: whether to generate alerts on start of snapshot creation/deletion activity.
913 @ivar alert_on_success: whether to generate alerts on successful completion of snapshot creation/deletion activity.
914 @ivar alert_on_fail: whether to generate alerts on failure of snapshot creation/deletion activity.
915 @ivar alert_on_abort: whether to generate alerts on abort of snapshot creation/deletion activity.
916 @type hbaseArguments: ApiHBaseSnapshotPolicyArguments
917 @ivar hbaseArguments: HBase specific arguments for the replication job.
918 @type hdfsArguments: ApiHdfsSnapshotPolicyArguments
919 @ivar hdfsArguments: HDFS specific arguments for the replication job.
920 """
921 _ATTRIBUTES = {
922 'name' : None,
923 'description' : None,
924 'hourlySnapshots' : None,
925 'dailySnapshots' : None,
926 'weeklySnapshots' : None,
927 'monthlySnapshots' : None,
928 'yearlySnapshots' : None,
929 'minuteOfHour' : None,
930 'hourOfDay' : None,
931 'dayOfWeek' : None,
932 'dayOfMonth' : None,
933 'monthOfYear' : None,
934 'hoursForHourlySnapshots' : None,
935 'alertOnStart' : None,
936 'alertOnSuccess' : None,
937 'alertOnFail' : None,
938 'alertOnAbort' : None,
939 'hbaseArguments' : Attr(ApiHBaseSnapshotPolicyArguments),
940 'hdfsArguments' : Attr(ApiHdfsSnapshotPolicyArguments),
941 'lastCommand' : ROAttr(ApiSnapshotCommand),
942 'lastSuccessfulCommand' : ROAttr(ApiSnapshotCommand),
943 }
944
950 """One element in a batch request."""
951 _ATTRIBUTES = {
952 'method' : None,
953 'url' : None,
954 'body' : None,
955 'contentType' : None,
956 'acceptType' : None,
957 }
958
960 """One element in a batch response."""
961 _ATTRIBUTES = {
962 'statusCode' : ROAttr(),
963 'response' : ROAttr(),
964 }
965
972
973
974
975
976
977 -class ApiConfig(BaseApiObject):
978 _ATTRIBUTES = {
979 'name' : None,
980 'value' : None,
981 'required' : ROAttr(),
982 'default' : ROAttr(),
983 'displayName' : ROAttr(),
984 'description' : ROAttr(),
985 'relatedName' : ROAttr(),
986 'validationState' : ROAttr(),
987 'validationMessage' : ROAttr(),
988 }
989
990 - def __init__(self, resource_root, name=None, value=None):
992
994 return "<ApiConfig>: %s = %s" % (self.name, self.value)
995
997 _ATTRIBUTES = {
998 'queryId' : ROAttr(),
999 'queryState' : ROAttr(),
1000 'queryType' : ROAttr(),
1001 'statement' : ROAttr(),
1002 'database' : ROAttr(),
1003 'rowsProduced' : ROAttr(),
1004 'coordinator' : ROAttr(ApiHostRef),
1005 'user' : ROAttr(),
1006 'startTime' : ROAttr(datetime.datetime),
1007 'endTime' : ROAttr(datetime.datetime),
1008 'detailsAvailable' : ROAttr(),
1009 'attributes' : ROAttr(),
1010 'durationMillis' : ROAttr()
1011 }
1012
1014 return "<ApiImpalaQuery>: %s" % (self.queryId)
1015
1023
1025 _ATTRIBUTES = {
1026 'details' : ROAttr()
1027 }
1028
1030 return "<AipImpalaQueryDetailsResponse> %s" % self.details
1031
1033 _ATTRIBUTES = {
1034 'warning' : ROAttr()
1035 }
1036
1038 return "<ApiImpalaCancelResponse> %s" % self.warning
1039
1041
1042 _ATTRIBUTES = {
1043 'name' : ROAttr(),
1044 'type' : ROAttr(),
1045 'displayName' : ROAttr(),
1046 'supportsHistograms' : ROAttr(),
1047 'description' : ROAttr()
1048 }
1049
1051 return "<ApiImpalaQueryAttribute> %s" % name
1052
1060
1062 _ATTRIBUTES = {
1063 'applicationId' : ROAttr(),
1064 'name' : ROAttr(),
1065 'user' : ROAttr(),
1066 'startTime' : ROAttr(datetime.datetime),
1067 'endTime' : ROAttr(datetime.datetime),
1068 'pool' : ROAttr(),
1069 'state' : ROAttr(),
1070 'progress' : ROAttr(),
1071 'mr2AppInformation' : ROAttr(ApiMr2AppInformation),
1072 'attributes' : ROAttr(),
1073 }
1074
1076 return "<ApiYarnApplication>: %s" % (self.applicationId)
1077
1084
1086 _ATTRIBUTES = {
1087 'warning' : ROAttr()
1088 }
1089
1091 return "<ApiYarnKillResponse> %s" % self.warning
1092
1094
1095 _ATTRIBUTES = {
1096 'name' : ROAttr(),
1097 'type' : ROAttr(),
1098 'displayName' : ROAttr(),
1099 'supportsHistograms' : ROAttr(),
1100 'description' : ROAttr()
1101 }
1102
1104 return "<ApiYarnApplicationAttribute> %s" % name
1105
1107 """
1108 Converts a python dictionary into a list containing the proper
1109 ApiConfig encoding for configuration data.
1110
1111 @param dic: Key-value pairs to convert.
1112 @return: JSON dictionary of an ApiConfig list (*not* an ApiList).
1113 """
1114 config = [ ]
1115 for k, v in dic.iteritems():
1116 config.append({ 'name' : k, 'value': v })
1117 return { ApiList.LIST_KEY : config }
1118
1120 """
1121 Converts a python dictionary into a JSON payload.
1122
1123 The payload matches the expected "apiConfig list" type used to update
1124 configuration parameters using the API.
1125
1126 @param dic: Key-value pairs to convert.
1127 @return: String with the JSON-encoded data.
1128 """
1129 return json.dumps(config_to_api_list(dic))
1130
1132 """
1133 Converts a JSON-decoded config dictionary to a python dictionary.
1134
1135 When materializing the full view, the values in the dictionary will be
1136 instances of ApiConfig, instead of strings.
1137
1138 @param dic: JSON-decoded config dictionary.
1139 @param full: Whether to materialize the full view of the config data.
1140 @return: Python dictionary with config data.
1141 """
1142 config = { }
1143 for entry in dic['items']:
1144 k = entry['name']
1145 if full:
1146 config[k] = ApiConfig.from_json_dict(entry, None)
1147 else:
1148 config[k] = entry.get('value')
1149 return config
1150