Commit 05493f89 authored by Andrew Mitchell's avatar Andrew Mitchell
Browse files

Added conversion method from status code to proto status. Moved conversion... 

Added conversion method from status code to proto status. Moved conversion methods out of nonblocking_packet_receiver, where they didn't really belong
parent 36c5812d

CMakeLists.txt

+1 −0
Original line number Diff line number Diff line
@@ -134,6 +134,7 @@ add_library(kinetic_client 
    src/main/socket_wrapper.cc

    src/main/blocking_kinetic_connection.cc

    src/main/threadsafe_blocking_kinetic_connection.cc

    src/main/status_code.cc



    src/main/key_range_iterator.cc

)

include/kinetic/status_code.h

+6 −0
Original line number Diff line number Diff line
@@ -21,8 +21,11 @@ 
#ifndef KINETIC_CPP_CLIENT_STATUS_CODE_H_

#define KINETIC_CPP_CLIENT_STATUS_CODE_H_



#include "kinetic_client.pb.h"



namespace kinetic {



using com::seagate::kinetic::client::proto::Message_Status_StatusCode;

using std::string;



enum class StatusCode {
@@ -50,6 +53,9 @@ enum class StatusCode { 
    PROTOCOL_ERROR_RESPONSE_NO_ACKSEQUENCE

};



StatusCode ConvertFromProtoStatus(Message_Status_StatusCode status);

Message_Status_StatusCode ConvertToProtoStatus(StatusCode status);



} // namespace kinetic



#endif  // KINETIC_CPP_CLIENT_STATUS_CODE_H_

src/main/nonblocking_kinetic_connection.cc

+1 −1
Original line number Diff line number Diff line
@@ -214,7 +214,7 @@ void P2PPushHandler::Handle(const Message& response, unique_ptr<const string> va 
        Message_Status const &status = p2pop.operation(i).status();



        statuses->push_back(

                KineticStatus(ConvertProtoStatus(status.code()), status.statusmessage()));

                KineticStatus(ConvertFromProtoStatus(status.code()), status.statusmessage()));

    }



    callback_->Success(move(statuses));

src/main/nonblocking_packet_receiver.cc

+1 −60
Original line number Diff line number Diff line
@@ -22,25 +22,7 @@ 


namespace kinetic {



using com::seagate::kinetic::client::proto::Message_Status_StatusCode;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_INVALID_STATUS_CODE;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_HMAC_FAILURE;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_NOT_AUTHORIZED;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_NOT_FOUND;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_INTERNAL_ERROR;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_HEADER_REQUIRED;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_SUCCESS;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_VERSION_FAILURE;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_VERSION_MISMATCH;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_SERVICE_BUSY;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_EXPIRED;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_DATA_ERROR;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_PERM_DATA_ERROR;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_REMOTE_CONNECTION_ERROR;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_NO_SPACE;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_NO_SUCH_HMAC_ALGORITHM;

using com::seagate::kinetic::client::proto::Message_Status_StatusCode_INVALID_REQUEST;



using std::string;

using std::shared_ptr;

using std::unique_ptr;
@@ -48,47 +30,6 @@ using std::move; 
using std::make_pair;





StatusCode ConvertProtoStatus(Message_Status_StatusCode status) {

    switch (status) {

        case Message_Status_StatusCode_SUCCESS:

            return StatusCode::OK;

        case Message_Status_StatusCode_HMAC_FAILURE:

            return StatusCode::REMOTE_HMAC_ERROR;

        case Message_Status_StatusCode_NOT_AUTHORIZED:

            return StatusCode::REMOTE_NOT_AUTHORIZED;

        case Message_Status_StatusCode_VERSION_FAILURE:

            return StatusCode::REMOTE_CLUSTER_VERSION_MISMATCH;

        case Message_Status_StatusCode_INTERNAL_ERROR:

            return StatusCode::REMOTE_INTERNAL_ERROR;

        case Message_Status_StatusCode_HEADER_REQUIRED:

            return StatusCode::REMOTE_HEADER_REQUIRED;

        case Message_Status_StatusCode_NOT_FOUND:

            return StatusCode::REMOTE_NOT_FOUND;

        case Message_Status_StatusCode_VERSION_MISMATCH:

            return StatusCode::REMOTE_VERSION_MISMATCH;

        case Message_Status_StatusCode_SERVICE_BUSY:

            return StatusCode::REMOTE_SERVICE_BUSY;

        case Message_Status_StatusCode_EXPIRED:

            return StatusCode::REMOTE_EXPIRED;

        case Message_Status_StatusCode_DATA_ERROR:

            return StatusCode::REMOTE_DATA_ERROR;

        case Message_Status_StatusCode_PERM_DATA_ERROR:

            return StatusCode::REMOTE_PERM_DATA_ERROR;

        case Message_Status_StatusCode_REMOTE_CONNECTION_ERROR:

            return StatusCode::REMOTE_REMOTE_CONNECTION_ERROR;

        case Message_Status_StatusCode_NO_SPACE:

            return StatusCode::REMOTE_NO_SPACE;

        case Message_Status_StatusCode_NO_SUCH_HMAC_ALGORITHM:

            return StatusCode::REMOTE_NO_SUCH_HMAC_ALGORITHM;

        case Message_Status_StatusCode_INVALID_REQUEST:

            return StatusCode::REMOTE_INVALID_REQUEST;

        case Message_Status_StatusCode_INVALID_STATUS_CODE:

            return StatusCode::CLIENT_INTERNAL_ERROR;

        default:

            return StatusCode::REMOTE_OTHER_ERROR;

    }

}



KineticStatus GetKineticStatus(StatusCode code) {

    switch (code) {

        case StatusCode::CLIENT_IO_ERROR:
@@ -228,7 +169,7 @@ NonblockingPacketServiceStatus NonblockingReceiver::Receive() { 
        if (response_.command().status().code() == Message_Status_StatusCode_SUCCESS) {

            handler_->Handle(response_, move(value_));

        } else {

            handler_->Error(GetKineticStatus(ConvertProtoStatus(

            handler_->Error(GetKineticStatus(ConvertFromProtoStatus(

                    response_.command().status().code())));

        }

src/main/nonblocking_packet_receiver.h

+0 −2
Original line number Diff line number Diff line
@@ -46,8 +46,6 @@ using std::deque; 
using std::pair;

using std::unordered_map;



StatusCode ConvertProtoStatus(Message_Status_StatusCode status);



enum NonblockingPacketServiceStatus {

    kIdle,      // nothing to do

    kIoWait,    // waiting for I/O to become possible