airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sma...@apache.org
Subject [3/5] airavata git commit: Stubs for credential store api methods - AIRAVATA-1616
Date Tue, 03 Mar 2015 17:34:58 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/33b403fc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
index a1ce19d..32390a3 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
@@ -39,6 +39,9 @@ class AiravataIf {
   virtual bool deleteGateway(const std::string& gatewayId) = 0;
   virtual void getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway>
& _return) = 0;
   virtual bool isGatewayExist(const std::string& gatewayId) = 0;
+  virtual void generateAndRegisterSSHKeys(std::string& _return, const std::string&
gatewayId, const std::string& userName) = 0;
+  virtual void getSSHPubKey(std::string& _return, const std::string& airavataCredStoreToken)
= 0;
+  virtual void getAllUserSSHPubKeys(std::map<std::string, std::string> & _return,
const std::string& userName) = 0;
   virtual void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project&
project) = 0;
   virtual void updateProject(const std::string& projectId, const  ::apache::airavata::model::workspace::Project&
updatedProject) = 0;
   virtual void getProject( ::apache::airavata::model::workspace::Project& _return, const
std::string& projectId) = 0;
@@ -196,6 +199,15 @@ class AiravataNull : virtual public AiravataIf {
     bool _return = false;
     return _return;
   }
+  void generateAndRegisterSSHKeys(std::string& /* _return */, const std::string&
/* gatewayId */, const std::string& /* userName */) {
+    return;
+  }
+  void getSSHPubKey(std::string& /* _return */, const std::string& /* airavataCredStoreToken
*/) {
+    return;
+  }
+  void getAllUserSSHPubKeys(std::map<std::string, std::string> & /* _return */,
const std::string& /* userName */) {
+    return;
+  }
   void createProject(std::string& /* _return */, const  ::apache::airavata::model::workspace::Project&
/* project */) {
     return;
   }
@@ -1452,6 +1464,410 @@ class Airavata_isGatewayExist_presult {
 };
 
 
+class Airavata_generateAndRegisterSSHKeys_args {
+ public:
+
+  Airavata_generateAndRegisterSSHKeys_args() : gatewayId(), userName() {
+  }
+
+  virtual ~Airavata_generateAndRegisterSSHKeys_args() throw() {}
+
+  std::string gatewayId;
+  std::string userName;
+
+  void __set_gatewayId(const std::string& val) {
+    gatewayId = val;
+  }
+
+  void __set_userName(const std::string& val) {
+    userName = val;
+  }
+
+  bool operator == (const Airavata_generateAndRegisterSSHKeys_args & rhs) const
+  {
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    if (!(userName == rhs.userName))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_generateAndRegisterSSHKeys_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_generateAndRegisterSSHKeys_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_generateAndRegisterSSHKeys_pargs {
+ public:
+
+
+  virtual ~Airavata_generateAndRegisterSSHKeys_pargs() throw() {}
+
+  const std::string* gatewayId;
+  const std::string* userName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_generateAndRegisterSSHKeys_result__isset {
+  _Airavata_generateAndRegisterSSHKeys_result__isset() : success(false), ire(false), ace(false),
ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_generateAndRegisterSSHKeys_result__isset;
+
+class Airavata_generateAndRegisterSSHKeys_result {
+ public:
+
+  Airavata_generateAndRegisterSSHKeys_result() : success() {
+  }
+
+  virtual ~Airavata_generateAndRegisterSSHKeys_result() throw() {}
+
+  std::string success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_generateAndRegisterSSHKeys_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val)
{
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val)
{
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val)
{
+    ase = val;
+  }
+
+  bool operator == (const Airavata_generateAndRegisterSSHKeys_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_generateAndRegisterSSHKeys_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_generateAndRegisterSSHKeys_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_generateAndRegisterSSHKeys_presult__isset {
+  _Airavata_generateAndRegisterSSHKeys_presult__isset() : success(false), ire(false), ace(false),
ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_generateAndRegisterSSHKeys_presult__isset;
+
+class Airavata_generateAndRegisterSSHKeys_presult {
+ public:
+
+
+  virtual ~Airavata_generateAndRegisterSSHKeys_presult() throw() {}
+
+  std::string* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_generateAndRegisterSSHKeys_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getSSHPubKey_args {
+ public:
+
+  Airavata_getSSHPubKey_args() : airavataCredStoreToken() {
+  }
+
+  virtual ~Airavata_getSSHPubKey_args() throw() {}
+
+  std::string airavataCredStoreToken;
+
+  void __set_airavataCredStoreToken(const std::string& val) {
+    airavataCredStoreToken = val;
+  }
+
+  bool operator == (const Airavata_getSSHPubKey_args & rhs) const
+  {
+    if (!(airavataCredStoreToken == rhs.airavataCredStoreToken))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getSSHPubKey_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getSSHPubKey_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getSSHPubKey_pargs {
+ public:
+
+
+  virtual ~Airavata_getSSHPubKey_pargs() throw() {}
+
+  const std::string* airavataCredStoreToken;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getSSHPubKey_result__isset {
+  _Airavata_getSSHPubKey_result__isset() : success(false), ire(false), ace(false), ase(false)
{}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getSSHPubKey_result__isset;
+
+class Airavata_getSSHPubKey_result {
+ public:
+
+  Airavata_getSSHPubKey_result() : success() {
+  }
+
+  virtual ~Airavata_getSSHPubKey_result() throw() {}
+
+  std::string success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getSSHPubKey_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val)
{
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val)
{
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val)
{
+    ase = val;
+  }
+
+  bool operator == (const Airavata_getSSHPubKey_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getSSHPubKey_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getSSHPubKey_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getSSHPubKey_presult__isset {
+  _Airavata_getSSHPubKey_presult__isset() : success(false), ire(false), ace(false), ase(false)
{}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getSSHPubKey_presult__isset;
+
+class Airavata_getSSHPubKey_presult {
+ public:
+
+
+  virtual ~Airavata_getSSHPubKey_presult() throw() {}
+
+  std::string* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getSSHPubKey_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getAllUserSSHPubKeys_args {
+ public:
+
+  Airavata_getAllUserSSHPubKeys_args() : userName() {
+  }
+
+  virtual ~Airavata_getAllUserSSHPubKeys_args() throw() {}
+
+  std::string userName;
+
+  void __set_userName(const std::string& val) {
+    userName = val;
+  }
+
+  bool operator == (const Airavata_getAllUserSSHPubKeys_args & rhs) const
+  {
+    if (!(userName == rhs.userName))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getAllUserSSHPubKeys_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAllUserSSHPubKeys_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAllUserSSHPubKeys_pargs {
+ public:
+
+
+  virtual ~Airavata_getAllUserSSHPubKeys_pargs() throw() {}
+
+  const std::string* userName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllUserSSHPubKeys_result__isset {
+  _Airavata_getAllUserSSHPubKeys_result__isset() : success(false), ire(false), ace(false),
ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllUserSSHPubKeys_result__isset;
+
+class Airavata_getAllUserSSHPubKeys_result {
+ public:
+
+  Airavata_getAllUserSSHPubKeys_result() {
+  }
+
+  virtual ~Airavata_getAllUserSSHPubKeys_result() throw() {}
+
+  std::map<std::string, std::string>  success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllUserSSHPubKeys_result__isset __isset;
+
+  void __set_success(const std::map<std::string, std::string> & val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val)
{
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val)
{
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val)
{
+    ase = val;
+  }
+
+  bool operator == (const Airavata_getAllUserSSHPubKeys_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getAllUserSSHPubKeys_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAllUserSSHPubKeys_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllUserSSHPubKeys_presult__isset {
+  _Airavata_getAllUserSSHPubKeys_presult__isset() : success(false), ire(false), ace(false),
ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllUserSSHPubKeys_presult__isset;
+
+class Airavata_getAllUserSSHPubKeys_presult {
+ public:
+
+
+  virtual ~Airavata_getAllUserSSHPubKeys_presult() throw() {}
+
+  std::map<std::string, std::string> * success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllUserSSHPubKeys_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
 class Airavata_createProject_args {
  public:
 
@@ -15757,6 +16173,15 @@ class AiravataClient : virtual public AiravataIf {
   bool isGatewayExist(const std::string& gatewayId);
   void send_isGatewayExist(const std::string& gatewayId);
   bool recv_isGatewayExist();
+  void generateAndRegisterSSHKeys(std::string& _return, const std::string& gatewayId,
const std::string& userName);
+  void send_generateAndRegisterSSHKeys(const std::string& gatewayId, const std::string&
userName);
+  void recv_generateAndRegisterSSHKeys(std::string& _return);
+  void getSSHPubKey(std::string& _return, const std::string& airavataCredStoreToken);
+  void send_getSSHPubKey(const std::string& airavataCredStoreToken);
+  void recv_getSSHPubKey(std::string& _return);
+  void getAllUserSSHPubKeys(std::map<std::string, std::string> & _return, const
std::string& userName);
+  void send_getAllUserSSHPubKeys(const std::string& userName);
+  void recv_getAllUserSSHPubKeys(std::map<std::string, std::string> & _return);
   void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project&
project);
   void send_createProject(const  ::apache::airavata::model::workspace::Project& project);
   void recv_createProject(std::string& _return);
@@ -16094,6 +16519,9 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor
{
   void process_deleteGateway(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getAllGateways(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_isGatewayExist(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_generateAndRegisterSSHKeys(int32_t seqid, ::apache::thrift::protocol::TProtocol*
iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getSSHPubKey(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getAllUserSSHPubKeys(int32_t seqid, ::apache::thrift::protocol::TProtocol*
iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_createProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_updateProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol*
oprot, void* callContext);
@@ -16209,6 +16637,9 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor
{
     processMap_["deleteGateway"] = &AiravataProcessor::process_deleteGateway;
     processMap_["getAllGateways"] = &AiravataProcessor::process_getAllGateways;
     processMap_["isGatewayExist"] = &AiravataProcessor::process_isGatewayExist;
+    processMap_["generateAndRegisterSSHKeys"] = &AiravataProcessor::process_generateAndRegisterSSHKeys;
+    processMap_["getSSHPubKey"] = &AiravataProcessor::process_getSSHPubKey;
+    processMap_["getAllUserSSHPubKeys"] = &AiravataProcessor::process_getAllUserSSHPubKeys;
     processMap_["createProject"] = &AiravataProcessor::process_createProject;
     processMap_["updateProject"] = &AiravataProcessor::process_updateProject;
     processMap_["getProject"] = &AiravataProcessor::process_getProject;
@@ -16409,6 +16840,36 @@ class AiravataMultiface : virtual public AiravataIf {
     return ifaces_[i]->isGatewayExist(gatewayId);
   }
 
+  void generateAndRegisterSSHKeys(std::string& _return, const std::string& gatewayId,
const std::string& userName) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->generateAndRegisterSSHKeys(_return, gatewayId, userName);
+    }
+    ifaces_[i]->generateAndRegisterSSHKeys(_return, gatewayId, userName);
+    return;
+  }
+
+  void getSSHPubKey(std::string& _return, const std::string& airavataCredStoreToken)
{
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getSSHPubKey(_return, airavataCredStoreToken);
+    }
+    ifaces_[i]->getSSHPubKey(_return, airavataCredStoreToken);
+    return;
+  }
+
+  void getAllUserSSHPubKeys(std::map<std::string, std::string> & _return, const
std::string& userName) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getAllUserSSHPubKeys(_return, userName);
+    }
+    ifaces_[i]->getAllUserSSHPubKeys(_return, userName);
+    return;
+  }
+
   void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project&
project) {
     size_t sz = ifaces_.size();
     size_t i = 0;

http://git-wip-us.apache.org/repos/asf/airavata/blob/33b403fc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
index 42f63a2..ef13e57 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
@@ -74,6 +74,21 @@ class AiravataHandler : virtual public AiravataIf {
     printf("isGatewayExist\n");
   }
 
+  void generateAndRegisterSSHKeys(std::string& _return, const std::string& gatewayId,
const std::string& userName) {
+    // Your implementation goes here
+    printf("generateAndRegisterSSHKeys\n");
+  }
+
+  void getSSHPubKey(std::string& _return, const std::string& airavataCredStoreToken)
{
+    // Your implementation goes here
+    printf("getSSHPubKey\n");
+  }
+
+  void getAllUserSSHPubKeys(std::map<std::string, std::string> & _return, const
std::string& userName) {
+    // Your implementation goes here
+    printf("getAllUserSSHPubKeys\n");
+  }
+
   void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project&
project) {
     // Your implementation goes here
     printf("createProject\n");

http://git-wip-us.apache.org/repos/asf/airavata/blob/33b403fc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
index 87fd134..1c465e4 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
@@ -27,8 +27,8 @@
 
 namespace apache { namespace airavata { namespace model { namespace appcatalog { namespace
gatewayprofile {
 
-const char* ComputeResourcePreference::ascii_fingerprint = "365108C84A2E160D53CD17C2A7F06F5C";
-const uint8_t ComputeResourcePreference::binary_fingerprint[16] = {0x36,0x51,0x08,0xC8,0x4A,0x2E,0x16,0x0D,0x53,0xCD,0x17,0xC2,0xA7,0xF0,0x6F,0x5C};
+const char* ComputeResourcePreference::ascii_fingerprint = "D89E0E13D04B60B99B78496AC9B85D52";
+const uint8_t ComputeResourcePreference::binary_fingerprint[16] = {0xD8,0x9E,0x0E,0x13,0xD0,0x4B,0x60,0xB9,0x9B,0x78,0x49,0x6A,0xC9,0xB8,0x5D,0x52};
 
 uint32_t ComputeResourcePreference::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -69,6 +69,14 @@ uint32_t ComputeResourcePreference::read(::apache::thrift::protocol::TProtocol*
         }
         break;
       case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->loginUserName);
+          this->__isset.loginUserName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
           int32_t ecast0;
           xfer += iprot->readI32(ecast0);
@@ -78,7 +86,7 @@ uint32_t ComputeResourcePreference::read(::apache::thrift::protocol::TProtocol*
           xfer += iprot->skip(ftype);
         }
         break;
-      case 4:
+      case 5:
         if (ftype == ::apache::thrift::protocol::T_I32) {
           int32_t ecast1;
           xfer += iprot->readI32(ecast1);
@@ -88,7 +96,7 @@ uint32_t ComputeResourcePreference::read(::apache::thrift::protocol::TProtocol*
           xfer += iprot->skip(ftype);
         }
         break;
-      case 5:
+      case 6:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
           xfer += iprot->readString(this->preferredBatchQueue);
           this->__isset.preferredBatchQueue = true;
@@ -96,7 +104,7 @@ uint32_t ComputeResourcePreference::read(::apache::thrift::protocol::TProtocol*
           xfer += iprot->skip(ftype);
         }
         break;
-      case 6:
+      case 7:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
           xfer += iprot->readString(this->scratchLocation);
           this->__isset.scratchLocation = true;
@@ -104,7 +112,7 @@ uint32_t ComputeResourcePreference::read(::apache::thrift::protocol::TProtocol*
           xfer += iprot->skip(ftype);
         }
         break;
-      case 7:
+      case 8:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
           xfer += iprot->readString(this->allocationProjectNumber);
           this->__isset.allocationProjectNumber = true;
@@ -140,28 +148,33 @@ uint32_t ComputeResourcePreference::write(::apache::thrift::protocol::TProtocol*
   xfer += oprot->writeBool(this->overridebyAiravata);
   xfer += oprot->writeFieldEnd();
 
+  if (this->__isset.loginUserName) {
+    xfer += oprot->writeFieldBegin("loginUserName", ::apache::thrift::protocol::T_STRING,
3);
+    xfer += oprot->writeString(this->loginUserName);
+    xfer += oprot->writeFieldEnd();
+  }
   if (this->__isset.preferredJobSubmissionProtocol) {
-    xfer += oprot->writeFieldBegin("preferredJobSubmissionProtocol", ::apache::thrift::protocol::T_I32,
3);
+    xfer += oprot->writeFieldBegin("preferredJobSubmissionProtocol", ::apache::thrift::protocol::T_I32,
4);
     xfer += oprot->writeI32((int32_t)this->preferredJobSubmissionProtocol);
     xfer += oprot->writeFieldEnd();
   }
   if (this->__isset.preferredDataMovementProtocol) {
-    xfer += oprot->writeFieldBegin("preferredDataMovementProtocol", ::apache::thrift::protocol::T_I32,
4);
+    xfer += oprot->writeFieldBegin("preferredDataMovementProtocol", ::apache::thrift::protocol::T_I32,
5);
     xfer += oprot->writeI32((int32_t)this->preferredDataMovementProtocol);
     xfer += oprot->writeFieldEnd();
   }
   if (this->__isset.preferredBatchQueue) {
-    xfer += oprot->writeFieldBegin("preferredBatchQueue", ::apache::thrift::protocol::T_STRING,
5);
+    xfer += oprot->writeFieldBegin("preferredBatchQueue", ::apache::thrift::protocol::T_STRING,
6);
     xfer += oprot->writeString(this->preferredBatchQueue);
     xfer += oprot->writeFieldEnd();
   }
   if (this->__isset.scratchLocation) {
-    xfer += oprot->writeFieldBegin("scratchLocation", ::apache::thrift::protocol::T_STRING,
6);
+    xfer += oprot->writeFieldBegin("scratchLocation", ::apache::thrift::protocol::T_STRING,
7);
     xfer += oprot->writeString(this->scratchLocation);
     xfer += oprot->writeFieldEnd();
   }
   if (this->__isset.allocationProjectNumber) {
-    xfer += oprot->writeFieldBegin("allocationProjectNumber", ::apache::thrift::protocol::T_STRING,
7);
+    xfer += oprot->writeFieldBegin("allocationProjectNumber", ::apache::thrift::protocol::T_STRING,
8);
     xfer += oprot->writeString(this->allocationProjectNumber);
     xfer += oprot->writeFieldEnd();
   }
@@ -174,6 +187,7 @@ void swap(ComputeResourcePreference &a, ComputeResourcePreference
&b) {
   using ::std::swap;
   swap(a.computeResourceId, b.computeResourceId);
   swap(a.overridebyAiravata, b.overridebyAiravata);
+  swap(a.loginUserName, b.loginUserName);
   swap(a.preferredJobSubmissionProtocol, b.preferredJobSubmissionProtocol);
   swap(a.preferredDataMovementProtocol, b.preferredDataMovementProtocol);
   swap(a.preferredBatchQueue, b.preferredBatchQueue);
@@ -182,8 +196,8 @@ void swap(ComputeResourcePreference &a, ComputeResourcePreference
&b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* GatewayResourceProfile::ascii_fingerprint = "2C13C97D8E01026228E6E378E58505CC";
-const uint8_t GatewayResourceProfile::binary_fingerprint[16] = {0x2C,0x13,0xC9,0x7D,0x8E,0x01,0x02,0x62,0x28,0xE6,0xE3,0x78,0xE5,0x85,0x05,0xCC};
+const char* GatewayResourceProfile::ascii_fingerprint = "106DE1CD0F7026F6471DE8DAF360BE03";
+const uint8_t GatewayResourceProfile::binary_fingerprint[16] = {0x10,0x6D,0xE1,0xCD,0x0F,0x70,0x26,0xF6,0x47,0x1D,0xE8,0xDA,0xF3,0x60,0xBE,0x03};
 
 uint32_t GatewayResourceProfile::read(::apache::thrift::protocol::TProtocol* iprot) {
 

http://git-wip-us.apache.org/repos/asf/airavata/blob/33b403fc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
index 231d73f..c664087 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
@@ -36,7 +36,8 @@
 namespace apache { namespace airavata { namespace model { namespace appcatalog { namespace
gatewayprofile {
 
 typedef struct _ComputeResourcePreference__isset {
-  _ComputeResourcePreference__isset() : preferredJobSubmissionProtocol(false), preferredDataMovementProtocol(false),
preferredBatchQueue(false), scratchLocation(false), allocationProjectNumber(false) {}
+  _ComputeResourcePreference__isset() : loginUserName(false), preferredJobSubmissionProtocol(false),
preferredDataMovementProtocol(false), preferredBatchQueue(false), scratchLocation(false),
allocationProjectNumber(false) {}
+  bool loginUserName;
   bool preferredJobSubmissionProtocol;
   bool preferredDataMovementProtocol;
   bool preferredBatchQueue;
@@ -47,16 +48,17 @@ typedef struct _ComputeResourcePreference__isset {
 class ComputeResourcePreference {
  public:
 
-  static const char* ascii_fingerprint; // = "365108C84A2E160D53CD17C2A7F06F5C";
-  static const uint8_t binary_fingerprint[16]; // = {0x36,0x51,0x08,0xC8,0x4A,0x2E,0x16,0x0D,0x53,0xCD,0x17,0xC2,0xA7,0xF0,0x6F,0x5C};
+  static const char* ascii_fingerprint; // = "D89E0E13D04B60B99B78496AC9B85D52";
+  static const uint8_t binary_fingerprint[16]; // = {0xD8,0x9E,0x0E,0x13,0xD0,0x4B,0x60,0xB9,0x9B,0x78,0x49,0x6A,0xC9,0xB8,0x5D,0x52};
 
-  ComputeResourcePreference() : computeResourceId(), overridebyAiravata(true), preferredJobSubmissionProtocol((
::apache::airavata::model::appcatalog::computeresource::JobSubmissionProtocol::type)0), preferredDataMovementProtocol((
::apache::airavata::model::appcatalog::computeresource::DataMovementProtocol::type)0), preferredBatchQueue(),
scratchLocation(), allocationProjectNumber() {
+  ComputeResourcePreference() : computeResourceId(), overridebyAiravata(true), loginUserName(),
preferredJobSubmissionProtocol(( ::apache::airavata::model::appcatalog::computeresource::JobSubmissionProtocol::type)0),
preferredDataMovementProtocol(( ::apache::airavata::model::appcatalog::computeresource::DataMovementProtocol::type)0),
preferredBatchQueue(), scratchLocation(), allocationProjectNumber() {
   }
 
   virtual ~ComputeResourcePreference() throw() {}
 
   std::string computeResourceId;
   bool overridebyAiravata;
+  std::string loginUserName;
    ::apache::airavata::model::appcatalog::computeresource::JobSubmissionProtocol::type preferredJobSubmissionProtocol;
    ::apache::airavata::model::appcatalog::computeresource::DataMovementProtocol::type preferredDataMovementProtocol;
   std::string preferredBatchQueue;
@@ -73,6 +75,11 @@ class ComputeResourcePreference {
     overridebyAiravata = val;
   }
 
+  void __set_loginUserName(const std::string& val) {
+    loginUserName = val;
+    __isset.loginUserName = true;
+  }
+
   void __set_preferredJobSubmissionProtocol(const  ::apache::airavata::model::appcatalog::computeresource::JobSubmissionProtocol::type
val) {
     preferredJobSubmissionProtocol = val;
     __isset.preferredJobSubmissionProtocol = true;
@@ -104,6 +111,10 @@ class ComputeResourcePreference {
       return false;
     if (!(overridebyAiravata == rhs.overridebyAiravata))
       return false;
+    if (__isset.loginUserName != rhs.__isset.loginUserName)
+      return false;
+    else if (__isset.loginUserName && !(loginUserName == rhs.loginUserName))
+      return false;
     if (__isset.preferredJobSubmissionProtocol != rhs.__isset.preferredJobSubmissionProtocol)
       return false;
     else if (__isset.preferredJobSubmissionProtocol && !(preferredJobSubmissionProtocol
== rhs.preferredJobSubmissionProtocol))
@@ -147,8 +158,8 @@ typedef struct _GatewayResourceProfile__isset {
 class GatewayResourceProfile {
  public:
 
-  static const char* ascii_fingerprint; // = "2C13C97D8E01026228E6E378E58505CC";
-  static const uint8_t binary_fingerprint[16]; // = {0x2C,0x13,0xC9,0x7D,0x8E,0x01,0x02,0x62,0x28,0xE6,0xE3,0x78,0xE5,0x85,0x05,0xCC};
+  static const char* ascii_fingerprint; // = "106DE1CD0F7026F6471DE8DAF360BE03";
+  static const uint8_t binary_fingerprint[16]; // = {0x10,0x6D,0xE1,0xCD,0x0F,0x70,0x26,0xF6,0x47,0x1D,0xE8,0xDA,0xF3,0x60,0xBE,0x03};
 
   GatewayResourceProfile() : gatewayID() {
   }


Mime
View raw message