| # |
| # Autogenerated by Thrift Compiler (0.9.2) |
| # |
| # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| # |
| # options string: py:utf8strings |
| # |
| |
| from thrift.Thrift import TType, TMessageType, TException, TApplicationException |
| from ttypes import * |
| from thrift.Thrift import TProcessor |
| from thrift.transport import TTransport |
| from thrift.protocol import TBinaryProtocol, TProtocol |
| try: |
| from thrift.protocol import fastbinary |
| except: |
| fastbinary = None |
| |
| |
| class Iface: |
| def submitTopology(self, name, uploadedJarLocation, jsonConf, topology): |
| """ |
| Parameters: |
| - name |
| - uploadedJarLocation |
| - jsonConf |
| - topology |
| """ |
| pass |
| |
| def submitTopologyWithOpts(self, name, uploadedJarLocation, jsonConf, topology, options): |
| """ |
| Parameters: |
| - name |
| - uploadedJarLocation |
| - jsonConf |
| - topology |
| - options |
| """ |
| pass |
| |
| def killTopology(self, name): |
| """ |
| Parameters: |
| - name |
| """ |
| pass |
| |
| def killTopologyWithOpts(self, name, options): |
| """ |
| Parameters: |
| - name |
| - options |
| """ |
| pass |
| |
| def activate(self, name): |
| """ |
| Parameters: |
| - name |
| """ |
| pass |
| |
| def deactivate(self, name): |
| """ |
| Parameters: |
| - name |
| """ |
| pass |
| |
| def rebalance(self, name, options): |
| """ |
| Parameters: |
| - name |
| - options |
| """ |
| pass |
| |
| def metricMonitor(self, name, options): |
| """ |
| Parameters: |
| - name |
| - options |
| """ |
| pass |
| |
| def restart(self, name, jsonConf): |
| """ |
| Parameters: |
| - name |
| - jsonConf |
| """ |
| pass |
| |
| def beginLibUpload(self, libName): |
| """ |
| Parameters: |
| - libName |
| """ |
| pass |
| |
| def beginFileUpload(self): |
| pass |
| |
| def uploadChunk(self, location, chunk): |
| """ |
| Parameters: |
| - location |
| - chunk |
| """ |
| pass |
| |
| def finishFileUpload(self, location): |
| """ |
| Parameters: |
| - location |
| """ |
| pass |
| |
| def beginFileDownload(self, file): |
| """ |
| Parameters: |
| - file |
| """ |
| pass |
| |
| def downloadChunk(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| pass |
| |
| def finishFileDownload(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| pass |
| |
| def getNimbusConf(self): |
| pass |
| |
| def getTopologyConf(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| pass |
| |
| def getTopologyId(self, topologyName): |
| """ |
| Parameters: |
| - topologyName |
| """ |
| pass |
| |
| def getClusterInfo(self): |
| pass |
| |
| def getSupervisorWorkers(self, host): |
| """ |
| Parameters: |
| - host |
| """ |
| pass |
| |
| def getTopologyInfo(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| pass |
| |
| def getTopologyInfoByName(self, topologyName): |
| """ |
| Parameters: |
| - topologyName |
| """ |
| pass |
| |
| def getTopology(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| pass |
| |
| def getUserTopology(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| pass |
| |
| def uploadTopologyMetrics(self, topologyId, topologyMetrics): |
| """ |
| Parameters: |
| - topologyId |
| - topologyMetrics |
| """ |
| pass |
| |
| def registerMetrics(self, topologyId, metrics): |
| """ |
| Parameters: |
| - topologyId |
| - metrics |
| """ |
| pass |
| |
| def getTopologyMetrics(self, topologyId): |
| """ |
| Parameters: |
| - topologyId |
| """ |
| pass |
| |
| def getMetrics(self, topologyId, type): |
| """ |
| Parameters: |
| - topologyId |
| - type |
| """ |
| pass |
| |
| def getNettyMetrics(self, topologyId): |
| """ |
| Parameters: |
| - topologyId |
| """ |
| pass |
| |
| def getNettyMetricsByHost(self, topologyId, host): |
| """ |
| Parameters: |
| - topologyId |
| - host |
| """ |
| pass |
| |
| def getPagingNettyMetrics(self, topologyId, host, page): |
| """ |
| Parameters: |
| - topologyId |
| - host |
| - page |
| """ |
| pass |
| |
| def getNettyMetricSizeByHost(self, topologyId, host): |
| """ |
| Parameters: |
| - topologyId |
| - host |
| """ |
| pass |
| |
| def getTaskMetrics(self, topologyId, component): |
| """ |
| Parameters: |
| - topologyId |
| - component |
| """ |
| pass |
| |
| def getTaskAndStreamMetrics(self, topologyId, taskId): |
| """ |
| Parameters: |
| - topologyId |
| - taskId |
| """ |
| pass |
| |
| def getSummarizedTopologyMetrics(self, topologyId): |
| """ |
| Parameters: |
| - topologyId |
| """ |
| pass |
| |
| def getVersion(self): |
| pass |
| |
| def updateTopology(self, name, uploadedLocation, updateConf): |
| """ |
| Parameters: |
| - name |
| - uploadedLocation |
| - updateConf |
| """ |
| pass |
| |
| def updateTaskHeartbeat(self, taskHbs): |
| """ |
| Parameters: |
| - taskHbs |
| """ |
| pass |
| |
| |
| class Client(Iface): |
| def __init__(self, iprot, oprot=None): |
| self._iprot = self._oprot = iprot |
| if oprot is not None: |
| self._oprot = oprot |
| self._seqid = 0 |
| |
| def submitTopology(self, name, uploadedJarLocation, jsonConf, topology): |
| """ |
| Parameters: |
| - name |
| - uploadedJarLocation |
| - jsonConf |
| - topology |
| """ |
| self.send_submitTopology(name, uploadedJarLocation, jsonConf, topology) |
| self.recv_submitTopology() |
| |
| def send_submitTopology(self, name, uploadedJarLocation, jsonConf, topology): |
| self._oprot.writeMessageBegin('submitTopology', TMessageType.CALL, self._seqid) |
| args = submitTopology_args() |
| args.name = name |
| args.uploadedJarLocation = uploadedJarLocation |
| args.jsonConf = jsonConf |
| args.topology = topology |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_submitTopology(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = submitTopology_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| if result.ite is not None: |
| raise result.ite |
| if result.tae is not None: |
| raise result.tae |
| return |
| |
| def submitTopologyWithOpts(self, name, uploadedJarLocation, jsonConf, topology, options): |
| """ |
| Parameters: |
| - name |
| - uploadedJarLocation |
| - jsonConf |
| - topology |
| - options |
| """ |
| self.send_submitTopologyWithOpts(name, uploadedJarLocation, jsonConf, topology, options) |
| self.recv_submitTopologyWithOpts() |
| |
| def send_submitTopologyWithOpts(self, name, uploadedJarLocation, jsonConf, topology, options): |
| self._oprot.writeMessageBegin('submitTopologyWithOpts', TMessageType.CALL, self._seqid) |
| args = submitTopologyWithOpts_args() |
| args.name = name |
| args.uploadedJarLocation = uploadedJarLocation |
| args.jsonConf = jsonConf |
| args.topology = topology |
| args.options = options |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_submitTopologyWithOpts(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = submitTopologyWithOpts_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| if result.ite is not None: |
| raise result.ite |
| if result.tae is not None: |
| raise result.tae |
| return |
| |
| def killTopology(self, name): |
| """ |
| Parameters: |
| - name |
| """ |
| self.send_killTopology(name) |
| self.recv_killTopology() |
| |
| def send_killTopology(self, name): |
| self._oprot.writeMessageBegin('killTopology', TMessageType.CALL, self._seqid) |
| args = killTopology_args() |
| args.name = name |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_killTopology(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = killTopology_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| return |
| |
| def killTopologyWithOpts(self, name, options): |
| """ |
| Parameters: |
| - name |
| - options |
| """ |
| self.send_killTopologyWithOpts(name, options) |
| self.recv_killTopologyWithOpts() |
| |
| def send_killTopologyWithOpts(self, name, options): |
| self._oprot.writeMessageBegin('killTopologyWithOpts', TMessageType.CALL, self._seqid) |
| args = killTopologyWithOpts_args() |
| args.name = name |
| args.options = options |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_killTopologyWithOpts(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = killTopologyWithOpts_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| return |
| |
| def activate(self, name): |
| """ |
| Parameters: |
| - name |
| """ |
| self.send_activate(name) |
| self.recv_activate() |
| |
| def send_activate(self, name): |
| self._oprot.writeMessageBegin('activate', TMessageType.CALL, self._seqid) |
| args = activate_args() |
| args.name = name |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_activate(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = activate_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| return |
| |
| def deactivate(self, name): |
| """ |
| Parameters: |
| - name |
| """ |
| self.send_deactivate(name) |
| self.recv_deactivate() |
| |
| def send_deactivate(self, name): |
| self._oprot.writeMessageBegin('deactivate', TMessageType.CALL, self._seqid) |
| args = deactivate_args() |
| args.name = name |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_deactivate(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = deactivate_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| return |
| |
| def rebalance(self, name, options): |
| """ |
| Parameters: |
| - name |
| - options |
| """ |
| self.send_rebalance(name, options) |
| self.recv_rebalance() |
| |
| def send_rebalance(self, name, options): |
| self._oprot.writeMessageBegin('rebalance', TMessageType.CALL, self._seqid) |
| args = rebalance_args() |
| args.name = name |
| args.options = options |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_rebalance(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = rebalance_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| if result.ite is not None: |
| raise result.ite |
| return |
| |
| def metricMonitor(self, name, options): |
| """ |
| Parameters: |
| - name |
| - options |
| """ |
| self.send_metricMonitor(name, options) |
| self.recv_metricMonitor() |
| |
| def send_metricMonitor(self, name, options): |
| self._oprot.writeMessageBegin('metricMonitor', TMessageType.CALL, self._seqid) |
| args = metricMonitor_args() |
| args.name = name |
| args.options = options |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_metricMonitor(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = metricMonitor_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| return |
| |
| def restart(self, name, jsonConf): |
| """ |
| Parameters: |
| - name |
| - jsonConf |
| """ |
| self.send_restart(name, jsonConf) |
| self.recv_restart() |
| |
| def send_restart(self, name, jsonConf): |
| self._oprot.writeMessageBegin('restart', TMessageType.CALL, self._seqid) |
| args = restart_args() |
| args.name = name |
| args.jsonConf = jsonConf |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_restart(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = restart_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| if result.ite is not None: |
| raise result.ite |
| if result.tae is not None: |
| raise result.tae |
| return |
| |
| def beginLibUpload(self, libName): |
| """ |
| Parameters: |
| - libName |
| """ |
| self.send_beginLibUpload(libName) |
| self.recv_beginLibUpload() |
| |
| def send_beginLibUpload(self, libName): |
| self._oprot.writeMessageBegin('beginLibUpload', TMessageType.CALL, self._seqid) |
| args = beginLibUpload_args() |
| args.libName = libName |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_beginLibUpload(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = beginLibUpload_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| return |
| |
| def beginFileUpload(self): |
| self.send_beginFileUpload() |
| return self.recv_beginFileUpload() |
| |
| def send_beginFileUpload(self): |
| self._oprot.writeMessageBegin('beginFileUpload', TMessageType.CALL, self._seqid) |
| args = beginFileUpload_args() |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_beginFileUpload(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = beginFileUpload_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "beginFileUpload failed: unknown result"); |
| |
| def uploadChunk(self, location, chunk): |
| """ |
| Parameters: |
| - location |
| - chunk |
| """ |
| self.send_uploadChunk(location, chunk) |
| self.recv_uploadChunk() |
| |
| def send_uploadChunk(self, location, chunk): |
| self._oprot.writeMessageBegin('uploadChunk', TMessageType.CALL, self._seqid) |
| args = uploadChunk_args() |
| args.location = location |
| args.chunk = chunk |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_uploadChunk(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = uploadChunk_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| return |
| |
| def finishFileUpload(self, location): |
| """ |
| Parameters: |
| - location |
| """ |
| self.send_finishFileUpload(location) |
| self.recv_finishFileUpload() |
| |
| def send_finishFileUpload(self, location): |
| self._oprot.writeMessageBegin('finishFileUpload', TMessageType.CALL, self._seqid) |
| args = finishFileUpload_args() |
| args.location = location |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_finishFileUpload(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = finishFileUpload_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| return |
| |
| def beginFileDownload(self, file): |
| """ |
| Parameters: |
| - file |
| """ |
| self.send_beginFileDownload(file) |
| return self.recv_beginFileDownload() |
| |
| def send_beginFileDownload(self, file): |
| self._oprot.writeMessageBegin('beginFileDownload', TMessageType.CALL, self._seqid) |
| args = beginFileDownload_args() |
| args.file = file |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_beginFileDownload(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = beginFileDownload_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "beginFileDownload failed: unknown result"); |
| |
| def downloadChunk(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| self.send_downloadChunk(id) |
| return self.recv_downloadChunk() |
| |
| def send_downloadChunk(self, id): |
| self._oprot.writeMessageBegin('downloadChunk', TMessageType.CALL, self._seqid) |
| args = downloadChunk_args() |
| args.id = id |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_downloadChunk(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = downloadChunk_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "downloadChunk failed: unknown result"); |
| |
| def finishFileDownload(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| self.send_finishFileDownload(id) |
| self.recv_finishFileDownload() |
| |
| def send_finishFileDownload(self, id): |
| self._oprot.writeMessageBegin('finishFileDownload', TMessageType.CALL, self._seqid) |
| args = finishFileDownload_args() |
| args.id = id |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_finishFileDownload(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = finishFileDownload_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| return |
| |
| def getNimbusConf(self): |
| self.send_getNimbusConf() |
| return self.recv_getNimbusConf() |
| |
| def send_getNimbusConf(self): |
| self._oprot.writeMessageBegin('getNimbusConf', TMessageType.CALL, self._seqid) |
| args = getNimbusConf_args() |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getNimbusConf(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getNimbusConf_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getNimbusConf failed: unknown result"); |
| |
| def getTopologyConf(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| self.send_getTopologyConf(id) |
| return self.recv_getTopologyConf() |
| |
| def send_getTopologyConf(self, id): |
| self._oprot.writeMessageBegin('getTopologyConf', TMessageType.CALL, self._seqid) |
| args = getTopologyConf_args() |
| args.id = id |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getTopologyConf(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getTopologyConf_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.e is not None: |
| raise result.e |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getTopologyConf failed: unknown result"); |
| |
| def getTopologyId(self, topologyName): |
| """ |
| Parameters: |
| - topologyName |
| """ |
| self.send_getTopologyId(topologyName) |
| return self.recv_getTopologyId() |
| |
| def send_getTopologyId(self, topologyName): |
| self._oprot.writeMessageBegin('getTopologyId', TMessageType.CALL, self._seqid) |
| args = getTopologyId_args() |
| args.topologyName = topologyName |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getTopologyId(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getTopologyId_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.e is not None: |
| raise result.e |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getTopologyId failed: unknown result"); |
| |
| def getClusterInfo(self): |
| self.send_getClusterInfo() |
| return self.recv_getClusterInfo() |
| |
| def send_getClusterInfo(self): |
| self._oprot.writeMessageBegin('getClusterInfo', TMessageType.CALL, self._seqid) |
| args = getClusterInfo_args() |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getClusterInfo(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getClusterInfo_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getClusterInfo failed: unknown result"); |
| |
| def getSupervisorWorkers(self, host): |
| """ |
| Parameters: |
| - host |
| """ |
| self.send_getSupervisorWorkers(host) |
| return self.recv_getSupervisorWorkers() |
| |
| def send_getSupervisorWorkers(self, host): |
| self._oprot.writeMessageBegin('getSupervisorWorkers', TMessageType.CALL, self._seqid) |
| args = getSupervisorWorkers_args() |
| args.host = host |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getSupervisorWorkers(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getSupervisorWorkers_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.e is not None: |
| raise result.e |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getSupervisorWorkers failed: unknown result"); |
| |
| def getTopologyInfo(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| self.send_getTopologyInfo(id) |
| return self.recv_getTopologyInfo() |
| |
| def send_getTopologyInfo(self, id): |
| self._oprot.writeMessageBegin('getTopologyInfo', TMessageType.CALL, self._seqid) |
| args = getTopologyInfo_args() |
| args.id = id |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getTopologyInfo(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getTopologyInfo_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.e is not None: |
| raise result.e |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getTopologyInfo failed: unknown result"); |
| |
| def getTopologyInfoByName(self, topologyName): |
| """ |
| Parameters: |
| - topologyName |
| """ |
| self.send_getTopologyInfoByName(topologyName) |
| return self.recv_getTopologyInfoByName() |
| |
| def send_getTopologyInfoByName(self, topologyName): |
| self._oprot.writeMessageBegin('getTopologyInfoByName', TMessageType.CALL, self._seqid) |
| args = getTopologyInfoByName_args() |
| args.topologyName = topologyName |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getTopologyInfoByName(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getTopologyInfoByName_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.e is not None: |
| raise result.e |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getTopologyInfoByName failed: unknown result"); |
| |
| def getTopology(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| self.send_getTopology(id) |
| return self.recv_getTopology() |
| |
| def send_getTopology(self, id): |
| self._oprot.writeMessageBegin('getTopology', TMessageType.CALL, self._seqid) |
| args = getTopology_args() |
| args.id = id |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getTopology(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getTopology_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.e is not None: |
| raise result.e |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getTopology failed: unknown result"); |
| |
| def getUserTopology(self, id): |
| """ |
| Parameters: |
| - id |
| """ |
| self.send_getUserTopology(id) |
| return self.recv_getUserTopology() |
| |
| def send_getUserTopology(self, id): |
| self._oprot.writeMessageBegin('getUserTopology', TMessageType.CALL, self._seqid) |
| args = getUserTopology_args() |
| args.id = id |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getUserTopology(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getUserTopology_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.e is not None: |
| raise result.e |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserTopology failed: unknown result"); |
| |
| def uploadTopologyMetrics(self, topologyId, topologyMetrics): |
| """ |
| Parameters: |
| - topologyId |
| - topologyMetrics |
| """ |
| self.send_uploadTopologyMetrics(topologyId, topologyMetrics) |
| self.recv_uploadTopologyMetrics() |
| |
| def send_uploadTopologyMetrics(self, topologyId, topologyMetrics): |
| self._oprot.writeMessageBegin('uploadTopologyMetrics', TMessageType.CALL, self._seqid) |
| args = uploadTopologyMetrics_args() |
| args.topologyId = topologyId |
| args.topologyMetrics = topologyMetrics |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_uploadTopologyMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = uploadTopologyMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| return |
| |
| def registerMetrics(self, topologyId, metrics): |
| """ |
| Parameters: |
| - topologyId |
| - metrics |
| """ |
| self.send_registerMetrics(topologyId, metrics) |
| return self.recv_registerMetrics() |
| |
| def send_registerMetrics(self, topologyId, metrics): |
| self._oprot.writeMessageBegin('registerMetrics', TMessageType.CALL, self._seqid) |
| args = registerMetrics_args() |
| args.topologyId = topologyId |
| args.metrics = metrics |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_registerMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = registerMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "registerMetrics failed: unknown result"); |
| |
| def getTopologyMetrics(self, topologyId): |
| """ |
| Parameters: |
| - topologyId |
| """ |
| self.send_getTopologyMetrics(topologyId) |
| return self.recv_getTopologyMetrics() |
| |
| def send_getTopologyMetrics(self, topologyId): |
| self._oprot.writeMessageBegin('getTopologyMetrics', TMessageType.CALL, self._seqid) |
| args = getTopologyMetrics_args() |
| args.topologyId = topologyId |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getTopologyMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getTopologyMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getTopologyMetrics failed: unknown result"); |
| |
| def getMetrics(self, topologyId, type): |
| """ |
| Parameters: |
| - topologyId |
| - type |
| """ |
| self.send_getMetrics(topologyId, type) |
| return self.recv_getMetrics() |
| |
| def send_getMetrics(self, topologyId, type): |
| self._oprot.writeMessageBegin('getMetrics', TMessageType.CALL, self._seqid) |
| args = getMetrics_args() |
| args.topologyId = topologyId |
| args.type = type |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getMetrics failed: unknown result"); |
| |
| def getNettyMetrics(self, topologyId): |
| """ |
| Parameters: |
| - topologyId |
| """ |
| self.send_getNettyMetrics(topologyId) |
| return self.recv_getNettyMetrics() |
| |
| def send_getNettyMetrics(self, topologyId): |
| self._oprot.writeMessageBegin('getNettyMetrics', TMessageType.CALL, self._seqid) |
| args = getNettyMetrics_args() |
| args.topologyId = topologyId |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getNettyMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getNettyMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getNettyMetrics failed: unknown result"); |
| |
| def getNettyMetricsByHost(self, topologyId, host): |
| """ |
| Parameters: |
| - topologyId |
| - host |
| """ |
| self.send_getNettyMetricsByHost(topologyId, host) |
| return self.recv_getNettyMetricsByHost() |
| |
| def send_getNettyMetricsByHost(self, topologyId, host): |
| self._oprot.writeMessageBegin('getNettyMetricsByHost', TMessageType.CALL, self._seqid) |
| args = getNettyMetricsByHost_args() |
| args.topologyId = topologyId |
| args.host = host |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getNettyMetricsByHost(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getNettyMetricsByHost_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getNettyMetricsByHost failed: unknown result"); |
| |
| def getPagingNettyMetrics(self, topologyId, host, page): |
| """ |
| Parameters: |
| - topologyId |
| - host |
| - page |
| """ |
| self.send_getPagingNettyMetrics(topologyId, host, page) |
| return self.recv_getPagingNettyMetrics() |
| |
| def send_getPagingNettyMetrics(self, topologyId, host, page): |
| self._oprot.writeMessageBegin('getPagingNettyMetrics', TMessageType.CALL, self._seqid) |
| args = getPagingNettyMetrics_args() |
| args.topologyId = topologyId |
| args.host = host |
| args.page = page |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getPagingNettyMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getPagingNettyMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getPagingNettyMetrics failed: unknown result"); |
| |
| def getNettyMetricSizeByHost(self, topologyId, host): |
| """ |
| Parameters: |
| - topologyId |
| - host |
| """ |
| self.send_getNettyMetricSizeByHost(topologyId, host) |
| return self.recv_getNettyMetricSizeByHost() |
| |
| def send_getNettyMetricSizeByHost(self, topologyId, host): |
| self._oprot.writeMessageBegin('getNettyMetricSizeByHost', TMessageType.CALL, self._seqid) |
| args = getNettyMetricSizeByHost_args() |
| args.topologyId = topologyId |
| args.host = host |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getNettyMetricSizeByHost(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getNettyMetricSizeByHost_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getNettyMetricSizeByHost failed: unknown result"); |
| |
| def getTaskMetrics(self, topologyId, component): |
| """ |
| Parameters: |
| - topologyId |
| - component |
| """ |
| self.send_getTaskMetrics(topologyId, component) |
| return self.recv_getTaskMetrics() |
| |
| def send_getTaskMetrics(self, topologyId, component): |
| self._oprot.writeMessageBegin('getTaskMetrics', TMessageType.CALL, self._seqid) |
| args = getTaskMetrics_args() |
| args.topologyId = topologyId |
| args.component = component |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getTaskMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getTaskMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getTaskMetrics failed: unknown result"); |
| |
| def getTaskAndStreamMetrics(self, topologyId, taskId): |
| """ |
| Parameters: |
| - topologyId |
| - taskId |
| """ |
| self.send_getTaskAndStreamMetrics(topologyId, taskId) |
| return self.recv_getTaskAndStreamMetrics() |
| |
| def send_getTaskAndStreamMetrics(self, topologyId, taskId): |
| self._oprot.writeMessageBegin('getTaskAndStreamMetrics', TMessageType.CALL, self._seqid) |
| args = getTaskAndStreamMetrics_args() |
| args.topologyId = topologyId |
| args.taskId = taskId |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getTaskAndStreamMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getTaskAndStreamMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getTaskAndStreamMetrics failed: unknown result"); |
| |
| def getSummarizedTopologyMetrics(self, topologyId): |
| """ |
| Parameters: |
| - topologyId |
| """ |
| self.send_getSummarizedTopologyMetrics(topologyId) |
| return self.recv_getSummarizedTopologyMetrics() |
| |
| def send_getSummarizedTopologyMetrics(self, topologyId): |
| self._oprot.writeMessageBegin('getSummarizedTopologyMetrics', TMessageType.CALL, self._seqid) |
| args = getSummarizedTopologyMetrics_args() |
| args.topologyId = topologyId |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getSummarizedTopologyMetrics(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getSummarizedTopologyMetrics_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getSummarizedTopologyMetrics failed: unknown result"); |
| |
| def getVersion(self): |
| self.send_getVersion() |
| return self.recv_getVersion() |
| |
| def send_getVersion(self): |
| self._oprot.writeMessageBegin('getVersion', TMessageType.CALL, self._seqid) |
| args = getVersion_args() |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_getVersion(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = getVersion_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "getVersion failed: unknown result"); |
| |
| def updateTopology(self, name, uploadedLocation, updateConf): |
| """ |
| Parameters: |
| - name |
| - uploadedLocation |
| - updateConf |
| """ |
| self.send_updateTopology(name, uploadedLocation, updateConf) |
| self.recv_updateTopology() |
| |
| def send_updateTopology(self, name, uploadedLocation, updateConf): |
| self._oprot.writeMessageBegin('updateTopology', TMessageType.CALL, self._seqid) |
| args = updateTopology_args() |
| args.name = name |
| args.uploadedLocation = uploadedLocation |
| args.updateConf = updateConf |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_updateTopology(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = updateTopology_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.e is not None: |
| raise result.e |
| if result.ite is not None: |
| raise result.ite |
| return |
| |
| def updateTaskHeartbeat(self, taskHbs): |
| """ |
| Parameters: |
| - taskHbs |
| """ |
| self.send_updateTaskHeartbeat(taskHbs) |
| self.recv_updateTaskHeartbeat() |
| |
| def send_updateTaskHeartbeat(self, taskHbs): |
| self._oprot.writeMessageBegin('updateTaskHeartbeat', TMessageType.CALL, self._seqid) |
| args = updateTaskHeartbeat_args() |
| args.taskHbs = taskHbs |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_updateTaskHeartbeat(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = updateTaskHeartbeat_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| return |
| |
| |
| class Processor(Iface, TProcessor): |
| def __init__(self, handler): |
| self._handler = handler |
| self._processMap = {} |
| self._processMap["submitTopology"] = Processor.process_submitTopology |
| self._processMap["submitTopologyWithOpts"] = Processor.process_submitTopologyWithOpts |
| self._processMap["killTopology"] = Processor.process_killTopology |
| self._processMap["killTopologyWithOpts"] = Processor.process_killTopologyWithOpts |
| self._processMap["activate"] = Processor.process_activate |
| self._processMap["deactivate"] = Processor.process_deactivate |
| self._processMap["rebalance"] = Processor.process_rebalance |
| self._processMap["metricMonitor"] = Processor.process_metricMonitor |
| self._processMap["restart"] = Processor.process_restart |
| self._processMap["beginLibUpload"] = Processor.process_beginLibUpload |
| self._processMap["beginFileUpload"] = Processor.process_beginFileUpload |
| self._processMap["uploadChunk"] = Processor.process_uploadChunk |
| self._processMap["finishFileUpload"] = Processor.process_finishFileUpload |
| self._processMap["beginFileDownload"] = Processor.process_beginFileDownload |
| self._processMap["downloadChunk"] = Processor.process_downloadChunk |
| self._processMap["finishFileDownload"] = Processor.process_finishFileDownload |
| self._processMap["getNimbusConf"] = Processor.process_getNimbusConf |
| self._processMap["getTopologyConf"] = Processor.process_getTopologyConf |
| self._processMap["getTopologyId"] = Processor.process_getTopologyId |
| self._processMap["getClusterInfo"] = Processor.process_getClusterInfo |
| self._processMap["getSupervisorWorkers"] = Processor.process_getSupervisorWorkers |
| self._processMap["getTopologyInfo"] = Processor.process_getTopologyInfo |
| self._processMap["getTopologyInfoByName"] = Processor.process_getTopologyInfoByName |
| self._processMap["getTopology"] = Processor.process_getTopology |
| self._processMap["getUserTopology"] = Processor.process_getUserTopology |
| self._processMap["uploadTopologyMetrics"] = Processor.process_uploadTopologyMetrics |
| self._processMap["registerMetrics"] = Processor.process_registerMetrics |
| self._processMap["getTopologyMetrics"] = Processor.process_getTopologyMetrics |
| self._processMap["getMetrics"] = Processor.process_getMetrics |
| self._processMap["getNettyMetrics"] = Processor.process_getNettyMetrics |
| self._processMap["getNettyMetricsByHost"] = Processor.process_getNettyMetricsByHost |
| self._processMap["getPagingNettyMetrics"] = Processor.process_getPagingNettyMetrics |
| self._processMap["getNettyMetricSizeByHost"] = Processor.process_getNettyMetricSizeByHost |
| self._processMap["getTaskMetrics"] = Processor.process_getTaskMetrics |
| self._processMap["getTaskAndStreamMetrics"] = Processor.process_getTaskAndStreamMetrics |
| self._processMap["getSummarizedTopologyMetrics"] = Processor.process_getSummarizedTopologyMetrics |
| self._processMap["getVersion"] = Processor.process_getVersion |
| self._processMap["updateTopology"] = Processor.process_updateTopology |
| self._processMap["updateTaskHeartbeat"] = Processor.process_updateTaskHeartbeat |
| |
| def process(self, iprot, oprot): |
| (name, type, seqid) = iprot.readMessageBegin() |
| if name not in self._processMap: |
| iprot.skip(TType.STRUCT) |
| iprot.readMessageEnd() |
| x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name)) |
| oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid) |
| x.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| return |
| else: |
| self._processMap[name](self, seqid, iprot, oprot) |
| return True |
| |
| def process_submitTopology(self, seqid, iprot, oprot): |
| args = submitTopology_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = submitTopology_result() |
| try: |
| self._handler.submitTopology(args.name, args.uploadedJarLocation, args.jsonConf, args.topology) |
| except AlreadyAliveException, e: |
| result.e = e |
| except InvalidTopologyException, ite: |
| result.ite = ite |
| except TopologyAssignException, tae: |
| result.tae = tae |
| oprot.writeMessageBegin("submitTopology", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_submitTopologyWithOpts(self, seqid, iprot, oprot): |
| args = submitTopologyWithOpts_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = submitTopologyWithOpts_result() |
| try: |
| self._handler.submitTopologyWithOpts(args.name, args.uploadedJarLocation, args.jsonConf, args.topology, args.options) |
| except AlreadyAliveException, e: |
| result.e = e |
| except InvalidTopologyException, ite: |
| result.ite = ite |
| except TopologyAssignException, tae: |
| result.tae = tae |
| oprot.writeMessageBegin("submitTopologyWithOpts", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_killTopology(self, seqid, iprot, oprot): |
| args = killTopology_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = killTopology_result() |
| try: |
| self._handler.killTopology(args.name) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("killTopology", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_killTopologyWithOpts(self, seqid, iprot, oprot): |
| args = killTopologyWithOpts_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = killTopologyWithOpts_result() |
| try: |
| self._handler.killTopologyWithOpts(args.name, args.options) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("killTopologyWithOpts", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_activate(self, seqid, iprot, oprot): |
| args = activate_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = activate_result() |
| try: |
| self._handler.activate(args.name) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("activate", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_deactivate(self, seqid, iprot, oprot): |
| args = deactivate_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = deactivate_result() |
| try: |
| self._handler.deactivate(args.name) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("deactivate", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_rebalance(self, seqid, iprot, oprot): |
| args = rebalance_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = rebalance_result() |
| try: |
| self._handler.rebalance(args.name, args.options) |
| except NotAliveException, e: |
| result.e = e |
| except InvalidTopologyException, ite: |
| result.ite = ite |
| oprot.writeMessageBegin("rebalance", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_metricMonitor(self, seqid, iprot, oprot): |
| args = metricMonitor_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = metricMonitor_result() |
| try: |
| self._handler.metricMonitor(args.name, args.options) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("metricMonitor", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_restart(self, seqid, iprot, oprot): |
| args = restart_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = restart_result() |
| try: |
| self._handler.restart(args.name, args.jsonConf) |
| except NotAliveException, e: |
| result.e = e |
| except InvalidTopologyException, ite: |
| result.ite = ite |
| except TopologyAssignException, tae: |
| result.tae = tae |
| oprot.writeMessageBegin("restart", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_beginLibUpload(self, seqid, iprot, oprot): |
| args = beginLibUpload_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = beginLibUpload_result() |
| self._handler.beginLibUpload(args.libName) |
| oprot.writeMessageBegin("beginLibUpload", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_beginFileUpload(self, seqid, iprot, oprot): |
| args = beginFileUpload_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = beginFileUpload_result() |
| result.success = self._handler.beginFileUpload() |
| oprot.writeMessageBegin("beginFileUpload", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_uploadChunk(self, seqid, iprot, oprot): |
| args = uploadChunk_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = uploadChunk_result() |
| self._handler.uploadChunk(args.location, args.chunk) |
| oprot.writeMessageBegin("uploadChunk", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_finishFileUpload(self, seqid, iprot, oprot): |
| args = finishFileUpload_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = finishFileUpload_result() |
| self._handler.finishFileUpload(args.location) |
| oprot.writeMessageBegin("finishFileUpload", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_beginFileDownload(self, seqid, iprot, oprot): |
| args = beginFileDownload_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = beginFileDownload_result() |
| result.success = self._handler.beginFileDownload(args.file) |
| oprot.writeMessageBegin("beginFileDownload", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_downloadChunk(self, seqid, iprot, oprot): |
| args = downloadChunk_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = downloadChunk_result() |
| result.success = self._handler.downloadChunk(args.id) |
| oprot.writeMessageBegin("downloadChunk", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_finishFileDownload(self, seqid, iprot, oprot): |
| args = finishFileDownload_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = finishFileDownload_result() |
| self._handler.finishFileDownload(args.id) |
| oprot.writeMessageBegin("finishFileDownload", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getNimbusConf(self, seqid, iprot, oprot): |
| args = getNimbusConf_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getNimbusConf_result() |
| result.success = self._handler.getNimbusConf() |
| oprot.writeMessageBegin("getNimbusConf", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getTopologyConf(self, seqid, iprot, oprot): |
| args = getTopologyConf_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getTopologyConf_result() |
| try: |
| result.success = self._handler.getTopologyConf(args.id) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("getTopologyConf", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getTopologyId(self, seqid, iprot, oprot): |
| args = getTopologyId_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getTopologyId_result() |
| try: |
| result.success = self._handler.getTopologyId(args.topologyName) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("getTopologyId", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getClusterInfo(self, seqid, iprot, oprot): |
| args = getClusterInfo_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getClusterInfo_result() |
| result.success = self._handler.getClusterInfo() |
| oprot.writeMessageBegin("getClusterInfo", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getSupervisorWorkers(self, seqid, iprot, oprot): |
| args = getSupervisorWorkers_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getSupervisorWorkers_result() |
| try: |
| result.success = self._handler.getSupervisorWorkers(args.host) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("getSupervisorWorkers", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getTopologyInfo(self, seqid, iprot, oprot): |
| args = getTopologyInfo_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getTopologyInfo_result() |
| try: |
| result.success = self._handler.getTopologyInfo(args.id) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("getTopologyInfo", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getTopologyInfoByName(self, seqid, iprot, oprot): |
| args = getTopologyInfoByName_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getTopologyInfoByName_result() |
| try: |
| result.success = self._handler.getTopologyInfoByName(args.topologyName) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("getTopologyInfoByName", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getTopology(self, seqid, iprot, oprot): |
| args = getTopology_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getTopology_result() |
| try: |
| result.success = self._handler.getTopology(args.id) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("getTopology", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getUserTopology(self, seqid, iprot, oprot): |
| args = getUserTopology_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getUserTopology_result() |
| try: |
| result.success = self._handler.getUserTopology(args.id) |
| except NotAliveException, e: |
| result.e = e |
| oprot.writeMessageBegin("getUserTopology", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_uploadTopologyMetrics(self, seqid, iprot, oprot): |
| args = uploadTopologyMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = uploadTopologyMetrics_result() |
| self._handler.uploadTopologyMetrics(args.topologyId, args.topologyMetrics) |
| oprot.writeMessageBegin("uploadTopologyMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_registerMetrics(self, seqid, iprot, oprot): |
| args = registerMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = registerMetrics_result() |
| result.success = self._handler.registerMetrics(args.topologyId, args.metrics) |
| oprot.writeMessageBegin("registerMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getTopologyMetrics(self, seqid, iprot, oprot): |
| args = getTopologyMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getTopologyMetrics_result() |
| result.success = self._handler.getTopologyMetrics(args.topologyId) |
| oprot.writeMessageBegin("getTopologyMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getMetrics(self, seqid, iprot, oprot): |
| args = getMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getMetrics_result() |
| result.success = self._handler.getMetrics(args.topologyId, args.type) |
| oprot.writeMessageBegin("getMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getNettyMetrics(self, seqid, iprot, oprot): |
| args = getNettyMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getNettyMetrics_result() |
| result.success = self._handler.getNettyMetrics(args.topologyId) |
| oprot.writeMessageBegin("getNettyMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getNettyMetricsByHost(self, seqid, iprot, oprot): |
| args = getNettyMetricsByHost_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getNettyMetricsByHost_result() |
| result.success = self._handler.getNettyMetricsByHost(args.topologyId, args.host) |
| oprot.writeMessageBegin("getNettyMetricsByHost", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getPagingNettyMetrics(self, seqid, iprot, oprot): |
| args = getPagingNettyMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getPagingNettyMetrics_result() |
| result.success = self._handler.getPagingNettyMetrics(args.topologyId, args.host, args.page) |
| oprot.writeMessageBegin("getPagingNettyMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getNettyMetricSizeByHost(self, seqid, iprot, oprot): |
| args = getNettyMetricSizeByHost_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getNettyMetricSizeByHost_result() |
| result.success = self._handler.getNettyMetricSizeByHost(args.topologyId, args.host) |
| oprot.writeMessageBegin("getNettyMetricSizeByHost", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getTaskMetrics(self, seqid, iprot, oprot): |
| args = getTaskMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getTaskMetrics_result() |
| result.success = self._handler.getTaskMetrics(args.topologyId, args.component) |
| oprot.writeMessageBegin("getTaskMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getTaskAndStreamMetrics(self, seqid, iprot, oprot): |
| args = getTaskAndStreamMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getTaskAndStreamMetrics_result() |
| result.success = self._handler.getTaskAndStreamMetrics(args.topologyId, args.taskId) |
| oprot.writeMessageBegin("getTaskAndStreamMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getSummarizedTopologyMetrics(self, seqid, iprot, oprot): |
| args = getSummarizedTopologyMetrics_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getSummarizedTopologyMetrics_result() |
| result.success = self._handler.getSummarizedTopologyMetrics(args.topologyId) |
| oprot.writeMessageBegin("getSummarizedTopologyMetrics", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_getVersion(self, seqid, iprot, oprot): |
| args = getVersion_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = getVersion_result() |
| result.success = self._handler.getVersion() |
| oprot.writeMessageBegin("getVersion", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_updateTopology(self, seqid, iprot, oprot): |
| args = updateTopology_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = updateTopology_result() |
| try: |
| self._handler.updateTopology(args.name, args.uploadedLocation, args.updateConf) |
| except NotAliveException, e: |
| result.e = e |
| except InvalidTopologyException, ite: |
| result.ite = ite |
| oprot.writeMessageBegin("updateTopology", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_updateTaskHeartbeat(self, seqid, iprot, oprot): |
| args = updateTaskHeartbeat_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = updateTaskHeartbeat_result() |
| self._handler.updateTaskHeartbeat(args.taskHbs) |
| oprot.writeMessageBegin("updateTaskHeartbeat", TMessageType.REPLY, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| |
| # HELPER FUNCTIONS AND STRUCTURES |
| |
| class submitTopology_args: |
| """ |
| Attributes: |
| - name |
| - uploadedJarLocation |
| - jsonConf |
| - topology |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| (2, TType.STRING, 'uploadedJarLocation', None, None, ), # 2 |
| (3, TType.STRING, 'jsonConf', None, None, ), # 3 |
| (4, TType.STRUCT, 'topology', (StormTopology, StormTopology.thrift_spec), None, ), # 4 |
| ) |
| |
| def __init__(self, name=None, uploadedJarLocation=None, jsonConf=None, topology=None,): |
| self.name = name |
| self.uploadedJarLocation = uploadedJarLocation |
| self.jsonConf = jsonConf |
| self.topology = topology |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.uploadedJarLocation = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.STRING: |
| self.jsonConf = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 4: |
| if ftype == TType.STRUCT: |
| self.topology = StormTopology() |
| self.topology.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('submitTopology_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.uploadedJarLocation is not None: |
| oprot.writeFieldBegin('uploadedJarLocation', TType.STRING, 2) |
| oprot.writeString(self.uploadedJarLocation.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.jsonConf is not None: |
| oprot.writeFieldBegin('jsonConf', TType.STRING, 3) |
| oprot.writeString(self.jsonConf.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.topology is not None: |
| oprot.writeFieldBegin('topology', TType.STRUCT, 4) |
| self.topology.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| value = (value * 31) ^ hash(self.uploadedJarLocation) |
| value = (value * 31) ^ hash(self.jsonConf) |
| value = (value * 31) ^ hash(self.topology) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class submitTopology_result: |
| """ |
| Attributes: |
| - e |
| - ite |
| - tae |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (AlreadyAliveException, AlreadyAliveException.thrift_spec), None, ), # 1 |
| (2, TType.STRUCT, 'ite', (InvalidTopologyException, InvalidTopologyException.thrift_spec), None, ), # 2 |
| (3, TType.STRUCT, 'tae', (TopologyAssignException, TopologyAssignException.thrift_spec), None, ), # 3 |
| ) |
| |
| def __init__(self, e=None, ite=None, tae=None,): |
| self.e = e |
| self.ite = ite |
| self.tae = tae |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = AlreadyAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.ite = InvalidTopologyException() |
| self.ite.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.STRUCT: |
| self.tae = TopologyAssignException() |
| self.tae.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('submitTopology_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| if self.ite is not None: |
| oprot.writeFieldBegin('ite', TType.STRUCT, 2) |
| self.ite.write(oprot) |
| oprot.writeFieldEnd() |
| if self.tae is not None: |
| oprot.writeFieldBegin('tae', TType.STRUCT, 3) |
| self.tae.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| value = (value * 31) ^ hash(self.ite) |
| value = (value * 31) ^ hash(self.tae) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class submitTopologyWithOpts_args: |
| """ |
| Attributes: |
| - name |
| - uploadedJarLocation |
| - jsonConf |
| - topology |
| - options |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| (2, TType.STRING, 'uploadedJarLocation', None, None, ), # 2 |
| (3, TType.STRING, 'jsonConf', None, None, ), # 3 |
| (4, TType.STRUCT, 'topology', (StormTopology, StormTopology.thrift_spec), None, ), # 4 |
| (5, TType.STRUCT, 'options', (SubmitOptions, SubmitOptions.thrift_spec), None, ), # 5 |
| ) |
| |
| def __init__(self, name=None, uploadedJarLocation=None, jsonConf=None, topology=None, options=None,): |
| self.name = name |
| self.uploadedJarLocation = uploadedJarLocation |
| self.jsonConf = jsonConf |
| self.topology = topology |
| self.options = options |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.uploadedJarLocation = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.STRING: |
| self.jsonConf = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 4: |
| if ftype == TType.STRUCT: |
| self.topology = StormTopology() |
| self.topology.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 5: |
| if ftype == TType.STRUCT: |
| self.options = SubmitOptions() |
| self.options.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('submitTopologyWithOpts_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.uploadedJarLocation is not None: |
| oprot.writeFieldBegin('uploadedJarLocation', TType.STRING, 2) |
| oprot.writeString(self.uploadedJarLocation.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.jsonConf is not None: |
| oprot.writeFieldBegin('jsonConf', TType.STRING, 3) |
| oprot.writeString(self.jsonConf.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.topology is not None: |
| oprot.writeFieldBegin('topology', TType.STRUCT, 4) |
| self.topology.write(oprot) |
| oprot.writeFieldEnd() |
| if self.options is not None: |
| oprot.writeFieldBegin('options', TType.STRUCT, 5) |
| self.options.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| value = (value * 31) ^ hash(self.uploadedJarLocation) |
| value = (value * 31) ^ hash(self.jsonConf) |
| value = (value * 31) ^ hash(self.topology) |
| value = (value * 31) ^ hash(self.options) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class submitTopologyWithOpts_result: |
| """ |
| Attributes: |
| - e |
| - ite |
| - tae |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (AlreadyAliveException, AlreadyAliveException.thrift_spec), None, ), # 1 |
| (2, TType.STRUCT, 'ite', (InvalidTopologyException, InvalidTopologyException.thrift_spec), None, ), # 2 |
| (3, TType.STRUCT, 'tae', (TopologyAssignException, TopologyAssignException.thrift_spec), None, ), # 3 |
| ) |
| |
| def __init__(self, e=None, ite=None, tae=None,): |
| self.e = e |
| self.ite = ite |
| self.tae = tae |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = AlreadyAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.ite = InvalidTopologyException() |
| self.ite.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.STRUCT: |
| self.tae = TopologyAssignException() |
| self.tae.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('submitTopologyWithOpts_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| if self.ite is not None: |
| oprot.writeFieldBegin('ite', TType.STRUCT, 2) |
| self.ite.write(oprot) |
| oprot.writeFieldEnd() |
| if self.tae is not None: |
| oprot.writeFieldBegin('tae', TType.STRUCT, 3) |
| self.tae.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| value = (value * 31) ^ hash(self.ite) |
| value = (value * 31) ^ hash(self.tae) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class killTopology_args: |
| """ |
| Attributes: |
| - name |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| ) |
| |
| def __init__(self, name=None,): |
| self.name = name |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('killTopology_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class killTopology_result: |
| """ |
| Attributes: |
| - e |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, e=None,): |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('killTopology_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class killTopologyWithOpts_args: |
| """ |
| Attributes: |
| - name |
| - options |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| (2, TType.STRUCT, 'options', (KillOptions, KillOptions.thrift_spec), None, ), # 2 |
| ) |
| |
| def __init__(self, name=None, options=None,): |
| self.name = name |
| self.options = options |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.options = KillOptions() |
| self.options.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('killTopologyWithOpts_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.options is not None: |
| oprot.writeFieldBegin('options', TType.STRUCT, 2) |
| self.options.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| value = (value * 31) ^ hash(self.options) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class killTopologyWithOpts_result: |
| """ |
| Attributes: |
| - e |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, e=None,): |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('killTopologyWithOpts_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class activate_args: |
| """ |
| Attributes: |
| - name |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| ) |
| |
| def __init__(self, name=None,): |
| self.name = name |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('activate_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class activate_result: |
| """ |
| Attributes: |
| - e |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, e=None,): |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('activate_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class deactivate_args: |
| """ |
| Attributes: |
| - name |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| ) |
| |
| def __init__(self, name=None,): |
| self.name = name |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('deactivate_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class deactivate_result: |
| """ |
| Attributes: |
| - e |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, e=None,): |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('deactivate_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class rebalance_args: |
| """ |
| Attributes: |
| - name |
| - options |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| (2, TType.STRUCT, 'options', (RebalanceOptions, RebalanceOptions.thrift_spec), None, ), # 2 |
| ) |
| |
| def __init__(self, name=None, options=None,): |
| self.name = name |
| self.options = options |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.options = RebalanceOptions() |
| self.options.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('rebalance_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.options is not None: |
| oprot.writeFieldBegin('options', TType.STRUCT, 2) |
| self.options.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| value = (value * 31) ^ hash(self.options) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class rebalance_result: |
| """ |
| Attributes: |
| - e |
| - ite |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| (2, TType.STRUCT, 'ite', (InvalidTopologyException, InvalidTopologyException.thrift_spec), None, ), # 2 |
| ) |
| |
| def __init__(self, e=None, ite=None,): |
| self.e = e |
| self.ite = ite |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.ite = InvalidTopologyException() |
| self.ite.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('rebalance_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| if self.ite is not None: |
| oprot.writeFieldBegin('ite', TType.STRUCT, 2) |
| self.ite.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| value = (value * 31) ^ hash(self.ite) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class metricMonitor_args: |
| """ |
| Attributes: |
| - name |
| - options |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| (2, TType.STRUCT, 'options', (MonitorOptions, MonitorOptions.thrift_spec), None, ), # 2 |
| ) |
| |
| def __init__(self, name=None, options=None,): |
| self.name = name |
| self.options = options |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.options = MonitorOptions() |
| self.options.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('metricMonitor_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.options is not None: |
| oprot.writeFieldBegin('options', TType.STRUCT, 2) |
| self.options.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| value = (value * 31) ^ hash(self.options) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class metricMonitor_result: |
| """ |
| Attributes: |
| - e |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, e=None,): |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('metricMonitor_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class restart_args: |
| """ |
| Attributes: |
| - name |
| - jsonConf |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| (2, TType.STRING, 'jsonConf', None, None, ), # 2 |
| ) |
| |
| def __init__(self, name=None, jsonConf=None,): |
| self.name = name |
| self.jsonConf = jsonConf |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.jsonConf = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('restart_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.jsonConf is not None: |
| oprot.writeFieldBegin('jsonConf', TType.STRING, 2) |
| oprot.writeString(self.jsonConf.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| value = (value * 31) ^ hash(self.jsonConf) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class restart_result: |
| """ |
| Attributes: |
| - e |
| - ite |
| - tae |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| (2, TType.STRUCT, 'ite', (InvalidTopologyException, InvalidTopologyException.thrift_spec), None, ), # 2 |
| (3, TType.STRUCT, 'tae', (TopologyAssignException, TopologyAssignException.thrift_spec), None, ), # 3 |
| ) |
| |
| def __init__(self, e=None, ite=None, tae=None,): |
| self.e = e |
| self.ite = ite |
| self.tae = tae |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.ite = InvalidTopologyException() |
| self.ite.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.STRUCT: |
| self.tae = TopologyAssignException() |
| self.tae.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('restart_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| if self.ite is not None: |
| oprot.writeFieldBegin('ite', TType.STRUCT, 2) |
| self.ite.write(oprot) |
| oprot.writeFieldEnd() |
| if self.tae is not None: |
| oprot.writeFieldBegin('tae', TType.STRUCT, 3) |
| self.tae.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| value = (value * 31) ^ hash(self.ite) |
| value = (value * 31) ^ hash(self.tae) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class beginLibUpload_args: |
| """ |
| Attributes: |
| - libName |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'libName', None, None, ), # 1 |
| ) |
| |
| def __init__(self, libName=None,): |
| self.libName = libName |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.libName = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('beginLibUpload_args') |
| if self.libName is not None: |
| oprot.writeFieldBegin('libName', TType.STRING, 1) |
| oprot.writeString(self.libName.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.libName) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class beginLibUpload_result: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('beginLibUpload_result') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class beginFileUpload_args: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('beginFileUpload_args') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class beginFileUpload_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRING, 'success', None, None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRING: |
| self.success = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('beginFileUpload_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRING, 0) |
| oprot.writeString(self.success.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class uploadChunk_args: |
| """ |
| Attributes: |
| - location |
| - chunk |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'location', None, None, ), # 1 |
| (2, TType.STRING, 'chunk', None, None, ), # 2 |
| ) |
| |
| def __init__(self, location=None, chunk=None,): |
| self.location = location |
| self.chunk = chunk |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.location = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.chunk = iprot.readString(); |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('uploadChunk_args') |
| if self.location is not None: |
| oprot.writeFieldBegin('location', TType.STRING, 1) |
| oprot.writeString(self.location.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.chunk is not None: |
| oprot.writeFieldBegin('chunk', TType.STRING, 2) |
| oprot.writeString(self.chunk) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.location) |
| value = (value * 31) ^ hash(self.chunk) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class uploadChunk_result: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('uploadChunk_result') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class finishFileUpload_args: |
| """ |
| Attributes: |
| - location |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'location', None, None, ), # 1 |
| ) |
| |
| def __init__(self, location=None,): |
| self.location = location |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.location = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('finishFileUpload_args') |
| if self.location is not None: |
| oprot.writeFieldBegin('location', TType.STRING, 1) |
| oprot.writeString(self.location.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.location) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class finishFileUpload_result: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('finishFileUpload_result') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class beginFileDownload_args: |
| """ |
| Attributes: |
| - file |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'file', None, None, ), # 1 |
| ) |
| |
| def __init__(self, file=None,): |
| self.file = file |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.file = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('beginFileDownload_args') |
| if self.file is not None: |
| oprot.writeFieldBegin('file', TType.STRING, 1) |
| oprot.writeString(self.file.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.file) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class beginFileDownload_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRING, 'success', None, None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRING: |
| self.success = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('beginFileDownload_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRING, 0) |
| oprot.writeString(self.success.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class downloadChunk_args: |
| """ |
| Attributes: |
| - id |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'id', None, None, ), # 1 |
| ) |
| |
| def __init__(self, id=None,): |
| self.id = id |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.id = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('downloadChunk_args') |
| if self.id is not None: |
| oprot.writeFieldBegin('id', TType.STRING, 1) |
| oprot.writeString(self.id.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.id) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class downloadChunk_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRING, 'success', None, None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRING: |
| self.success = iprot.readString(); |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('downloadChunk_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRING, 0) |
| oprot.writeString(self.success) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class finishFileDownload_args: |
| """ |
| Attributes: |
| - id |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'id', None, None, ), # 1 |
| ) |
| |
| def __init__(self, id=None,): |
| self.id = id |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.id = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('finishFileDownload_args') |
| if self.id is not None: |
| oprot.writeFieldBegin('id', TType.STRING, 1) |
| oprot.writeString(self.id.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.id) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class finishFileDownload_result: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('finishFileDownload_result') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getNimbusConf_args: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getNimbusConf_args') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getNimbusConf_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRING, 'success', None, None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRING: |
| self.success = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getNimbusConf_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRING, 0) |
| oprot.writeString(self.success.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyConf_args: |
| """ |
| Attributes: |
| - id |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'id', None, None, ), # 1 |
| ) |
| |
| def __init__(self, id=None,): |
| self.id = id |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.id = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyConf_args') |
| if self.id is not None: |
| oprot.writeFieldBegin('id', TType.STRING, 1) |
| oprot.writeString(self.id.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.id) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyConf_result: |
| """ |
| Attributes: |
| - success |
| - e |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRING, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, e=None,): |
| self.success = success |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRING: |
| self.success = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyConf_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRING, 0) |
| oprot.writeString(self.success.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyId_args: |
| """ |
| Attributes: |
| - topologyName |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyName', None, None, ), # 1 |
| ) |
| |
| def __init__(self, topologyName=None,): |
| self.topologyName = topologyName |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyName = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyId_args') |
| if self.topologyName is not None: |
| oprot.writeFieldBegin('topologyName', TType.STRING, 1) |
| oprot.writeString(self.topologyName.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyName) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyId_result: |
| """ |
| Attributes: |
| - success |
| - e |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRING, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, e=None,): |
| self.success = success |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRING: |
| self.success = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyId_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRING, 0) |
| oprot.writeString(self.success.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getClusterInfo_args: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getClusterInfo_args') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getClusterInfo_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (ClusterSummary, ClusterSummary.thrift_spec), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = ClusterSummary() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getClusterInfo_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getSupervisorWorkers_args: |
| """ |
| Attributes: |
| - host |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'host', None, None, ), # 1 |
| ) |
| |
| def __init__(self, host=None,): |
| self.host = host |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.host = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getSupervisorWorkers_args') |
| if self.host is not None: |
| oprot.writeFieldBegin('host', TType.STRING, 1) |
| oprot.writeString(self.host.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.host) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getSupervisorWorkers_result: |
| """ |
| Attributes: |
| - success |
| - e |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (SupervisorWorkers, SupervisorWorkers.thrift_spec), None, ), # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, e=None,): |
| self.success = success |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = SupervisorWorkers() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getSupervisorWorkers_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyInfo_args: |
| """ |
| Attributes: |
| - id |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'id', None, None, ), # 1 |
| ) |
| |
| def __init__(self, id=None,): |
| self.id = id |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.id = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyInfo_args') |
| if self.id is not None: |
| oprot.writeFieldBegin('id', TType.STRING, 1) |
| oprot.writeString(self.id.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.id) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyInfo_result: |
| """ |
| Attributes: |
| - success |
| - e |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (TopologyInfo, TopologyInfo.thrift_spec), None, ), # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, e=None,): |
| self.success = success |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = TopologyInfo() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyInfo_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyInfoByName_args: |
| """ |
| Attributes: |
| - topologyName |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyName', None, None, ), # 1 |
| ) |
| |
| def __init__(self, topologyName=None,): |
| self.topologyName = topologyName |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyName = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyInfoByName_args') |
| if self.topologyName is not None: |
| oprot.writeFieldBegin('topologyName', TType.STRING, 1) |
| oprot.writeString(self.topologyName.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyName) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyInfoByName_result: |
| """ |
| Attributes: |
| - success |
| - e |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (TopologyInfo, TopologyInfo.thrift_spec), None, ), # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, e=None,): |
| self.success = success |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = TopologyInfo() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyInfoByName_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopology_args: |
| """ |
| Attributes: |
| - id |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'id', None, None, ), # 1 |
| ) |
| |
| def __init__(self, id=None,): |
| self.id = id |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.id = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopology_args') |
| if self.id is not None: |
| oprot.writeFieldBegin('id', TType.STRING, 1) |
| oprot.writeString(self.id.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.id) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopology_result: |
| """ |
| Attributes: |
| - success |
| - e |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (StormTopology, StormTopology.thrift_spec), None, ), # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, e=None,): |
| self.success = success |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = StormTopology() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopology_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getUserTopology_args: |
| """ |
| Attributes: |
| - id |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'id', None, None, ), # 1 |
| ) |
| |
| def __init__(self, id=None,): |
| self.id = id |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.id = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getUserTopology_args') |
| if self.id is not None: |
| oprot.writeFieldBegin('id', TType.STRING, 1) |
| oprot.writeString(self.id.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.id) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getUserTopology_result: |
| """ |
| Attributes: |
| - success |
| - e |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (StormTopology, StormTopology.thrift_spec), None, ), # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, e=None,): |
| self.success = success |
| self.e = e |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = StormTopology() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getUserTopology_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| value = (value * 31) ^ hash(self.e) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class uploadTopologyMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| - topologyMetrics |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| (2, TType.STRUCT, 'topologyMetrics', (TopologyMetric, TopologyMetric.thrift_spec), None, ), # 2 |
| ) |
| |
| def __init__(self, topologyId=None, topologyMetrics=None,): |
| self.topologyId = topologyId |
| self.topologyMetrics = topologyMetrics |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.topologyMetrics = TopologyMetric() |
| self.topologyMetrics.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('uploadTopologyMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.topologyMetrics is not None: |
| oprot.writeFieldBegin('topologyMetrics', TType.STRUCT, 2) |
| self.topologyMetrics.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| value = (value * 31) ^ hash(self.topologyMetrics) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class uploadTopologyMetrics_result: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('uploadTopologyMetrics_result') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class registerMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| - metrics |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| (2, TType.SET, 'metrics', (TType.STRING,None), None, ), # 2 |
| ) |
| |
| def __init__(self, topologyId=None, metrics=None,): |
| self.topologyId = topologyId |
| self.metrics = metrics |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.SET: |
| self.metrics = set() |
| (_etype209, _size206) = iprot.readSetBegin() |
| for _i210 in xrange(_size206): |
| _elem211 = iprot.readString().decode('utf-8') |
| self.metrics.add(_elem211) |
| iprot.readSetEnd() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('registerMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.metrics is not None: |
| oprot.writeFieldBegin('metrics', TType.SET, 2) |
| oprot.writeSetBegin(TType.STRING, len(self.metrics)) |
| for iter212 in self.metrics: |
| oprot.writeString(iter212.encode('utf-8')) |
| oprot.writeSetEnd() |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| value = (value * 31) ^ hash(self.metrics) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class registerMetrics_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.MAP, 'success', (TType.STRING,None,TType.I64,None), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.MAP: |
| self.success = {} |
| (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin() |
| for _i217 in xrange(_size213): |
| _key218 = iprot.readString().decode('utf-8') |
| _val219 = iprot.readI64(); |
| self.success[_key218] = _val219 |
| iprot.readMapEnd() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('registerMetrics_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.MAP, 0) |
| oprot.writeMapBegin(TType.STRING, TType.I64, len(self.success)) |
| for kiter220,viter221 in self.success.items(): |
| oprot.writeString(kiter220.encode('utf-8')) |
| oprot.writeI64(viter221) |
| oprot.writeMapEnd() |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| ) |
| |
| def __init__(self, topologyId=None,): |
| self.topologyId = topologyId |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTopologyMetrics_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (TopologyMetric, TopologyMetric.thrift_spec), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = TopologyMetric() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTopologyMetrics_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| - type |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| (2, TType.I32, 'type', None, None, ), # 2 |
| ) |
| |
| def __init__(self, topologyId=None, type=None,): |
| self.topologyId = topologyId |
| self.type = type |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.I32: |
| self.type = iprot.readI32(); |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.type is not None: |
| oprot.writeFieldBegin('type', TType.I32, 2) |
| oprot.writeI32(self.type) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| value = (value * 31) ^ hash(self.type) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getMetrics_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.LIST, 'success', (TType.STRUCT,(MetricInfo, MetricInfo.thrift_spec)), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.LIST: |
| self.success = [] |
| (_etype225, _size222) = iprot.readListBegin() |
| for _i226 in xrange(_size222): |
| _elem227 = MetricInfo() |
| _elem227.read(iprot) |
| self.success.append(_elem227) |
| iprot.readListEnd() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getMetrics_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.LIST, 0) |
| oprot.writeListBegin(TType.STRUCT, len(self.success)) |
| for iter228 in self.success: |
| iter228.write(oprot) |
| oprot.writeListEnd() |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getNettyMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| ) |
| |
| def __init__(self, topologyId=None,): |
| self.topologyId = topologyId |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getNettyMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getNettyMetrics_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (MetricInfo, MetricInfo.thrift_spec), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = MetricInfo() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getNettyMetrics_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getNettyMetricsByHost_args: |
| """ |
| Attributes: |
| - topologyId |
| - host |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| (2, TType.STRING, 'host', None, None, ), # 2 |
| ) |
| |
| def __init__(self, topologyId=None, host=None,): |
| self.topologyId = topologyId |
| self.host = host |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.host = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getNettyMetricsByHost_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.host is not None: |
| oprot.writeFieldBegin('host', TType.STRING, 2) |
| oprot.writeString(self.host.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| value = (value * 31) ^ hash(self.host) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getNettyMetricsByHost_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (MetricInfo, MetricInfo.thrift_spec), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = MetricInfo() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getNettyMetricsByHost_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getPagingNettyMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| - host |
| - page |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| (2, TType.STRING, 'host', None, None, ), # 2 |
| (3, TType.I32, 'page', None, None, ), # 3 |
| ) |
| |
| def __init__(self, topologyId=None, host=None, page=None,): |
| self.topologyId = topologyId |
| self.host = host |
| self.page = page |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.host = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.I32: |
| self.page = iprot.readI32(); |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getPagingNettyMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.host is not None: |
| oprot.writeFieldBegin('host', TType.STRING, 2) |
| oprot.writeString(self.host.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.page is not None: |
| oprot.writeFieldBegin('page', TType.I32, 3) |
| oprot.writeI32(self.page) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| value = (value * 31) ^ hash(self.host) |
| value = (value * 31) ^ hash(self.page) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getPagingNettyMetrics_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (MetricInfo, MetricInfo.thrift_spec), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = MetricInfo() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getPagingNettyMetrics_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getNettyMetricSizeByHost_args: |
| """ |
| Attributes: |
| - topologyId |
| - host |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| (2, TType.STRING, 'host', None, None, ), # 2 |
| ) |
| |
| def __init__(self, topologyId=None, host=None,): |
| self.topologyId = topologyId |
| self.host = host |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.host = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getNettyMetricSizeByHost_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.host is not None: |
| oprot.writeFieldBegin('host', TType.STRING, 2) |
| oprot.writeString(self.host.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| value = (value * 31) ^ hash(self.host) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getNettyMetricSizeByHost_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32(); |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getNettyMetricSizeByHost_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTaskMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| - component |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| (2, TType.STRING, 'component', None, None, ), # 2 |
| ) |
| |
| def __init__(self, topologyId=None, component=None,): |
| self.topologyId = topologyId |
| self.component = component |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.component = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTaskMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.component is not None: |
| oprot.writeFieldBegin('component', TType.STRING, 2) |
| oprot.writeString(self.component.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| value = (value * 31) ^ hash(self.component) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTaskMetrics_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (MetricInfo, MetricInfo.thrift_spec), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRUCT: |
| self.success = MetricInfo() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTaskMetrics_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRUCT, 0) |
| self.success.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTaskAndStreamMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| - taskId |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| (2, TType.I32, 'taskId', None, None, ), # 2 |
| ) |
| |
| def __init__(self, topologyId=None, taskId=None,): |
| self.topologyId = topologyId |
| self.taskId = taskId |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.I32: |
| self.taskId = iprot.readI32(); |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTaskAndStreamMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.taskId is not None: |
| oprot.writeFieldBegin('taskId', TType.I32, 2) |
| oprot.writeI32(self.taskId) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| value = (value * 31) ^ hash(self.taskId) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getTaskAndStreamMetrics_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.LIST, 'success', (TType.STRUCT,(MetricInfo, MetricInfo.thrift_spec)), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.LIST: |
| self.success = [] |
| (_etype232, _size229) = iprot.readListBegin() |
| for _i233 in xrange(_size229): |
| _elem234 = MetricInfo() |
| _elem234.read(iprot) |
| self.success.append(_elem234) |
| iprot.readListEnd() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getTaskAndStreamMetrics_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.LIST, 0) |
| oprot.writeListBegin(TType.STRUCT, len(self.success)) |
| for iter235 in self.success: |
| iter235.write(oprot) |
| oprot.writeListEnd() |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getSummarizedTopologyMetrics_args: |
| """ |
| Attributes: |
| - topologyId |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'topologyId', None, None, ), # 1 |
| ) |
| |
| def __init__(self, topologyId=None,): |
| self.topologyId = topologyId |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.topologyId = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getSummarizedTopologyMetrics_args') |
| if self.topologyId is not None: |
| oprot.writeFieldBegin('topologyId', TType.STRING, 1) |
| oprot.writeString(self.topologyId.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.topologyId) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getSummarizedTopologyMetrics_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.LIST, 'success', (TType.STRUCT,(MetricInfo, MetricInfo.thrift_spec)), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.LIST: |
| self.success = [] |
| (_etype239, _size236) = iprot.readListBegin() |
| for _i240 in xrange(_size236): |
| _elem241 = MetricInfo() |
| _elem241.read(iprot) |
| self.success.append(_elem241) |
| iprot.readListEnd() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getSummarizedTopologyMetrics_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.LIST, 0) |
| oprot.writeListBegin(TType.STRUCT, len(self.success)) |
| for iter242 in self.success: |
| iter242.write(oprot) |
| oprot.writeListEnd() |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getVersion_args: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getVersion_args') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class getVersion_result: |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRING, 'success', None, None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.STRING: |
| self.success = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('getVersion_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.STRING, 0) |
| oprot.writeString(self.success.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.success) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class updateTopology_args: |
| """ |
| Attributes: |
| - name |
| - uploadedLocation |
| - updateConf |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRING, 'name', None, None, ), # 1 |
| (2, TType.STRING, 'uploadedLocation', None, None, ), # 2 |
| (3, TType.STRING, 'updateConf', None, None, ), # 3 |
| ) |
| |
| def __init__(self, name=None, uploadedLocation=None, updateConf=None,): |
| self.name = name |
| self.uploadedLocation = uploadedLocation |
| self.updateConf = updateConf |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRING: |
| self.name = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRING: |
| self.uploadedLocation = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.STRING: |
| self.updateConf = iprot.readString().decode('utf-8') |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('updateTopology_args') |
| if self.name is not None: |
| oprot.writeFieldBegin('name', TType.STRING, 1) |
| oprot.writeString(self.name.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.uploadedLocation is not None: |
| oprot.writeFieldBegin('uploadedLocation', TType.STRING, 2) |
| oprot.writeString(self.uploadedLocation.encode('utf-8')) |
| oprot.writeFieldEnd() |
| if self.updateConf is not None: |
| oprot.writeFieldBegin('updateConf', TType.STRING, 3) |
| oprot.writeString(self.updateConf.encode('utf-8')) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.name) |
| value = (value * 31) ^ hash(self.uploadedLocation) |
| value = (value * 31) ^ hash(self.updateConf) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class updateTopology_result: |
| """ |
| Attributes: |
| - e |
| - ite |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'e', (NotAliveException, NotAliveException.thrift_spec), None, ), # 1 |
| (2, TType.STRUCT, 'ite', (InvalidTopologyException, InvalidTopologyException.thrift_spec), None, ), # 2 |
| ) |
| |
| def __init__(self, e=None, ite=None,): |
| self.e = e |
| self.ite = ite |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.e = NotAliveException() |
| self.e.read(iprot) |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.STRUCT: |
| self.ite = InvalidTopologyException() |
| self.ite.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('updateTopology_result') |
| if self.e is not None: |
| oprot.writeFieldBegin('e', TType.STRUCT, 1) |
| self.e.write(oprot) |
| oprot.writeFieldEnd() |
| if self.ite is not None: |
| oprot.writeFieldBegin('ite', TType.STRUCT, 2) |
| self.ite.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.e) |
| value = (value * 31) ^ hash(self.ite) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class updateTaskHeartbeat_args: |
| """ |
| Attributes: |
| - taskHbs |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'taskHbs', (TopologyTaskHbInfo, TopologyTaskHbInfo.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, taskHbs=None,): |
| self.taskHbs = taskHbs |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.STRUCT: |
| self.taskHbs = TopologyTaskHbInfo() |
| self.taskHbs.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('updateTaskHeartbeat_args') |
| if self.taskHbs is not None: |
| oprot.writeFieldBegin('taskHbs', TType.STRUCT, 1) |
| self.taskHbs.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| value = (value * 31) ^ hash(self.taskHbs) |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| class updateTaskHeartbeat_result: |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: |
| fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: |
| oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('updateTaskHeartbeat_result') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| |
| def __hash__(self): |
| value = 17 |
| return value |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.iteritems()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
