accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From e..@apache.org
Subject [14/18] ACCUMULO-1957 added Durability options to the Proxy and Shell, swap test and proxy module dependencies
Date Fri, 05 Sep 2014 21:17:30 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/cpp/proxy_types.cpp
----------------------------------------------------------------------
diff --git a/proxy/src/main/cpp/proxy_types.cpp b/proxy/src/main/cpp/proxy_types.cpp
index d472402..edb0978 100644
--- a/proxy/src/main/cpp/proxy_types.cpp
+++ b/proxy/src/main/cpp/proxy_types.cpp
@@ -122,6 +122,22 @@ const char* _kConditionalStatusNames[] = {
 };
 const std::map<int, const char*> _ConditionalStatus_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kConditionalStatusValues, _kConditionalStatusNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
 
+int _kDurabilityValues[] = {
+  Durability::DEFAULT,
+  Durability::NONE,
+  Durability::LOG,
+  Durability::FLUSH,
+  Durability::SYNC
+};
+const char* _kDurabilityNames[] = {
+  "DEFAULT",
+  "NONE",
+  "LOG",
+  "FLUSH",
+  "SYNC"
+};
+const std::map<int, const char*> _Durability_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kDurabilityValues, _kDurabilityNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
 int _kCompactionTypeValues[] = {
   CompactionType::MINOR,
   CompactionType::MERGE,
@@ -1857,8 +1873,8 @@ void swap(ConditionalUpdates &a, ConditionalUpdates &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ConditionalWriterOptions::ascii_fingerprint = "2A7184C7CE319A61E12C337D8EAB3FB9";
-const uint8_t ConditionalWriterOptions::binary_fingerprint[16] = {0x2A,0x71,0x84,0xC7,0xCE,0x31,0x9A,0x61,0xE1,0x2C,0x33,0x7D,0x8E,0xAB,0x3F,0xB9};
+const char* ConditionalWriterOptions::ascii_fingerprint = "C345C04E84A351638B6EACB741BD600E";
+const uint8_t ConditionalWriterOptions::binary_fingerprint[16] = {0xC3,0x45,0xC0,0x4E,0x84,0xA3,0x51,0x63,0x8B,0x6E,0xAC,0xB7,0x41,0xBD,0x60,0x0E};
 
 uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -1925,6 +1941,16 @@ uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* i
           xfer += iprot->skip(ftype);
         }
         break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast88;
+          xfer += iprot->readI32(ecast88);
+          this->durability = (Durability::type)ecast88;
+          this->__isset.durability = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -1960,15 +1986,20 @@ uint32_t ConditionalWriterOptions::write(::apache::thrift::protocol::TProtocol*
     xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 4);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size()));
-      std::set<std::string> ::const_iterator _iter88;
-      for (_iter88 = this->authorizations.begin(); _iter88 != this->authorizations.end(); ++_iter88)
+      std::set<std::string> ::const_iterator _iter89;
+      for (_iter89 = this->authorizations.begin(); _iter89 != this->authorizations.end(); ++_iter89)
       {
-        xfer += oprot->writeBinary((*_iter88));
+        xfer += oprot->writeBinary((*_iter89));
       }
       xfer += oprot->writeSetEnd();
     }
     xfer += oprot->writeFieldEnd();
   }
+  if (this->__isset.durability) {
+    xfer += oprot->writeFieldBegin("durability", ::apache::thrift::protocol::T_I32, 5);
+    xfer += oprot->writeI32((int32_t)this->durability);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -1980,6 +2011,7 @@ void swap(ConditionalWriterOptions &a, ConditionalWriterOptions &b) {
   swap(a.timeoutMs, b.timeoutMs);
   swap(a.threads, b.threads);
   swap(a.authorizations, b.authorizations);
+  swap(a.durability, b.durability);
   swap(a.__isset, b.__isset);
 }
 
@@ -2048,9 +2080,9 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 6:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast89;
-          xfer += iprot->readI32(ecast89);
-          this->type = (ScanType::type)ecast89;
+          int32_t ecast90;
+          xfer += iprot->readI32(ecast90);
+          this->type = (ScanType::type)ecast90;
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2058,9 +2090,9 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 7:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast90;
-          xfer += iprot->readI32(ecast90);
-          this->state = (ScanState::type)ecast90;
+          int32_t ecast91;
+          xfer += iprot->readI32(ecast91);
+          this->state = (ScanState::type)ecast91;
           this->__isset.state = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2078,14 +2110,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->columns.clear();
-            uint32_t _size91;
-            ::apache::thrift::protocol::TType _etype94;
-            xfer += iprot->readListBegin(_etype94, _size91);
-            this->columns.resize(_size91);
-            uint32_t _i95;
-            for (_i95 = 0; _i95 < _size91; ++_i95)
+            uint32_t _size92;
+            ::apache::thrift::protocol::TType _etype95;
+            xfer += iprot->readListBegin(_etype95, _size92);
+            this->columns.resize(_size92);
+            uint32_t _i96;
+            for (_i96 = 0; _i96 < _size92; ++_i96)
             {
-              xfer += this->columns[_i95].read(iprot);
+              xfer += this->columns[_i96].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -2098,14 +2130,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size96;
-            ::apache::thrift::protocol::TType _etype99;
-            xfer += iprot->readListBegin(_etype99, _size96);
-            this->iterators.resize(_size96);
-            uint32_t _i100;
-            for (_i100 = 0; _i100 < _size96; ++_i100)
+            uint32_t _size97;
+            ::apache::thrift::protocol::TType _etype100;
+            xfer += iprot->readListBegin(_etype100, _size97);
+            this->iterators.resize(_size97);
+            uint32_t _i101;
+            for (_i101 = 0; _i101 < _size97; ++_i101)
             {
-              xfer += this->iterators[_i100].read(iprot);
+              xfer += this->iterators[_i101].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -2118,14 +2150,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->authorizations.clear();
-            uint32_t _size101;
-            ::apache::thrift::protocol::TType _etype104;
-            xfer += iprot->readListBegin(_etype104, _size101);
-            this->authorizations.resize(_size101);
-            uint32_t _i105;
-            for (_i105 = 0; _i105 < _size101; ++_i105)
+            uint32_t _size102;
+            ::apache::thrift::protocol::TType _etype105;
+            xfer += iprot->readListBegin(_etype105, _size102);
+            this->authorizations.resize(_size102);
+            uint32_t _i106;
+            for (_i106 = 0; _i106 < _size102; ++_i106)
             {
-              xfer += iprot->readBinary(this->authorizations[_i105]);
+              xfer += iprot->readBinary(this->authorizations[_i106]);
             }
             xfer += iprot->readListEnd();
           }
@@ -2185,10 +2217,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 9);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-    std::vector<Column> ::const_iterator _iter106;
-    for (_iter106 = this->columns.begin(); _iter106 != this->columns.end(); ++_iter106)
+    std::vector<Column> ::const_iterator _iter107;
+    for (_iter107 = this->columns.begin(); _iter107 != this->columns.end(); ++_iter107)
     {
-      xfer += (*_iter106).write(oprot);
+      xfer += (*_iter107).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2197,10 +2229,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 10);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size()));
-    std::vector<IteratorSetting> ::const_iterator _iter107;
-    for (_iter107 = this->iterators.begin(); _iter107 != this->iterators.end(); ++_iter107)
+    std::vector<IteratorSetting> ::const_iterator _iter108;
+    for (_iter108 = this->iterators.begin(); _iter108 != this->iterators.end(); ++_iter108)
     {
-      xfer += (*_iter107).write(oprot);
+      xfer += (*_iter108).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2209,10 +2241,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_LIST, 11);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size()));
-    std::vector<std::string> ::const_iterator _iter108;
-    for (_iter108 = this->authorizations.begin(); _iter108 != this->authorizations.end(); ++_iter108)
+    std::vector<std::string> ::const_iterator _iter109;
+    for (_iter109 = this->authorizations.begin(); _iter109 != this->authorizations.end(); ++_iter109)
     {
-      xfer += oprot->writeBinary((*_iter108));
+      xfer += oprot->writeBinary((*_iter109));
     }
     xfer += oprot->writeListEnd();
   }
@@ -2282,14 +2314,14 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->inputFiles.clear();
-            uint32_t _size109;
-            ::apache::thrift::protocol::TType _etype112;
-            xfer += iprot->readListBegin(_etype112, _size109);
-            this->inputFiles.resize(_size109);
-            uint32_t _i113;
-            for (_i113 = 0; _i113 < _size109; ++_i113)
+            uint32_t _size110;
+            ::apache::thrift::protocol::TType _etype113;
+            xfer += iprot->readListBegin(_etype113, _size110);
+            this->inputFiles.resize(_size110);
+            uint32_t _i114;
+            for (_i114 = 0; _i114 < _size110; ++_i114)
             {
-              xfer += iprot->readString(this->inputFiles[_i113]);
+              xfer += iprot->readString(this->inputFiles[_i114]);
             }
             xfer += iprot->readListEnd();
           }
@@ -2308,9 +2340,9 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 5:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast114;
-          xfer += iprot->readI32(ecast114);
-          this->type = (CompactionType::type)ecast114;
+          int32_t ecast115;
+          xfer += iprot->readI32(ecast115);
+          this->type = (CompactionType::type)ecast115;
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2318,9 +2350,9 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 6:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast115;
-          xfer += iprot->readI32(ecast115);
-          this->reason = (CompactionReason::type)ecast115;
+          int32_t ecast116;
+          xfer += iprot->readI32(ecast116);
+          this->reason = (CompactionReason::type)ecast116;
           this->__isset.reason = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2354,14 +2386,14 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->iterators.clear();
-            uint32_t _size116;
-            ::apache::thrift::protocol::TType _etype119;
-            xfer += iprot->readListBegin(_etype119, _size116);
-            this->iterators.resize(_size116);
-            uint32_t _i120;
-            for (_i120 = 0; _i120 < _size116; ++_i120)
+            uint32_t _size117;
+            ::apache::thrift::protocol::TType _etype120;
+            xfer += iprot->readListBegin(_etype120, _size117);
+            this->iterators.resize(_size117);
+            uint32_t _i121;
+            for (_i121 = 0; _i121 < _size117; ++_i121)
             {
-              xfer += this->iterators[_i120].read(iprot);
+              xfer += this->iterators[_i121].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -2397,10 +2429,10 @@ uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) c
   xfer += oprot->writeFieldBegin("inputFiles", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->inputFiles.size()));
-    std::vector<std::string> ::const_iterator _iter121;
-    for (_iter121 = this->inputFiles.begin(); _iter121 != this->inputFiles.end(); ++_iter121)
+    std::vector<std::string> ::const_iterator _iter122;
+    for (_iter122 = this->inputFiles.begin(); _iter122 != this->inputFiles.end(); ++_iter122)
     {
-      xfer += oprot->writeString((*_iter121));
+      xfer += oprot->writeString((*_iter122));
     }
     xfer += oprot->writeListEnd();
   }
@@ -2433,10 +2465,10 @@ uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) c
   xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 10);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size()));
-    std::vector<IteratorSetting> ::const_iterator _iter122;
-    for (_iter122 = this->iterators.begin(); _iter122 != this->iterators.end(); ++_iter122)
+    std::vector<IteratorSetting> ::const_iterator _iter123;
+    for (_iter123 = this->iterators.begin(); _iter123 != this->iterators.end(); ++_iter123)
     {
-      xfer += (*_iter122).write(oprot);
+      xfer += (*_iter123).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -2462,8 +2494,8 @@ void swap(ActiveCompaction &a, ActiveCompaction &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* WriterOptions::ascii_fingerprint = "D6FB71C9973666B9F6B5C20D5B7B19EF";
-const uint8_t WriterOptions::binary_fingerprint[16] = {0xD6,0xFB,0x71,0xC9,0x97,0x36,0x66,0xB9,0xF6,0xB5,0xC2,0x0D,0x5B,0x7B,0x19,0xEF};
+const char* WriterOptions::ascii_fingerprint = "6640C55D2C0D4C8C2E7589456EA0C61A";
+const uint8_t WriterOptions::binary_fingerprint[16] = {0x66,0x40,0xC5,0x5D,0x2C,0x0D,0x4C,0x8C,0x2E,0x75,0x89,0x45,0x6E,0xA0,0xC6,0x1A};
 
 uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -2517,6 +2549,16 @@ uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) {
           xfer += iprot->skip(ftype);
         }
         break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast124;
+          xfer += iprot->readI32(ecast124);
+          this->durability = (Durability::type)ecast124;
+          this->__isset.durability = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -2549,6 +2591,11 @@ uint32_t WriterOptions::write(::apache::thrift::protocol::TProtocol* oprot) cons
   xfer += oprot->writeI32(this->threads);
   xfer += oprot->writeFieldEnd();
 
+  if (this->__isset.durability) {
+    xfer += oprot->writeFieldBegin("durability", ::apache::thrift::protocol::T_I32, 5);
+    xfer += oprot->writeI32((int32_t)this->durability);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -2560,6 +2607,7 @@ void swap(WriterOptions &a, WriterOptions &b) {
   swap(a.latencyMs, b.latencyMs);
   swap(a.timeoutMs, b.timeoutMs);
   swap(a.threads, b.threads);
+  swap(a.durability, b.durability);
   swap(a.__isset, b.__isset);
 }
 

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/cpp/proxy_types.h
----------------------------------------------------------------------
diff --git a/proxy/src/main/cpp/proxy_types.h b/proxy/src/main/cpp/proxy_types.h
index c320d39..625586c 100644
--- a/proxy/src/main/cpp/proxy_types.h
+++ b/proxy/src/main/cpp/proxy_types.h
@@ -105,6 +105,18 @@ struct ConditionalStatus {
 
 extern const std::map<int, const char*> _ConditionalStatus_VALUES_TO_NAMES;
 
+struct Durability {
+  enum type {
+    DEFAULT = 0,
+    NONE = 1,
+    LOG = 2,
+    FLUSH = 3,
+    SYNC = 4
+  };
+};
+
+extern const std::map<int, const char*> _Durability_VALUES_TO_NAMES;
+
 struct CompactionType {
   enum type {
     MINOR = 0,
@@ -1138,20 +1150,21 @@ class ConditionalUpdates {
 void swap(ConditionalUpdates &a, ConditionalUpdates &b);
 
 typedef struct _ConditionalWriterOptions__isset {
-  _ConditionalWriterOptions__isset() : maxMemory(false), timeoutMs(false), threads(false), authorizations(false) {}
+  _ConditionalWriterOptions__isset() : maxMemory(false), timeoutMs(false), threads(false), authorizations(false), durability(false) {}
   bool maxMemory;
   bool timeoutMs;
   bool threads;
   bool authorizations;
+  bool durability;
 } _ConditionalWriterOptions__isset;
 
 class ConditionalWriterOptions {
  public:
 
-  static const char* ascii_fingerprint; // = "2A7184C7CE319A61E12C337D8EAB3FB9";
-  static const uint8_t binary_fingerprint[16]; // = {0x2A,0x71,0x84,0xC7,0xCE,0x31,0x9A,0x61,0xE1,0x2C,0x33,0x7D,0x8E,0xAB,0x3F,0xB9};
+  static const char* ascii_fingerprint; // = "C345C04E84A351638B6EACB741BD600E";
+  static const uint8_t binary_fingerprint[16]; // = {0xC3,0x45,0xC0,0x4E,0x84,0xA3,0x51,0x63,0x8B,0x6E,0xAC,0xB7,0x41,0xBD,0x60,0x0E};
 
-  ConditionalWriterOptions() : maxMemory(0), timeoutMs(0), threads(0) {
+  ConditionalWriterOptions() : maxMemory(0), timeoutMs(0), threads(0), durability((Durability::type)0) {
   }
 
   virtual ~ConditionalWriterOptions() throw() {}
@@ -1160,6 +1173,7 @@ class ConditionalWriterOptions {
   int64_t timeoutMs;
   int32_t threads;
   std::set<std::string>  authorizations;
+  Durability::type durability;
 
   _ConditionalWriterOptions__isset __isset;
 
@@ -1183,6 +1197,11 @@ class ConditionalWriterOptions {
     __isset.authorizations = true;
   }
 
+  void __set_durability(const Durability::type val) {
+    durability = val;
+    __isset.durability = true;
+  }
+
   bool operator == (const ConditionalWriterOptions & rhs) const
   {
     if (__isset.maxMemory != rhs.__isset.maxMemory)
@@ -1201,6 +1220,10 @@ class ConditionalWriterOptions {
       return false;
     else if (__isset.authorizations && !(authorizations == rhs.authorizations))
       return false;
+    if (__isset.durability != rhs.__isset.durability)
+      return false;
+    else if (__isset.durability && !(durability == rhs.durability))
+      return false;
     return true;
   }
   bool operator != (const ConditionalWriterOptions &rhs) const {
@@ -1455,20 +1478,21 @@ class ActiveCompaction {
 void swap(ActiveCompaction &a, ActiveCompaction &b);
 
 typedef struct _WriterOptions__isset {
-  _WriterOptions__isset() : maxMemory(false), latencyMs(false), timeoutMs(false), threads(false) {}
+  _WriterOptions__isset() : maxMemory(false), latencyMs(false), timeoutMs(false), threads(false), durability(false) {}
   bool maxMemory;
   bool latencyMs;
   bool timeoutMs;
   bool threads;
+  bool durability;
 } _WriterOptions__isset;
 
 class WriterOptions {
  public:
 
-  static const char* ascii_fingerprint; // = "D6FB71C9973666B9F6B5C20D5B7B19EF";
-  static const uint8_t binary_fingerprint[16]; // = {0xD6,0xFB,0x71,0xC9,0x97,0x36,0x66,0xB9,0xF6,0xB5,0xC2,0x0D,0x5B,0x7B,0x19,0xEF};
+  static const char* ascii_fingerprint; // = "6640C55D2C0D4C8C2E7589456EA0C61A";
+  static const uint8_t binary_fingerprint[16]; // = {0x66,0x40,0xC5,0x5D,0x2C,0x0D,0x4C,0x8C,0x2E,0x75,0x89,0x45,0x6E,0xA0,0xC6,0x1A};
 
-  WriterOptions() : maxMemory(0), latencyMs(0), timeoutMs(0), threads(0) {
+  WriterOptions() : maxMemory(0), latencyMs(0), timeoutMs(0), threads(0), durability((Durability::type)0) {
   }
 
   virtual ~WriterOptions() throw() {}
@@ -1477,6 +1501,7 @@ class WriterOptions {
   int64_t latencyMs;
   int64_t timeoutMs;
   int32_t threads;
+  Durability::type durability;
 
   _WriterOptions__isset __isset;
 
@@ -1496,6 +1521,11 @@ class WriterOptions {
     threads = val;
   }
 
+  void __set_durability(const Durability::type val) {
+    durability = val;
+    __isset.durability = true;
+  }
+
   bool operator == (const WriterOptions & rhs) const
   {
     if (!(maxMemory == rhs.maxMemory))
@@ -1506,6 +1536,10 @@ class WriterOptions {
       return false;
     if (!(threads == rhs.threads))
       return false;
+    if (__isset.durability != rhs.__isset.durability)
+      return false;
+    else if (__isset.durability && !(durability == rhs.durability))
+      return false;
     return true;
   }
   bool operator != (const WriterOptions &rhs) const {

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/java/org/apache/accumulo/proxy/ProxyServer.java
----------------------------------------------------------------------
diff --git a/proxy/src/main/java/org/apache/accumulo/proxy/ProxyServer.java b/proxy/src/main/java/org/apache/accumulo/proxy/ProxyServer.java
index e65b956..1dc1dd3 100644
--- a/proxy/src/main/java/org/apache/accumulo/proxy/ProxyServer.java
+++ b/proxy/src/main/java/org/apache/accumulo/proxy/ProxyServer.java
@@ -88,6 +88,7 @@ import org.apache.accumulo.proxy.thrift.ConditionalStatus;
 import org.apache.accumulo.proxy.thrift.ConditionalUpdates;
 import org.apache.accumulo.proxy.thrift.ConditionalWriterOptions;
 import org.apache.accumulo.proxy.thrift.DiskUsage;
+import org.apache.accumulo.proxy.thrift.Durability;
 import org.apache.accumulo.proxy.thrift.KeyValue;
 import org.apache.accumulo.proxy.thrift.KeyValueAndPeek;
 import org.apache.accumulo.proxy.thrift.NoMoreEntriesException;
@@ -1285,12 +1286,31 @@ public class ProxyServer implements AccumuloProxy.Iface {
         cfg.setTimeout(opts.timeoutMs, TimeUnit.MILLISECONDS);
       if (opts.latencyMs != 0)
         cfg.setMaxLatency(opts.latencyMs, TimeUnit.MILLISECONDS);
+      if (opts.isSetDurability()) {
+        cfg.setDurability(getDurability(opts.getDurability()));
+      }
     }
     BatchWriterPlusException result = new BatchWriterPlusException();
     result.writer = getConnector(login).createBatchWriter(tableName, cfg);
     return result;
   }
   
+  private org.apache.accumulo.core.client.Durability getDurability(Durability durability) {
+    switch (durability) {
+      case DEFAULT:
+        return org.apache.accumulo.core.client.Durability.DEFAULT;
+      case FLUSH:
+        return org.apache.accumulo.core.client.Durability.FLUSH;
+      case LOG:
+        return org.apache.accumulo.core.client.Durability.LOG;
+      case NONE:
+        return org.apache.accumulo.core.client.Durability.NONE;
+      case SYNC:
+        return org.apache.accumulo.core.client.Durability.SYNC;
+    }
+    return org.apache.accumulo.core.client.Durability.DEFAULT;
+  }
+
   private IteratorSetting getIteratorSetting(org.apache.accumulo.proxy.thrift.IteratorSetting setting) {
     return new IteratorSetting(setting.priority, setting.name, setting.iteratorClass, setting.getProperties());
   }
@@ -1541,6 +1561,8 @@ public class ProxyServer implements AccumuloProxy.Iface {
         cwc.setTimeout(options.getTimeoutMs(), TimeUnit.MILLISECONDS);
       if (options.isSetAuthorizations() && options.getAuthorizations() != null)
         cwc.setAuthorizations(getAuthorizations(options.getAuthorizations()));
+      if (options.isSetDurability() && options.getDurability() != null)
+        cwc.setDurability(getDurability(options.getDurability()));
       
       ConditionalWriter cw = getConnector(login).createConditionalWriter(tableName, cwc);
       

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ConditionalWriterOptions.java
----------------------------------------------------------------------
diff --git a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ConditionalWriterOptions.java b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ConditionalWriterOptions.java
index bb4ad51..42b8ca5 100644
--- a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ConditionalWriterOptions.java
+++ b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/ConditionalWriterOptions.java
@@ -55,6 +55,7 @@ import org.slf4j.LoggerFactory;
   private static final org.apache.thrift.protocol.TField TIMEOUT_MS_FIELD_DESC = new org.apache.thrift.protocol.TField("timeoutMs", org.apache.thrift.protocol.TType.I64, (short)2);
   private static final org.apache.thrift.protocol.TField THREADS_FIELD_DESC = new org.apache.thrift.protocol.TField("threads", org.apache.thrift.protocol.TType.I32, (short)3);
   private static final org.apache.thrift.protocol.TField AUTHORIZATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("authorizations", org.apache.thrift.protocol.TType.SET, (short)4);
+  private static final org.apache.thrift.protocol.TField DURABILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("durability", org.apache.thrift.protocol.TType.I32, (short)5);
 
   private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
   static {
@@ -66,13 +67,23 @@ import org.slf4j.LoggerFactory;
   public long timeoutMs; // optional
   public int threads; // optional
   public Set<ByteBuffer> authorizations; // optional
+  /**
+   * 
+   * @see Durability
+   */
+  public Durability durability; // optional
 
   /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
   @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
     MAX_MEMORY((short)1, "maxMemory"),
     TIMEOUT_MS((short)2, "timeoutMs"),
     THREADS((short)3, "threads"),
-    AUTHORIZATIONS((short)4, "authorizations");
+    AUTHORIZATIONS((short)4, "authorizations"),
+    /**
+     * 
+     * @see Durability
+     */
+    DURABILITY((short)5, "durability");
 
     private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
 
@@ -95,6 +106,8 @@ import org.slf4j.LoggerFactory;
           return THREADS;
         case 4: // AUTHORIZATIONS
           return AUTHORIZATIONS;
+        case 5: // DURABILITY
+          return DURABILITY;
         default:
           return null;
       }
@@ -139,7 +152,7 @@ import org.slf4j.LoggerFactory;
   private static final int __TIMEOUTMS_ISSET_ID = 1;
   private static final int __THREADS_ISSET_ID = 2;
   private byte __isset_bitfield = 0;
-  private _Fields optionals[] = {_Fields.MAX_MEMORY,_Fields.TIMEOUT_MS,_Fields.THREADS,_Fields.AUTHORIZATIONS};
+  private _Fields optionals[] = {_Fields.MAX_MEMORY,_Fields.TIMEOUT_MS,_Fields.THREADS,_Fields.AUTHORIZATIONS,_Fields.DURABILITY};
   public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
   static {
     Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
@@ -152,6 +165,8 @@ import org.slf4j.LoggerFactory;
     tmpMap.put(_Fields.AUTHORIZATIONS, new org.apache.thrift.meta_data.FieldMetaData("authorizations", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
         new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET, 
             new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING            , true))));
+    tmpMap.put(_Fields.DURABILITY, new org.apache.thrift.meta_data.FieldMetaData("durability", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Durability.class)));
     metaDataMap = Collections.unmodifiableMap(tmpMap);
     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ConditionalWriterOptions.class, metaDataMap);
   }
@@ -171,6 +186,9 @@ import org.slf4j.LoggerFactory;
       Set<ByteBuffer> __this__authorizations = new HashSet<ByteBuffer>(other.authorizations);
       this.authorizations = __this__authorizations;
     }
+    if (other.isSetDurability()) {
+      this.durability = other.durability;
+    }
   }
 
   public ConditionalWriterOptions deepCopy() {
@@ -186,6 +204,7 @@ import org.slf4j.LoggerFactory;
     setThreadsIsSet(false);
     this.threads = 0;
     this.authorizations = null;
+    this.durability = null;
   }
 
   public long getMaxMemory() {
@@ -296,6 +315,38 @@ import org.slf4j.LoggerFactory;
     }
   }
 
+  /**
+   * 
+   * @see Durability
+   */
+  public Durability getDurability() {
+    return this.durability;
+  }
+
+  /**
+   * 
+   * @see Durability
+   */
+  public ConditionalWriterOptions setDurability(Durability durability) {
+    this.durability = durability;
+    return this;
+  }
+
+  public void unsetDurability() {
+    this.durability = null;
+  }
+
+  /** Returns true if field durability is set (has been assigned a value) and false otherwise */
+  public boolean isSetDurability() {
+    return this.durability != null;
+  }
+
+  public void setDurabilityIsSet(boolean value) {
+    if (!value) {
+      this.durability = null;
+    }
+  }
+
   public void setFieldValue(_Fields field, Object value) {
     switch (field) {
     case MAX_MEMORY:
@@ -330,6 +381,14 @@ import org.slf4j.LoggerFactory;
       }
       break;
 
+    case DURABILITY:
+      if (value == null) {
+        unsetDurability();
+      } else {
+        setDurability((Durability)value);
+      }
+      break;
+
     }
   }
 
@@ -347,6 +406,9 @@ import org.slf4j.LoggerFactory;
     case AUTHORIZATIONS:
       return getAuthorizations();
 
+    case DURABILITY:
+      return getDurability();
+
     }
     throw new IllegalStateException();
   }
@@ -366,6 +428,8 @@ import org.slf4j.LoggerFactory;
       return isSetThreads();
     case AUTHORIZATIONS:
       return isSetAuthorizations();
+    case DURABILITY:
+      return isSetDurability();
     }
     throw new IllegalStateException();
   }
@@ -419,6 +483,15 @@ import org.slf4j.LoggerFactory;
         return false;
     }
 
+    boolean this_present_durability = true && this.isSetDurability();
+    boolean that_present_durability = true && that.isSetDurability();
+    if (this_present_durability || that_present_durability) {
+      if (!(this_present_durability && that_present_durability))
+        return false;
+      if (!this.durability.equals(that.durability))
+        return false;
+    }
+
     return true;
   }
 
@@ -475,6 +548,16 @@ import org.slf4j.LoggerFactory;
         return lastComparison;
       }
     }
+    lastComparison = Boolean.valueOf(isSetDurability()).compareTo(other.isSetDurability());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetDurability()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.durability, other.durability);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
     return 0;
   }
 
@@ -522,6 +605,16 @@ import org.slf4j.LoggerFactory;
       }
       first = false;
     }
+    if (isSetDurability()) {
+      if (!first) sb.append(", ");
+      sb.append("durability:");
+      if (this.durability == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.durability);
+      }
+      first = false;
+    }
     sb.append(")");
     return sb.toString();
   }
@@ -609,6 +702,14 @@ import org.slf4j.LoggerFactory;
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
+          case 5: // DURABILITY
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.durability = Durability.findByValue(iprot.readI32());
+              struct.setDurabilityIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
           default:
             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
         }
@@ -653,6 +754,13 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldEnd();
         }
       }
+      if (struct.durability != null) {
+        if (struct.isSetDurability()) {
+          oprot.writeFieldBegin(DURABILITY_FIELD_DESC);
+          oprot.writeI32(struct.durability.getValue());
+          oprot.writeFieldEnd();
+        }
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
     }
@@ -683,7 +791,10 @@ import org.slf4j.LoggerFactory;
       if (struct.isSetAuthorizations()) {
         optionals.set(3);
       }
-      oprot.writeBitSet(optionals, 4);
+      if (struct.isSetDurability()) {
+        optionals.set(4);
+      }
+      oprot.writeBitSet(optionals, 5);
       if (struct.isSetMaxMemory()) {
         oprot.writeI64(struct.maxMemory);
       }
@@ -702,12 +813,15 @@ import org.slf4j.LoggerFactory;
           }
         }
       }
+      if (struct.isSetDurability()) {
+        oprot.writeI32(struct.durability.getValue());
+      }
     }
 
     @Override
     public void read(org.apache.thrift.protocol.TProtocol prot, ConditionalWriterOptions struct) throws org.apache.thrift.TException {
       TTupleProtocol iprot = (TTupleProtocol) prot;
-      BitSet incoming = iprot.readBitSet(4);
+      BitSet incoming = iprot.readBitSet(5);
       if (incoming.get(0)) {
         struct.maxMemory = iprot.readI64();
         struct.setMaxMemoryIsSet(true);
@@ -733,6 +847,10 @@ import org.slf4j.LoggerFactory;
         }
         struct.setAuthorizationsIsSet(true);
       }
+      if (incoming.get(4)) {
+        struct.durability = Durability.findByValue(iprot.readI32());
+        struct.setDurabilityIsSet(true);
+      }
     }
   }
 

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/java/org/apache/accumulo/proxy/thrift/Durability.java
----------------------------------------------------------------------
diff --git a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/Durability.java b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/Durability.java
new file mode 100644
index 0000000..cf729fc
--- /dev/null
+++ b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/Durability.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.accumulo.proxy.thrift;
+
+
+import java.util.Map;
+import java.util.HashMap;
+import org.apache.thrift.TEnum;
+
+@SuppressWarnings("all") public enum Durability implements org.apache.thrift.TEnum {
+  DEFAULT(0),
+  NONE(1),
+  LOG(2),
+  FLUSH(3),
+  SYNC(4);
+
+  private final int value;
+
+  private Durability(int value) {
+    this.value = value;
+  }
+
+  /**
+   * Get the integer value of this enum value, as defined in the Thrift IDL.
+   */
+  public int getValue() {
+    return value;
+  }
+
+  /**
+   * Find a the enum type by its integer value, as defined in the Thrift IDL.
+   * @return null if the value is not found.
+   */
+  public static Durability findByValue(int value) { 
+    switch (value) {
+      case 0:
+        return DEFAULT;
+      case 1:
+        return NONE;
+      case 2:
+        return LOG;
+      case 3:
+        return FLUSH;
+      case 4:
+        return SYNC;
+      default:
+        return null;
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/java/org/apache/accumulo/proxy/thrift/WriterOptions.java
----------------------------------------------------------------------
diff --git a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/WriterOptions.java b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/WriterOptions.java
index 5f000a8..97a57c8 100644
--- a/proxy/src/main/java/org/apache/accumulo/proxy/thrift/WriterOptions.java
+++ b/proxy/src/main/java/org/apache/accumulo/proxy/thrift/WriterOptions.java
@@ -55,6 +55,7 @@ import org.slf4j.LoggerFactory;
   private static final org.apache.thrift.protocol.TField LATENCY_MS_FIELD_DESC = new org.apache.thrift.protocol.TField("latencyMs", org.apache.thrift.protocol.TType.I64, (short)2);
   private static final org.apache.thrift.protocol.TField TIMEOUT_MS_FIELD_DESC = new org.apache.thrift.protocol.TField("timeoutMs", org.apache.thrift.protocol.TType.I64, (short)3);
   private static final org.apache.thrift.protocol.TField THREADS_FIELD_DESC = new org.apache.thrift.protocol.TField("threads", org.apache.thrift.protocol.TType.I32, (short)4);
+  private static final org.apache.thrift.protocol.TField DURABILITY_FIELD_DESC = new org.apache.thrift.protocol.TField("durability", org.apache.thrift.protocol.TType.I32, (short)5);
 
   private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
   static {
@@ -66,13 +67,23 @@ import org.slf4j.LoggerFactory;
   public long latencyMs; // required
   public long timeoutMs; // required
   public int threads; // required
+  /**
+   * 
+   * @see Durability
+   */
+  public Durability durability; // optional
 
   /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
   @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum {
     MAX_MEMORY((short)1, "maxMemory"),
     LATENCY_MS((short)2, "latencyMs"),
     TIMEOUT_MS((short)3, "timeoutMs"),
-    THREADS((short)4, "threads");
+    THREADS((short)4, "threads"),
+    /**
+     * 
+     * @see Durability
+     */
+    DURABILITY((short)5, "durability");
 
     private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
 
@@ -95,6 +106,8 @@ import org.slf4j.LoggerFactory;
           return TIMEOUT_MS;
         case 4: // THREADS
           return THREADS;
+        case 5: // DURABILITY
+          return DURABILITY;
         default:
           return null;
       }
@@ -140,6 +153,7 @@ import org.slf4j.LoggerFactory;
   private static final int __TIMEOUTMS_ISSET_ID = 2;
   private static final int __THREADS_ISSET_ID = 3;
   private byte __isset_bitfield = 0;
+  private _Fields optionals[] = {_Fields.DURABILITY};
   public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
   static {
     Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
@@ -151,6 +165,8 @@ import org.slf4j.LoggerFactory;
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
     tmpMap.put(_Fields.THREADS, new org.apache.thrift.meta_data.FieldMetaData("threads", org.apache.thrift.TFieldRequirementType.DEFAULT, 
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.DURABILITY, new org.apache.thrift.meta_data.FieldMetaData("durability", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Durability.class)));
     metaDataMap = Collections.unmodifiableMap(tmpMap);
     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WriterOptions.class, metaDataMap);
   }
@@ -184,6 +200,9 @@ import org.slf4j.LoggerFactory;
     this.latencyMs = other.latencyMs;
     this.timeoutMs = other.timeoutMs;
     this.threads = other.threads;
+    if (other.isSetDurability()) {
+      this.durability = other.durability;
+    }
   }
 
   public WriterOptions deepCopy() {
@@ -200,6 +219,7 @@ import org.slf4j.LoggerFactory;
     this.timeoutMs = 0;
     setThreadsIsSet(false);
     this.threads = 0;
+    this.durability = null;
   }
 
   public long getMaxMemory() {
@@ -294,6 +314,38 @@ import org.slf4j.LoggerFactory;
     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __THREADS_ISSET_ID, value);
   }
 
+  /**
+   * 
+   * @see Durability
+   */
+  public Durability getDurability() {
+    return this.durability;
+  }
+
+  /**
+   * 
+   * @see Durability
+   */
+  public WriterOptions setDurability(Durability durability) {
+    this.durability = durability;
+    return this;
+  }
+
+  public void unsetDurability() {
+    this.durability = null;
+  }
+
+  /** Returns true if field durability is set (has been assigned a value) and false otherwise */
+  public boolean isSetDurability() {
+    return this.durability != null;
+  }
+
+  public void setDurabilityIsSet(boolean value) {
+    if (!value) {
+      this.durability = null;
+    }
+  }
+
   public void setFieldValue(_Fields field, Object value) {
     switch (field) {
     case MAX_MEMORY:
@@ -328,6 +380,14 @@ import org.slf4j.LoggerFactory;
       }
       break;
 
+    case DURABILITY:
+      if (value == null) {
+        unsetDurability();
+      } else {
+        setDurability((Durability)value);
+      }
+      break;
+
     }
   }
 
@@ -345,6 +405,9 @@ import org.slf4j.LoggerFactory;
     case THREADS:
       return Integer.valueOf(getThreads());
 
+    case DURABILITY:
+      return getDurability();
+
     }
     throw new IllegalStateException();
   }
@@ -364,6 +427,8 @@ import org.slf4j.LoggerFactory;
       return isSetTimeoutMs();
     case THREADS:
       return isSetThreads();
+    case DURABILITY:
+      return isSetDurability();
     }
     throw new IllegalStateException();
   }
@@ -417,6 +482,15 @@ import org.slf4j.LoggerFactory;
         return false;
     }
 
+    boolean this_present_durability = true && this.isSetDurability();
+    boolean that_present_durability = true && that.isSetDurability();
+    if (this_present_durability || that_present_durability) {
+      if (!(this_present_durability && that_present_durability))
+        return false;
+      if (!this.durability.equals(that.durability))
+        return false;
+    }
+
     return true;
   }
 
@@ -473,6 +547,16 @@ import org.slf4j.LoggerFactory;
         return lastComparison;
       }
     }
+    lastComparison = Boolean.valueOf(isSetDurability()).compareTo(other.isSetDurability());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetDurability()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.durability, other.durability);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
     return 0;
   }
 
@@ -508,6 +592,16 @@ import org.slf4j.LoggerFactory;
     sb.append("threads:");
     sb.append(this.threads);
     first = false;
+    if (isSetDurability()) {
+      if (!first) sb.append(", ");
+      sb.append("durability:");
+      if (this.durability == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.durability);
+      }
+      first = false;
+    }
     sb.append(")");
     return sb.toString();
   }
@@ -585,6 +679,14 @@ import org.slf4j.LoggerFactory;
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
+          case 5: // DURABILITY
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.durability = Durability.findByValue(iprot.readI32());
+              struct.setDurabilityIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
           default:
             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
         }
@@ -612,6 +714,13 @@ import org.slf4j.LoggerFactory;
       oprot.writeFieldBegin(THREADS_FIELD_DESC);
       oprot.writeI32(struct.threads);
       oprot.writeFieldEnd();
+      if (struct.durability != null) {
+        if (struct.isSetDurability()) {
+          oprot.writeFieldBegin(DURABILITY_FIELD_DESC);
+          oprot.writeI32(struct.durability.getValue());
+          oprot.writeFieldEnd();
+        }
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
     }
@@ -642,7 +751,10 @@ import org.slf4j.LoggerFactory;
       if (struct.isSetThreads()) {
         optionals.set(3);
       }
-      oprot.writeBitSet(optionals, 4);
+      if (struct.isSetDurability()) {
+        optionals.set(4);
+      }
+      oprot.writeBitSet(optionals, 5);
       if (struct.isSetMaxMemory()) {
         oprot.writeI64(struct.maxMemory);
       }
@@ -655,12 +767,15 @@ import org.slf4j.LoggerFactory;
       if (struct.isSetThreads()) {
         oprot.writeI32(struct.threads);
       }
+      if (struct.isSetDurability()) {
+        oprot.writeI32(struct.durability.getValue());
+      }
     }
 
     @Override
     public void read(org.apache.thrift.protocol.TProtocol prot, WriterOptions struct) throws org.apache.thrift.TException {
       TTupleProtocol iprot = (TTupleProtocol) prot;
-      BitSet incoming = iprot.readBitSet(4);
+      BitSet incoming = iprot.readBitSet(5);
       if (incoming.get(0)) {
         struct.maxMemory = iprot.readI64();
         struct.setMaxMemoryIsSet(true);
@@ -677,6 +792,10 @@ import org.slf4j.LoggerFactory;
         struct.threads = iprot.readI32();
         struct.setThreadsIsSet(true);
       }
+      if (incoming.get(4)) {
+        struct.durability = Durability.findByValue(iprot.readI32());
+        struct.setDurabilityIsSet(true);
+      }
     }
   }
 

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/python/ttypes.py
----------------------------------------------------------------------
diff --git a/proxy/src/main/python/ttypes.py b/proxy/src/main/python/ttypes.py
index 6a1b423..5e4c001 100644
--- a/proxy/src/main/python/ttypes.py
+++ b/proxy/src/main/python/ttypes.py
@@ -168,6 +168,29 @@ class ConditionalStatus:
     "INVISIBLE_VISIBILITY": 4,
   }
 
+class Durability:
+  DEFAULT = 0
+  NONE = 1
+  LOG = 2
+  FLUSH = 3
+  SYNC = 4
+
+  _VALUES_TO_NAMES = {
+    0: "DEFAULT",
+    1: "NONE",
+    2: "LOG",
+    3: "FLUSH",
+    4: "SYNC",
+  }
+
+  _NAMES_TO_VALUES = {
+    "DEFAULT": 0,
+    "NONE": 1,
+    "LOG": 2,
+    "FLUSH": 3,
+    "SYNC": 4,
+  }
+
 class CompactionType:
   MINOR = 0
   MERGE = 1
@@ -1704,6 +1727,7 @@ class ConditionalWriterOptions:
    - timeoutMs
    - threads
    - authorizations
+   - durability
   """
 
   thrift_spec = (
@@ -1712,13 +1736,15 @@ class ConditionalWriterOptions:
     (2, TType.I64, 'timeoutMs', None, None, ), # 2
     (3, TType.I32, 'threads', None, None, ), # 3
     (4, TType.SET, 'authorizations', (TType.STRING,None), None, ), # 4
+    (5, TType.I32, 'durability', None, None, ), # 5
   )
 
-  def __init__(self, maxMemory=None, timeoutMs=None, threads=None, authorizations=None,):
+  def __init__(self, maxMemory=None, timeoutMs=None, threads=None, authorizations=None, durability=None,):
     self.maxMemory = maxMemory
     self.timeoutMs = timeoutMs
     self.threads = threads
     self.authorizations = authorizations
+    self.durability = durability
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -1754,6 +1780,11 @@ class ConditionalWriterOptions:
           iprot.readSetEnd()
         else:
           iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.I32:
+          self.durability = iprot.readI32();
+        else:
+          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
@@ -1783,6 +1814,10 @@ class ConditionalWriterOptions:
         oprot.writeString(iter99)
       oprot.writeSetEnd()
       oprot.writeFieldEnd()
+    if self.durability is not None:
+      oprot.writeFieldBegin('durability', TType.I32, 5)
+      oprot.writeI32(self.durability)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 
@@ -2201,6 +2236,7 @@ class WriterOptions:
    - latencyMs
    - timeoutMs
    - threads
+   - durability
   """
 
   thrift_spec = (
@@ -2209,13 +2245,15 @@ class WriterOptions:
     (2, TType.I64, 'latencyMs', None, None, ), # 2
     (3, TType.I64, 'timeoutMs', None, None, ), # 3
     (4, TType.I32, 'threads', None, None, ), # 4
+    (5, TType.I32, 'durability', None, None, ), # 5
   )
 
-  def __init__(self, maxMemory=None, latencyMs=None, timeoutMs=None, threads=None,):
+  def __init__(self, maxMemory=None, latencyMs=None, timeoutMs=None, threads=None, durability=None,):
     self.maxMemory = maxMemory
     self.latencyMs = latencyMs
     self.timeoutMs = timeoutMs
     self.threads = threads
+    self.durability = durability
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -2246,6 +2284,11 @@ class WriterOptions:
           self.threads = iprot.readI32();
         else:
           iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.I32:
+          self.durability = iprot.readI32();
+        else:
+          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
@@ -2272,6 +2315,10 @@ class WriterOptions:
       oprot.writeFieldBegin('threads', TType.I32, 4)
       oprot.writeI32(self.threads)
       oprot.writeFieldEnd()
+    if self.durability is not None:
+      oprot.writeFieldBegin('durability', TType.I32, 5)
+      oprot.writeI32(self.durability)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
 

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/ruby/proxy_types.rb
----------------------------------------------------------------------
diff --git a/proxy/src/main/ruby/proxy_types.rb b/proxy/src/main/ruby/proxy_types.rb
index 722e248..beeeee4 100644
--- a/proxy/src/main/ruby/proxy_types.rb
+++ b/proxy/src/main/ruby/proxy_types.rb
@@ -81,6 +81,16 @@ module Accumulo
     VALID_VALUES = Set.new([ACCEPTED, REJECTED, VIOLATED, UNKNOWN, INVISIBLE_VISIBILITY]).freeze
   end
 
+  module Durability
+    DEFAULT = 0
+    NONE = 1
+    LOG = 2
+    FLUSH = 3
+    SYNC = 4
+    VALUE_MAP = {0 => "DEFAULT", 1 => "NONE", 2 => "LOG", 3 => "FLUSH", 4 => "SYNC"}
+    VALID_VALUES = Set.new([DEFAULT, NONE, LOG, FLUSH, SYNC]).freeze
+  end
+
   module CompactionType
     MINOR = 0
     MERGE = 1
@@ -433,17 +443,22 @@ module Accumulo
     TIMEOUTMS = 2
     THREADS = 3
     AUTHORIZATIONS = 4
+    DURABILITY = 5
 
     FIELDS = {
       MAXMEMORY => {:type => ::Thrift::Types::I64, :name => 'maxMemory', :optional => true},
       TIMEOUTMS => {:type => ::Thrift::Types::I64, :name => 'timeoutMs', :optional => true},
       THREADS => {:type => ::Thrift::Types::I32, :name => 'threads', :optional => true},
-      AUTHORIZATIONS => {:type => ::Thrift::Types::SET, :name => 'authorizations', :element => {:type => ::Thrift::Types::STRING, :binary => true}, :optional => true}
+      AUTHORIZATIONS => {:type => ::Thrift::Types::SET, :name => 'authorizations', :element => {:type => ::Thrift::Types::STRING, :binary => true}, :optional => true},
+      DURABILITY => {:type => ::Thrift::Types::I32, :name => 'durability', :optional => true, :enum_class => ::Accumulo::Durability}
     }
 
     def struct_fields; FIELDS; end
 
     def validate
+      unless @durability.nil? || ::Accumulo::Durability::VALID_VALUES.include?(@durability)
+        raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field durability!')
+      end
     end
 
     ::Thrift::Struct.generate_accessors self
@@ -537,17 +552,22 @@ module Accumulo
     LATENCYMS = 2
     TIMEOUTMS = 3
     THREADS = 4
+    DURABILITY = 5
 
     FIELDS = {
       MAXMEMORY => {:type => ::Thrift::Types::I64, :name => 'maxMemory'},
       LATENCYMS => {:type => ::Thrift::Types::I64, :name => 'latencyMs'},
       TIMEOUTMS => {:type => ::Thrift::Types::I64, :name => 'timeoutMs'},
-      THREADS => {:type => ::Thrift::Types::I32, :name => 'threads'}
+      THREADS => {:type => ::Thrift::Types::I32, :name => 'threads'},
+      DURABILITY => {:type => ::Thrift::Types::I32, :name => 'durability', :optional => true, :enum_class => ::Accumulo::Durability}
     }
 
     def struct_fields; FIELDS; end
 
     def validate
+      unless @durability.nil? || ::Accumulo::Durability::VALID_VALUES.include?(@durability)
+        raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field durability!')
+      end
     end
 
     ::Thrift::Struct.generate_accessors self

http://git-wip-us.apache.org/repos/asf/accumulo/blob/3a0beab0/proxy/src/main/thrift/proxy.thrift
----------------------------------------------------------------------
diff --git a/proxy/src/main/thrift/proxy.thrift b/proxy/src/main/thrift/proxy.thrift
index 6488f4f..fbd9c52 100644
--- a/proxy/src/main/thrift/proxy.thrift
+++ b/proxy/src/main/thrift/proxy.thrift
@@ -179,12 +179,23 @@ enum ConditionalStatus {
   INVISIBLE_VISIBILITY
 }
 
+//since 1.7.0
+enum Durability {
+	DEFAULT,
+	NONE,
+	LOG,
+	FLUSH,
+	SYNC
+}
+
 //since 1.6.0
 struct ConditionalWriterOptions {
    1:optional i64 maxMemory
    2:optional i64 timeoutMs
    3:optional i32 threads
    4:optional set<binary> authorizations;
+   //since 1.7.0
+   5:optional Durability durability;
 }
 
 struct ActiveScan {
@@ -234,6 +245,8 @@ struct WriterOptions {
  2:i64 latencyMs
  3:i64 timeoutMs
  4:i32 threads
+ //since 1.7.0
+ 5:optional Durability durability
 }
 
 enum IteratorScope {


Mime
View raw message