• Home
• com.xiaomi.infra.galaxy
• galaxy-thrift-api
• 1.2.10
• source code
• EMRSchedulerService.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.xiaomi.infra.galaxy.emr.thrift.EMRSchedulerService Maven / Gradle / Ivy

/**
 * Autogenerated by Thrift Compiler (0.9.2)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package com.xiaomi.infra.galaxy.emr.thrift;

import libthrift091.scheme.IScheme;
import libthrift091.scheme.SchemeFactory;
import libthrift091.scheme.StandardScheme;

import libthrift091.scheme.TupleScheme;
import libthrift091.protocol.TTupleProtocol;
import libthrift091.protocol.TProtocolException;
import libthrift091.EncodingUtils;
import libthrift091.TException;
import libthrift091.async.AsyncMethodCallback;
import libthrift091.server.AbstractNonblockingServer.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.EnumMap;
import java.util.Set;
import java.util.HashSet;
import java.util.EnumSet;
import java.util.Collections;
import java.util.BitSet;
import java.nio.ByteBuffer;
import java.util.Arrays;
import javax.annotation.Generated;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2016-8-2")
public class EMRSchedulerService {

  public interface Iface extends com.xiaomi.infra.galaxy.rpc.thrift.BaseService.Iface {

    public CreateClusterResponse createCluster(CreateClusterRequest cluster) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public AddInstanceGroupResponse addInstanceGroup(AddInstanceGroupRequest instanceGroup) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public List addInstanceGroups(List instanceGroups) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public SubmitJobResponse submitJob(SubmitJobRequest job) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public List submitJobs(List jobs) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public String terminateCluster(TerminateClusterRequest terminateCluster) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public ModifyInstanceGroupResponse modifyInstanceGroup(ModifyInstanceGroupRequest instanceGroup) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public ClusterDetail describeCluster(String clusterId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public InstanceGroupDetail describeInstanceGroup(String instanceGroupId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public InstanceDetail describeInstance(String clusterId, String instanceId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public JobDetail describeJob(String clusterId, String jobId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public List listClusters(int createdAfter, int createdBefore) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public List listClustersWithPrefix(String prefix) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public List listInstanceGroups(String clusterId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public List listInstancesInCluster(String clusterId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public List listInstancesInGroup(String clusterId, String groupId, InstanceGroupRole groupRole) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public List listJobs(String clusterId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public void setPermission(SetPermissionRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public void revokePermission(RevokePermissionRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public QueryPermissionResponse queryPermission(QueryPermissionRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public ListPermissionResponse listPermissions(ListPermissionRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public GetSSHPublicKeysResponse getSSHPublicKeys(GetSSHPublicKeysRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public void addSSHPublicKeys(AddSSHPublicKeysRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public void deleteSSHPublicKeys(DeleteSSHPublicKeysRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public GetQuotaResponse getQuota(GetQuotaRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public DeleteClusterResponse deleteCluster(DeleteClusterRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public GetEMRBasicConfigResponse getEMRBasicConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public GetSoftwareConfigResponse getSoftwareConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public GetHardwareConfigResponse getHardwareConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public void addTags(AddTagsRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public GetTagsResponse getTags(GetTagsRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public void deleteTag(DeleteTagRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

    public ResizeInstanceGroupResponse resizeInstanceGroup(ResizeInstanceGroupRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException;

  }

  public interface AsyncIface extends com.xiaomi.infra.galaxy.rpc.thrift.BaseService .AsyncIface {

    public void createCluster(CreateClusterRequest cluster, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void addInstanceGroup(AddInstanceGroupRequest instanceGroup, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void addInstanceGroups(List instanceGroups, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void submitJob(SubmitJobRequest job, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void submitJobs(List jobs, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void terminateCluster(TerminateClusterRequest terminateCluster, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void modifyInstanceGroup(ModifyInstanceGroupRequest instanceGroup, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void describeCluster(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void describeInstanceGroup(String instanceGroupId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void describeInstance(String clusterId, String instanceId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void describeJob(String clusterId, String jobId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void listClusters(int createdAfter, int createdBefore, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void listClustersWithPrefix(String prefix, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void listInstanceGroups(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void listInstancesInCluster(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void listInstancesInGroup(String clusterId, String groupId, InstanceGroupRole groupRole, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void listJobs(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void setPermission(SetPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void revokePermission(RevokePermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void queryPermission(QueryPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void listPermissions(ListPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void getSSHPublicKeys(GetSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void addSSHPublicKeys(AddSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void deleteSSHPublicKeys(DeleteSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void getQuota(GetQuotaRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void deleteCluster(DeleteClusterRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void getEMRBasicConfig(libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void getSoftwareConfig(libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void getHardwareConfig(libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void addTags(AddTagsRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void getTags(GetTagsRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void deleteTag(DeleteTagRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

    public void resizeInstanceGroup(ResizeInstanceGroupRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException;

  }

  public static class Client extends com.xiaomi.infra.galaxy.rpc.thrift.BaseService.Client implements Iface {
    public static class Factory implements libthrift091.TServiceClientFactory {
      public Factory() {}
      public Client getClient(libthrift091.protocol.TProtocol prot) {
        return new Client(prot);
      }
      public Client getClient(libthrift091.protocol.TProtocol iprot, libthrift091.protocol.TProtocol oprot) {
        return new Client(iprot, oprot);
      }
    }

    public Client(libthrift091.protocol.TProtocol prot)
    {
      super(prot, prot);
    }

    public Client(libthrift091.protocol.TProtocol iprot, libthrift091.protocol.TProtocol oprot) {
      super(iprot, oprot);
    }

    public CreateClusterResponse createCluster(CreateClusterRequest cluster) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_createCluster(cluster);
      return recv_createCluster();
    }

    public void send_createCluster(CreateClusterRequest cluster) throws libthrift091.TException
    {
      createCluster_args args = new createCluster_args();
      args.setCluster(cluster);
      sendBase("createCluster", args);
    }

    public CreateClusterResponse recv_createCluster() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      createCluster_result result = new createCluster_result();
      receiveBase(result, "createCluster");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "createCluster failed: unknown result");
    }

    public AddInstanceGroupResponse addInstanceGroup(AddInstanceGroupRequest instanceGroup) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_addInstanceGroup(instanceGroup);
      return recv_addInstanceGroup();
    }

    public void send_addInstanceGroup(AddInstanceGroupRequest instanceGroup) throws libthrift091.TException
    {
      addInstanceGroup_args args = new addInstanceGroup_args();
      args.setInstanceGroup(instanceGroup);
      sendBase("addInstanceGroup", args);
    }

    public AddInstanceGroupResponse recv_addInstanceGroup() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      addInstanceGroup_result result = new addInstanceGroup_result();
      receiveBase(result, "addInstanceGroup");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "addInstanceGroup failed: unknown result");
    }

    public List addInstanceGroups(List instanceGroups) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_addInstanceGroups(instanceGroups);
      return recv_addInstanceGroups();
    }

    public void send_addInstanceGroups(List instanceGroups) throws libthrift091.TException
    {
      addInstanceGroups_args args = new addInstanceGroups_args();
      args.setInstanceGroups(instanceGroups);
      sendBase("addInstanceGroups", args);
    }

    public List recv_addInstanceGroups() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      addInstanceGroups_result result = new addInstanceGroups_result();
      receiveBase(result, "addInstanceGroups");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "addInstanceGroups failed: unknown result");
    }

    public SubmitJobResponse submitJob(SubmitJobRequest job) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_submitJob(job);
      return recv_submitJob();
    }

    public void send_submitJob(SubmitJobRequest job) throws libthrift091.TException
    {
      submitJob_args args = new submitJob_args();
      args.setJob(job);
      sendBase("submitJob", args);
    }

    public SubmitJobResponse recv_submitJob() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      submitJob_result result = new submitJob_result();
      receiveBase(result, "submitJob");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "submitJob failed: unknown result");
    }

    public List submitJobs(List jobs) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_submitJobs(jobs);
      return recv_submitJobs();
    }

    public void send_submitJobs(List jobs) throws libthrift091.TException
    {
      submitJobs_args args = new submitJobs_args();
      args.setJobs(jobs);
      sendBase("submitJobs", args);
    }

    public List recv_submitJobs() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      submitJobs_result result = new submitJobs_result();
      receiveBase(result, "submitJobs");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "submitJobs failed: unknown result");
    }

    public String terminateCluster(TerminateClusterRequest terminateCluster) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_terminateCluster(terminateCluster);
      return recv_terminateCluster();
    }

    public void send_terminateCluster(TerminateClusterRequest terminateCluster) throws libthrift091.TException
    {
      terminateCluster_args args = new terminateCluster_args();
      args.setTerminateCluster(terminateCluster);
      sendBase("terminateCluster", args);
    }

    public String recv_terminateCluster() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      terminateCluster_result result = new terminateCluster_result();
      receiveBase(result, "terminateCluster");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "terminateCluster failed: unknown result");
    }

    public ModifyInstanceGroupResponse modifyInstanceGroup(ModifyInstanceGroupRequest instanceGroup) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_modifyInstanceGroup(instanceGroup);
      return recv_modifyInstanceGroup();
    }

    public void send_modifyInstanceGroup(ModifyInstanceGroupRequest instanceGroup) throws libthrift091.TException
    {
      modifyInstanceGroup_args args = new modifyInstanceGroup_args();
      args.setInstanceGroup(instanceGroup);
      sendBase("modifyInstanceGroup", args);
    }

    public ModifyInstanceGroupResponse recv_modifyInstanceGroup() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      modifyInstanceGroup_result result = new modifyInstanceGroup_result();
      receiveBase(result, "modifyInstanceGroup");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "modifyInstanceGroup failed: unknown result");
    }

    public ClusterDetail describeCluster(String clusterId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_describeCluster(clusterId);
      return recv_describeCluster();
    }

    public void send_describeCluster(String clusterId) throws libthrift091.TException
    {
      describeCluster_args args = new describeCluster_args();
      args.setClusterId(clusterId);
      sendBase("describeCluster", args);
    }

    public ClusterDetail recv_describeCluster() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      describeCluster_result result = new describeCluster_result();
      receiveBase(result, "describeCluster");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "describeCluster failed: unknown result");
    }

    public InstanceGroupDetail describeInstanceGroup(String instanceGroupId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_describeInstanceGroup(instanceGroupId);
      return recv_describeInstanceGroup();
    }

    public void send_describeInstanceGroup(String instanceGroupId) throws libthrift091.TException
    {
      describeInstanceGroup_args args = new describeInstanceGroup_args();
      args.setInstanceGroupId(instanceGroupId);
      sendBase("describeInstanceGroup", args);
    }

    public InstanceGroupDetail recv_describeInstanceGroup() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      describeInstanceGroup_result result = new describeInstanceGroup_result();
      receiveBase(result, "describeInstanceGroup");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "describeInstanceGroup failed: unknown result");
    }

    public InstanceDetail describeInstance(String clusterId, String instanceId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_describeInstance(clusterId, instanceId);
      return recv_describeInstance();
    }

    public void send_describeInstance(String clusterId, String instanceId) throws libthrift091.TException
    {
      describeInstance_args args = new describeInstance_args();
      args.setClusterId(clusterId);
      args.setInstanceId(instanceId);
      sendBase("describeInstance", args);
    }

    public InstanceDetail recv_describeInstance() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      describeInstance_result result = new describeInstance_result();
      receiveBase(result, "describeInstance");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "describeInstance failed: unknown result");
    }

    public JobDetail describeJob(String clusterId, String jobId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_describeJob(clusterId, jobId);
      return recv_describeJob();
    }

    public void send_describeJob(String clusterId, String jobId) throws libthrift091.TException
    {
      describeJob_args args = new describeJob_args();
      args.setClusterId(clusterId);
      args.setJobId(jobId);
      sendBase("describeJob", args);
    }

    public JobDetail recv_describeJob() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      describeJob_result result = new describeJob_result();
      receiveBase(result, "describeJob");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "describeJob failed: unknown result");
    }

    public List listClusters(int createdAfter, int createdBefore) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_listClusters(createdAfter, createdBefore);
      return recv_listClusters();
    }

    public void send_listClusters(int createdAfter, int createdBefore) throws libthrift091.TException
    {
      listClusters_args args = new listClusters_args();
      args.setCreatedAfter(createdAfter);
      args.setCreatedBefore(createdBefore);
      sendBase("listClusters", args);
    }

    public List recv_listClusters() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      listClusters_result result = new listClusters_result();
      receiveBase(result, "listClusters");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "listClusters failed: unknown result");
    }

    public List listClustersWithPrefix(String prefix) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_listClustersWithPrefix(prefix);
      return recv_listClustersWithPrefix();
    }

    public void send_listClustersWithPrefix(String prefix) throws libthrift091.TException
    {
      listClustersWithPrefix_args args = new listClustersWithPrefix_args();
      args.setPrefix(prefix);
      sendBase("listClustersWithPrefix", args);
    }

    public List recv_listClustersWithPrefix() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      listClustersWithPrefix_result result = new listClustersWithPrefix_result();
      receiveBase(result, "listClustersWithPrefix");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "listClustersWithPrefix failed: unknown result");
    }

    public List listInstanceGroups(String clusterId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_listInstanceGroups(clusterId);
      return recv_listInstanceGroups();
    }

    public void send_listInstanceGroups(String clusterId) throws libthrift091.TException
    {
      listInstanceGroups_args args = new listInstanceGroups_args();
      args.setClusterId(clusterId);
      sendBase("listInstanceGroups", args);
    }

    public List recv_listInstanceGroups() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      listInstanceGroups_result result = new listInstanceGroups_result();
      receiveBase(result, "listInstanceGroups");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "listInstanceGroups failed: unknown result");
    }

    public List listInstancesInCluster(String clusterId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_listInstancesInCluster(clusterId);
      return recv_listInstancesInCluster();
    }

    public void send_listInstancesInCluster(String clusterId) throws libthrift091.TException
    {
      listInstancesInCluster_args args = new listInstancesInCluster_args();
      args.setClusterId(clusterId);
      sendBase("listInstancesInCluster", args);
    }

    public List recv_listInstancesInCluster() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      listInstancesInCluster_result result = new listInstancesInCluster_result();
      receiveBase(result, "listInstancesInCluster");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "listInstancesInCluster failed: unknown result");
    }

    public List listInstancesInGroup(String clusterId, String groupId, InstanceGroupRole groupRole) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_listInstancesInGroup(clusterId, groupId, groupRole);
      return recv_listInstancesInGroup();
    }

    public void send_listInstancesInGroup(String clusterId, String groupId, InstanceGroupRole groupRole) throws libthrift091.TException
    {
      listInstancesInGroup_args args = new listInstancesInGroup_args();
      args.setClusterId(clusterId);
      args.setGroupId(groupId);
      args.setGroupRole(groupRole);
      sendBase("listInstancesInGroup", args);
    }

    public List recv_listInstancesInGroup() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      listInstancesInGroup_result result = new listInstancesInGroup_result();
      receiveBase(result, "listInstancesInGroup");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "listInstancesInGroup failed: unknown result");
    }

    public List listJobs(String clusterId) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_listJobs(clusterId);
      return recv_listJobs();
    }

    public void send_listJobs(String clusterId) throws libthrift091.TException
    {
      listJobs_args args = new listJobs_args();
      args.setClusterId(clusterId);
      sendBase("listJobs", args);
    }

    public List recv_listJobs() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      listJobs_result result = new listJobs_result();
      receiveBase(result, "listJobs");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "listJobs failed: unknown result");
    }

    public void setPermission(SetPermissionRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_setPermission(request);
      recv_setPermission();
    }

    public void send_setPermission(SetPermissionRequest request) throws libthrift091.TException
    {
      setPermission_args args = new setPermission_args();
      args.setRequest(request);
      sendBase("setPermission", args);
    }

    public void recv_setPermission() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      setPermission_result result = new setPermission_result();
      receiveBase(result, "setPermission");
      if (result.se != null) {
        throw result.se;
      }
      return;
    }

    public void revokePermission(RevokePermissionRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_revokePermission(request);
      recv_revokePermission();
    }

    public void send_revokePermission(RevokePermissionRequest request) throws libthrift091.TException
    {
      revokePermission_args args = new revokePermission_args();
      args.setRequest(request);
      sendBase("revokePermission", args);
    }

    public void recv_revokePermission() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      revokePermission_result result = new revokePermission_result();
      receiveBase(result, "revokePermission");
      if (result.se != null) {
        throw result.se;
      }
      return;
    }

    public QueryPermissionResponse queryPermission(QueryPermissionRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_queryPermission(request);
      return recv_queryPermission();
    }

    public void send_queryPermission(QueryPermissionRequest request) throws libthrift091.TException
    {
      queryPermission_args args = new queryPermission_args();
      args.setRequest(request);
      sendBase("queryPermission", args);
    }

    public QueryPermissionResponse recv_queryPermission() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      queryPermission_result result = new queryPermission_result();
      receiveBase(result, "queryPermission");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "queryPermission failed: unknown result");
    }

    public ListPermissionResponse listPermissions(ListPermissionRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_listPermissions(request);
      return recv_listPermissions();
    }

    public void send_listPermissions(ListPermissionRequest request) throws libthrift091.TException
    {
      listPermissions_args args = new listPermissions_args();
      args.setRequest(request);
      sendBase("listPermissions", args);
    }

    public ListPermissionResponse recv_listPermissions() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      listPermissions_result result = new listPermissions_result();
      receiveBase(result, "listPermissions");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "listPermissions failed: unknown result");
    }

    public GetSSHPublicKeysResponse getSSHPublicKeys(GetSSHPublicKeysRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_getSSHPublicKeys(request);
      return recv_getSSHPublicKeys();
    }

    public void send_getSSHPublicKeys(GetSSHPublicKeysRequest request) throws libthrift091.TException
    {
      getSSHPublicKeys_args args = new getSSHPublicKeys_args();
      args.setRequest(request);
      sendBase("getSSHPublicKeys", args);
    }

    public GetSSHPublicKeysResponse recv_getSSHPublicKeys() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      getSSHPublicKeys_result result = new getSSHPublicKeys_result();
      receiveBase(result, "getSSHPublicKeys");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "getSSHPublicKeys failed: unknown result");
    }

    public void addSSHPublicKeys(AddSSHPublicKeysRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_addSSHPublicKeys(request);
      recv_addSSHPublicKeys();
    }

    public void send_addSSHPublicKeys(AddSSHPublicKeysRequest request) throws libthrift091.TException
    {
      addSSHPublicKeys_args args = new addSSHPublicKeys_args();
      args.setRequest(request);
      sendBase("addSSHPublicKeys", args);
    }

    public void recv_addSSHPublicKeys() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      addSSHPublicKeys_result result = new addSSHPublicKeys_result();
      receiveBase(result, "addSSHPublicKeys");
      if (result.se != null) {
        throw result.se;
      }
      return;
    }

    public void deleteSSHPublicKeys(DeleteSSHPublicKeysRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_deleteSSHPublicKeys(request);
      recv_deleteSSHPublicKeys();
    }

    public void send_deleteSSHPublicKeys(DeleteSSHPublicKeysRequest request) throws libthrift091.TException
    {
      deleteSSHPublicKeys_args args = new deleteSSHPublicKeys_args();
      args.setRequest(request);
      sendBase("deleteSSHPublicKeys", args);
    }

    public void recv_deleteSSHPublicKeys() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      deleteSSHPublicKeys_result result = new deleteSSHPublicKeys_result();
      receiveBase(result, "deleteSSHPublicKeys");
      if (result.se != null) {
        throw result.se;
      }
      return;
    }

    public GetQuotaResponse getQuota(GetQuotaRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_getQuota(request);
      return recv_getQuota();
    }

    public void send_getQuota(GetQuotaRequest request) throws libthrift091.TException
    {
      getQuota_args args = new getQuota_args();
      args.setRequest(request);
      sendBase("getQuota", args);
    }

    public GetQuotaResponse recv_getQuota() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      getQuota_result result = new getQuota_result();
      receiveBase(result, "getQuota");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "getQuota failed: unknown result");
    }

    public DeleteClusterResponse deleteCluster(DeleteClusterRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_deleteCluster(request);
      return recv_deleteCluster();
    }

    public void send_deleteCluster(DeleteClusterRequest request) throws libthrift091.TException
    {
      deleteCluster_args args = new deleteCluster_args();
      args.setRequest(request);
      sendBase("deleteCluster", args);
    }

    public DeleteClusterResponse recv_deleteCluster() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      deleteCluster_result result = new deleteCluster_result();
      receiveBase(result, "deleteCluster");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "deleteCluster failed: unknown result");
    }

    public GetEMRBasicConfigResponse getEMRBasicConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_getEMRBasicConfig();
      return recv_getEMRBasicConfig();
    }

    public void send_getEMRBasicConfig() throws libthrift091.TException
    {
      getEMRBasicConfig_args args = new getEMRBasicConfig_args();
      sendBase("getEMRBasicConfig", args);
    }

    public GetEMRBasicConfigResponse recv_getEMRBasicConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      getEMRBasicConfig_result result = new getEMRBasicConfig_result();
      receiveBase(result, "getEMRBasicConfig");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "getEMRBasicConfig failed: unknown result");
    }

    public GetSoftwareConfigResponse getSoftwareConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_getSoftwareConfig();
      return recv_getSoftwareConfig();
    }

    public void send_getSoftwareConfig() throws libthrift091.TException
    {
      getSoftwareConfig_args args = new getSoftwareConfig_args();
      sendBase("getSoftwareConfig", args);
    }

    public GetSoftwareConfigResponse recv_getSoftwareConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      getSoftwareConfig_result result = new getSoftwareConfig_result();
      receiveBase(result, "getSoftwareConfig");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "getSoftwareConfig failed: unknown result");
    }

    public GetHardwareConfigResponse getHardwareConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_getHardwareConfig();
      return recv_getHardwareConfig();
    }

    public void send_getHardwareConfig() throws libthrift091.TException
    {
      getHardwareConfig_args args = new getHardwareConfig_args();
      sendBase("getHardwareConfig", args);
    }

    public GetHardwareConfigResponse recv_getHardwareConfig() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      getHardwareConfig_result result = new getHardwareConfig_result();
      receiveBase(result, "getHardwareConfig");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "getHardwareConfig failed: unknown result");
    }

    public void addTags(AddTagsRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_addTags(request);
      recv_addTags();
    }

    public void send_addTags(AddTagsRequest request) throws libthrift091.TException
    {
      addTags_args args = new addTags_args();
      args.setRequest(request);
      sendBase("addTags", args);
    }

    public void recv_addTags() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      addTags_result result = new addTags_result();
      receiveBase(result, "addTags");
      if (result.se != null) {
        throw result.se;
      }
      return;
    }

    public GetTagsResponse getTags(GetTagsRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_getTags(request);
      return recv_getTags();
    }

    public void send_getTags(GetTagsRequest request) throws libthrift091.TException
    {
      getTags_args args = new getTags_args();
      args.setRequest(request);
      sendBase("getTags", args);
    }

    public GetTagsResponse recv_getTags() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      getTags_result result = new getTags_result();
      receiveBase(result, "getTags");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "getTags failed: unknown result");
    }

    public void deleteTag(DeleteTagRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_deleteTag(request);
      recv_deleteTag();
    }

    public void send_deleteTag(DeleteTagRequest request) throws libthrift091.TException
    {
      deleteTag_args args = new deleteTag_args();
      args.setRequest(request);
      sendBase("deleteTag", args);
    }

    public void recv_deleteTag() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      deleteTag_result result = new deleteTag_result();
      receiveBase(result, "deleteTag");
      if (result.se != null) {
        throw result.se;
      }
      return;
    }

    public ResizeInstanceGroupResponse resizeInstanceGroup(ResizeInstanceGroupRequest request) throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      send_resizeInstanceGroup(request);
      return recv_resizeInstanceGroup();
    }

    public void send_resizeInstanceGroup(ResizeInstanceGroupRequest request) throws libthrift091.TException
    {
      resizeInstanceGroup_args args = new resizeInstanceGroup_args();
      args.setRequest(request);
      sendBase("resizeInstanceGroup", args);
    }

    public ResizeInstanceGroupResponse recv_resizeInstanceGroup() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException
    {
      resizeInstanceGroup_result result = new resizeInstanceGroup_result();
      receiveBase(result, "resizeInstanceGroup");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.se != null) {
        throw result.se;
      }
      throw new libthrift091.TApplicationException(libthrift091.TApplicationException.MISSING_RESULT, "resizeInstanceGroup failed: unknown result");
    }

  }
  public static class AsyncClient extends com.xiaomi.infra.galaxy.rpc.thrift.BaseService.AsyncClient implements AsyncIface {
    public static class Factory implements libthrift091.async.TAsyncClientFactory {
      private libthrift091.async.TAsyncClientManager clientManager;
      private libthrift091.protocol.TProtocolFactory protocolFactory;
      public Factory(libthrift091.async.TAsyncClientManager clientManager, libthrift091.protocol.TProtocolFactory protocolFactory) {
        this.clientManager = clientManager;
        this.protocolFactory = protocolFactory;
      }
      public AsyncClient getAsyncClient(libthrift091.transport.TNonblockingTransport transport) {
        return new AsyncClient(protocolFactory, clientManager, transport);
      }
    }

    public AsyncClient(libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.async.TAsyncClientManager clientManager, libthrift091.transport.TNonblockingTransport transport) {
      super(protocolFactory, clientManager, transport);
    }

    public void createCluster(CreateClusterRequest cluster, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      createCluster_call method_call = new createCluster_call(cluster, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class createCluster_call extends libthrift091.async.TAsyncMethodCall {
      private CreateClusterRequest cluster;
      public createCluster_call(CreateClusterRequest cluster, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.cluster = cluster;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("createCluster", libthrift091.protocol.TMessageType.CALL, 0));
        createCluster_args args = new createCluster_args();
        args.setCluster(cluster);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public CreateClusterResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_createCluster();
      }
    }

    public void addInstanceGroup(AddInstanceGroupRequest instanceGroup, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      addInstanceGroup_call method_call = new addInstanceGroup_call(instanceGroup, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class addInstanceGroup_call extends libthrift091.async.TAsyncMethodCall {
      private AddInstanceGroupRequest instanceGroup;
      public addInstanceGroup_call(AddInstanceGroupRequest instanceGroup, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.instanceGroup = instanceGroup;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("addInstanceGroup", libthrift091.protocol.TMessageType.CALL, 0));
        addInstanceGroup_args args = new addInstanceGroup_args();
        args.setInstanceGroup(instanceGroup);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public AddInstanceGroupResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_addInstanceGroup();
      }
    }

    public void addInstanceGroups(List instanceGroups, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      addInstanceGroups_call method_call = new addInstanceGroups_call(instanceGroups, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class addInstanceGroups_call extends libthrift091.async.TAsyncMethodCall {
      private List instanceGroups;
      public addInstanceGroups_call(List instanceGroups, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.instanceGroups = instanceGroups;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("addInstanceGroups", libthrift091.protocol.TMessageType.CALL, 0));
        addInstanceGroups_args args = new addInstanceGroups_args();
        args.setInstanceGroups(instanceGroups);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_addInstanceGroups();
      }
    }

    public void submitJob(SubmitJobRequest job, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      submitJob_call method_call = new submitJob_call(job, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class submitJob_call extends libthrift091.async.TAsyncMethodCall {
      private SubmitJobRequest job;
      public submitJob_call(SubmitJobRequest job, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.job = job;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("submitJob", libthrift091.protocol.TMessageType.CALL, 0));
        submitJob_args args = new submitJob_args();
        args.setJob(job);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public SubmitJobResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_submitJob();
      }
    }

    public void submitJobs(List jobs, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      submitJobs_call method_call = new submitJobs_call(jobs, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class submitJobs_call extends libthrift091.async.TAsyncMethodCall {
      private List jobs;
      public submitJobs_call(List jobs, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.jobs = jobs;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("submitJobs", libthrift091.protocol.TMessageType.CALL, 0));
        submitJobs_args args = new submitJobs_args();
        args.setJobs(jobs);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_submitJobs();
      }
    }

    public void terminateCluster(TerminateClusterRequest terminateCluster, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      terminateCluster_call method_call = new terminateCluster_call(terminateCluster, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class terminateCluster_call extends libthrift091.async.TAsyncMethodCall {
      private TerminateClusterRequest terminateCluster;
      public terminateCluster_call(TerminateClusterRequest terminateCluster, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.terminateCluster = terminateCluster;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("terminateCluster", libthrift091.protocol.TMessageType.CALL, 0));
        terminateCluster_args args = new terminateCluster_args();
        args.setTerminateCluster(terminateCluster);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public String getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_terminateCluster();
      }
    }

    public void modifyInstanceGroup(ModifyInstanceGroupRequest instanceGroup, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      modifyInstanceGroup_call method_call = new modifyInstanceGroup_call(instanceGroup, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class modifyInstanceGroup_call extends libthrift091.async.TAsyncMethodCall {
      private ModifyInstanceGroupRequest instanceGroup;
      public modifyInstanceGroup_call(ModifyInstanceGroupRequest instanceGroup, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.instanceGroup = instanceGroup;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("modifyInstanceGroup", libthrift091.protocol.TMessageType.CALL, 0));
        modifyInstanceGroup_args args = new modifyInstanceGroup_args();
        args.setInstanceGroup(instanceGroup);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public ModifyInstanceGroupResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_modifyInstanceGroup();
      }
    }

    public void describeCluster(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      describeCluster_call method_call = new describeCluster_call(clusterId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class describeCluster_call extends libthrift091.async.TAsyncMethodCall {
      private String clusterId;
      public describeCluster_call(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.clusterId = clusterId;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("describeCluster", libthrift091.protocol.TMessageType.CALL, 0));
        describeCluster_args args = new describeCluster_args();
        args.setClusterId(clusterId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public ClusterDetail getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_describeCluster();
      }
    }

    public void describeInstanceGroup(String instanceGroupId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      describeInstanceGroup_call method_call = new describeInstanceGroup_call(instanceGroupId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class describeInstanceGroup_call extends libthrift091.async.TAsyncMethodCall {
      private String instanceGroupId;
      public describeInstanceGroup_call(String instanceGroupId, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.instanceGroupId = instanceGroupId;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("describeInstanceGroup", libthrift091.protocol.TMessageType.CALL, 0));
        describeInstanceGroup_args args = new describeInstanceGroup_args();
        args.setInstanceGroupId(instanceGroupId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public InstanceGroupDetail getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_describeInstanceGroup();
      }
    }

    public void describeInstance(String clusterId, String instanceId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      describeInstance_call method_call = new describeInstance_call(clusterId, instanceId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class describeInstance_call extends libthrift091.async.TAsyncMethodCall {
      private String clusterId;
      private String instanceId;
      public describeInstance_call(String clusterId, String instanceId, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.clusterId = clusterId;
        this.instanceId = instanceId;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("describeInstance", libthrift091.protocol.TMessageType.CALL, 0));
        describeInstance_args args = new describeInstance_args();
        args.setClusterId(clusterId);
        args.setInstanceId(instanceId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public InstanceDetail getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_describeInstance();
      }
    }

    public void describeJob(String clusterId, String jobId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      describeJob_call method_call = new describeJob_call(clusterId, jobId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class describeJob_call extends libthrift091.async.TAsyncMethodCall {
      private String clusterId;
      private String jobId;
      public describeJob_call(String clusterId, String jobId, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.clusterId = clusterId;
        this.jobId = jobId;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("describeJob", libthrift091.protocol.TMessageType.CALL, 0));
        describeJob_args args = new describeJob_args();
        args.setClusterId(clusterId);
        args.setJobId(jobId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public JobDetail getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_describeJob();
      }
    }

    public void listClusters(int createdAfter, int createdBefore, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      listClusters_call method_call = new listClusters_call(createdAfter, createdBefore, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class listClusters_call extends libthrift091.async.TAsyncMethodCall {
      private int createdAfter;
      private int createdBefore;
      public listClusters_call(int createdAfter, int createdBefore, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.createdAfter = createdAfter;
        this.createdBefore = createdBefore;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("listClusters", libthrift091.protocol.TMessageType.CALL, 0));
        listClusters_args args = new listClusters_args();
        args.setCreatedAfter(createdAfter);
        args.setCreatedBefore(createdBefore);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_listClusters();
      }
    }

    public void listClustersWithPrefix(String prefix, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      listClustersWithPrefix_call method_call = new listClustersWithPrefix_call(prefix, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class listClustersWithPrefix_call extends libthrift091.async.TAsyncMethodCall {
      private String prefix;
      public listClustersWithPrefix_call(String prefix, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.prefix = prefix;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("listClustersWithPrefix", libthrift091.protocol.TMessageType.CALL, 0));
        listClustersWithPrefix_args args = new listClustersWithPrefix_args();
        args.setPrefix(prefix);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_listClustersWithPrefix();
      }
    }

    public void listInstanceGroups(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      listInstanceGroups_call method_call = new listInstanceGroups_call(clusterId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class listInstanceGroups_call extends libthrift091.async.TAsyncMethodCall {
      private String clusterId;
      public listInstanceGroups_call(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.clusterId = clusterId;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("listInstanceGroups", libthrift091.protocol.TMessageType.CALL, 0));
        listInstanceGroups_args args = new listInstanceGroups_args();
        args.setClusterId(clusterId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_listInstanceGroups();
      }
    }

    public void listInstancesInCluster(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      listInstancesInCluster_call method_call = new listInstancesInCluster_call(clusterId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class listInstancesInCluster_call extends libthrift091.async.TAsyncMethodCall {
      private String clusterId;
      public listInstancesInCluster_call(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.clusterId = clusterId;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("listInstancesInCluster", libthrift091.protocol.TMessageType.CALL, 0));
        listInstancesInCluster_args args = new listInstancesInCluster_args();
        args.setClusterId(clusterId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_listInstancesInCluster();
      }
    }

    public void listInstancesInGroup(String clusterId, String groupId, InstanceGroupRole groupRole, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      listInstancesInGroup_call method_call = new listInstancesInGroup_call(clusterId, groupId, groupRole, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class listInstancesInGroup_call extends libthrift091.async.TAsyncMethodCall {
      private String clusterId;
      private String groupId;
      private InstanceGroupRole groupRole;
      public listInstancesInGroup_call(String clusterId, String groupId, InstanceGroupRole groupRole, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.clusterId = clusterId;
        this.groupId = groupId;
        this.groupRole = groupRole;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("listInstancesInGroup", libthrift091.protocol.TMessageType.CALL, 0));
        listInstancesInGroup_args args = new listInstancesInGroup_args();
        args.setClusterId(clusterId);
        args.setGroupId(groupId);
        args.setGroupRole(groupRole);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_listInstancesInGroup();
      }
    }

    public void listJobs(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      listJobs_call method_call = new listJobs_call(clusterId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class listJobs_call extends libthrift091.async.TAsyncMethodCall {
      private String clusterId;
      public listJobs_call(String clusterId, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.clusterId = clusterId;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("listJobs", libthrift091.protocol.TMessageType.CALL, 0));
        listJobs_args args = new listJobs_args();
        args.setClusterId(clusterId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_listJobs();
      }
    }

    public void setPermission(SetPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      setPermission_call method_call = new setPermission_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class setPermission_call extends libthrift091.async.TAsyncMethodCall {
      private SetPermissionRequest request;
      public setPermission_call(SetPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("setPermission", libthrift091.protocol.TMessageType.CALL, 0));
        setPermission_args args = new setPermission_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_setPermission();
      }
    }

    public void revokePermission(RevokePermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      revokePermission_call method_call = new revokePermission_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class revokePermission_call extends libthrift091.async.TAsyncMethodCall {
      private RevokePermissionRequest request;
      public revokePermission_call(RevokePermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("revokePermission", libthrift091.protocol.TMessageType.CALL, 0));
        revokePermission_args args = new revokePermission_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_revokePermission();
      }
    }

    public void queryPermission(QueryPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      queryPermission_call method_call = new queryPermission_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class queryPermission_call extends libthrift091.async.TAsyncMethodCall {
      private QueryPermissionRequest request;
      public queryPermission_call(QueryPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("queryPermission", libthrift091.protocol.TMessageType.CALL, 0));
        queryPermission_args args = new queryPermission_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public QueryPermissionResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_queryPermission();
      }
    }

    public void listPermissions(ListPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      listPermissions_call method_call = new listPermissions_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class listPermissions_call extends libthrift091.async.TAsyncMethodCall {
      private ListPermissionRequest request;
      public listPermissions_call(ListPermissionRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("listPermissions", libthrift091.protocol.TMessageType.CALL, 0));
        listPermissions_args args = new listPermissions_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public ListPermissionResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_listPermissions();
      }
    }

    public void getSSHPublicKeys(GetSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      getSSHPublicKeys_call method_call = new getSSHPublicKeys_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getSSHPublicKeys_call extends libthrift091.async.TAsyncMethodCall {
      private GetSSHPublicKeysRequest request;
      public getSSHPublicKeys_call(GetSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("getSSHPublicKeys", libthrift091.protocol.TMessageType.CALL, 0));
        getSSHPublicKeys_args args = new getSSHPublicKeys_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public GetSSHPublicKeysResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getSSHPublicKeys();
      }
    }

    public void addSSHPublicKeys(AddSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      addSSHPublicKeys_call method_call = new addSSHPublicKeys_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class addSSHPublicKeys_call extends libthrift091.async.TAsyncMethodCall {
      private AddSSHPublicKeysRequest request;
      public addSSHPublicKeys_call(AddSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("addSSHPublicKeys", libthrift091.protocol.TMessageType.CALL, 0));
        addSSHPublicKeys_args args = new addSSHPublicKeys_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_addSSHPublicKeys();
      }
    }

    public void deleteSSHPublicKeys(DeleteSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      deleteSSHPublicKeys_call method_call = new deleteSSHPublicKeys_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class deleteSSHPublicKeys_call extends libthrift091.async.TAsyncMethodCall {
      private DeleteSSHPublicKeysRequest request;
      public deleteSSHPublicKeys_call(DeleteSSHPublicKeysRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("deleteSSHPublicKeys", libthrift091.protocol.TMessageType.CALL, 0));
        deleteSSHPublicKeys_args args = new deleteSSHPublicKeys_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_deleteSSHPublicKeys();
      }
    }

    public void getQuota(GetQuotaRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      getQuota_call method_call = new getQuota_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getQuota_call extends libthrift091.async.TAsyncMethodCall {
      private GetQuotaRequest request;
      public getQuota_call(GetQuotaRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("getQuota", libthrift091.protocol.TMessageType.CALL, 0));
        getQuota_args args = new getQuota_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public GetQuotaResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getQuota();
      }
    }

    public void deleteCluster(DeleteClusterRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      deleteCluster_call method_call = new deleteCluster_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class deleteCluster_call extends libthrift091.async.TAsyncMethodCall {
      private DeleteClusterRequest request;
      public deleteCluster_call(DeleteClusterRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("deleteCluster", libthrift091.protocol.TMessageType.CALL, 0));
        deleteCluster_args args = new deleteCluster_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public DeleteClusterResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_deleteCluster();
      }
    }

    public void getEMRBasicConfig(libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      getEMRBasicConfig_call method_call = new getEMRBasicConfig_call(resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getEMRBasicConfig_call extends libthrift091.async.TAsyncMethodCall {
      public getEMRBasicConfig_call(libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("getEMRBasicConfig", libthrift091.protocol.TMessageType.CALL, 0));
        getEMRBasicConfig_args args = new getEMRBasicConfig_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public GetEMRBasicConfigResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getEMRBasicConfig();
      }
    }

    public void getSoftwareConfig(libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      getSoftwareConfig_call method_call = new getSoftwareConfig_call(resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getSoftwareConfig_call extends libthrift091.async.TAsyncMethodCall {
      public getSoftwareConfig_call(libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("getSoftwareConfig", libthrift091.protocol.TMessageType.CALL, 0));
        getSoftwareConfig_args args = new getSoftwareConfig_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public GetSoftwareConfigResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getSoftwareConfig();
      }
    }

    public void getHardwareConfig(libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      getHardwareConfig_call method_call = new getHardwareConfig_call(resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getHardwareConfig_call extends libthrift091.async.TAsyncMethodCall {
      public getHardwareConfig_call(libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("getHardwareConfig", libthrift091.protocol.TMessageType.CALL, 0));
        getHardwareConfig_args args = new getHardwareConfig_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public GetHardwareConfigResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getHardwareConfig();
      }
    }

    public void addTags(AddTagsRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      addTags_call method_call = new addTags_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class addTags_call extends libthrift091.async.TAsyncMethodCall {
      private AddTagsRequest request;
      public addTags_call(AddTagsRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("addTags", libthrift091.protocol.TMessageType.CALL, 0));
        addTags_args args = new addTags_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_addTags();
      }
    }

    public void getTags(GetTagsRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      getTags_call method_call = new getTags_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getTags_call extends libthrift091.async.TAsyncMethodCall {
      private GetTagsRequest request;
      public getTags_call(GetTagsRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("getTags", libthrift091.protocol.TMessageType.CALL, 0));
        getTags_args args = new getTags_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public GetTagsResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getTags();
      }
    }

    public void deleteTag(DeleteTagRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      deleteTag_call method_call = new deleteTag_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class deleteTag_call extends libthrift091.async.TAsyncMethodCall {
      private DeleteTagRequest request;
      public deleteTag_call(DeleteTagRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("deleteTag", libthrift091.protocol.TMessageType.CALL, 0));
        deleteTag_args args = new deleteTag_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_deleteTag();
      }
    }

    public void resizeInstanceGroup(ResizeInstanceGroupRequest request, libthrift091.async.AsyncMethodCallback resultHandler) throws libthrift091.TException {
      checkReady();
      resizeInstanceGroup_call method_call = new resizeInstanceGroup_call(request, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class resizeInstanceGroup_call extends libthrift091.async.TAsyncMethodCall {
      private ResizeInstanceGroupRequest request;
      public resizeInstanceGroup_call(ResizeInstanceGroupRequest request, libthrift091.async.AsyncMethodCallback resultHandler, libthrift091.async.TAsyncClient client, libthrift091.protocol.TProtocolFactory protocolFactory, libthrift091.transport.TNonblockingTransport transport) throws libthrift091.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.request = request;
      }

      public void write_args(libthrift091.protocol.TProtocol prot) throws libthrift091.TException {
        prot.writeMessageBegin(new libthrift091.protocol.TMessage("resizeInstanceGroup", libthrift091.protocol.TMessageType.CALL, 0));
        resizeInstanceGroup_args args = new resizeInstanceGroup_args();
        args.setRequest(request);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public ResizeInstanceGroupResponse getResult() throws com.xiaomi.infra.galaxy.rpc.thrift.ServiceException, libthrift091.TException {
        if (getState() != libthrift091.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        libthrift091.transport.TMemoryInputTransport memoryTransport = new libthrift091.transport.TMemoryInputTransport(getFrameBuffer().array());
        libthrift091.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_resizeInstanceGroup();
      }
    }

  }

  public static class Processor extends com.xiaomi.infra.galaxy.rpc.thrift.BaseService.Processor implements libthrift091.TProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
    public Processor(I iface) {
      super(iface, getProcessMap(new HashMap>()));
    }

    protected Processor(I iface, Map> processMap) {
      super(iface, getProcessMap(processMap));
    }

    private static  Map> getProcessMap(Map> processMap) {
      processMap.put("createCluster", new createCluster());
      processMap.put("addInstanceGroup", new addInstanceGroup());
      processMap.put("addInstanceGroups", new addInstanceGroups());
      processMap.put("submitJob", new submitJob());
      processMap.put("submitJobs", new submitJobs());
      processMap.put("terminateCluster", new terminateCluster());
      processMap.put("modifyInstanceGroup", new modifyInstanceGroup());
      processMap.put("describeCluster", new describeCluster());
      processMap.put("describeInstanceGroup", new describeInstanceGroup());
      processMap.put("describeInstance", new describeInstance());
      processMap.put("describeJob", new describeJob());
      processMap.put("listClusters", new listClusters());
      processMap.put("listClustersWithPrefix", new listClustersWithPrefix());
      processMap.put("listInstanceGroups", new listInstanceGroups());
      processMap.put("listInstancesInCluster", new listInstancesInCluster());
      processMap.put("listInstancesInGroup", new listInstancesInGroup());
      processMap.put("listJobs", new listJobs());
      processMap.put("setPermission", new setPermission());
      processMap.put("revokePermission", new revokePermission());
      processMap.put("queryPermission", new queryPermission());
      processMap.put("listPermissions", new listPermissions());
      processMap.put("getSSHPublicKeys", new getSSHPublicKeys());
      processMap.put("addSSHPublicKeys", new addSSHPublicKeys());
      processMap.put("deleteSSHPublicKeys", new deleteSSHPublicKeys());
      processMap.put("getQuota", new getQuota());
      processMap.put("deleteCluster", new deleteCluster());
      processMap.put("getEMRBasicConfig", new getEMRBasicConfig());
      processMap.put("getSoftwareConfig", new getSoftwareConfig());
      processMap.put("getHardwareConfig", new getHardwareConfig());
      processMap.put("addTags", new addTags());
      processMap.put("getTags", new getTags());
      processMap.put("deleteTag", new deleteTag());
      processMap.put("resizeInstanceGroup", new resizeInstanceGroup());
      return processMap;
    }

    public static class createCluster extends libthrift091.ProcessFunction {
      public createCluster() {
        super("createCluster");
      }

      public createCluster_args getEmptyArgsInstance() {
        return new createCluster_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public createCluster_result getResult(I iface, createCluster_args args) throws libthrift091.TException {
        createCluster_result result = new createCluster_result();
        try {
          result.success = iface.createCluster(args.cluster);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class addInstanceGroup extends libthrift091.ProcessFunction {
      public addInstanceGroup() {
        super("addInstanceGroup");
      }

      public addInstanceGroup_args getEmptyArgsInstance() {
        return new addInstanceGroup_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public addInstanceGroup_result getResult(I iface, addInstanceGroup_args args) throws libthrift091.TException {
        addInstanceGroup_result result = new addInstanceGroup_result();
        try {
          result.success = iface.addInstanceGroup(args.instanceGroup);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class addInstanceGroups extends libthrift091.ProcessFunction {
      public addInstanceGroups() {
        super("addInstanceGroups");
      }

      public addInstanceGroups_args getEmptyArgsInstance() {
        return new addInstanceGroups_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public addInstanceGroups_result getResult(I iface, addInstanceGroups_args args) throws libthrift091.TException {
        addInstanceGroups_result result = new addInstanceGroups_result();
        try {
          result.success = iface.addInstanceGroups(args.instanceGroups);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class submitJob extends libthrift091.ProcessFunction {
      public submitJob() {
        super("submitJob");
      }

      public submitJob_args getEmptyArgsInstance() {
        return new submitJob_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public submitJob_result getResult(I iface, submitJob_args args) throws libthrift091.TException {
        submitJob_result result = new submitJob_result();
        try {
          result.success = iface.submitJob(args.job);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class submitJobs extends libthrift091.ProcessFunction {
      public submitJobs() {
        super("submitJobs");
      }

      public submitJobs_args getEmptyArgsInstance() {
        return new submitJobs_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public submitJobs_result getResult(I iface, submitJobs_args args) throws libthrift091.TException {
        submitJobs_result result = new submitJobs_result();
        try {
          result.success = iface.submitJobs(args.jobs);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class terminateCluster extends libthrift091.ProcessFunction {
      public terminateCluster() {
        super("terminateCluster");
      }

      public terminateCluster_args getEmptyArgsInstance() {
        return new terminateCluster_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public terminateCluster_result getResult(I iface, terminateCluster_args args) throws libthrift091.TException {
        terminateCluster_result result = new terminateCluster_result();
        try {
          result.success = iface.terminateCluster(args.terminateCluster);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class modifyInstanceGroup extends libthrift091.ProcessFunction {
      public modifyInstanceGroup() {
        super("modifyInstanceGroup");
      }

      public modifyInstanceGroup_args getEmptyArgsInstance() {
        return new modifyInstanceGroup_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public modifyInstanceGroup_result getResult(I iface, modifyInstanceGroup_args args) throws libthrift091.TException {
        modifyInstanceGroup_result result = new modifyInstanceGroup_result();
        try {
          result.success = iface.modifyInstanceGroup(args.instanceGroup);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class describeCluster extends libthrift091.ProcessFunction {
      public describeCluster() {
        super("describeCluster");
      }

      public describeCluster_args getEmptyArgsInstance() {
        return new describeCluster_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public describeCluster_result getResult(I iface, describeCluster_args args) throws libthrift091.TException {
        describeCluster_result result = new describeCluster_result();
        try {
          result.success = iface.describeCluster(args.clusterId);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class describeInstanceGroup extends libthrift091.ProcessFunction {
      public describeInstanceGroup() {
        super("describeInstanceGroup");
      }

      public describeInstanceGroup_args getEmptyArgsInstance() {
        return new describeInstanceGroup_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public describeInstanceGroup_result getResult(I iface, describeInstanceGroup_args args) throws libthrift091.TException {
        describeInstanceGroup_result result = new describeInstanceGroup_result();
        try {
          result.success = iface.describeInstanceGroup(args.instanceGroupId);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class describeInstance extends libthrift091.ProcessFunction {
      public describeInstance() {
        super("describeInstance");
      }

      public describeInstance_args getEmptyArgsInstance() {
        return new describeInstance_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public describeInstance_result getResult(I iface, describeInstance_args args) throws libthrift091.TException {
        describeInstance_result result = new describeInstance_result();
        try {
          result.success = iface.describeInstance(args.clusterId, args.instanceId);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class describeJob extends libthrift091.ProcessFunction {
      public describeJob() {
        super("describeJob");
      }

      public describeJob_args getEmptyArgsInstance() {
        return new describeJob_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public describeJob_result getResult(I iface, describeJob_args args) throws libthrift091.TException {
        describeJob_result result = new describeJob_result();
        try {
          result.success = iface.describeJob(args.clusterId, args.jobId);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class listClusters extends libthrift091.ProcessFunction {
      public listClusters() {
        super("listClusters");
      }

      public listClusters_args getEmptyArgsInstance() {
        return new listClusters_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public listClusters_result getResult(I iface, listClusters_args args) throws libthrift091.TException {
        listClusters_result result = new listClusters_result();
        try {
          result.success = iface.listClusters(args.createdAfter, args.createdBefore);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class listClustersWithPrefix extends libthrift091.ProcessFunction {
      public listClustersWithPrefix() {
        super("listClustersWithPrefix");
      }

      public listClustersWithPrefix_args getEmptyArgsInstance() {
        return new listClustersWithPrefix_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public listClustersWithPrefix_result getResult(I iface, listClustersWithPrefix_args args) throws libthrift091.TException {
        listClustersWithPrefix_result result = new listClustersWithPrefix_result();
        try {
          result.success = iface.listClustersWithPrefix(args.prefix);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class listInstanceGroups extends libthrift091.ProcessFunction {
      public listInstanceGroups() {
        super("listInstanceGroups");
      }

      public listInstanceGroups_args getEmptyArgsInstance() {
        return new listInstanceGroups_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public listInstanceGroups_result getResult(I iface, listInstanceGroups_args args) throws libthrift091.TException {
        listInstanceGroups_result result = new listInstanceGroups_result();
        try {
          result.success = iface.listInstanceGroups(args.clusterId);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class listInstancesInCluster extends libthrift091.ProcessFunction {
      public listInstancesInCluster() {
        super("listInstancesInCluster");
      }

      public listInstancesInCluster_args getEmptyArgsInstance() {
        return new listInstancesInCluster_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public listInstancesInCluster_result getResult(I iface, listInstancesInCluster_args args) throws libthrift091.TException {
        listInstancesInCluster_result result = new listInstancesInCluster_result();
        try {
          result.success = iface.listInstancesInCluster(args.clusterId);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class listInstancesInGroup extends libthrift091.ProcessFunction {
      public listInstancesInGroup() {
        super("listInstancesInGroup");
      }

      public listInstancesInGroup_args getEmptyArgsInstance() {
        return new listInstancesInGroup_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public listInstancesInGroup_result getResult(I iface, listInstancesInGroup_args args) throws libthrift091.TException {
        listInstancesInGroup_result result = new listInstancesInGroup_result();
        try {
          result.success = iface.listInstancesInGroup(args.clusterId, args.groupId, args.groupRole);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class listJobs extends libthrift091.ProcessFunction {
      public listJobs() {
        super("listJobs");
      }

      public listJobs_args getEmptyArgsInstance() {
        return new listJobs_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public listJobs_result getResult(I iface, listJobs_args args) throws libthrift091.TException {
        listJobs_result result = new listJobs_result();
        try {
          result.success = iface.listJobs(args.clusterId);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class setPermission extends libthrift091.ProcessFunction {
      public setPermission() {
        super("setPermission");
      }

      public setPermission_args getEmptyArgsInstance() {
        return new setPermission_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public setPermission_result getResult(I iface, setPermission_args args) throws libthrift091.TException {
        setPermission_result result = new setPermission_result();
        try {
          iface.setPermission(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class revokePermission extends libthrift091.ProcessFunction {
      public revokePermission() {
        super("revokePermission");
      }

      public revokePermission_args getEmptyArgsInstance() {
        return new revokePermission_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public revokePermission_result getResult(I iface, revokePermission_args args) throws libthrift091.TException {
        revokePermission_result result = new revokePermission_result();
        try {
          iface.revokePermission(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class queryPermission extends libthrift091.ProcessFunction {
      public queryPermission() {
        super("queryPermission");
      }

      public queryPermission_args getEmptyArgsInstance() {
        return new queryPermission_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public queryPermission_result getResult(I iface, queryPermission_args args) throws libthrift091.TException {
        queryPermission_result result = new queryPermission_result();
        try {
          result.success = iface.queryPermission(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class listPermissions extends libthrift091.ProcessFunction {
      public listPermissions() {
        super("listPermissions");
      }

      public listPermissions_args getEmptyArgsInstance() {
        return new listPermissions_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public listPermissions_result getResult(I iface, listPermissions_args args) throws libthrift091.TException {
        listPermissions_result result = new listPermissions_result();
        try {
          result.success = iface.listPermissions(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class getSSHPublicKeys extends libthrift091.ProcessFunction {
      public getSSHPublicKeys() {
        super("getSSHPublicKeys");
      }

      public getSSHPublicKeys_args getEmptyArgsInstance() {
        return new getSSHPublicKeys_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getSSHPublicKeys_result getResult(I iface, getSSHPublicKeys_args args) throws libthrift091.TException {
        getSSHPublicKeys_result result = new getSSHPublicKeys_result();
        try {
          result.success = iface.getSSHPublicKeys(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class addSSHPublicKeys extends libthrift091.ProcessFunction {
      public addSSHPublicKeys() {
        super("addSSHPublicKeys");
      }

      public addSSHPublicKeys_args getEmptyArgsInstance() {
        return new addSSHPublicKeys_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public addSSHPublicKeys_result getResult(I iface, addSSHPublicKeys_args args) throws libthrift091.TException {
        addSSHPublicKeys_result result = new addSSHPublicKeys_result();
        try {
          iface.addSSHPublicKeys(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class deleteSSHPublicKeys extends libthrift091.ProcessFunction {
      public deleteSSHPublicKeys() {
        super("deleteSSHPublicKeys");
      }

      public deleteSSHPublicKeys_args getEmptyArgsInstance() {
        return new deleteSSHPublicKeys_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public deleteSSHPublicKeys_result getResult(I iface, deleteSSHPublicKeys_args args) throws libthrift091.TException {
        deleteSSHPublicKeys_result result = new deleteSSHPublicKeys_result();
        try {
          iface.deleteSSHPublicKeys(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class getQuota extends libthrift091.ProcessFunction {
      public getQuota() {
        super("getQuota");
      }

      public getQuota_args getEmptyArgsInstance() {
        return new getQuota_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getQuota_result getResult(I iface, getQuota_args args) throws libthrift091.TException {
        getQuota_result result = new getQuota_result();
        try {
          result.success = iface.getQuota(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class deleteCluster extends libthrift091.ProcessFunction {
      public deleteCluster() {
        super("deleteCluster");
      }

      public deleteCluster_args getEmptyArgsInstance() {
        return new deleteCluster_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public deleteCluster_result getResult(I iface, deleteCluster_args args) throws libthrift091.TException {
        deleteCluster_result result = new deleteCluster_result();
        try {
          result.success = iface.deleteCluster(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class getEMRBasicConfig extends libthrift091.ProcessFunction {
      public getEMRBasicConfig() {
        super("getEMRBasicConfig");
      }

      public getEMRBasicConfig_args getEmptyArgsInstance() {
        return new getEMRBasicConfig_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getEMRBasicConfig_result getResult(I iface, getEMRBasicConfig_args args) throws libthrift091.TException {
        getEMRBasicConfig_result result = new getEMRBasicConfig_result();
        try {
          result.success = iface.getEMRBasicConfig();
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class getSoftwareConfig extends libthrift091.ProcessFunction {
      public getSoftwareConfig() {
        super("getSoftwareConfig");
      }

      public getSoftwareConfig_args getEmptyArgsInstance() {
        return new getSoftwareConfig_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getSoftwareConfig_result getResult(I iface, getSoftwareConfig_args args) throws libthrift091.TException {
        getSoftwareConfig_result result = new getSoftwareConfig_result();
        try {
          result.success = iface.getSoftwareConfig();
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class getHardwareConfig extends libthrift091.ProcessFunction {
      public getHardwareConfig() {
        super("getHardwareConfig");
      }

      public getHardwareConfig_args getEmptyArgsInstance() {
        return new getHardwareConfig_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getHardwareConfig_result getResult(I iface, getHardwareConfig_args args) throws libthrift091.TException {
        getHardwareConfig_result result = new getHardwareConfig_result();
        try {
          result.success = iface.getHardwareConfig();
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class addTags extends libthrift091.ProcessFunction {
      public addTags() {
        super("addTags");
      }

      public addTags_args getEmptyArgsInstance() {
        return new addTags_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public addTags_result getResult(I iface, addTags_args args) throws libthrift091.TException {
        addTags_result result = new addTags_result();
        try {
          iface.addTags(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class getTags extends libthrift091.ProcessFunction {
      public getTags() {
        super("getTags");
      }

      public getTags_args getEmptyArgsInstance() {
        return new getTags_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getTags_result getResult(I iface, getTags_args args) throws libthrift091.TException {
        getTags_result result = new getTags_result();
        try {
          result.success = iface.getTags(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class deleteTag extends libthrift091.ProcessFunction {
      public deleteTag() {
        super("deleteTag");
      }

      public deleteTag_args getEmptyArgsInstance() {
        return new deleteTag_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public deleteTag_result getResult(I iface, deleteTag_args args) throws libthrift091.TException {
        deleteTag_result result = new deleteTag_result();
        try {
          iface.deleteTag(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

    public static class resizeInstanceGroup extends libthrift091.ProcessFunction {
      public resizeInstanceGroup() {
        super("resizeInstanceGroup");
      }

      public resizeInstanceGroup_args getEmptyArgsInstance() {
        return new resizeInstanceGroup_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public resizeInstanceGroup_result getResult(I iface, resizeInstanceGroup_args args) throws libthrift091.TException {
        resizeInstanceGroup_result result = new resizeInstanceGroup_result();
        try {
          result.success = iface.resizeInstanceGroup(args.request);
        } catch (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException se) {
          result.se = se;
        }
        return result;
      }
    }

  }

  public static class AsyncProcessor extends com.xiaomi.infra.galaxy.rpc.thrift.BaseService.AsyncProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(AsyncProcessor.class.getName());
    public AsyncProcessor(I iface) {
      super(iface, getProcessMap(new HashMap>()));
    }

    protected AsyncProcessor(I iface, Map> processMap) {
      super(iface, getProcessMap(processMap));
    }

    private static  Map> getProcessMap(Map> processMap) {
      processMap.put("createCluster", new createCluster());
      processMap.put("addInstanceGroup", new addInstanceGroup());
      processMap.put("addInstanceGroups", new addInstanceGroups());
      processMap.put("submitJob", new submitJob());
      processMap.put("submitJobs", new submitJobs());
      processMap.put("terminateCluster", new terminateCluster());
      processMap.put("modifyInstanceGroup", new modifyInstanceGroup());
      processMap.put("describeCluster", new describeCluster());
      processMap.put("describeInstanceGroup", new describeInstanceGroup());
      processMap.put("describeInstance", new describeInstance());
      processMap.put("describeJob", new describeJob());
      processMap.put("listClusters", new listClusters());
      processMap.put("listClustersWithPrefix", new listClustersWithPrefix());
      processMap.put("listInstanceGroups", new listInstanceGroups());
      processMap.put("listInstancesInCluster", new listInstancesInCluster());
      processMap.put("listInstancesInGroup", new listInstancesInGroup());
      processMap.put("listJobs", new listJobs());
      processMap.put("setPermission", new setPermission());
      processMap.put("revokePermission", new revokePermission());
      processMap.put("queryPermission", new queryPermission());
      processMap.put("listPermissions", new listPermissions());
      processMap.put("getSSHPublicKeys", new getSSHPublicKeys());
      processMap.put("addSSHPublicKeys", new addSSHPublicKeys());
      processMap.put("deleteSSHPublicKeys", new deleteSSHPublicKeys());
      processMap.put("getQuota", new getQuota());
      processMap.put("deleteCluster", new deleteCluster());
      processMap.put("getEMRBasicConfig", new getEMRBasicConfig());
      processMap.put("getSoftwareConfig", new getSoftwareConfig());
      processMap.put("getHardwareConfig", new getHardwareConfig());
      processMap.put("addTags", new addTags());
      processMap.put("getTags", new getTags());
      processMap.put("deleteTag", new deleteTag());
      processMap.put("resizeInstanceGroup", new resizeInstanceGroup());
      return processMap;
    }

    public static class createCluster extends libthrift091.AsyncProcessFunction {
      public createCluster() {
        super("createCluster");
      }

      public createCluster_args getEmptyArgsInstance() {
        return new createCluster_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(CreateClusterResponse o) {
            createCluster_result result = new createCluster_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            createCluster_result result = new createCluster_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, createCluster_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.createCluster(args.cluster,resultHandler);
      }
    }

    public static class addInstanceGroup extends libthrift091.AsyncProcessFunction {
      public addInstanceGroup() {
        super("addInstanceGroup");
      }

      public addInstanceGroup_args getEmptyArgsInstance() {
        return new addInstanceGroup_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(AddInstanceGroupResponse o) {
            addInstanceGroup_result result = new addInstanceGroup_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            addInstanceGroup_result result = new addInstanceGroup_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, addInstanceGroup_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.addInstanceGroup(args.instanceGroup,resultHandler);
      }
    }

    public static class addInstanceGroups extends libthrift091.AsyncProcessFunction> {
      public addInstanceGroups() {
        super("addInstanceGroups");
      }

      public addInstanceGroups_args getEmptyArgsInstance() {
        return new addInstanceGroups_args();
      }

      public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback>() { 
          public void onComplete(List o) {
            addInstanceGroups_result result = new addInstanceGroups_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            addInstanceGroups_result result = new addInstanceGroups_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, addInstanceGroups_args args, libthrift091.async.AsyncMethodCallback> resultHandler) throws TException {
        iface.addInstanceGroups(args.instanceGroups,resultHandler);
      }
    }

    public static class submitJob extends libthrift091.AsyncProcessFunction {
      public submitJob() {
        super("submitJob");
      }

      public submitJob_args getEmptyArgsInstance() {
        return new submitJob_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(SubmitJobResponse o) {
            submitJob_result result = new submitJob_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            submitJob_result result = new submitJob_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, submitJob_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.submitJob(args.job,resultHandler);
      }
    }

    public static class submitJobs extends libthrift091.AsyncProcessFunction> {
      public submitJobs() {
        super("submitJobs");
      }

      public submitJobs_args getEmptyArgsInstance() {
        return new submitJobs_args();
      }

      public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback>() { 
          public void onComplete(List o) {
            submitJobs_result result = new submitJobs_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            submitJobs_result result = new submitJobs_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, submitJobs_args args, libthrift091.async.AsyncMethodCallback> resultHandler) throws TException {
        iface.submitJobs(args.jobs,resultHandler);
      }
    }

    public static class terminateCluster extends libthrift091.AsyncProcessFunction {
      public terminateCluster() {
        super("terminateCluster");
      }

      public terminateCluster_args getEmptyArgsInstance() {
        return new terminateCluster_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(String o) {
            terminateCluster_result result = new terminateCluster_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            terminateCluster_result result = new terminateCluster_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, terminateCluster_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.terminateCluster(args.terminateCluster,resultHandler);
      }
    }

    public static class modifyInstanceGroup extends libthrift091.AsyncProcessFunction {
      public modifyInstanceGroup() {
        super("modifyInstanceGroup");
      }

      public modifyInstanceGroup_args getEmptyArgsInstance() {
        return new modifyInstanceGroup_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(ModifyInstanceGroupResponse o) {
            modifyInstanceGroup_result result = new modifyInstanceGroup_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            modifyInstanceGroup_result result = new modifyInstanceGroup_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, modifyInstanceGroup_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.modifyInstanceGroup(args.instanceGroup,resultHandler);
      }
    }

    public static class describeCluster extends libthrift091.AsyncProcessFunction {
      public describeCluster() {
        super("describeCluster");
      }

      public describeCluster_args getEmptyArgsInstance() {
        return new describeCluster_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(ClusterDetail o) {
            describeCluster_result result = new describeCluster_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            describeCluster_result result = new describeCluster_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, describeCluster_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.describeCluster(args.clusterId,resultHandler);
      }
    }

    public static class describeInstanceGroup extends libthrift091.AsyncProcessFunction {
      public describeInstanceGroup() {
        super("describeInstanceGroup");
      }

      public describeInstanceGroup_args getEmptyArgsInstance() {
        return new describeInstanceGroup_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(InstanceGroupDetail o) {
            describeInstanceGroup_result result = new describeInstanceGroup_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            describeInstanceGroup_result result = new describeInstanceGroup_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, describeInstanceGroup_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.describeInstanceGroup(args.instanceGroupId,resultHandler);
      }
    }

    public static class describeInstance extends libthrift091.AsyncProcessFunction {
      public describeInstance() {
        super("describeInstance");
      }

      public describeInstance_args getEmptyArgsInstance() {
        return new describeInstance_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(InstanceDetail o) {
            describeInstance_result result = new describeInstance_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            describeInstance_result result = new describeInstance_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, describeInstance_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.describeInstance(args.clusterId, args.instanceId,resultHandler);
      }
    }

    public static class describeJob extends libthrift091.AsyncProcessFunction {
      public describeJob() {
        super("describeJob");
      }

      public describeJob_args getEmptyArgsInstance() {
        return new describeJob_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(JobDetail o) {
            describeJob_result result = new describeJob_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            describeJob_result result = new describeJob_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, describeJob_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.describeJob(args.clusterId, args.jobId,resultHandler);
      }
    }

    public static class listClusters extends libthrift091.AsyncProcessFunction> {
      public listClusters() {
        super("listClusters");
      }

      public listClusters_args getEmptyArgsInstance() {
        return new listClusters_args();
      }

      public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback>() { 
          public void onComplete(List o) {
            listClusters_result result = new listClusters_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            listClusters_result result = new listClusters_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, listClusters_args args, libthrift091.async.AsyncMethodCallback> resultHandler) throws TException {
        iface.listClusters(args.createdAfter, args.createdBefore,resultHandler);
      }
    }

    public static class listClustersWithPrefix extends libthrift091.AsyncProcessFunction> {
      public listClustersWithPrefix() {
        super("listClustersWithPrefix");
      }

      public listClustersWithPrefix_args getEmptyArgsInstance() {
        return new listClustersWithPrefix_args();
      }

      public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback>() { 
          public void onComplete(List o) {
            listClustersWithPrefix_result result = new listClustersWithPrefix_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            listClustersWithPrefix_result result = new listClustersWithPrefix_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, listClustersWithPrefix_args args, libthrift091.async.AsyncMethodCallback> resultHandler) throws TException {
        iface.listClustersWithPrefix(args.prefix,resultHandler);
      }
    }

    public static class listInstanceGroups extends libthrift091.AsyncProcessFunction> {
      public listInstanceGroups() {
        super("listInstanceGroups");
      }

      public listInstanceGroups_args getEmptyArgsInstance() {
        return new listInstanceGroups_args();
      }

      public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback>() { 
          public void onComplete(List o) {
            listInstanceGroups_result result = new listInstanceGroups_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            listInstanceGroups_result result = new listInstanceGroups_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, listInstanceGroups_args args, libthrift091.async.AsyncMethodCallback> resultHandler) throws TException {
        iface.listInstanceGroups(args.clusterId,resultHandler);
      }
    }

    public static class listInstancesInCluster extends libthrift091.AsyncProcessFunction> {
      public listInstancesInCluster() {
        super("listInstancesInCluster");
      }

      public listInstancesInCluster_args getEmptyArgsInstance() {
        return new listInstancesInCluster_args();
      }

      public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback>() { 
          public void onComplete(List o) {
            listInstancesInCluster_result result = new listInstancesInCluster_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            listInstancesInCluster_result result = new listInstancesInCluster_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, listInstancesInCluster_args args, libthrift091.async.AsyncMethodCallback> resultHandler) throws TException {
        iface.listInstancesInCluster(args.clusterId,resultHandler);
      }
    }

    public static class listInstancesInGroup extends libthrift091.AsyncProcessFunction> {
      public listInstancesInGroup() {
        super("listInstancesInGroup");
      }

      public listInstancesInGroup_args getEmptyArgsInstance() {
        return new listInstancesInGroup_args();
      }

      public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback>() { 
          public void onComplete(List o) {
            listInstancesInGroup_result result = new listInstancesInGroup_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            listInstancesInGroup_result result = new listInstancesInGroup_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, listInstancesInGroup_args args, libthrift091.async.AsyncMethodCallback> resultHandler) throws TException {
        iface.listInstancesInGroup(args.clusterId, args.groupId, args.groupRole,resultHandler);
      }
    }

    public static class listJobs extends libthrift091.AsyncProcessFunction> {
      public listJobs() {
        super("listJobs");
      }

      public listJobs_args getEmptyArgsInstance() {
        return new listJobs_args();
      }

      public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback>() { 
          public void onComplete(List o) {
            listJobs_result result = new listJobs_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            listJobs_result result = new listJobs_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, listJobs_args args, libthrift091.async.AsyncMethodCallback> resultHandler) throws TException {
        iface.listJobs(args.clusterId,resultHandler);
      }
    }

    public static class setPermission extends libthrift091.AsyncProcessFunction {
      public setPermission() {
        super("setPermission");
      }

      public setPermission_args getEmptyArgsInstance() {
        return new setPermission_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(Void o) {
            setPermission_result result = new setPermission_result();
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            setPermission_result result = new setPermission_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, setPermission_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.setPermission(args.request,resultHandler);
      }
    }

    public static class revokePermission extends libthrift091.AsyncProcessFunction {
      public revokePermission() {
        super("revokePermission");
      }

      public revokePermission_args getEmptyArgsInstance() {
        return new revokePermission_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(Void o) {
            revokePermission_result result = new revokePermission_result();
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            revokePermission_result result = new revokePermission_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, revokePermission_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.revokePermission(args.request,resultHandler);
      }
    }

    public static class queryPermission extends libthrift091.AsyncProcessFunction {
      public queryPermission() {
        super("queryPermission");
      }

      public queryPermission_args getEmptyArgsInstance() {
        return new queryPermission_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(QueryPermissionResponse o) {
            queryPermission_result result = new queryPermission_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            queryPermission_result result = new queryPermission_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, queryPermission_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.queryPermission(args.request,resultHandler);
      }
    }

    public static class listPermissions extends libthrift091.AsyncProcessFunction {
      public listPermissions() {
        super("listPermissions");
      }

      public listPermissions_args getEmptyArgsInstance() {
        return new listPermissions_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(ListPermissionResponse o) {
            listPermissions_result result = new listPermissions_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            listPermissions_result result = new listPermissions_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, listPermissions_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.listPermissions(args.request,resultHandler);
      }
    }

    public static class getSSHPublicKeys extends libthrift091.AsyncProcessFunction {
      public getSSHPublicKeys() {
        super("getSSHPublicKeys");
      }

      public getSSHPublicKeys_args getEmptyArgsInstance() {
        return new getSSHPublicKeys_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(GetSSHPublicKeysResponse o) {
            getSSHPublicKeys_result result = new getSSHPublicKeys_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            getSSHPublicKeys_result result = new getSSHPublicKeys_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getSSHPublicKeys_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.getSSHPublicKeys(args.request,resultHandler);
      }
    }

    public static class addSSHPublicKeys extends libthrift091.AsyncProcessFunction {
      public addSSHPublicKeys() {
        super("addSSHPublicKeys");
      }

      public addSSHPublicKeys_args getEmptyArgsInstance() {
        return new addSSHPublicKeys_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(Void o) {
            addSSHPublicKeys_result result = new addSSHPublicKeys_result();
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            addSSHPublicKeys_result result = new addSSHPublicKeys_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, addSSHPublicKeys_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.addSSHPublicKeys(args.request,resultHandler);
      }
    }

    public static class deleteSSHPublicKeys extends libthrift091.AsyncProcessFunction {
      public deleteSSHPublicKeys() {
        super("deleteSSHPublicKeys");
      }

      public deleteSSHPublicKeys_args getEmptyArgsInstance() {
        return new deleteSSHPublicKeys_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(Void o) {
            deleteSSHPublicKeys_result result = new deleteSSHPublicKeys_result();
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            deleteSSHPublicKeys_result result = new deleteSSHPublicKeys_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, deleteSSHPublicKeys_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.deleteSSHPublicKeys(args.request,resultHandler);
      }
    }

    public static class getQuota extends libthrift091.AsyncProcessFunction {
      public getQuota() {
        super("getQuota");
      }

      public getQuota_args getEmptyArgsInstance() {
        return new getQuota_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(GetQuotaResponse o) {
            getQuota_result result = new getQuota_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            getQuota_result result = new getQuota_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getQuota_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.getQuota(args.request,resultHandler);
      }
    }

    public static class deleteCluster extends libthrift091.AsyncProcessFunction {
      public deleteCluster() {
        super("deleteCluster");
      }

      public deleteCluster_args getEmptyArgsInstance() {
        return new deleteCluster_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(DeleteClusterResponse o) {
            deleteCluster_result result = new deleteCluster_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            deleteCluster_result result = new deleteCluster_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, deleteCluster_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.deleteCluster(args.request,resultHandler);
      }
    }

    public static class getEMRBasicConfig extends libthrift091.AsyncProcessFunction {
      public getEMRBasicConfig() {
        super("getEMRBasicConfig");
      }

      public getEMRBasicConfig_args getEmptyArgsInstance() {
        return new getEMRBasicConfig_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(GetEMRBasicConfigResponse o) {
            getEMRBasicConfig_result result = new getEMRBasicConfig_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            getEMRBasicConfig_result result = new getEMRBasicConfig_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getEMRBasicConfig_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.getEMRBasicConfig(resultHandler);
      }
    }

    public static class getSoftwareConfig extends libthrift091.AsyncProcessFunction {
      public getSoftwareConfig() {
        super("getSoftwareConfig");
      }

      public getSoftwareConfig_args getEmptyArgsInstance() {
        return new getSoftwareConfig_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(GetSoftwareConfigResponse o) {
            getSoftwareConfig_result result = new getSoftwareConfig_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            getSoftwareConfig_result result = new getSoftwareConfig_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getSoftwareConfig_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.getSoftwareConfig(resultHandler);
      }
    }

    public static class getHardwareConfig extends libthrift091.AsyncProcessFunction {
      public getHardwareConfig() {
        super("getHardwareConfig");
      }

      public getHardwareConfig_args getEmptyArgsInstance() {
        return new getHardwareConfig_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(GetHardwareConfigResponse o) {
            getHardwareConfig_result result = new getHardwareConfig_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            getHardwareConfig_result result = new getHardwareConfig_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getHardwareConfig_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.getHardwareConfig(resultHandler);
      }
    }

    public static class addTags extends libthrift091.AsyncProcessFunction {
      public addTags() {
        super("addTags");
      }

      public addTags_args getEmptyArgsInstance() {
        return new addTags_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(Void o) {
            addTags_result result = new addTags_result();
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            addTags_result result = new addTags_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, addTags_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.addTags(args.request,resultHandler);
      }
    }

    public static class getTags extends libthrift091.AsyncProcessFunction {
      public getTags() {
        super("getTags");
      }

      public getTags_args getEmptyArgsInstance() {
        return new getTags_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(GetTagsResponse o) {
            getTags_result result = new getTags_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            getTags_result result = new getTags_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getTags_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.getTags(args.request,resultHandler);
      }
    }

    public static class deleteTag extends libthrift091.AsyncProcessFunction {
      public deleteTag() {
        super("deleteTag");
      }

      public deleteTag_args getEmptyArgsInstance() {
        return new deleteTag_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(Void o) {
            deleteTag_result result = new deleteTag_result();
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            deleteTag_result result = new deleteTag_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, deleteTag_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.deleteTag(args.request,resultHandler);
      }
    }

    public static class resizeInstanceGroup extends libthrift091.AsyncProcessFunction {
      public resizeInstanceGroup() {
        super("resizeInstanceGroup");
      }

      public resizeInstanceGroup_args getEmptyArgsInstance() {
        return new resizeInstanceGroup_args();
      }

      public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final libthrift091.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback() { 
          public void onComplete(ResizeInstanceGroupResponse o) {
            resizeInstanceGroup_result result = new resizeInstanceGroup_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, libthrift091.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = libthrift091.protocol.TMessageType.REPLY;
            libthrift091.TBase msg;
            resizeInstanceGroup_result result = new resizeInstanceGroup_result();
            if (e instanceof com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) {
                        result.se = (com.xiaomi.infra.galaxy.rpc.thrift.ServiceException) e;
                        result.setSeIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = libthrift091.protocol.TMessageType.EXCEPTION;
              msg = (libthrift091.TBase)new libthrift091.TApplicationException(libthrift091.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, resizeInstanceGroup_args args, libthrift091.async.AsyncMethodCallback resultHandler) throws TException {
        iface.resizeInstanceGroup(args.request,resultHandler);
      }
    }

  }

  public static class createCluster_args implements libthrift091.TBase, java.io.Serializable, Cloneable, Comparable   {
    private static final libthrift091.protocol.TStruct STRUCT_DESC = new libthrift091.protocol.TStruct("createCluster_args");

    private static final libthrift091.protocol.TField CLUSTER_FIELD_DESC = new libthrift091.protocol.TField("cluster", libthrift091.protocol.TType.STRUCT, (short)1);

    private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new createCluster_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new createCluster_argsTupleSchemeFactory());
    }

    public CreateClusterRequest cluster; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements libthrift091.TFieldIdEnum {
      CLUSTER((short)1, "cluster");

      private static final Map byName = new HashMap();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // CLUSTER
            return CLUSTER;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, libthrift091.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, libthrift091.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, libthrift091.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.CLUSTER, new libthrift091.meta_data.FieldMetaData("cluster", libthrift091.TFieldRequirementType.DEFAULT, 
          new libthrift091.meta_data.StructMetaData(libthrift091.protocol.TType.STRUCT, CreateClusterRequest.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      libthrift091.meta_data.FieldMetaData.addStructMetaDataMap(createCluster_args.class, metaDataMap);
    }

    public createCluster_args() {
    }

    public createCluster_args(
      CreateClusterRequest cluster)
    {
      this();
      this.cluster = cluster;
    }

    /**
     * Performs a deep copy on other.
     */
    public createCluster_args(createCluster_args other) {
      if (other.isSetCluster()) {
        this.cluster = new CreateClusterRequest(other.cluster);
      }
    }

    public createCluster_args deepCopy() {
      return new createCluster_args(this);
    }

    @Override
    public void clear() {
      this.cluster = null;
    }

    public CreateClusterRequest getCluster() {
      return this.cluster;
    }

    public createCluster_args setCluster(CreateClusterRequest cluster) {
      this.cluster = cluster;
      return this;
    }

    public void unsetCluster() {
      this.cluster = null;
    }

    /** Returns true if field cluster is set (has been assigned a value) and false otherwise */
    public boolean isSetCluster() {
      return this.cluster != null;
    }

    public void setClusterIsSet(boolean value) {
      if (!value) {
        this.cluster = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case CLUSTER:
        if (value == null) {
          unsetCluster();
        } else {
          setCluster((CreateClusterRequest)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case CLUSTER:
        return getCluster();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case CLUSTER:
        return isSetCluster();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof createCluster_args)
        return this.equals((createCluster_args)that);
      return false;
    }

    public boolean equals(createCluster_args that) {
      if (that == null)
        return false;

      boolean this_present_cluster = true && this.isSetCluster();
      boolean that_present_cluster = true && that.isSetCluster();
      if (this_present_cluster || that_present_cluster) {
        if (!(this_present_cluster && that_present_cluster))
          return false;
        if (!this.cluster.equals(that.cluster))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      List