Commit 601a4788 authored by Steven Murray's avatar Steven Murray
Browse files

DataTransferSession is now ran by the ProcessForker

parent 25ef0fb3
......@@ -32,7 +32,9 @@
//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
castor::legacymsg::VdqmProxyTcpIp::VdqmProxyTcpIp(log::Logger &log, const std::string &vdqmHostName, const unsigned short vdqmPort, const int netTimeout) throw():
castor::legacymsg::VdqmProxyTcpIp::VdqmProxyTcpIp(log::Logger &log,
const std::string &vdqmHostName, const unsigned short vdqmPort,
const int netTimeout) throw():
m_log(log),
m_vdqmHostName(vdqmHostName),
m_vdqmPort(vdqmPort),
......@@ -48,7 +50,8 @@ castor::legacymsg::VdqmProxyTcpIp::~VdqmProxyTcpIp() throw() {
//------------------------------------------------------------------------------
// setDriveDown
//------------------------------------------------------------------------------
void castor::legacymsg::VdqmProxyTcpIp::setDriveDown(const std::string &server, const std::string &unitName, const std::string &dgn) {
void castor::legacymsg::VdqmProxyTcpIp::setDriveDown(const std::string &server,
const std::string &unitName, const std::string &dgn) {
try {
legacymsg::VdqmDrvRqstMsgBody body;
body.status = VDQM_UNIT_DOWN;
......@@ -59,8 +62,9 @@ void castor::legacymsg::VdqmProxyTcpIp::setDriveDown(const std::string &server,
setDriveStatus(body);
} catch(castor::exception::Exception &ne) {
castor::exception::Exception ex;
ex.getMessage() << "Failed to set status of tape drive " << unitName <<
" to down: " << ne.getMessage().str();
ex.getMessage() << "Failed to set state of tape drive"
": server=" << server << " unitName=" << unitName << " dgn=" << dgn <<
" state=down: " << ne.getMessage().str();
throw ex;
}
}
......@@ -68,7 +72,8 @@ void castor::legacymsg::VdqmProxyTcpIp::setDriveDown(const std::string &server,
//------------------------------------------------------------------------------
// setDriveUp
//------------------------------------------------------------------------------
void castor::legacymsg::VdqmProxyTcpIp::setDriveUp(const std::string &server, const std::string &unitName, const std::string &dgn) {
void castor::legacymsg::VdqmProxyTcpIp::setDriveUp(const std::string &server,
const std::string &unitName, const std::string &dgn) {
try {
legacymsg::VdqmDrvRqstMsgBody body;
body.status = VDQM_UNIT_UP;
......@@ -79,8 +84,9 @@ void castor::legacymsg::VdqmProxyTcpIp::setDriveUp(const std::string &server, co
setDriveStatus(body);
} catch(castor::exception::Exception &ne) {
castor::exception::Exception ex;
ex.getMessage() << "Failed to set status of tape drive " << unitName <<
" to up: " << ne.getMessage().str();
ex.getMessage() << "Failed to set state of tape drive"
": server=" << server << " unitName=" << unitName << " dgn=" << dgn <<
" state=up: " << ne.getMessage().str();
throw ex;
}
}
......@@ -88,7 +94,9 @@ void castor::legacymsg::VdqmProxyTcpIp::setDriveUp(const std::string &server, co
//------------------------------------------------------------------------------
// assignDrive
//------------------------------------------------------------------------------
void castor::legacymsg::VdqmProxyTcpIp::assignDrive(const std::string &server, const std::string &unitName, const std::string &dgn, const uint32_t mountTransactionId, const pid_t sessionPid) {
void castor::legacymsg::VdqmProxyTcpIp::assignDrive(const std::string &server,
const std::string &unitName, const std::string &dgn,
const uint32_t mountTransactionId, const pid_t sessionPid) {
try {
legacymsg::VdqmDrvRqstMsgBody body;
body.status = VDQM_UNIT_ASSIGN;
......@@ -101,8 +109,10 @@ void castor::legacymsg::VdqmProxyTcpIp::assignDrive(const std::string &server, c
setDriveStatus(body);
} catch(castor::exception::Exception &ne) {
castor::exception::Exception ex;
ex.getMessage() << "Failed to assign mount-session with process ID " <<
sessionPid << "to tape drive " << unitName << ": " << ne.getMessage().str();
ex.getMessage() << "Failed to assign drive"
": server=" << server << " unitName=" << unitName << " dgn=" << dgn <<
" mountTransactionId=" << mountTransactionId << " sessionPid=" <<
sessionPid << ": " << ne.getMessage().str();
throw ex;
}
}
......@@ -126,8 +136,10 @@ void castor::legacymsg::VdqmProxyTcpIp::tapeMounted(const std::string &server,
setDriveStatus(body);
} catch(castor::exception::Exception &ne) {
castor::exception::Exception ex;
ex.getMessage() << "Failed to notify vdqm that tape " << vid <<
" was mounted on tape drive " << unitName << ": " << ne.getMessage().str();
ex.getMessage() << "Failed to notify vdqm that tape is mounted"
": server=" << server << " unitName=" << unitName << " dgn=" << dgn <<
" vid=" << vid << " sessionPid=" << sessionPid << ": " <<
ne.getMessage().str();
throw ex;
}
}
......@@ -155,8 +167,10 @@ void castor::legacymsg::VdqmProxyTcpIp::releaseDrive(const std::string &server,
setDriveStatus(body);
} catch(castor::exception::Exception &ne) {
castor::exception::Exception ex;
ex.getMessage() << "Failed to release tape drive " << unitName << ": " <<
ne.getMessage().str();
ex.getMessage() << "Failed to release tape drive"
": server=" << server << " unitName=" << unitName << " dgn=" << dgn <<
" forceUnmount=" << forceUnmount << " sessionPid=" << sessionPid << ": "
<< ne.getMessage().str();
throw ex;
}
}
......@@ -164,7 +178,8 @@ void castor::legacymsg::VdqmProxyTcpIp::releaseDrive(const std::string &server,
//------------------------------------------------------------------------------
// setDriveStatus
//------------------------------------------------------------------------------
void castor::legacymsg::VdqmProxyTcpIp::setDriveStatus(const legacymsg::VdqmDrvRqstMsgBody &body) {
void castor::legacymsg::VdqmProxyTcpIp::setDriveStatus(
const legacymsg::VdqmDrvRqstMsgBody &body) {
castor::utils::SmartFd fd(connectToVdqm());
writeDriveStatusMsg(fd.get(), body);
readCommitAck(fd.get());
......@@ -194,7 +209,8 @@ int castor::legacymsg::VdqmProxyTcpIp::connectToVdqm() const {
//-----------------------------------------------------------------------------
// writeDriveStatusMsg
//-----------------------------------------------------------------------------
void castor::legacymsg::VdqmProxyTcpIp::writeDriveStatusMsg(const int fd, const legacymsg::VdqmDrvRqstMsgBody &body) {
void castor::legacymsg::VdqmProxyTcpIp::writeDriveStatusMsg(const int fd,
const legacymsg::VdqmDrvRqstMsgBody &body) {
char buf[VDQM_MSGBUFSIZ];
const size_t len = legacymsg::marshal(buf, body);
......@@ -252,7 +268,8 @@ void castor::legacymsg::VdqmProxyTcpIp::readCommitAck(const int fd) {
//-----------------------------------------------------------------------------
// readAck
//-----------------------------------------------------------------------------
castor::legacymsg::MessageHeader castor::legacymsg::VdqmProxyTcpIp::readAck(const int fd) {
castor::legacymsg::MessageHeader castor::legacymsg::VdqmProxyTcpIp::readAck(
const int fd) {
char buf[12]; // Magic + type + len
legacymsg::MessageHeader ack;
......@@ -275,7 +292,8 @@ castor::legacymsg::MessageHeader castor::legacymsg::VdqmProxyTcpIp::readAck(cons
//-----------------------------------------------------------------------------
// readDriveStatusMsgHeader
//-----------------------------------------------------------------------------
castor::legacymsg::MessageHeader castor::legacymsg::VdqmProxyTcpIp::readDriveStatusMsgHeader(const int fd) {
castor::legacymsg::MessageHeader castor::legacymsg::VdqmProxyTcpIp::
readDriveStatusMsgHeader(const int fd) {
char buf[12]; // Magic + type + len
legacymsg::MessageHeader header;
......@@ -316,7 +334,8 @@ castor::legacymsg::MessageHeader castor::legacymsg::VdqmProxyTcpIp::readDriveSta
//-----------------------------------------------------------------------------
// readDriveStatusMsgBody
//-----------------------------------------------------------------------------
castor::legacymsg::VdqmDrvRqstMsgBody castor::legacymsg::VdqmProxyTcpIp::readDriveStatusMsgBody(const int fd, const uint32_t bodyLen) {
castor::legacymsg::VdqmDrvRqstMsgBody castor::legacymsg::VdqmProxyTcpIp::
readDriveStatusMsgBody(const int fd, const uint32_t bodyLen) {
char buf[VDQM_MSGBUFSIZ];
if(sizeof(buf) < bodyLen) {
......@@ -368,7 +387,9 @@ void castor::legacymsg::VdqmProxyTcpIp::writeCommitAck(const int fd) {
//-----------------------------------------------------------------------------
// tapeUnmounted
//-----------------------------------------------------------------------------
void castor::legacymsg::VdqmProxyTcpIp::tapeUnmounted(const std::string &server, const std::string &unitName, const std::string &dgn, const std::string &vid) {
void castor::legacymsg::VdqmProxyTcpIp::tapeUnmounted(
const std::string &server, const std::string &unitName,
const std::string &dgn, const std::string &vid) {
int status = VDQM_VOL_UNMOUNT;
try {
......
add_library(castormessages SHARED
Exception.pb.cc
ForkCleaner.pb.cc
ForkDataTransfer.pb.cc
ForkLabel.pb.cc
......@@ -7,8 +8,9 @@ add_library(castormessages SHARED
Heartbeat.pb.cc
messages.cpp
NotifyDrive.pb.cc
ProcessCrashed.pb.cc
ProcessExited.pb.cc
ReplyContainer.cpp
Status.pb.cc
StopProcessForker.pb.cc
TapeserverProxy.cpp
TapeserverProxyDummy.cpp
......
// Generated by the protocol buffer compiler. DO NOT EDIT!
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "Status.pb.h"
#include "Exception.pb.h"
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
......@@ -15,35 +15,35 @@ namespace messages {
namespace {
const ::google::protobuf::Descriptor* Status_descriptor_ = NULL;
const ::google::protobuf::Descriptor* Exception_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
Status_reflection_ = NULL;
Exception_reflection_ = NULL;
} // namespace
void protobuf_AssignDesc_Status_2eproto() {
protobuf_AddDesc_Status_2eproto();
void protobuf_AssignDesc_Exception_2eproto() {
protobuf_AddDesc_Exception_2eproto();
const ::google::protobuf::FileDescriptor* file =
::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
"Status.proto");
"Exception.proto");
GOOGLE_CHECK(file != NULL);
Status_descriptor_ = file->message_type(0);
static const int Status_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Status, status_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Status, message_),
Exception_descriptor_ = file->message_type(0);
static const int Exception_offsets_[2] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Exception, code_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Exception, message_),
};
Status_reflection_ =
Exception_reflection_ =
new ::google::protobuf::internal::GeneratedMessageReflection(
Status_descriptor_,
Status::default_instance_,
Status_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Status, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Status, _unknown_fields_),
Exception_descriptor_,
Exception::default_instance_,
Exception_offsets_,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Exception, _has_bits_[0]),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Exception, _unknown_fields_),
-1,
::google::protobuf::DescriptorPool::generated_pool(),
::google::protobuf::MessageFactory::generated_factory(),
sizeof(Status));
sizeof(Exception));
}
namespace {
......@@ -51,80 +51,80 @@ namespace {
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
&protobuf_AssignDesc_Status_2eproto);
&protobuf_AssignDesc_Exception_2eproto);
}
void protobuf_RegisterTypes(const ::std::string&) {
protobuf_AssignDescriptorsOnce();
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
Status_descriptor_, &Status::default_instance());
Exception_descriptor_, &Exception::default_instance());
}
} // namespace
void protobuf_ShutdownFile_Status_2eproto() {
delete Status::default_instance_;
delete Status_reflection_;
void protobuf_ShutdownFile_Exception_2eproto() {
delete Exception::default_instance_;
delete Exception_reflection_;
}
void protobuf_AddDesc_Status_2eproto() {
void protobuf_AddDesc_Exception_2eproto() {
static bool already_here = false;
if (already_here) return;
already_here = true;
GOOGLE_PROTOBUF_VERIFY_VERSION;
::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
"\n\014Status.proto\022\017castor.messages\")\n\006Statu"
"s\022\016\n\006status\030\001 \002(\r\022\017\n\007message\030\002 \002(\t", 74);
"\n\017Exception.proto\022\017castor.messages\"*\n\tEx"
"ception\022\014\n\004code\030\001 \002(\r\022\017\n\007message\030\002 \002(\t", 78);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"Status.proto", &protobuf_RegisterTypes);
Status::default_instance_ = new Status();
Status::default_instance_->InitAsDefaultInstance();
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_Status_2eproto);
"Exception.proto", &protobuf_RegisterTypes);
Exception::default_instance_ = new Exception();
Exception::default_instance_->InitAsDefaultInstance();
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_Exception_2eproto);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_Status_2eproto {
StaticDescriptorInitializer_Status_2eproto() {
protobuf_AddDesc_Status_2eproto();
struct StaticDescriptorInitializer_Exception_2eproto {
StaticDescriptorInitializer_Exception_2eproto() {
protobuf_AddDesc_Exception_2eproto();
}
} static_descriptor_initializer_Status_2eproto_;
} static_descriptor_initializer_Exception_2eproto_;
// ===================================================================
const ::std::string Status::_default_message_;
const ::std::string Exception::_default_message_;
#ifndef _MSC_VER
const int Status::kStatusFieldNumber;
const int Status::kMessageFieldNumber;
const int Exception::kCodeFieldNumber;
const int Exception::kMessageFieldNumber;
#endif // !_MSC_VER
Status::Status()
Exception::Exception()
: ::google::protobuf::Message() {
SharedCtor();
}
void Status::InitAsDefaultInstance() {
void Exception::InitAsDefaultInstance() {
}
Status::Status(const Status& from)
Exception::Exception(const Exception& from)
: ::google::protobuf::Message() {
SharedCtor();
MergeFrom(from);
}
void Status::SharedCtor() {
void Exception::SharedCtor() {
_cached_size_ = 0;
status_ = 0u;
code_ = 0u;
message_ = const_cast< ::std::string*>(&_default_message_);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
Status::~Status() {
Exception::~Exception() {
SharedDtor();
}
void Status::SharedDtor() {
void Exception::SharedDtor() {
if (message_ != &_default_message_) {
delete message_;
}
......@@ -132,29 +132,29 @@ void Status::SharedDtor() {
}
}
void Status::SetCachedSize(int size) const {
void Exception::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Status::descriptor() {
const ::google::protobuf::Descriptor* Exception::descriptor() {
protobuf_AssignDescriptorsOnce();
return Status_descriptor_;
return Exception_descriptor_;
}
const Status& Status::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_Status_2eproto(); return *default_instance_;
const Exception& Exception::default_instance() {
if (default_instance_ == NULL) protobuf_AddDesc_Exception_2eproto(); return *default_instance_;
}
Status* Status::default_instance_ = NULL;
Exception* Exception::default_instance_ = NULL;
Status* Status::New() const {
return new Status;
Exception* Exception::New() const {
return new Exception;
}
void Status::Clear() {
void Exception::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
status_ = 0u;
code_ = 0u;
if (_has_bit(1)) {
if (message_ != &_default_message_) {
message_->clear();
......@@ -165,19 +165,19 @@ void Status::Clear() {
mutable_unknown_fields()->Clear();
}
bool Status::MergePartialFromCodedStream(
bool Exception::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
::google::protobuf::uint32 tag;
while ((tag = input->ReadTag()) != 0) {
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// required uint32 status = 1;
// required uint32 code = 1;
case 1: {
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
input, &status_)));
input, &code_)));
_set_bit(0);
} else {
goto handle_uninterpreted;
......@@ -219,11 +219,11 @@ bool Status::MergePartialFromCodedStream(
#undef DO_
}
void Status::SerializeWithCachedSizes(
void Exception::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// required uint32 status = 1;
// required uint32 code = 1;
if (_has_bit(0)) {
::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->status(), output);
::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->code(), output);
}
// required string message = 2;
......@@ -241,11 +241,11 @@ void Status::SerializeWithCachedSizes(
}
}
::google::protobuf::uint8* Status::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* Exception::SerializeWithCachedSizesToArray(
::google::protobuf::uint8* target) const {
// required uint32 status = 1;
// required uint32 code = 1;
if (_has_bit(0)) {
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->status(), target);
target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->code(), target);
}
// required string message = 2;
......@@ -265,15 +265,15 @@ void Status::SerializeWithCachedSizes(
return target;
}
int Status::ByteSize() const {
int Exception::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required uint32 status = 1;
if (has_status()) {
// required uint32 code = 1;
if (has_code()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::UInt32Size(
this->status());
this->code());
}
// required string message = 2;
......@@ -295,10 +295,10 @@ int Status::ByteSize() const {
return total_size;
}
void Status::MergeFrom(const ::google::protobuf::Message& from) {
void Exception::MergeFrom(const ::google::protobuf::Message& from) {
GOOGLE_CHECK_NE(&from, this);
const Status* source =
::google::protobuf::internal::dynamic_cast_if_available<const Status*>(
const Exception* source =
::google::protobuf::internal::dynamic_cast_if_available<const Exception*>(
&from);
if (source == NULL) {
::google::protobuf::internal::ReflectionOps::Merge(from, this);
......@@ -307,11 +307,11 @@ void Status::MergeFrom(const ::google::protobuf::Message& from) {
}
}
void Status::MergeFrom(const Status& from) {
void Exception::MergeFrom(const Exception& from) {
GOOGLE_CHECK_NE(&from, this);
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (from._has_bit(0)) {
set_status(from.status());
set_code(from.code());
}
if (from._has_bit(1)) {
set_message(from.message());
......@@ -320,27 +320,27 @@ void Status::MergeFrom(const Status& from) {
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}
void Status::CopyFrom(const ::google::protobuf::Message& from) {
void Exception::CopyFrom(const ::google::protobuf::Message& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
void Status::CopyFrom(const Status& from) {
void Exception::CopyFrom(const Exception& from) {
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool Status::IsInitialized() const {
bool Exception::IsInitialized() const {
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
return true;
}
void Status::Swap(Status* other) {
void Exception::Swap(Exception* other) {
if (other != this) {
std::swap(status_, other->status_);
std::swap(code_, other->code_);
std::swap(message_, other->message_);
std::swap(_has_bits_[0], other->_has_bits_[0]);
_unknown_fields_.Swap(&other->_unknown_fields_);
......@@ -348,11 +348,11 @@ void Status::Swap(Status* other) {
}
}
::google::protobuf::Metadata Status::GetMetadata() const {
::google::protobuf::Metadata Exception::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
::google::protobuf::Metadata metadata;
metadata.descriptor = Status_descriptor_;
metadata.reflection = Status_reflection_;
metadata.descriptor = Exception_descriptor_;
metadata.reflection = Exception_reflection_;
return metadata;
}
......
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: Status.proto
// source: Exception.proto
#ifndef PROTOBUF_Status_2eproto__INCLUDED
#define PROTOBUF_Status_2eproto__INCLUDED
#ifndef PROTOBUF_Exception_2eproto__INCLUDED
#define PROTOBUF_Exception_2eproto__INCLUDED
#include <string>
......@@ -29,22 +29,22 @@ namespace castor {
namespace messages {
// Internal implementation detail -- do not call these.
void protobuf_AddDesc_Status_2eproto();
void protobuf_AssignDesc_Status_2eproto();
void protobuf_ShutdownFile_Status_2eproto();
void protobuf_AddDesc_Exception_2eproto();
void protobuf_AssignDesc_Exception_2eproto();
void protobuf_ShutdownFile_Exception_2eproto();
class Status;
class Exception;
// ===================================================================
class Status : public ::google::protobuf::Message {
class Exception : public ::google::protobuf::Message {
public:
Status();
virtual ~Status();
Exception();
virtual ~Exception();
Status(const Status& from);
Exception(const Exception& from);
inline Status& operator=(const Status& from) {
inline Exception& operator=(const Exception& from) {
CopyFrom(from);
return *this;
}
......@@ -58,17 +58,17 @@ class Status : public ::google::protobuf::Message {
}
static const ::google::protobuf::Descriptor* descriptor();
static const Status& default_instance();
static const Exception& default_instance();
void Swap(Status* other);
void Swap(Exception* other);
// implements Message ----------------------------------------------
Status* New() const;
Exception* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const Status& from);
void MergeFrom(const Status& from);
void CopyFrom(const Exception& from);
void MergeFrom(const Exception& from);
void Clear();
bool IsInitialized() const;
......@@ -91,12 +91,12 @@ class Status : public ::google::protobuf::Message {
// accessors -------------------------------------------------------
// required uint32 status = 1;
inline bool has_status() const;
inline void clear_status();