airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sma...@apache.org
Subject [09/10] Committed generated classes for thrift models - AIRAVATA-1203
Date Thu, 03 Jul 2014 20:13:57 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/59a7443a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/computeResourceModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/computeResourceModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/computeResourceModel_types.h
index 15e893f..9dff04c 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/computeResourceModel_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/computeResourceModel_types.h
@@ -28,27 +28,17 @@ struct ResourceJobManager {
 
 extern const std::map<int, const char*> _ResourceJobManager_VALUES_TO_NAMES;
 
-struct JobSubmissionProtocol {
+struct FileSystems {
   enum type {
-    SSH = 0,
-    GSISSH = 1,
-    GRAM = 2,
-    UNICORE = 3
+    HOME = 0,
+    WORK = 1,
+    LOCALTMP = 2,
+    SCRATCH = 3,
+    ARCHIVE = 4
   };
 };
 
-extern const std::map<int, const char*> _JobSubmissionProtocol_VALUES_TO_NAMES;
-
-struct DataMovementProtocol {
-  enum type {
-    SCP = 0,
-    SFTP = 1,
-    GridFTP = 2,
-    UNICORE_STORAGE_SERVICE = 3
-  };
-};
-
-extern const std::map<int, const char*> _DataMovementProtocol_VALUES_TO_NAMES;
+extern const std::map<int, const char*> _FileSystems_VALUES_TO_NAMES;
 
 struct SecurityProtocol {
   enum type {
@@ -62,36 +52,164 @@ struct SecurityProtocol {
 
 extern const std::map<int, const char*> _SecurityProtocol_VALUES_TO_NAMES;
 
+struct JobSubmissionProtocol {
+  enum type {
+    LOCAL = 0,
+    SSH = 1,
+    GSISSH = 2,
+    GRAM = 3,
+    UNICORE = 4
+  };
+};
+
+extern const std::map<int, const char*> _JobSubmissionProtocol_VALUES_TO_NAMES;
+
+struct DataMovementProtocol {
+  enum type {
+    LOCAL = 0,
+    SCP = 1,
+    SFTP = 2,
+    GridFTP = 3,
+    UNICORE_STORAGE_SERVICE = 4
+  };
+};
+
+extern const std::map<int, const char*> _DataMovementProtocol_VALUES_TO_NAMES;
+
+typedef struct _BatchQueue__isset {
+  _BatchQueue__isset() : queueDescription(false), maxRunTime(false), maxNodes(false), maxProcessors(false), maxJobsInQueue(false) {}
+  bool queueDescription;
+  bool maxRunTime;
+  bool maxNodes;
+  bool maxProcessors;
+  bool maxJobsInQueue;
+} _BatchQueue__isset;
+
+class BatchQueue {
+ public:
+
+  static const char* ascii_fingerprint; // = "DA59FF8EE453E1822971C1CE1471EEA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xDA,0x59,0xFF,0x8E,0xE4,0x53,0xE1,0x82,0x29,0x71,0xC1,0xCE,0x14,0x71,0xEE,0xA1};
+
+  BatchQueue() : queueName(), queueDescription(), maxRunTime(0), maxNodes(0), maxProcessors(0), maxJobsInQueue(0) {
+  }
+
+  virtual ~BatchQueue() throw() {}
+
+  std::string queueName;
+  std::string queueDescription;
+  int32_t maxRunTime;
+  int32_t maxNodes;
+  int32_t maxProcessors;
+  int32_t maxJobsInQueue;
+
+  _BatchQueue__isset __isset;
+
+  void __set_queueName(const std::string& val) {
+    queueName = val;
+  }
+
+  void __set_queueDescription(const std::string& val) {
+    queueDescription = val;
+    __isset.queueDescription = true;
+  }
+
+  void __set_maxRunTime(const int32_t val) {
+    maxRunTime = val;
+    __isset.maxRunTime = true;
+  }
+
+  void __set_maxNodes(const int32_t val) {
+    maxNodes = val;
+    __isset.maxNodes = true;
+  }
+
+  void __set_maxProcessors(const int32_t val) {
+    maxProcessors = val;
+    __isset.maxProcessors = true;
+  }
+
+  void __set_maxJobsInQueue(const int32_t val) {
+    maxJobsInQueue = val;
+    __isset.maxJobsInQueue = true;
+  }
+
+  bool operator == (const BatchQueue & rhs) const
+  {
+    if (!(queueName == rhs.queueName))
+      return false;
+    if (__isset.queueDescription != rhs.__isset.queueDescription)
+      return false;
+    else if (__isset.queueDescription && !(queueDescription == rhs.queueDescription))
+      return false;
+    if (__isset.maxRunTime != rhs.__isset.maxRunTime)
+      return false;
+    else if (__isset.maxRunTime && !(maxRunTime == rhs.maxRunTime))
+      return false;
+    if (__isset.maxNodes != rhs.__isset.maxNodes)
+      return false;
+    else if (__isset.maxNodes && !(maxNodes == rhs.maxNodes))
+      return false;
+    if (__isset.maxProcessors != rhs.__isset.maxProcessors)
+      return false;
+    else if (__isset.maxProcessors && !(maxProcessors == rhs.maxProcessors))
+      return false;
+    if (__isset.maxJobsInQueue != rhs.__isset.maxJobsInQueue)
+      return false;
+    else if (__isset.maxJobsInQueue && !(maxJobsInQueue == rhs.maxJobsInQueue))
+      return false;
+    return true;
+  }
+  bool operator != (const BatchQueue &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const BatchQueue & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(BatchQueue &a, BatchQueue &b);
+
 typedef struct _SCPDataMovement__isset {
-  _SCPDataMovement__isset() : sshPort(true) {}
+  _SCPDataMovement__isset() : alternativeSCPHostName(false), sshPort(true) {}
+  bool alternativeSCPHostName;
   bool sshPort;
 } _SCPDataMovement__isset;
 
 class SCPDataMovement {
  public:
 
-  static const char* ascii_fingerprint; // = "FEB6B2CD28861B4EED855CACA1FEF2CB";
-  static const uint8_t binary_fingerprint[16]; // = {0xFE,0xB6,0xB2,0xCD,0x28,0x86,0x1B,0x4E,0xED,0x85,0x5C,0xAC,0xA1,0xFE,0xF2,0xCB};
+  static const char* ascii_fingerprint; // = "63CAE6EE336A7DBD91CCCD6E22628F4A";
+  static const uint8_t binary_fingerprint[16]; // = {0x63,0xCA,0xE6,0xEE,0x33,0x6A,0x7D,0xBD,0x91,0xCC,0xCD,0x6E,0x22,0x62,0x8F,0x4A};
 
-  SCPDataMovement() : dataMovementDataID("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0), sshPort(22) {
+  SCPDataMovement() : dataMovementInterfaceId("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0), alternativeSCPHostName(), sshPort(22) {
   }
 
   virtual ~SCPDataMovement() throw() {}
 
-  std::string dataMovementDataID;
+  std::string dataMovementInterfaceId;
   SecurityProtocol::type securityProtocol;
+  std::string alternativeSCPHostName;
   int32_t sshPort;
 
   _SCPDataMovement__isset __isset;
 
-  void __set_dataMovementDataID(const std::string& val) {
-    dataMovementDataID = val;
+  void __set_dataMovementInterfaceId(const std::string& val) {
+    dataMovementInterfaceId = val;
   }
 
   void __set_securityProtocol(const SecurityProtocol::type val) {
     securityProtocol = val;
   }
 
+  void __set_alternativeSCPHostName(const std::string& val) {
+    alternativeSCPHostName = val;
+    __isset.alternativeSCPHostName = true;
+  }
+
   void __set_sshPort(const int32_t val) {
     sshPort = val;
     __isset.sshPort = true;
@@ -99,10 +217,14 @@ class SCPDataMovement {
 
   bool operator == (const SCPDataMovement & rhs) const
   {
-    if (!(dataMovementDataID == rhs.dataMovementDataID))
+    if (!(dataMovementInterfaceId == rhs.dataMovementInterfaceId))
       return false;
     if (!(securityProtocol == rhs.securityProtocol))
       return false;
+    if (__isset.alternativeSCPHostName != rhs.__isset.alternativeSCPHostName)
+      return false;
+    else if (__isset.alternativeSCPHostName && !(alternativeSCPHostName == rhs.alternativeSCPHostName))
+      return false;
     if (__isset.sshPort != rhs.__isset.sshPort)
       return false;
     else if (__isset.sshPort && !(sshPort == rhs.sshPort))
@@ -129,34 +251,34 @@ class GridFTPDataMovement {
   static const char* ascii_fingerprint; // = "790EE8B1D56A3B9B76C41DD063726E75";
   static const uint8_t binary_fingerprint[16]; // = {0x79,0x0E,0xE8,0xB1,0xD5,0x6A,0x3B,0x9B,0x76,0xC4,0x1D,0xD0,0x63,0x72,0x6E,0x75};
 
-  GridFTPDataMovement() : dataMovementDataID("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0) {
+  GridFTPDataMovement() : dataMovementInterfaceId("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0) {
   }
 
   virtual ~GridFTPDataMovement() throw() {}
 
-  std::string dataMovementDataID;
+  std::string dataMovementInterfaceId;
   SecurityProtocol::type securityProtocol;
-  std::vector<std::string>  gridFTPEndPoint;
+  std::vector<std::string>  gridFTPEndPoints;
 
-  void __set_dataMovementDataID(const std::string& val) {
-    dataMovementDataID = val;
+  void __set_dataMovementInterfaceId(const std::string& val) {
+    dataMovementInterfaceId = val;
   }
 
   void __set_securityProtocol(const SecurityProtocol::type val) {
     securityProtocol = val;
   }
 
-  void __set_gridFTPEndPoint(const std::vector<std::string> & val) {
-    gridFTPEndPoint = val;
+  void __set_gridFTPEndPoints(const std::vector<std::string> & val) {
+    gridFTPEndPoints = val;
   }
 
   bool operator == (const GridFTPDataMovement & rhs) const
   {
-    if (!(dataMovementDataID == rhs.dataMovementDataID))
+    if (!(dataMovementInterfaceId == rhs.dataMovementInterfaceId))
       return false;
     if (!(securityProtocol == rhs.securityProtocol))
       return false;
-    if (!(gridFTPEndPoint == rhs.gridFTPEndPoint))
+    if (!(gridFTPEndPoints == rhs.gridFTPEndPoints))
       return false;
     return true;
   }
@@ -173,51 +295,177 @@ class GridFTPDataMovement {
 
 void swap(GridFTPDataMovement &a, GridFTPDataMovement &b);
 
+typedef struct _LOCALSubmission__isset {
+  _LOCALSubmission__isset() : monitoringMechanism(false) {}
+  bool monitoringMechanism;
+} _LOCALSubmission__isset;
+
+class LOCALSubmission {
+ public:
+
+  static const char* ascii_fingerprint; // = "C9C13E23D75AC7D7DB268099D53EE995";
+  static const uint8_t binary_fingerprint[16]; // = {0xC9,0xC1,0x3E,0x23,0xD7,0x5A,0xC7,0xD7,0xDB,0x26,0x80,0x99,0xD5,0x3E,0xE9,0x95};
+
+  LOCALSubmission() : jobSubmissionInterfaceId("DO_NOT_SET_AT_CLIENTS"), resourceJobManager((ResourceJobManager::type)0), monitoringMechanism() {
+  }
+
+  virtual ~LOCALSubmission() throw() {}
+
+  std::string jobSubmissionInterfaceId;
+  ResourceJobManager::type resourceJobManager;
+  std::string monitoringMechanism;
+
+  _LOCALSubmission__isset __isset;
+
+  void __set_jobSubmissionInterfaceId(const std::string& val) {
+    jobSubmissionInterfaceId = val;
+  }
+
+  void __set_resourceJobManager(const ResourceJobManager::type val) {
+    resourceJobManager = val;
+  }
+
+  void __set_monitoringMechanism(const std::string& val) {
+    monitoringMechanism = val;
+    __isset.monitoringMechanism = true;
+  }
+
+  bool operator == (const LOCALSubmission & rhs) const
+  {
+    if (!(jobSubmissionInterfaceId == rhs.jobSubmissionInterfaceId))
+      return false;
+    if (!(resourceJobManager == rhs.resourceJobManager))
+      return false;
+    if (__isset.monitoringMechanism != rhs.__isset.monitoringMechanism)
+      return false;
+    else if (__isset.monitoringMechanism && !(monitoringMechanism == rhs.monitoringMechanism))
+      return false;
+    return true;
+  }
+  bool operator != (const LOCALSubmission &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const LOCALSubmission & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(LOCALSubmission &a, LOCALSubmission &b);
+
+
+class LOCALDataMovement {
+ public:
+
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+  LOCALDataMovement() : dataMovementInterfaceId("DO_NOT_SET_AT_CLIENTS") {
+  }
+
+  virtual ~LOCALDataMovement() throw() {}
+
+  std::string dataMovementInterfaceId;
+
+  void __set_dataMovementInterfaceId(const std::string& val) {
+    dataMovementInterfaceId = val;
+  }
+
+  bool operator == (const LOCALDataMovement & rhs) const
+  {
+    if (!(dataMovementInterfaceId == rhs.dataMovementInterfaceId))
+      return false;
+    return true;
+  }
+  bool operator != (const LOCALDataMovement &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const LOCALDataMovement & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(LOCALDataMovement &a, LOCALDataMovement &b);
+
 typedef struct _SSHJobSubmission__isset {
-  _SSHJobSubmission__isset() : sshPort(true) {}
+  _SSHJobSubmission__isset() : alternativeSSHHostName(false), sshPort(true), monitoringMechanism(false) {}
+  bool alternativeSSHHostName;
   bool sshPort;
+  bool monitoringMechanism;
 } _SSHJobSubmission__isset;
 
 class SSHJobSubmission {
  public:
 
-  static const char* ascii_fingerprint; // = "FEB6B2CD28861B4EED855CACA1FEF2CB";
-  static const uint8_t binary_fingerprint[16]; // = {0xFE,0xB6,0xB2,0xCD,0x28,0x86,0x1B,0x4E,0xED,0x85,0x5C,0xAC,0xA1,0xFE,0xF2,0xCB};
+  static const char* ascii_fingerprint; // = "7AD7C2665ACC6606EC984DACFC74881E";
+  static const uint8_t binary_fingerprint[16]; // = {0x7A,0xD7,0xC2,0x66,0x5A,0xCC,0x66,0x06,0xEC,0x98,0x4D,0xAC,0xFC,0x74,0x88,0x1E};
 
-  SSHJobSubmission() : jobSubmissionDataID("DO_NOT_SET_AT_CLIENTS"), resourceJobManager((ResourceJobManager::type)0), sshPort(22) {
+  SSHJobSubmission() : jobSubmissionInterfaceId("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0), resourceJobManager((ResourceJobManager::type)0), alternativeSSHHostName(), sshPort(22), monitoringMechanism() {
   }
 
   virtual ~SSHJobSubmission() throw() {}
 
-  std::string jobSubmissionDataID;
+  std::string jobSubmissionInterfaceId;
+  SecurityProtocol::type securityProtocol;
   ResourceJobManager::type resourceJobManager;
+  std::string alternativeSSHHostName;
   int32_t sshPort;
+  std::string monitoringMechanism;
 
   _SSHJobSubmission__isset __isset;
 
-  void __set_jobSubmissionDataID(const std::string& val) {
-    jobSubmissionDataID = val;
+  void __set_jobSubmissionInterfaceId(const std::string& val) {
+    jobSubmissionInterfaceId = val;
+  }
+
+  void __set_securityProtocol(const SecurityProtocol::type val) {
+    securityProtocol = val;
   }
 
   void __set_resourceJobManager(const ResourceJobManager::type val) {
     resourceJobManager = val;
   }
 
+  void __set_alternativeSSHHostName(const std::string& val) {
+    alternativeSSHHostName = val;
+    __isset.alternativeSSHHostName = true;
+  }
+
   void __set_sshPort(const int32_t val) {
     sshPort = val;
     __isset.sshPort = true;
   }
 
+  void __set_monitoringMechanism(const std::string& val) {
+    monitoringMechanism = val;
+    __isset.monitoringMechanism = true;
+  }
+
   bool operator == (const SSHJobSubmission & rhs) const
   {
-    if (!(jobSubmissionDataID == rhs.jobSubmissionDataID))
+    if (!(jobSubmissionInterfaceId == rhs.jobSubmissionInterfaceId))
+      return false;
+    if (!(securityProtocol == rhs.securityProtocol))
       return false;
     if (!(resourceJobManager == rhs.resourceJobManager))
       return false;
+    if (__isset.alternativeSSHHostName != rhs.__isset.alternativeSSHHostName)
+      return false;
+    else if (__isset.alternativeSSHHostName && !(alternativeSSHHostName == rhs.alternativeSSHHostName))
+      return false;
     if (__isset.sshPort != rhs.__isset.sshPort)
       return false;
     else if (__isset.sshPort && !(sshPort == rhs.sshPort))
       return false;
+    if (__isset.monitoringMechanism != rhs.__isset.monitoringMechanism)
+      return false;
+    else if (__isset.monitoringMechanism && !(monitoringMechanism == rhs.monitoringMechanism))
+      return false;
     return true;
   }
   bool operator != (const SSHJobSubmission &rhs) const {
@@ -244,20 +492,20 @@ class GlobusJobSubmission {
   static const char* ascii_fingerprint; // = "DF4253F78D7B543C16FA461660D38A03";
   static const uint8_t binary_fingerprint[16]; // = {0xDF,0x42,0x53,0xF7,0x8D,0x7B,0x54,0x3C,0x16,0xFA,0x46,0x16,0x60,0xD3,0x8A,0x03};
 
-  GlobusJobSubmission() : jobSubmissionDataID("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0), resourceJobManager((ResourceJobManager::type)0) {
+  GlobusJobSubmission() : jobSubmissionInterfaceId("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0), resourceJobManager((ResourceJobManager::type)0) {
   }
 
   virtual ~GlobusJobSubmission() throw() {}
 
-  std::string jobSubmissionDataID;
+  std::string jobSubmissionInterfaceId;
   SecurityProtocol::type securityProtocol;
   ResourceJobManager::type resourceJobManager;
   std::vector<std::string>  globusGateKeeperEndPoint;
 
   _GlobusJobSubmission__isset __isset;
 
-  void __set_jobSubmissionDataID(const std::string& val) {
-    jobSubmissionDataID = val;
+  void __set_jobSubmissionInterfaceId(const std::string& val) {
+    jobSubmissionInterfaceId = val;
   }
 
   void __set_securityProtocol(const SecurityProtocol::type val) {
@@ -275,7 +523,7 @@ class GlobusJobSubmission {
 
   bool operator == (const GlobusJobSubmission & rhs) const
   {
-    if (!(jobSubmissionDataID == rhs.jobSubmissionDataID))
+    if (!(jobSubmissionInterfaceId == rhs.jobSubmissionInterfaceId))
       return false;
     if (!(securityProtocol == rhs.securityProtocol))
       return false;
@@ -300,149 +548,142 @@ class GlobusJobSubmission {
 
 void swap(GlobusJobSubmission &a, GlobusJobSubmission &b);
 
-typedef struct _GSISSHJobSubmission__isset {
-  _GSISSHJobSubmission__isset() : sshPort(true), exports(false), preJobCommands(false), postJobCommands(false), installedPath(false), monitorMode(false) {}
-  bool sshPort;
-  bool exports;
-  bool preJobCommands;
-  bool postJobCommands;
-  bool installedPath;
-  bool monitorMode;
-} _GSISSHJobSubmission__isset;
-
-class GSISSHJobSubmission {
+
+class JobSubmissionInterface {
  public:
 
-  static const char* ascii_fingerprint; // = "6969A7F145C4403B2F9081A498E933FD";
-  static const uint8_t binary_fingerprint[16]; // = {0x69,0x69,0xA7,0xF1,0x45,0xC4,0x40,0x3B,0x2F,0x90,0x81,0xA4,0x98,0xE9,0x33,0xFD};
+  static const char* ascii_fingerprint; // = "A0A4DD7B8243FB842E64EAC6E5DA6C7B";
+  static const uint8_t binary_fingerprint[16]; // = {0xA0,0xA4,0xDD,0x7B,0x82,0x43,0xFB,0x84,0x2E,0x64,0xEA,0xC6,0xE5,0xDA,0x6C,0x7B};
 
-  GSISSHJobSubmission() : jobSubmissionDataID("DO_NOT_SET_AT_CLIENTS"), resourceJobManager((ResourceJobManager::type)0), sshPort(22), installedPath(), monitorMode() {
+  JobSubmissionInterface() : jobSubmissionInterfaceId(), jobSubmissionProtocol((JobSubmissionProtocol::type)0), priorityOrder(0) {
   }
 
-  virtual ~GSISSHJobSubmission() throw() {}
-
-  std::string jobSubmissionDataID;
-  ResourceJobManager::type resourceJobManager;
-  int32_t sshPort;
-  std::set<std::string>  exports;
-  std::vector<std::string>  preJobCommands;
-  std::vector<std::string>  postJobCommands;
-  std::string installedPath;
-  std::string monitorMode;
+  virtual ~JobSubmissionInterface() throw() {}
 
-  _GSISSHJobSubmission__isset __isset;
+  std::string jobSubmissionInterfaceId;
+  JobSubmissionProtocol::type jobSubmissionProtocol;
+  int32_t priorityOrder;
 
-  void __set_jobSubmissionDataID(const std::string& val) {
-    jobSubmissionDataID = val;
+  void __set_jobSubmissionInterfaceId(const std::string& val) {
+    jobSubmissionInterfaceId = val;
   }
 
-  void __set_resourceJobManager(const ResourceJobManager::type val) {
-    resourceJobManager = val;
+  void __set_jobSubmissionProtocol(const JobSubmissionProtocol::type val) {
+    jobSubmissionProtocol = val;
   }
 
-  void __set_sshPort(const int32_t val) {
-    sshPort = val;
-    __isset.sshPort = true;
+  void __set_priorityOrder(const int32_t val) {
+    priorityOrder = val;
   }
 
-  void __set_exports(const std::set<std::string> & val) {
-    exports = val;
-    __isset.exports = true;
+  bool operator == (const JobSubmissionInterface & rhs) const
+  {
+    if (!(jobSubmissionInterfaceId == rhs.jobSubmissionInterfaceId))
+      return false;
+    if (!(jobSubmissionProtocol == rhs.jobSubmissionProtocol))
+      return false;
+    if (!(priorityOrder == rhs.priorityOrder))
+      return false;
+    return true;
+  }
+  bool operator != (const JobSubmissionInterface &rhs) const {
+    return !(*this == rhs);
   }
 
-  void __set_preJobCommands(const std::vector<std::string> & val) {
-    preJobCommands = val;
-    __isset.preJobCommands = true;
+  bool operator < (const JobSubmissionInterface & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(JobSubmissionInterface &a, JobSubmissionInterface &b);
+
+
+class DataMovementInterface {
+ public:
+
+  static const char* ascii_fingerprint; // = "A0A4DD7B8243FB842E64EAC6E5DA6C7B";
+  static const uint8_t binary_fingerprint[16]; // = {0xA0,0xA4,0xDD,0x7B,0x82,0x43,0xFB,0x84,0x2E,0x64,0xEA,0xC6,0xE5,0xDA,0x6C,0x7B};
+
+  DataMovementInterface() : dataMovementInterfaceId(), dataMovementProtocol((DataMovementProtocol::type)0), priorityOrder(0) {
   }
 
-  void __set_postJobCommands(const std::vector<std::string> & val) {
-    postJobCommands = val;
-    __isset.postJobCommands = true;
+  virtual ~DataMovementInterface() throw() {}
+
+  std::string dataMovementInterfaceId;
+  DataMovementProtocol::type dataMovementProtocol;
+  int32_t priorityOrder;
+
+  void __set_dataMovementInterfaceId(const std::string& val) {
+    dataMovementInterfaceId = val;
   }
 
-  void __set_installedPath(const std::string& val) {
-    installedPath = val;
-    __isset.installedPath = true;
+  void __set_dataMovementProtocol(const DataMovementProtocol::type val) {
+    dataMovementProtocol = val;
   }
 
-  void __set_monitorMode(const std::string& val) {
-    monitorMode = val;
-    __isset.monitorMode = true;
+  void __set_priorityOrder(const int32_t val) {
+    priorityOrder = val;
   }
 
-  bool operator == (const GSISSHJobSubmission & rhs) const
+  bool operator == (const DataMovementInterface & rhs) const
   {
-    if (!(jobSubmissionDataID == rhs.jobSubmissionDataID))
+    if (!(dataMovementInterfaceId == rhs.dataMovementInterfaceId))
       return false;
-    if (!(resourceJobManager == rhs.resourceJobManager))
+    if (!(dataMovementProtocol == rhs.dataMovementProtocol))
       return false;
-    if (__isset.sshPort != rhs.__isset.sshPort)
-      return false;
-    else if (__isset.sshPort && !(sshPort == rhs.sshPort))
-      return false;
-    if (__isset.exports != rhs.__isset.exports)
-      return false;
-    else if (__isset.exports && !(exports == rhs.exports))
-      return false;
-    if (__isset.preJobCommands != rhs.__isset.preJobCommands)
-      return false;
-    else if (__isset.preJobCommands && !(preJobCommands == rhs.preJobCommands))
-      return false;
-    if (__isset.postJobCommands != rhs.__isset.postJobCommands)
-      return false;
-    else if (__isset.postJobCommands && !(postJobCommands == rhs.postJobCommands))
-      return false;
-    if (__isset.installedPath != rhs.__isset.installedPath)
-      return false;
-    else if (__isset.installedPath && !(installedPath == rhs.installedPath))
-      return false;
-    if (__isset.monitorMode != rhs.__isset.monitorMode)
-      return false;
-    else if (__isset.monitorMode && !(monitorMode == rhs.monitorMode))
+    if (!(priorityOrder == rhs.priorityOrder))
       return false;
     return true;
   }
-  bool operator != (const GSISSHJobSubmission &rhs) const {
+  bool operator != (const DataMovementInterface &rhs) const {
     return !(*this == rhs);
   }
 
-  bool operator < (const GSISSHJobSubmission & ) const;
+  bool operator < (const DataMovementInterface & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
-void swap(GSISSHJobSubmission &a, GSISSHJobSubmission &b);
+void swap(DataMovementInterface &a, DataMovementInterface &b);
 
 typedef struct _ComputeResourceDescription__isset {
-  _ComputeResourceDescription__isset() : hostAliases(false), ipAddresses(false), resourceDescription(false), preferredJobSubmissionProtocol(false) {}
+  _ComputeResourceDescription__isset() : hostAliases(false), ipAddresses(false), computeResourceDescription(false), resourceJobManager(false), batchQueues(false), fileSystems(false), jobSubmissionInterfaces(false), dataMovemenetInterfaces(false) {}
   bool hostAliases;
   bool ipAddresses;
-  bool resourceDescription;
-  bool preferredJobSubmissionProtocol;
+  bool computeResourceDescription;
+  bool resourceJobManager;
+  bool batchQueues;
+  bool fileSystems;
+  bool jobSubmissionInterfaces;
+  bool dataMovemenetInterfaces;
 } _ComputeResourceDescription__isset;
 
 class ComputeResourceDescription {
  public:
 
-  static const char* ascii_fingerprint; // = "A31E9EF4FF0C9ADE9027FD5C59A96555";
-  static const uint8_t binary_fingerprint[16]; // = {0xA3,0x1E,0x9E,0xF4,0xFF,0x0C,0x9A,0xDE,0x90,0x27,0xFD,0x5C,0x59,0xA9,0x65,0x55};
+  static const char* ascii_fingerprint; // = "ADC1452A60F79D933D0EE4B9893AD048";
+  static const uint8_t binary_fingerprint[16]; // = {0xAD,0xC1,0x45,0x2A,0x60,0xF7,0x9D,0x93,0x3D,0x0E,0xE4,0xB9,0x89,0x3A,0xD0,0x48};
 
-  ComputeResourceDescription() : isEmpty(false), resourceId("DO_NOT_SET_AT_CLIENTS"), hostName(), resourceDescription(), preferredJobSubmissionProtocol() {
+  ComputeResourceDescription() : isEmpty(false), computeResourceId("DO_NOT_SET_AT_CLIENTS"), hostName(), computeResourceDescription(), resourceJobManager((ResourceJobManager::type)0) {
   }
 
   virtual ~ComputeResourceDescription() throw() {}
 
   bool isEmpty;
-  std::string resourceId;
+  std::string computeResourceId;
   std::string hostName;
   std::set<std::string>  hostAliases;
   std::set<std::string>  ipAddresses;
-  std::string resourceDescription;
-  std::string preferredJobSubmissionProtocol;
-  std::map<std::string, JobSubmissionProtocol::type>  jobSubmissionProtocols;
-  std::map<std::string, DataMovementProtocol::type>  dataMovementProtocols;
+  std::string computeResourceDescription;
+  ResourceJobManager::type resourceJobManager;
+  std::vector<BatchQueue>  batchQueues;
+  std::map<FileSystems::type, std::string>  fileSystems;
+  std::vector<JobSubmissionInterface>  jobSubmissionInterfaces;
+  std::vector<DataMovementInterface>  dataMovemenetInterfaces;
 
   _ComputeResourceDescription__isset __isset;
 
@@ -450,8 +691,8 @@ class ComputeResourceDescription {
     isEmpty = val;
   }
 
-  void __set_resourceId(const std::string& val) {
-    resourceId = val;
+  void __set_computeResourceId(const std::string& val) {
+    computeResourceId = val;
   }
 
   void __set_hostName(const std::string& val) {
@@ -468,29 +709,41 @@ class ComputeResourceDescription {
     __isset.ipAddresses = true;
   }
 
-  void __set_resourceDescription(const std::string& val) {
-    resourceDescription = val;
-    __isset.resourceDescription = true;
+  void __set_computeResourceDescription(const std::string& val) {
+    computeResourceDescription = val;
+    __isset.computeResourceDescription = true;
   }
 
-  void __set_preferredJobSubmissionProtocol(const std::string& val) {
-    preferredJobSubmissionProtocol = val;
-    __isset.preferredJobSubmissionProtocol = true;
+  void __set_resourceJobManager(const ResourceJobManager::type val) {
+    resourceJobManager = val;
+    __isset.resourceJobManager = true;
+  }
+
+  void __set_batchQueues(const std::vector<BatchQueue> & val) {
+    batchQueues = val;
+    __isset.batchQueues = true;
+  }
+
+  void __set_fileSystems(const std::map<FileSystems::type, std::string> & val) {
+    fileSystems = val;
+    __isset.fileSystems = true;
   }
 
-  void __set_jobSubmissionProtocols(const std::map<std::string, JobSubmissionProtocol::type> & val) {
-    jobSubmissionProtocols = val;
+  void __set_jobSubmissionInterfaces(const std::vector<JobSubmissionInterface> & val) {
+    jobSubmissionInterfaces = val;
+    __isset.jobSubmissionInterfaces = true;
   }
 
-  void __set_dataMovementProtocols(const std::map<std::string, DataMovementProtocol::type> & val) {
-    dataMovementProtocols = val;
+  void __set_dataMovemenetInterfaces(const std::vector<DataMovementInterface> & val) {
+    dataMovemenetInterfaces = val;
+    __isset.dataMovemenetInterfaces = true;
   }
 
   bool operator == (const ComputeResourceDescription & rhs) const
   {
     if (!(isEmpty == rhs.isEmpty))
       return false;
-    if (!(resourceId == rhs.resourceId))
+    if (!(computeResourceId == rhs.computeResourceId))
       return false;
     if (!(hostName == rhs.hostName))
       return false;
@@ -502,17 +755,29 @@ class ComputeResourceDescription {
       return false;
     else if (__isset.ipAddresses && !(ipAddresses == rhs.ipAddresses))
       return false;
-    if (__isset.resourceDescription != rhs.__isset.resourceDescription)
+    if (__isset.computeResourceDescription != rhs.__isset.computeResourceDescription)
+      return false;
+    else if (__isset.computeResourceDescription && !(computeResourceDescription == rhs.computeResourceDescription))
+      return false;
+    if (__isset.resourceJobManager != rhs.__isset.resourceJobManager)
+      return false;
+    else if (__isset.resourceJobManager && !(resourceJobManager == rhs.resourceJobManager))
+      return false;
+    if (__isset.batchQueues != rhs.__isset.batchQueues)
+      return false;
+    else if (__isset.batchQueues && !(batchQueues == rhs.batchQueues))
+      return false;
+    if (__isset.fileSystems != rhs.__isset.fileSystems)
       return false;
-    else if (__isset.resourceDescription && !(resourceDescription == rhs.resourceDescription))
+    else if (__isset.fileSystems && !(fileSystems == rhs.fileSystems))
       return false;
-    if (__isset.preferredJobSubmissionProtocol != rhs.__isset.preferredJobSubmissionProtocol)
+    if (__isset.jobSubmissionInterfaces != rhs.__isset.jobSubmissionInterfaces)
       return false;
-    else if (__isset.preferredJobSubmissionProtocol && !(preferredJobSubmissionProtocol == rhs.preferredJobSubmissionProtocol))
+    else if (__isset.jobSubmissionInterfaces && !(jobSubmissionInterfaces == rhs.jobSubmissionInterfaces))
       return false;
-    if (!(jobSubmissionProtocols == rhs.jobSubmissionProtocols))
+    if (__isset.dataMovemenetInterfaces != rhs.__isset.dataMovemenetInterfaces)
       return false;
-    if (!(dataMovementProtocols == rhs.dataMovementProtocols))
+    else if (__isset.dataMovemenetInterfaces && !(dataMovemenetInterfaces == rhs.dataMovemenetInterfaces))
       return false;
     return true;
   }

http://git-wip-us.apache.org/repos/asf/airavata/blob/59a7443a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.cpp
index 62264d4..896a770 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.cpp
@@ -10,8 +10,159 @@
 
 
 
-const char* GatewayProfile::ascii_fingerprint = "FED0FBEAA0C90D1589E8B650561B7675";
-const uint8_t GatewayProfile::binary_fingerprint[16] = {0xFE,0xD0,0xFB,0xEA,0xA0,0xC9,0x0D,0x15,0x89,0xE8,0xB6,0x50,0x56,0x1B,0x76,0x75};
+const char* ComputeResourcePreference::ascii_fingerprint = "9C98338B7E052CD4DEECB22F243D6DAE";
+const uint8_t ComputeResourcePreference::binary_fingerprint[16] = {0x9C,0x98,0x33,0x8B,0x7E,0x05,0x2C,0xD4,0xDE,0xEC,0xB2,0x2F,0x24,0x3D,0x6D,0xAE};
+
+uint32_t ComputeResourcePreference::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_computeResourceId = false;
+  bool isset_overridebyAiravata = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->computeResourceId);
+          isset_computeResourceId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->overridebyAiravata);
+          isset_overridebyAiravata = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->preferredJobSubmissionProtocol);
+          this->__isset.preferredJobSubmissionProtocol = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->preferredDataMovementProtocol);
+          this->__isset.preferredDataMovementProtocol = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->preferredBatchQueue);
+          this->__isset.preferredBatchQueue = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->scratchLocation);
+          this->__isset.scratchLocation = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->allocationProjectNumber);
+          this->__isset.allocationProjectNumber = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_computeResourceId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_overridebyAiravata)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ComputeResourcePreference::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ComputeResourcePreference");
+
+  xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->computeResourceId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("overridebyAiravata", ::apache::thrift::protocol::T_BOOL, 2);
+  xfer += oprot->writeBool(this->overridebyAiravata);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.preferredJobSubmissionProtocol) {
+    xfer += oprot->writeFieldBegin("preferredJobSubmissionProtocol", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->preferredJobSubmissionProtocol);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.preferredDataMovementProtocol) {
+    xfer += oprot->writeFieldBegin("preferredDataMovementProtocol", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->preferredDataMovementProtocol);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.preferredBatchQueue) {
+    xfer += oprot->writeFieldBegin("preferredBatchQueue", ::apache::thrift::protocol::T_STRING, 5);
+    xfer += oprot->writeString(this->preferredBatchQueue);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.scratchLocation) {
+    xfer += oprot->writeFieldBegin("scratchLocation", ::apache::thrift::protocol::T_STRING, 6);
+    xfer += oprot->writeString(this->scratchLocation);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.allocationProjectNumber) {
+    xfer += oprot->writeFieldBegin("allocationProjectNumber", ::apache::thrift::protocol::T_STRING, 7);
+    xfer += oprot->writeString(this->allocationProjectNumber);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ComputeResourcePreference &a, ComputeResourcePreference &b) {
+  using ::std::swap;
+  swap(a.computeResourceId, b.computeResourceId);
+  swap(a.overridebyAiravata, b.overridebyAiravata);
+  swap(a.preferredJobSubmissionProtocol, b.preferredJobSubmissionProtocol);
+  swap(a.preferredDataMovementProtocol, b.preferredDataMovementProtocol);
+  swap(a.preferredBatchQueue, b.preferredBatchQueue);
+  swap(a.scratchLocation, b.scratchLocation);
+  swap(a.allocationProjectNumber, b.allocationProjectNumber);
+  swap(a.__isset, b.__isset);
+}
+
+const char* GatewayProfile::ascii_fingerprint = "D6477904C48AAB4DC8F09369D670B400";
+const uint8_t GatewayProfile::binary_fingerprint[16] = {0xD6,0x47,0x79,0x04,0xC4,0x8A,0xAB,0x4D,0xC8,0xF0,0x93,0x69,0xD6,0x70,0xB4,0x00};
 
 uint32_t GatewayProfile::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -60,9 +211,21 @@ uint32_t GatewayProfile::read(::apache::thrift::protocol::TProtocol* iprot) {
         }
         break;
       case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->preferedResource);
-          this->__isset.preferedResource = true;
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->computeResourcePreferences.clear();
+            uint32_t _size0;
+            ::apache::thrift::protocol::TType _etype3;
+            xfer += iprot->readListBegin(_etype3, _size0);
+            this->computeResourcePreferences.resize(_size0);
+            uint32_t _i4;
+            for (_i4 = 0; _i4 < _size0; ++_i4)
+            {
+              xfer += this->computeResourcePreferences[_i4].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.computeResourcePreferences = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -100,9 +263,17 @@ uint32_t GatewayProfile::write(::apache::thrift::protocol::TProtocol* oprot) con
     xfer += oprot->writeString(this->gatewayDescription);
     xfer += oprot->writeFieldEnd();
   }
-  if (this->__isset.preferedResource) {
-    xfer += oprot->writeFieldBegin("preferedResource", ::apache::thrift::protocol::T_STRING, 4);
-    xfer += oprot->writeString(this->preferedResource);
+  if (this->__isset.computeResourcePreferences) {
+    xfer += oprot->writeFieldBegin("computeResourcePreferences", ::apache::thrift::protocol::T_LIST, 4);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->computeResourcePreferences.size()));
+      std::vector<ComputeResourcePreference> ::const_iterator _iter5;
+      for (_iter5 = this->computeResourcePreferences.begin(); _iter5 != this->computeResourcePreferences.end(); ++_iter5)
+      {
+        xfer += (*_iter5).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -115,7 +286,7 @@ void swap(GatewayProfile &a, GatewayProfile &b) {
   swap(a.gatewayID, b.gatewayID);
   swap(a.gatewayName, b.gatewayName);
   swap(a.gatewayDescription, b.gatewayDescription);
-  swap(a.preferedResource, b.preferedResource);
+  swap(a.computeResourcePreferences, b.computeResourcePreferences);
   swap(a.__isset, b.__isset);
 }
 

http://git-wip-us.apache.org/repos/asf/airavata/blob/59a7443a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.h
index 38a3338..6bab76c 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/gatewayProfileModel_types.h
@@ -17,19 +17,123 @@
 
 
 
+typedef struct _ComputeResourcePreference__isset {
+  _ComputeResourcePreference__isset() : preferredJobSubmissionProtocol(false), preferredDataMovementProtocol(false), preferredBatchQueue(false), scratchLocation(false), allocationProjectNumber(false) {}
+  bool preferredJobSubmissionProtocol;
+  bool preferredDataMovementProtocol;
+  bool preferredBatchQueue;
+  bool scratchLocation;
+  bool allocationProjectNumber;
+} _ComputeResourcePreference__isset;
+
+class ComputeResourcePreference {
+ public:
+
+  static const char* ascii_fingerprint; // = "9C98338B7E052CD4DEECB22F243D6DAE";
+  static const uint8_t binary_fingerprint[16]; // = {0x9C,0x98,0x33,0x8B,0x7E,0x05,0x2C,0xD4,0xDE,0xEC,0xB2,0x2F,0x24,0x3D,0x6D,0xAE};
+
+  ComputeResourcePreference() : computeResourceId(), overridebyAiravata(true), preferredJobSubmissionProtocol(), preferredDataMovementProtocol(), preferredBatchQueue(), scratchLocation(), allocationProjectNumber() {
+  }
+
+  virtual ~ComputeResourcePreference() throw() {}
+
+  std::string computeResourceId;
+  bool overridebyAiravata;
+  std::string preferredJobSubmissionProtocol;
+  std::string preferredDataMovementProtocol;
+  std::string preferredBatchQueue;
+  std::string scratchLocation;
+  std::string allocationProjectNumber;
+
+  _ComputeResourcePreference__isset __isset;
+
+  void __set_computeResourceId(const std::string& val) {
+    computeResourceId = val;
+  }
+
+  void __set_overridebyAiravata(const bool val) {
+    overridebyAiravata = val;
+  }
+
+  void __set_preferredJobSubmissionProtocol(const std::string& val) {
+    preferredJobSubmissionProtocol = val;
+    __isset.preferredJobSubmissionProtocol = true;
+  }
+
+  void __set_preferredDataMovementProtocol(const std::string& val) {
+    preferredDataMovementProtocol = val;
+    __isset.preferredDataMovementProtocol = true;
+  }
+
+  void __set_preferredBatchQueue(const std::string& val) {
+    preferredBatchQueue = val;
+    __isset.preferredBatchQueue = true;
+  }
+
+  void __set_scratchLocation(const std::string& val) {
+    scratchLocation = val;
+    __isset.scratchLocation = true;
+  }
+
+  void __set_allocationProjectNumber(const std::string& val) {
+    allocationProjectNumber = val;
+    __isset.allocationProjectNumber = true;
+  }
+
+  bool operator == (const ComputeResourcePreference & rhs) const
+  {
+    if (!(computeResourceId == rhs.computeResourceId))
+      return false;
+    if (!(overridebyAiravata == rhs.overridebyAiravata))
+      return false;
+    if (__isset.preferredJobSubmissionProtocol != rhs.__isset.preferredJobSubmissionProtocol)
+      return false;
+    else if (__isset.preferredJobSubmissionProtocol && !(preferredJobSubmissionProtocol == rhs.preferredJobSubmissionProtocol))
+      return false;
+    if (__isset.preferredDataMovementProtocol != rhs.__isset.preferredDataMovementProtocol)
+      return false;
+    else if (__isset.preferredDataMovementProtocol && !(preferredDataMovementProtocol == rhs.preferredDataMovementProtocol))
+      return false;
+    if (__isset.preferredBatchQueue != rhs.__isset.preferredBatchQueue)
+      return false;
+    else if (__isset.preferredBatchQueue && !(preferredBatchQueue == rhs.preferredBatchQueue))
+      return false;
+    if (__isset.scratchLocation != rhs.__isset.scratchLocation)
+      return false;
+    else if (__isset.scratchLocation && !(scratchLocation == rhs.scratchLocation))
+      return false;
+    if (__isset.allocationProjectNumber != rhs.__isset.allocationProjectNumber)
+      return false;
+    else if (__isset.allocationProjectNumber && !(allocationProjectNumber == rhs.allocationProjectNumber))
+      return false;
+    return true;
+  }
+  bool operator != (const ComputeResourcePreference &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ComputeResourcePreference & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ComputeResourcePreference &a, ComputeResourcePreference &b);
+
 typedef struct _GatewayProfile__isset {
-  _GatewayProfile__isset() : gatewayDescription(false), preferedResource(false) {}
+  _GatewayProfile__isset() : gatewayDescription(false), computeResourcePreferences(false) {}
   bool gatewayDescription;
-  bool preferedResource;
+  bool computeResourcePreferences;
 } _GatewayProfile__isset;
 
 class GatewayProfile {
  public:
 
-  static const char* ascii_fingerprint; // = "FED0FBEAA0C90D1589E8B650561B7675";
-  static const uint8_t binary_fingerprint[16]; // = {0xFE,0xD0,0xFB,0xEA,0xA0,0xC9,0x0D,0x15,0x89,0xE8,0xB6,0x50,0x56,0x1B,0x76,0x75};
+  static const char* ascii_fingerprint; // = "D6477904C48AAB4DC8F09369D670B400";
+  static const uint8_t binary_fingerprint[16]; // = {0xD6,0x47,0x79,0x04,0xC4,0x8A,0xAB,0x4D,0xC8,0xF0,0x93,0x69,0xD6,0x70,0xB4,0x00};
 
-  GatewayProfile() : gatewayID("DO_NOT_SET_AT_CLIENTS"), gatewayName(), gatewayDescription(), preferedResource() {
+  GatewayProfile() : gatewayID("DO_NOT_SET_AT_CLIENTS"), gatewayName(), gatewayDescription() {
   }
 
   virtual ~GatewayProfile() throw() {}
@@ -37,7 +141,7 @@ class GatewayProfile {
   std::string gatewayID;
   std::string gatewayName;
   std::string gatewayDescription;
-  std::string preferedResource;
+  std::vector<ComputeResourcePreference>  computeResourcePreferences;
 
   _GatewayProfile__isset __isset;
 
@@ -54,9 +158,9 @@ class GatewayProfile {
     __isset.gatewayDescription = true;
   }
 
-  void __set_preferedResource(const std::string& val) {
-    preferedResource = val;
-    __isset.preferedResource = true;
+  void __set_computeResourcePreferences(const std::vector<ComputeResourcePreference> & val) {
+    computeResourcePreferences = val;
+    __isset.computeResourcePreferences = true;
   }
 
   bool operator == (const GatewayProfile & rhs) const
@@ -69,9 +173,9 @@ class GatewayProfile {
       return false;
     else if (__isset.gatewayDescription && !(gatewayDescription == rhs.gatewayDescription))
       return false;
-    if (__isset.preferedResource != rhs.__isset.preferedResource)
+    if (__isset.computeResourcePreferences != rhs.__isset.computeResourcePreferences)
       return false;
-    else if (__isset.preferedResource && !(preferedResource == rhs.preferedResource))
+    else if (__isset.computeResourcePreferences && !(computeResourcePreferences == rhs.computeResourcePreferences))
       return false;
     return true;
   }

http://git-wip-us.apache.org/repos/asf/airavata/blob/59a7443a/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/AppCatalog/AppDeployment/Types.php
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/AppCatalog/AppDeployment/Types.php b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/AppCatalog/AppDeployment/Types.php
index 2c56b50..0098016 100644
--- a/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/AppCatalog/AppDeployment/Types.php
+++ b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/AppCatalog/AppDeployment/Types.php
@@ -270,7 +270,7 @@ class ApplicationDeploymentDescription {
   public $computeHostId = null;
   public $executablePath = null;
   public $appDeploymentDescription = null;
-  public $moduleLoadCmd = null;
+  public $moduleLoadCmds = null;
   public $libPrependPaths = null;
   public $libAppendPaths = null;
   public $setEnvironment = null;
@@ -303,8 +303,12 @@ class ApplicationDeploymentDescription {
           'type' => TType::STRING,
           ),
         7 => array(
-          'var' => 'moduleLoadCmd',
-          'type' => TType::STRING,
+          'var' => 'moduleLoadCmds',
+          'type' => TType::LST,
+          'etype' => TType::STRING,
+          'elem' => array(
+            'type' => TType::STRING,
+            ),
           ),
         8 => array(
           'var' => 'libPrependPaths',
@@ -354,8 +358,8 @@ class ApplicationDeploymentDescription {
       if (isset($vals['appDeploymentDescription'])) {
         $this->appDeploymentDescription = $vals['appDeploymentDescription'];
       }
-      if (isset($vals['moduleLoadCmd'])) {
-        $this->moduleLoadCmd = $vals['moduleLoadCmd'];
+      if (isset($vals['moduleLoadCmds'])) {
+        $this->moduleLoadCmds = $vals['moduleLoadCmds'];
       }
       if (isset($vals['libPrependPaths'])) {
         $this->libPrependPaths = $vals['libPrependPaths'];
@@ -431,33 +435,25 @@ class ApplicationDeploymentDescription {
           }
           break;
         case 7:
-          if ($ftype == TType::STRING) {
-            $xfer += $input->readString($this->moduleLoadCmd);
-          } else {
-            $xfer += $input->skip($ftype);
-          }
-          break;
-        case 8:
           if ($ftype == TType::LST) {
-            $this->libPrependPaths = array();
+            $this->moduleLoadCmds = array();
             $_size0 = 0;
             $_etype3 = 0;
             $xfer += $input->readListBegin($_etype3, $_size0);
             for ($_i4 = 0; $_i4 < $_size0; ++$_i4)
             {
               $elem5 = null;
-              $elem5 = new \Airavata\Model\AppCatalog\AppDeployment\SetEnvPaths();
-              $xfer += $elem5->read($input);
-              $this->libPrependPaths []= $elem5;
+              $xfer += $input->readString($elem5);
+              $this->moduleLoadCmds []= $elem5;
             }
             $xfer += $input->readListEnd();
           } else {
             $xfer += $input->skip($ftype);
           }
           break;
-        case 9:
+        case 8:
           if ($ftype == TType::LST) {
-            $this->libAppendPaths = array();
+            $this->libPrependPaths = array();
             $_size6 = 0;
             $_etype9 = 0;
             $xfer += $input->readListBegin($_etype9, $_size6);
@@ -466,16 +462,16 @@ class ApplicationDeploymentDescription {
               $elem11 = null;
               $elem11 = new \Airavata\Model\AppCatalog\AppDeployment\SetEnvPaths();
               $xfer += $elem11->read($input);
-              $this->libAppendPaths []= $elem11;
+              $this->libPrependPaths []= $elem11;
             }
             $xfer += $input->readListEnd();
           } else {
             $xfer += $input->skip($ftype);
           }
           break;
-        case 10:
+        case 9:
           if ($ftype == TType::LST) {
-            $this->setEnvironment = array();
+            $this->libAppendPaths = array();
             $_size12 = 0;
             $_etype15 = 0;
             $xfer += $input->readListBegin($_etype15, $_size12);
@@ -484,7 +480,25 @@ class ApplicationDeploymentDescription {
               $elem17 = null;
               $elem17 = new \Airavata\Model\AppCatalog\AppDeployment\SetEnvPaths();
               $xfer += $elem17->read($input);
-              $this->setEnvironment []= $elem17;
+              $this->libAppendPaths []= $elem17;
+            }
+            $xfer += $input->readListEnd();
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 10:
+          if ($ftype == TType::LST) {
+            $this->setEnvironment = array();
+            $_size18 = 0;
+            $_etype21 = 0;
+            $xfer += $input->readListBegin($_etype21, $_size18);
+            for ($_i22 = 0; $_i22 < $_size18; ++$_i22)
+            {
+              $elem23 = null;
+              $elem23 = new \Airavata\Model\AppCatalog\AppDeployment\SetEnvPaths();
+              $xfer += $elem23->read($input);
+              $this->setEnvironment []= $elem23;
             }
             $xfer += $input->readListEnd();
           } else {
@@ -534,9 +548,21 @@ class ApplicationDeploymentDescription {
       $xfer += $output->writeString($this->appDeploymentDescription);
       $xfer += $output->writeFieldEnd();
     }
-    if ($this->moduleLoadCmd !== null) {
-      $xfer += $output->writeFieldBegin('moduleLoadCmd', TType::STRING, 7);
-      $xfer += $output->writeString($this->moduleLoadCmd);
+    if ($this->moduleLoadCmds !== null) {
+      if (!is_array($this->moduleLoadCmds)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('moduleLoadCmds', TType::LST, 7);
+      {
+        $output->writeListBegin(TType::STRING, count($this->moduleLoadCmds));
+        {
+          foreach ($this->moduleLoadCmds as $iter24)
+          {
+            $xfer += $output->writeString($iter24);
+          }
+        }
+        $output->writeListEnd();
+      }
       $xfer += $output->writeFieldEnd();
     }
     if ($this->libPrependPaths !== null) {
@@ -547,9 +573,9 @@ class ApplicationDeploymentDescription {
       {
         $output->writeListBegin(TType::STRUCT, count($this->libPrependPaths));
         {
-          foreach ($this->libPrependPaths as $iter18)
+          foreach ($this->libPrependPaths as $iter25)
           {
-            $xfer += $iter18->write($output);
+            $xfer += $iter25->write($output);
           }
         }
         $output->writeListEnd();
@@ -564,9 +590,9 @@ class ApplicationDeploymentDescription {
       {
         $output->writeListBegin(TType::STRUCT, count($this->libAppendPaths));
         {
-          foreach ($this->libAppendPaths as $iter19)
+          foreach ($this->libAppendPaths as $iter26)
           {
-            $xfer += $iter19->write($output);
+            $xfer += $iter26->write($output);
           }
         }
         $output->writeListEnd();
@@ -581,9 +607,9 @@ class ApplicationDeploymentDescription {
       {
         $output->writeListBegin(TType::STRUCT, count($this->setEnvironment));
         {
-          foreach ($this->setEnvironment as $iter20)
+          foreach ($this->setEnvironment as $iter27)
           {
-            $xfer += $iter20->write($output);
+            $xfer += $iter27->write($output);
           }
         }
         $output->writeListEnd();


Mime
View raw message