mirror of https://github.com/grpc/grpc.git
yang-g
9 years ago
commit
4bcd135824
726 changed files with 34463 additions and 12062 deletions
@ -0,0 +1,91 @@ |
|||||||
|
GRPC C++ STYLE GUIDE |
||||||
|
===================== |
||||||
|
|
||||||
|
Background |
||||||
|
---------- |
||||||
|
|
||||||
|
Here we document style rules for C++ usage in the gRPC C++ bindings |
||||||
|
and tests. |
||||||
|
|
||||||
|
General |
||||||
|
------- |
||||||
|
|
||||||
|
- The majority of gRPC's C++ requirements are drawn from the [Google C++ style |
||||||
|
guide] (https://google.github.io/styleguide/cppguide.html) |
||||||
|
- However, gRPC has some additional requirements to maintain |
||||||
|
[portability] (#portability) |
||||||
|
- As in C, layout rules are defined by clang-format, and all code |
||||||
|
should be passed through clang-format. A (docker-based) script to do |
||||||
|
so is included in [tools/distrib/clang\_format\_code.sh] |
||||||
|
(../tools/distrib/clang_format_code.sh). |
||||||
|
|
||||||
|
<a name="portability"></a> |
||||||
|
Portability Restrictions |
||||||
|
------------------- |
||||||
|
|
||||||
|
gRPC supports a large number of compilers, ranging from those that are |
||||||
|
missing many key C++11 features to those that have quite detailed |
||||||
|
analysis. As a result, gRPC compiles with a high level of warnings and |
||||||
|
treat all warnings as errors. gRPC also forbids the use of some common |
||||||
|
C++11 constructs. Here are some guidelines, to be extended as needed: |
||||||
|
- Do not use range-based for. Expressions of the form |
||||||
|
```c |
||||||
|
for (auto& i: vec) { |
||||||
|
// code |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
are not allowed and should be replaced with code such as |
||||||
|
```c |
||||||
|
for (auto it = vec.begin; it != vec.end(); it++) { |
||||||
|
auto& i = *it; |
||||||
|
// code |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
- Do not use lambda of any kind (no capture, explicit capture, or |
||||||
|
default capture). Other C++ functional features such as |
||||||
|
`std::function` or `std::bind` are allowed |
||||||
|
- Do not use brace-list initializers. |
||||||
|
- Do not compare a pointer to `nullptr` . This is because gcc 4.4 |
||||||
|
does not support `nullptr` directly and gRPC implements a subset of |
||||||
|
its features in [include/grpc++/impl/codegen/config.h] |
||||||
|
(../include/grpc++/impl/codegen/config.h). Instead, pointers should |
||||||
|
be checked for validity using their implicit conversion to `bool`. |
||||||
|
In other words, use `if (p)` rather than `if (p != nullptr)` |
||||||
|
- Do not initialize global/static pointer variables to `nullptr`. Just let |
||||||
|
the compiler implicitly initialize them to `nullptr` (which it will |
||||||
|
definitely do). The reason is that `nullptr` is an actual object in |
||||||
|
our implementation rather than just a constant pointer value, so |
||||||
|
static/global constructors will be called in a potentially |
||||||
|
undesirable sequence. |
||||||
|
- Do not use `final` or `override` as these are not supported by some |
||||||
|
compilers. Instead use `GRPC_FINAL` and `GRPC_OVERRIDE` . These |
||||||
|
compile down to the traditional C++ forms for compilers that support |
||||||
|
them but are just elided if the compiler does not support those features. |
||||||
|
- In the [include] (../../../tree/master/include/grpc++) and [src] |
||||||
|
(../../../tree/master/src/cpp) directory trees, you should also not |
||||||
|
use certain STL objects like `std::mutex`, `std::lock_guard`, |
||||||
|
`std::unique_lock`, `std::nullptr`, `std::thread` . Instead, use |
||||||
|
`grpc::mutex`, `grpc::lock_guard`, etc., which are gRPC |
||||||
|
implementations of the prominent features of these objects that are |
||||||
|
not always available. You can use the `std` versions of those in [test] |
||||||
|
(../../../tree/master/test/cpp) |
||||||
|
- Similarly, in the same directories, do not use `std::chrono` unless |
||||||
|
it is guarded by `#ifndef GRPC_CXX0X_NO_CHRONO` . For platforms that |
||||||
|
lack`std::chrono,` there is a C-language timer called gpr_timespec that can |
||||||
|
be used instead. |
||||||
|
- `std::unique_ptr` must be used with extreme care in any kind of |
||||||
|
collection. For example `vector<std::unique_ptr>` does not work in |
||||||
|
gcc 4.4 if the vector is constructed to its full size at |
||||||
|
initialization but does work if elements are added to the vector |
||||||
|
using functions like `push_back`. `map` and other pair-based |
||||||
|
collections do not work with `unique_ptr` under gcc 4.4. The issue |
||||||
|
is that many of these collection implementations assume a copy |
||||||
|
constructor |
||||||
|
to be available. |
||||||
|
- Don't use `std::this_thread` . Use `gpr_sleep_until` for sleeping a thread. |
||||||
|
- [Some adjacent character combinations cause problems] |
||||||
|
(https://en.wikipedia.org/wiki/Digraphs_and_trigraphs#C). If declaring a |
||||||
|
template against some class relative to the global namespace, |
||||||
|
`<::name` will be non-portable. Separate the `<` from the `:` and use `< ::name`. |
||||||
@ -0,0 +1,69 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2015, Google Inc. |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are |
||||||
|
* met: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above |
||||||
|
* copyright notice, this list of conditions and the following disclaimer |
||||||
|
* in the documentation and/or other materials provided with the |
||||||
|
* distribution. |
||||||
|
* * Neither the name of Google Inc. nor the names of its |
||||||
|
* contributors may be used to endorse or promote products derived from |
||||||
|
* this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef GRPCXX_EXT_PROTO_SERVER_REFLECTION_PLUGIN_H |
||||||
|
#define GRPCXX_EXT_PROTO_SERVER_REFLECTION_PLUGIN_H |
||||||
|
|
||||||
|
#include <grpc++/impl/server_builder_plugin.h> |
||||||
|
#include <grpc++/support/config.h> |
||||||
|
|
||||||
|
namespace grpc { |
||||||
|
class ServerInitializer; |
||||||
|
class ProtoServerReflection; |
||||||
|
} // namespace grpc
|
||||||
|
|
||||||
|
namespace grpc { |
||||||
|
namespace reflection { |
||||||
|
|
||||||
|
class ProtoServerReflectionPlugin : public ::grpc::ServerBuilderPlugin { |
||||||
|
public: |
||||||
|
ProtoServerReflectionPlugin(); |
||||||
|
::grpc::string name() GRPC_OVERRIDE; |
||||||
|
void InitServer(::grpc::ServerInitializer* si) GRPC_OVERRIDE; |
||||||
|
void Finish(::grpc::ServerInitializer* si) GRPC_OVERRIDE; |
||||||
|
void ChangeArguments(const ::grpc::string& name, void* value) GRPC_OVERRIDE; |
||||||
|
bool has_async_methods() const GRPC_OVERRIDE; |
||||||
|
bool has_sync_methods() const GRPC_OVERRIDE; |
||||||
|
|
||||||
|
private: |
||||||
|
std::shared_ptr<grpc::ProtoServerReflection> reflection_service_; |
||||||
|
}; |
||||||
|
|
||||||
|
// Add proto reflection plugin to ServerBuilder. This function should be called
|
||||||
|
// at the static initialization time.
|
||||||
|
void InitProtoReflectionServerBuilderPlugin(); |
||||||
|
|
||||||
|
} // namespace reflection
|
||||||
|
} // namespace grpc
|
||||||
|
|
||||||
|
#endif // GRPCXX_EXT_PROTO_SERVER_REFLECTION_PLUGIN_H
|
||||||
@ -0,0 +1,184 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2015, Google Inc. |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are |
||||||
|
* met: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above |
||||||
|
* copyright notice, this list of conditions and the following disclaimer |
||||||
|
* in the documentation and/or other materials provided with the |
||||||
|
* distribution. |
||||||
|
* * Neither the name of Google Inc. nor the names of its |
||||||
|
* contributors may be used to endorse or promote products derived from |
||||||
|
* this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
|
||||||
|
// Generated by the gRPC protobuf plugin.
|
||||||
|
// If you make any local change, they will be lost.
|
||||||
|
// source: reflection.proto
|
||||||
|
// Original file comments:
|
||||||
|
// Copyright 2016, Google Inc.
|
||||||
|
// All rights reserved.
|
||||||
|
//
|
||||||
|
// Redistribution and use in source and binary forms, with or without
|
||||||
|
// modification, are permitted provided that the following conditions are
|
||||||
|
// met:
|
||||||
|
//
|
||||||
|
// * Redistributions of source code must retain the above copyright
|
||||||
|
// notice, this list of conditions and the following disclaimer.
|
||||||
|
// * Redistributions in binary form must reproduce the above
|
||||||
|
// copyright notice, this list of conditions and the following disclaimer
|
||||||
|
// in the documentation and/or other materials provided with the
|
||||||
|
// distribution.
|
||||||
|
// * Neither the name of Google Inc. nor the names of its
|
||||||
|
// contributors may be used to endorse or promote products derived from
|
||||||
|
// this software without specific prior written permission.
|
||||||
|
//
|
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
//
|
||||||
|
// Service exported by server reflection
|
||||||
|
//
|
||||||
|
#ifndef GRPC_reflection_2eproto__INCLUDED |
||||||
|
#define GRPC_reflection_2eproto__INCLUDED |
||||||
|
|
||||||
|
#include <grpc++/ext/reflection.pb.h> |
||||||
|
|
||||||
|
#include <grpc++/impl/codegen/async_stream.h> |
||||||
|
#include <grpc++/impl/codegen/async_unary_call.h> |
||||||
|
#include <grpc++/impl/codegen/proto_utils.h> |
||||||
|
#include <grpc++/impl/codegen/rpc_method.h> |
||||||
|
#include <grpc++/impl/codegen/service_type.h> |
||||||
|
#include <grpc++/impl/codegen/status.h> |
||||||
|
#include <grpc++/impl/codegen/stub_options.h> |
||||||
|
#include <grpc++/impl/codegen/sync_stream.h> |
||||||
|
|
||||||
|
namespace grpc { |
||||||
|
class CompletionQueue; |
||||||
|
class Channel; |
||||||
|
class RpcService; |
||||||
|
class ServerCompletionQueue; |
||||||
|
class ServerContext; |
||||||
|
} // namespace grpc
|
||||||
|
|
||||||
|
namespace grpc { |
||||||
|
namespace reflection { |
||||||
|
namespace v1alpha { |
||||||
|
|
||||||
|
class ServerReflection GRPC_FINAL { |
||||||
|
public: |
||||||
|
class StubInterface { |
||||||
|
public: |
||||||
|
virtual ~StubInterface() {} |
||||||
|
// The reflection service is structured as a bidirectional stream, ensuring
|
||||||
|
// all related requests go to a single server.
|
||||||
|
std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>> ServerReflectionInfo(::grpc::ClientContext* context) { |
||||||
|
return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>>(ServerReflectionInfoRaw(context)); |
||||||
|
} |
||||||
|
std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>> AsyncServerReflectionInfo(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { |
||||||
|
return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>>(AsyncServerReflectionInfoRaw(context, cq, tag)); |
||||||
|
} |
||||||
|
private: |
||||||
|
virtual ::grpc::ClientReaderWriterInterface< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>* ServerReflectionInfoRaw(::grpc::ClientContext* context) = 0; |
||||||
|
virtual ::grpc::ClientAsyncReaderWriterInterface< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>* AsyncServerReflectionInfoRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; |
||||||
|
}; |
||||||
|
class Stub GRPC_FINAL : public StubInterface { |
||||||
|
public: |
||||||
|
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); |
||||||
|
std::unique_ptr< ::grpc::ClientReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>> ServerReflectionInfo(::grpc::ClientContext* context) { |
||||||
|
return std::unique_ptr< ::grpc::ClientReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>>(ServerReflectionInfoRaw(context)); |
||||||
|
} |
||||||
|
std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>> AsyncServerReflectionInfo(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { |
||||||
|
return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>>(AsyncServerReflectionInfoRaw(context, cq, tag)); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
std::shared_ptr< ::grpc::ChannelInterface> channel_; |
||||||
|
::grpc::ClientReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>* ServerReflectionInfoRaw(::grpc::ClientContext* context) GRPC_OVERRIDE; |
||||||
|
::grpc::ClientAsyncReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>* AsyncServerReflectionInfoRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE; |
||||||
|
const ::grpc::RpcMethod rpcmethod_ServerReflectionInfo_; |
||||||
|
}; |
||||||
|
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); |
||||||
|
|
||||||
|
class Service : public ::grpc::Service { |
||||||
|
public: |
||||||
|
Service(); |
||||||
|
virtual ~Service(); |
||||||
|
// The reflection service is structured as a bidirectional stream, ensuring
|
||||||
|
// all related requests go to a single server.
|
||||||
|
virtual ::grpc::Status ServerReflectionInfo(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionResponse, ::grpc::reflection::v1alpha::ServerReflectionRequest>* stream); |
||||||
|
}; |
||||||
|
template <class BaseClass> |
||||||
|
class WithAsyncMethod_ServerReflectionInfo : public BaseClass { |
||||||
|
private: |
||||||
|
void BaseClassMustBeDerivedFromService(const Service *service) {} |
||||||
|
public: |
||||||
|
WithAsyncMethod_ServerReflectionInfo() { |
||||||
|
::grpc::Service::MarkMethodAsync(0); |
||||||
|
} |
||||||
|
~WithAsyncMethod_ServerReflectionInfo() GRPC_OVERRIDE { |
||||||
|
BaseClassMustBeDerivedFromService(this); |
||||||
|
} |
||||||
|
// disable synchronous version of this method
|
||||||
|
::grpc::Status ServerReflectionInfo(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionResponse, ::grpc::reflection::v1alpha::ServerReflectionRequest>* stream) GRPC_FINAL GRPC_OVERRIDE { |
||||||
|
abort(); |
||||||
|
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); |
||||||
|
} |
||||||
|
void RequestServerReflectionInfo(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionResponse, ::grpc::reflection::v1alpha::ServerReflectionRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { |
||||||
|
::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag); |
||||||
|
} |
||||||
|
}; |
||||||
|
typedef WithAsyncMethod_ServerReflectionInfo<Service > AsyncService; |
||||||
|
template <class BaseClass> |
||||||
|
class WithGenericMethod_ServerReflectionInfo : public BaseClass { |
||||||
|
private: |
||||||
|
void BaseClassMustBeDerivedFromService(const Service *service) {} |
||||||
|
public: |
||||||
|
WithGenericMethod_ServerReflectionInfo() { |
||||||
|
::grpc::Service::MarkMethodGeneric(0); |
||||||
|
} |
||||||
|
~WithGenericMethod_ServerReflectionInfo() GRPC_OVERRIDE { |
||||||
|
BaseClassMustBeDerivedFromService(this); |
||||||
|
} |
||||||
|
// disable synchronous version of this method
|
||||||
|
::grpc::Status ServerReflectionInfo(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionResponse, ::grpc::reflection::v1alpha::ServerReflectionRequest>* stream) GRPC_FINAL GRPC_OVERRIDE { |
||||||
|
abort(); |
||||||
|
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); |
||||||
|
} |
||||||
|
}; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace v1alpha
|
||||||
|
} // namespace reflection
|
||||||
|
} // namespace grpc
|
||||||
|
|
||||||
|
|
||||||
|
#endif // GRPC_reflection_2eproto__INCLUDED
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,513 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2015, Google Inc. |
|
||||||
* All rights reserved. |
|
||||||
* |
|
||||||
* Redistribution and use in source and binary forms, with or without |
|
||||||
* modification, are permitted provided that the following conditions are |
|
||||||
* met: |
|
||||||
* |
|
||||||
* * Redistributions of source code must retain the above copyright |
|
||||||
* notice, this list of conditions and the following disclaimer. |
|
||||||
* * Redistributions in binary form must reproduce the above |
|
||||||
* copyright notice, this list of conditions and the following disclaimer |
|
||||||
* in the documentation and/or other materials provided with the |
|
||||||
* distribution. |
|
||||||
* * Neither the name of Google Inc. nor the names of its |
|
||||||
* contributors may be used to endorse or promote products derived from |
|
||||||
* this software without specific prior written permission. |
|
||||||
* |
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
||||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
||||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
||||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
||||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
||||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
||||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
||||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
||||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
||||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
#include <string.h> |
|
||||||
|
|
||||||
#include <grpc/support/alloc.h> |
|
||||||
#include <grpc/support/string_util.h> |
|
||||||
|
|
||||||
#include <grpc/grpc_zookeeper.h> |
|
||||||
#include <zookeeper/zookeeper.h> |
|
||||||
|
|
||||||
#include "src/core/ext/client_config/lb_policy_registry.h" |
|
||||||
#include "src/core/ext/client_config/resolver_registry.h" |
|
||||||
#include "src/core/lib/iomgr/resolve_address.h" |
|
||||||
#include "src/core/lib/json/json.h" |
|
||||||
#include "src/core/lib/support/string.h" |
|
||||||
#include "src/core/lib/surface/api_trace.h" |
|
||||||
|
|
||||||
/** Zookeeper session expiration time in milliseconds */ |
|
||||||
#define GRPC_ZOOKEEPER_SESSION_TIMEOUT 15000 |
|
||||||
|
|
||||||
typedef struct { |
|
||||||
/** base class: must be first */ |
|
||||||
grpc_resolver base; |
|
||||||
/** refcount */ |
|
||||||
gpr_refcount refs; |
|
||||||
/** name to resolve */ |
|
||||||
char *name; |
|
||||||
/** subchannel factory */ |
|
||||||
grpc_client_channel_factory *client_channel_factory; |
|
||||||
/** load balancing policy name */ |
|
||||||
char *lb_policy_name; |
|
||||||
|
|
||||||
/** mutex guarding the rest of the state */ |
|
||||||
gpr_mu mu; |
|
||||||
/** are we currently resolving? */ |
|
||||||
int resolving; |
|
||||||
/** which version of resolved_config have we published? */ |
|
||||||
int published_version; |
|
||||||
/** which version of resolved_config is current? */ |
|
||||||
int resolved_version; |
|
||||||
/** pending next completion, or NULL */ |
|
||||||
grpc_closure *next_completion; |
|
||||||
/** target config address for next completion */ |
|
||||||
grpc_client_config **target_config; |
|
||||||
/** current (fully resolved) config */ |
|
||||||
grpc_client_config *resolved_config; |
|
||||||
|
|
||||||
/** zookeeper handle */ |
|
||||||
zhandle_t *zookeeper_handle; |
|
||||||
/** zookeeper resolved addresses */ |
|
||||||
grpc_resolved_addresses *resolved_addrs; |
|
||||||
/** total number of addresses to be resolved */ |
|
||||||
int resolved_total; |
|
||||||
/** number of addresses resolved */ |
|
||||||
int resolved_num; |
|
||||||
} zookeeper_resolver; |
|
||||||
|
|
||||||
static void zookeeper_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *r); |
|
||||||
|
|
||||||
static void zookeeper_start_resolving_locked(zookeeper_resolver *r); |
|
||||||
static void zookeeper_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx, |
|
||||||
zookeeper_resolver *r); |
|
||||||
|
|
||||||
static void zookeeper_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *r); |
|
||||||
static void zookeeper_channel_saw_error(grpc_exec_ctx *exec_ctx, |
|
||||||
grpc_resolver *r); |
|
||||||
static void zookeeper_next(grpc_exec_ctx *exec_ctx, grpc_resolver *r, |
|
||||||
grpc_client_config **target_config, |
|
||||||
grpc_closure *on_complete); |
|
||||||
|
|
||||||
static const grpc_resolver_vtable zookeeper_resolver_vtable = { |
|
||||||
zookeeper_destroy, zookeeper_shutdown, zookeeper_channel_saw_error, |
|
||||||
zookeeper_next}; |
|
||||||
|
|
||||||
static void zookeeper_shutdown(grpc_exec_ctx *exec_ctx, |
|
||||||
grpc_resolver *resolver) { |
|
||||||
zookeeper_resolver *r = (zookeeper_resolver *)resolver; |
|
||||||
grpc_closure *call = NULL; |
|
||||||
gpr_mu_lock(&r->mu); |
|
||||||
if (r->next_completion != NULL) { |
|
||||||
*r->target_config = NULL; |
|
||||||
call = r->next_completion; |
|
||||||
r->next_completion = NULL; |
|
||||||
} |
|
||||||
zookeeper_close(r->zookeeper_handle); |
|
||||||
gpr_mu_unlock(&r->mu); |
|
||||||
if (call != NULL) { |
|
||||||
call->cb(exec_ctx, call->cb_arg, 1); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_channel_saw_error(grpc_exec_ctx *exec_ctx, |
|
||||||
grpc_resolver *resolver) { |
|
||||||
zookeeper_resolver *r = (zookeeper_resolver *)resolver; |
|
||||||
gpr_mu_lock(&r->mu); |
|
||||||
if (r->resolving == 0) { |
|
||||||
zookeeper_start_resolving_locked(r); |
|
||||||
} |
|
||||||
gpr_mu_unlock(&r->mu); |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver, |
|
||||||
grpc_client_config **target_config, |
|
||||||
grpc_closure *on_complete) { |
|
||||||
zookeeper_resolver *r = (zookeeper_resolver *)resolver; |
|
||||||
gpr_mu_lock(&r->mu); |
|
||||||
GPR_ASSERT(r->next_completion == NULL); |
|
||||||
r->next_completion = on_complete; |
|
||||||
r->target_config = target_config; |
|
||||||
if (r->resolved_version == 0 && r->resolving == 0) { |
|
||||||
zookeeper_start_resolving_locked(r); |
|
||||||
} else { |
|
||||||
zookeeper_maybe_finish_next_locked(exec_ctx, r); |
|
||||||
} |
|
||||||
gpr_mu_unlock(&r->mu); |
|
||||||
} |
|
||||||
|
|
||||||
/** Zookeeper global watcher for connection management
|
|
||||||
TODO: better connection management besides logs */ |
|
||||||
static void zookeeper_global_watcher(zhandle_t *zookeeper_handle, int type, |
|
||||||
int state, const char *path, |
|
||||||
void *watcher_ctx) { |
|
||||||
if (type == ZOO_SESSION_EVENT) { |
|
||||||
if (state == ZOO_EXPIRED_SESSION_STATE) { |
|
||||||
gpr_log(GPR_ERROR, "Zookeeper session expired"); |
|
||||||
} else if (state == ZOO_AUTH_FAILED_STATE) { |
|
||||||
gpr_log(GPR_ERROR, "Zookeeper authentication failed"); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/** Zookeeper watcher triggered by changes to watched nodes
|
|
||||||
Once triggered, it tries to resolve again to get updated addresses */ |
|
||||||
static void zookeeper_watcher(zhandle_t *zookeeper_handle, int type, int state, |
|
||||||
const char *path, void *watcher_ctx) { |
|
||||||
if (watcher_ctx != NULL) { |
|
||||||
zookeeper_resolver *r = (zookeeper_resolver *)watcher_ctx; |
|
||||||
if (state == ZOO_CONNECTED_STATE) { |
|
||||||
gpr_mu_lock(&r->mu); |
|
||||||
if (r->resolving == 0) { |
|
||||||
zookeeper_start_resolving_locked(r); |
|
||||||
} |
|
||||||
gpr_mu_unlock(&r->mu); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/** Callback function after getting all resolved addresses
|
|
||||||
Creates a subchannel for each address */ |
|
||||||
static void zookeeper_on_resolved(grpc_exec_ctx *exec_ctx, void *arg, |
|
||||||
grpc_resolved_addresses *addresses) { |
|
||||||
zookeeper_resolver *r = arg; |
|
||||||
grpc_client_config *config = NULL; |
|
||||||
grpc_lb_policy *lb_policy; |
|
||||||
|
|
||||||
if (addresses != NULL) { |
|
||||||
grpc_lb_policy_args lb_policy_args; |
|
||||||
config = grpc_client_config_create(); |
|
||||||
lb_policy_args.addresses = addresses; |
|
||||||
lb_policy_args.client_channel_factory = r->client_channel_factory; |
|
||||||
lb_policy = |
|
||||||
grpc_lb_policy_create(exec_ctx, r->lb_policy_name, &lb_policy_args); |
|
||||||
|
|
||||||
if (lb_policy != NULL) { |
|
||||||
grpc_client_config_set_lb_policy(config, lb_policy); |
|
||||||
GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "construction"); |
|
||||||
} |
|
||||||
grpc_resolved_addresses_destroy(addresses); |
|
||||||
} |
|
||||||
gpr_mu_lock(&r->mu); |
|
||||||
GPR_ASSERT(r->resolving == 1); |
|
||||||
r->resolving = 0; |
|
||||||
if (r->resolved_config != NULL) { |
|
||||||
grpc_client_config_unref(exec_ctx, r->resolved_config); |
|
||||||
} |
|
||||||
r->resolved_config = config; |
|
||||||
r->resolved_version++; |
|
||||||
zookeeper_maybe_finish_next_locked(exec_ctx, r); |
|
||||||
gpr_mu_unlock(&r->mu); |
|
||||||
|
|
||||||
GRPC_RESOLVER_UNREF(exec_ctx, &r->base, "zookeeper-resolving"); |
|
||||||
} |
|
||||||
|
|
||||||
/** Callback function for each DNS resolved address */ |
|
||||||
static void zookeeper_dns_resolved(grpc_exec_ctx *exec_ctx, void *arg, |
|
||||||
grpc_resolved_addresses *addresses) { |
|
||||||
size_t i; |
|
||||||
zookeeper_resolver *r = arg; |
|
||||||
int resolve_done = 0; |
|
||||||
|
|
||||||
gpr_mu_lock(&r->mu); |
|
||||||
r->resolved_num++; |
|
||||||
r->resolved_addrs->addrs = |
|
||||||
gpr_realloc(r->resolved_addrs->addrs, |
|
||||||
sizeof(grpc_resolved_address) * |
|
||||||
(r->resolved_addrs->naddrs + addresses->naddrs)); |
|
||||||
for (i = 0; i < addresses->naddrs; i++) { |
|
||||||
memcpy(r->resolved_addrs->addrs[i + r->resolved_addrs->naddrs].addr, |
|
||||||
addresses->addrs[i].addr, addresses->addrs[i].len); |
|
||||||
r->resolved_addrs->addrs[i + r->resolved_addrs->naddrs].len = |
|
||||||
addresses->addrs[i].len; |
|
||||||
} |
|
||||||
|
|
||||||
r->resolved_addrs->naddrs += addresses->naddrs; |
|
||||||
grpc_resolved_addresses_destroy(addresses); |
|
||||||
|
|
||||||
/** Wait for all addresses to be resolved */ |
|
||||||
resolve_done = (r->resolved_num == r->resolved_total); |
|
||||||
gpr_mu_unlock(&r->mu); |
|
||||||
if (resolve_done) { |
|
||||||
zookeeper_on_resolved(exec_ctx, r, r->resolved_addrs); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/** Parses JSON format address of a zookeeper node */ |
|
||||||
static char *zookeeper_parse_address(const char *value, size_t value_len) { |
|
||||||
grpc_json *json; |
|
||||||
grpc_json *cur; |
|
||||||
const char *host; |
|
||||||
const char *port; |
|
||||||
char *buffer; |
|
||||||
char *address = NULL; |
|
||||||
|
|
||||||
buffer = gpr_malloc(value_len); |
|
||||||
memcpy(buffer, value, value_len); |
|
||||||
json = grpc_json_parse_string_with_len(buffer, value_len); |
|
||||||
if (json != NULL) { |
|
||||||
host = NULL; |
|
||||||
port = NULL; |
|
||||||
for (cur = json->child; cur != NULL; cur = cur->next) { |
|
||||||
if (!strcmp(cur->key, "host")) { |
|
||||||
host = cur->value; |
|
||||||
if (port != NULL) { |
|
||||||
break; |
|
||||||
} |
|
||||||
} else if (!strcmp(cur->key, "port")) { |
|
||||||
port = cur->value; |
|
||||||
if (host != NULL) { |
|
||||||
break; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
if (host != NULL && port != NULL) { |
|
||||||
gpr_asprintf(&address, "%s:%s", host, port); |
|
||||||
} |
|
||||||
grpc_json_destroy(json); |
|
||||||
} |
|
||||||
gpr_free(buffer); |
|
||||||
|
|
||||||
return address; |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_get_children_node_completion(int rc, const char *value, |
|
||||||
int value_len, |
|
||||||
const struct Stat *stat, |
|
||||||
const void *arg) { |
|
||||||
char *address = NULL; |
|
||||||
zookeeper_resolver *r = (zookeeper_resolver *)arg; |
|
||||||
int resolve_done = 0; |
|
||||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
|
||||||
|
|
||||||
if (rc != 0) { |
|
||||||
gpr_log(GPR_ERROR, "Error in getting a child node of %s", r->name); |
|
||||||
grpc_exec_ctx_finish(&exec_ctx); |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
address = zookeeper_parse_address(value, (size_t)value_len); |
|
||||||
if (address != NULL) { |
|
||||||
/** Further resolves address by DNS */ |
|
||||||
grpc_resolve_address(&exec_ctx, address, NULL, zookeeper_dns_resolved, r); |
|
||||||
gpr_free(address); |
|
||||||
} else { |
|
||||||
gpr_log(GPR_ERROR, "Error in resolving a child node of %s", r->name); |
|
||||||
gpr_mu_lock(&r->mu); |
|
||||||
r->resolved_total--; |
|
||||||
resolve_done = (r->resolved_num == r->resolved_total); |
|
||||||
gpr_mu_unlock(&r->mu); |
|
||||||
if (resolve_done) { |
|
||||||
zookeeper_on_resolved(&exec_ctx, r, r->resolved_addrs); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
grpc_exec_ctx_finish(&exec_ctx); |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_get_children_completion( |
|
||||||
int rc, const struct String_vector *children, const void *arg) { |
|
||||||
char *path; |
|
||||||
int status; |
|
||||||
int i; |
|
||||||
zookeeper_resolver *r = (zookeeper_resolver *)arg; |
|
||||||
|
|
||||||
if (rc != 0) { |
|
||||||
gpr_log(GPR_ERROR, "Error in getting zookeeper children of %s", r->name); |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
if (children->count == 0) { |
|
||||||
gpr_log(GPR_ERROR, "Error in resolving zookeeper address %s", r->name); |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
r->resolved_addrs = gpr_malloc(sizeof(grpc_resolved_addresses)); |
|
||||||
r->resolved_addrs->addrs = NULL; |
|
||||||
r->resolved_addrs->naddrs = 0; |
|
||||||
r->resolved_total = children->count; |
|
||||||
|
|
||||||
/** TODO: Replace expensive heap allocation with stack
|
|
||||||
if we can get maximum length of zookeeper path */ |
|
||||||
for (i = 0; i < children->count; i++) { |
|
||||||
gpr_asprintf(&path, "%s/%s", r->name, children->data[i]); |
|
||||||
status = zoo_awget(r->zookeeper_handle, path, zookeeper_watcher, r, |
|
||||||
zookeeper_get_children_node_completion, r); |
|
||||||
gpr_free(path); |
|
||||||
if (status != 0) { |
|
||||||
gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", path); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_get_node_completion(int rc, const char *value, |
|
||||||
int value_len, |
|
||||||
const struct Stat *stat, |
|
||||||
const void *arg) { |
|
||||||
int status; |
|
||||||
char *address = NULL; |
|
||||||
zookeeper_resolver *r = (zookeeper_resolver *)arg; |
|
||||||
r->resolved_addrs = NULL; |
|
||||||
r->resolved_total = 0; |
|
||||||
r->resolved_num = 0; |
|
||||||
|
|
||||||
if (rc != 0) { |
|
||||||
gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", r->name); |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
/** If zookeeper node of path r->name does not have address
|
|
||||||
(i.e. service node), get its children */ |
|
||||||
address = zookeeper_parse_address(value, (size_t)value_len); |
|
||||||
if (address != NULL) { |
|
||||||
r->resolved_addrs = gpr_malloc(sizeof(grpc_resolved_addresses)); |
|
||||||
r->resolved_addrs->addrs = NULL; |
|
||||||
r->resolved_addrs->naddrs = 0; |
|
||||||
r->resolved_total = 1; |
|
||||||
/** Further resolves address by DNS */ |
|
||||||
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; |
|
||||||
grpc_resolve_address(&exec_ctx, address, NULL, zookeeper_dns_resolved, r); |
|
||||||
gpr_free(address); |
|
||||||
grpc_exec_ctx_finish(&exec_ctx); |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
status = zoo_awget_children(r->zookeeper_handle, r->name, zookeeper_watcher, |
|
||||||
r, zookeeper_get_children_completion, r); |
|
||||||
if (status != 0) { |
|
||||||
gpr_log(GPR_ERROR, "Error in getting zookeeper children of %s", r->name); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_resolve_address(zookeeper_resolver *r) { |
|
||||||
int status; |
|
||||||
status = zoo_awget(r->zookeeper_handle, r->name, zookeeper_watcher, r, |
|
||||||
zookeeper_get_node_completion, r); |
|
||||||
if (status != 0) { |
|
||||||
gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", r->name); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_start_resolving_locked(zookeeper_resolver *r) { |
|
||||||
GRPC_RESOLVER_REF(&r->base, "zookeeper-resolving"); |
|
||||||
GPR_ASSERT(r->resolving == 0); |
|
||||||
r->resolving = 1; |
|
||||||
zookeeper_resolve_address(r); |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx, |
|
||||||
zookeeper_resolver *r) { |
|
||||||
if (r->next_completion != NULL && |
|
||||||
r->resolved_version != r->published_version) { |
|
||||||
*r->target_config = r->resolved_config; |
|
||||||
if (r->resolved_config != NULL) { |
|
||||||
grpc_client_config_ref(r->resolved_config); |
|
||||||
} |
|
||||||
grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, true, NULL); |
|
||||||
r->next_completion = NULL; |
|
||||||
r->published_version = r->resolved_version; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *gr) { |
|
||||||
zookeeper_resolver *r = (zookeeper_resolver *)gr; |
|
||||||
gpr_mu_destroy(&r->mu); |
|
||||||
if (r->resolved_config != NULL) { |
|
||||||
grpc_client_config_unref(exec_ctx, r->resolved_config); |
|
||||||
} |
|
||||||
grpc_client_channel_factory_unref(exec_ctx, r->client_channel_factory); |
|
||||||
gpr_free(r->name); |
|
||||||
gpr_free(r->lb_policy_name); |
|
||||||
gpr_free(r); |
|
||||||
} |
|
||||||
|
|
||||||
static grpc_resolver *zookeeper_create(grpc_resolver_args *args, |
|
||||||
const char *lb_policy_name) { |
|
||||||
zookeeper_resolver *r; |
|
||||||
size_t length; |
|
||||||
char *path = args->uri->path; |
|
||||||
|
|
||||||
if (0 == strcmp(args->uri->authority, "")) { |
|
||||||
gpr_log(GPR_ERROR, "No authority specified in zookeeper uri"); |
|
||||||
return NULL; |
|
||||||
} |
|
||||||
|
|
||||||
/** Removes the trailing slash if exists */ |
|
||||||
length = strlen(path); |
|
||||||
if (length > 1 && path[length - 1] == '/') { |
|
||||||
path[length - 1] = 0; |
|
||||||
} |
|
||||||
|
|
||||||
r = gpr_malloc(sizeof(zookeeper_resolver)); |
|
||||||
memset(r, 0, sizeof(*r)); |
|
||||||
gpr_ref_init(&r->refs, 1); |
|
||||||
gpr_mu_init(&r->mu); |
|
||||||
grpc_resolver_init(&r->base, &zookeeper_resolver_vtable); |
|
||||||
r->name = gpr_strdup(path); |
|
||||||
|
|
||||||
r->client_channel_factory = args->client_channel_factory; |
|
||||||
grpc_client_channel_factory_ref(r->client_channel_factory); |
|
||||||
|
|
||||||
r->lb_policy_name = gpr_strdup(lb_policy_name); |
|
||||||
|
|
||||||
/** Initializes zookeeper client */ |
|
||||||
zoo_set_debug_level(ZOO_LOG_LEVEL_WARN); |
|
||||||
r->zookeeper_handle = |
|
||||||
zookeeper_init(args->uri->authority, zookeeper_global_watcher, |
|
||||||
GRPC_ZOOKEEPER_SESSION_TIMEOUT, 0, 0, 0); |
|
||||||
if (r->zookeeper_handle == NULL) { |
|
||||||
gpr_log(GPR_ERROR, "Unable to connect to zookeeper server"); |
|
||||||
return NULL; |
|
||||||
} |
|
||||||
|
|
||||||
return &r->base; |
|
||||||
} |
|
||||||
|
|
||||||
/*
|
|
||||||
* FACTORY |
|
||||||
*/ |
|
||||||
|
|
||||||
static void zookeeper_factory_ref(grpc_resolver_factory *factory) {} |
|
||||||
|
|
||||||
static void zookeeper_factory_unref(grpc_resolver_factory *factory) {} |
|
||||||
|
|
||||||
static char *zookeeper_factory_get_default_hostname( |
|
||||||
grpc_resolver_factory *factory, grpc_uri *uri) { |
|
||||||
return NULL; |
|
||||||
} |
|
||||||
|
|
||||||
static grpc_resolver *zookeeper_factory_create_resolver( |
|
||||||
grpc_resolver_factory *factory, grpc_resolver_args *args) { |
|
||||||
return zookeeper_create(args, "pick_first"); |
|
||||||
} |
|
||||||
|
|
||||||
static const grpc_resolver_factory_vtable zookeeper_factory_vtable = { |
|
||||||
zookeeper_factory_ref, zookeeper_factory_unref, |
|
||||||
zookeeper_factory_create_resolver, zookeeper_factory_get_default_hostname, |
|
||||||
"zookeeper"}; |
|
||||||
|
|
||||||
static grpc_resolver_factory zookeeper_resolver_factory = { |
|
||||||
&zookeeper_factory_vtable}; |
|
||||||
|
|
||||||
static grpc_resolver_factory *zookeeper_resolver_factory_create() { |
|
||||||
return &zookeeper_resolver_factory; |
|
||||||
} |
|
||||||
|
|
||||||
static void zookeeper_plugin_init() { |
|
||||||
grpc_register_resolver_type(zookeeper_resolver_factory_create()); |
|
||||||
} |
|
||||||
|
|
||||||
void grpc_zookeeper_register() { |
|
||||||
GRPC_API_TRACE("grpc_zookeeper_register(void)", 0, ()); |
|
||||||
grpc_register_plugin(zookeeper_plugin_init, NULL); |
|
||||||
} |
|
||||||
@ -0,0 +1,232 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2016, Google Inc. |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are |
||||||
|
* met: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above |
||||||
|
* copyright notice, this list of conditions and the following disclaimer |
||||||
|
* in the documentation and/or other materials provided with the |
||||||
|
* distribution. |
||||||
|
* * Neither the name of Google Inc. nor the names of its |
||||||
|
* contributors may be used to endorse or promote products derived from |
||||||
|
* this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "src/core/ext/transport/chttp2/transport/bin_decoder.h" |
||||||
|
#include <grpc/support/alloc.h> |
||||||
|
#include <grpc/support/log.h> |
||||||
|
#include "src/core/lib/support/string.h" |
||||||
|
|
||||||
|
static uint8_t decode_table[] = { |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 62, 0x40, 0x40, 0x40, 63, |
||||||
|
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0, 1, 2, 3, 4, 5, 6, |
||||||
|
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, |
||||||
|
19, 20, 21, 22, 23, 24, 25, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, |
||||||
|
37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, |
||||||
|
49, 50, 51, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
||||||
|
0x40, 0x40, 0x40, 0x40}; |
||||||
|
|
||||||
|
static const uint8_t tail_xtra[4] = {0, 0, 1, 2}; |
||||||
|
|
||||||
|
static bool input_is_valid(uint8_t *input_ptr, size_t length) { |
||||||
|
size_t i; |
||||||
|
|
||||||
|
for (i = 0; i < length; ++i) { |
||||||
|
if ((decode_table[input_ptr[i]] & 0xC0) != 0) { |
||||||
|
gpr_log(GPR_ERROR, |
||||||
|
"Base64 decoding failed, invalid character '%c' in base64 " |
||||||
|
"input.\n", |
||||||
|
(char)(*input_ptr)); |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
#define COMPOSE_OUTPUT_BYTE_0(input_ptr) \ |
||||||
|
(uint8_t)((decode_table[input_ptr[0]] << 2) | \
|
||||||
|
(decode_table[input_ptr[1]] >> 4)) |
||||||
|
|
||||||
|
#define COMPOSE_OUTPUT_BYTE_1(input_ptr) \ |
||||||
|
(uint8_t)((decode_table[input_ptr[1]] << 4) | \
|
||||||
|
(decode_table[input_ptr[2]] >> 2)) |
||||||
|
|
||||||
|
#define COMPOSE_OUTPUT_BYTE_2(input_ptr) \ |
||||||
|
(uint8_t)((decode_table[input_ptr[2]] << 6) | decode_table[input_ptr[3]]) |
||||||
|
|
||||||
|
bool grpc_base64_decode_partial(struct grpc_base64_decode_context *ctx) { |
||||||
|
size_t input_tail; |
||||||
|
|
||||||
|
if (ctx->input_cur > ctx->input_end || ctx->output_cur > ctx->output_end) { |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
// Process a block of 4 input characters and 3 output bytes
|
||||||
|
while (ctx->input_end >= ctx->input_cur + 4 && |
||||||
|
ctx->output_end >= ctx->output_cur + 3) { |
||||||
|
if (!input_is_valid(ctx->input_cur, 4)) return false; |
||||||
|
ctx->output_cur[0] = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur); |
||||||
|
ctx->output_cur[1] = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur); |
||||||
|
ctx->output_cur[2] = COMPOSE_OUTPUT_BYTE_2(ctx->input_cur); |
||||||
|
ctx->output_cur += 3; |
||||||
|
ctx->input_cur += 4; |
||||||
|
} |
||||||
|
|
||||||
|
// Process the tail of input data
|
||||||
|
input_tail = (size_t)(ctx->input_end - ctx->input_cur); |
||||||
|
if (input_tail == 4) { |
||||||
|
// Process the input data with pad chars
|
||||||
|
if (ctx->input_cur[3] == '=') { |
||||||
|
if (ctx->input_cur[2] == '=' && ctx->output_end >= ctx->output_cur + 1) { |
||||||
|
if (!input_is_valid(ctx->input_cur, 2)) return false; |
||||||
|
*(ctx->output_cur++) = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur); |
||||||
|
ctx->input_cur += 4; |
||||||
|
} else if (ctx->output_end >= ctx->output_cur + 2) { |
||||||
|
if (!input_is_valid(ctx->input_cur, 3)) return false; |
||||||
|
*(ctx->output_cur++) = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur); |
||||||
|
*(ctx->output_cur++) = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur); |
||||||
|
; |
||||||
|
ctx->input_cur += 4; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
} else if (ctx->contains_tail && input_tail > 1) { |
||||||
|
// Process the input data without pad chars, but constains_tail is set
|
||||||
|
if (ctx->output_end >= ctx->output_cur + tail_xtra[input_tail]) { |
||||||
|
if (!input_is_valid(ctx->input_cur, input_tail)) return false; |
||||||
|
switch (input_tail) { |
||||||
|
case 3: |
||||||
|
ctx->output_cur[1] = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur); |
||||||
|
case 2: |
||||||
|
ctx->output_cur[0] = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur); |
||||||
|
} |
||||||
|
ctx->output_cur += tail_xtra[input_tail]; |
||||||
|
ctx->input_cur += input_tail; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
gpr_slice grpc_chttp2_base64_decode(gpr_slice input) { |
||||||
|
size_t input_length = GPR_SLICE_LENGTH(input); |
||||||
|
size_t output_length = input_length / 4 * 3; |
||||||
|
struct grpc_base64_decode_context ctx; |
||||||
|
gpr_slice output; |
||||||
|
|
||||||
|
if (input_length % 4 != 0) { |
||||||
|
gpr_log(GPR_ERROR, |
||||||
|
"Base64 decoding failed, input of " |
||||||
|
"grpc_chttp2_base64_decode has a length of %d, which is not a " |
||||||
|
"multiple of 4.\n", |
||||||
|
(int)input_length); |
||||||
|
return gpr_empty_slice(); |
||||||
|
} |
||||||
|
|
||||||
|
if (input_length > 0) { |
||||||
|
uint8_t *input_end = GPR_SLICE_END_PTR(input); |
||||||
|
if (*(--input_end) == '=') { |
||||||
|
output_length--; |
||||||
|
if (*(--input_end) == '=') { |
||||||
|
output_length--; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
output = gpr_slice_malloc(output_length); |
||||||
|
|
||||||
|
ctx.input_cur = GPR_SLICE_START_PTR(input); |
||||||
|
ctx.input_end = GPR_SLICE_END_PTR(input); |
||||||
|
ctx.output_cur = GPR_SLICE_START_PTR(output); |
||||||
|
ctx.output_end = GPR_SLICE_END_PTR(output); |
||||||
|
ctx.contains_tail = false; |
||||||
|
|
||||||
|
if (!grpc_base64_decode_partial(&ctx)) { |
||||||
|
char *s = gpr_dump_slice(input, GPR_DUMP_ASCII); |
||||||
|
gpr_log(GPR_ERROR, "Base64 decoding failed, input string:\n%s\n", s); |
||||||
|
gpr_free(s); |
||||||
|
gpr_slice_unref(output); |
||||||
|
return gpr_empty_slice(); |
||||||
|
} |
||||||
|
GPR_ASSERT(ctx.output_cur == GPR_SLICE_END_PTR(output)); |
||||||
|
GPR_ASSERT(ctx.input_cur == GPR_SLICE_END_PTR(input)); |
||||||
|
return output; |
||||||
|
} |
||||||
|
|
||||||
|
gpr_slice grpc_chttp2_base64_decode_with_length(gpr_slice input, |
||||||
|
size_t output_length) { |
||||||
|
size_t input_length = GPR_SLICE_LENGTH(input); |
||||||
|
gpr_slice output = gpr_slice_malloc(output_length); |
||||||
|
struct grpc_base64_decode_context ctx; |
||||||
|
|
||||||
|
// The length of a base64 string cannot be 4 * n + 1
|
||||||
|
if (input_length % 4 == 1) { |
||||||
|
gpr_log(GPR_ERROR, |
||||||
|
"Base64 decoding failed, input of " |
||||||
|
"grpc_chttp2_base64_decode_with_length has a length of %d, which " |
||||||
|
"has a tail of 1 byte.\n", |
||||||
|
(int)input_length); |
||||||
|
gpr_slice_unref(output); |
||||||
|
return gpr_empty_slice(); |
||||||
|
} |
||||||
|
|
||||||
|
if (output_length > input_length / 4 * 3 + tail_xtra[input_length % 4]) { |
||||||
|
gpr_log(GPR_ERROR, |
||||||
|
"Base64 decoding failed, output_length %d is longer " |
||||||
|
"than the max possible output length %d.\n", |
||||||
|
(int)output_length, |
||||||
|
(int)(input_length / 4 * 3 + tail_xtra[input_length % 4])); |
||||||
|
gpr_slice_unref(output); |
||||||
|
return gpr_empty_slice(); |
||||||
|
} |
||||||
|
|
||||||
|
ctx.input_cur = GPR_SLICE_START_PTR(input); |
||||||
|
ctx.input_end = GPR_SLICE_END_PTR(input); |
||||||
|
ctx.output_cur = GPR_SLICE_START_PTR(output); |
||||||
|
ctx.output_end = GPR_SLICE_END_PTR(output); |
||||||
|
ctx.contains_tail = true; |
||||||
|
|
||||||
|
if (!grpc_base64_decode_partial(&ctx)) { |
||||||
|
char *s = gpr_dump_slice(input, GPR_DUMP_ASCII); |
||||||
|
gpr_log(GPR_ERROR, "Base64 decoding failed, input string:\n%s\n", s); |
||||||
|
gpr_free(s); |
||||||
|
gpr_slice_unref(output); |
||||||
|
return gpr_empty_slice(); |
||||||
|
} |
||||||
|
GPR_ASSERT(ctx.output_cur == GPR_SLICE_END_PTR(output)); |
||||||
|
GPR_ASSERT(ctx.input_cur <= GPR_SLICE_END_PTR(input)); |
||||||
|
return output; |
||||||
|
} |
||||||
@ -0,0 +1,66 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2016, Google Inc. |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are |
||||||
|
* met: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above |
||||||
|
* copyright notice, this list of conditions and the following disclaimer |
||||||
|
* in the documentation and/or other materials provided with the |
||||||
|
* distribution. |
||||||
|
* * Neither the name of Google Inc. nor the names of its |
||||||
|
* contributors may be used to endorse or promote products derived from |
||||||
|
* this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_DECODER_H |
||||||
|
#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_DECODER_H |
||||||
|
|
||||||
|
#include <grpc/support/slice.h> |
||||||
|
#include <stdbool.h> |
||||||
|
|
||||||
|
struct grpc_base64_decode_context { |
||||||
|
/* input/output: */ |
||||||
|
uint8_t *input_cur; |
||||||
|
uint8_t *input_end; |
||||||
|
uint8_t *output_cur; |
||||||
|
uint8_t *output_end; |
||||||
|
/* Indicate if the decoder should handle the tail of input data*/ |
||||||
|
bool contains_tail; |
||||||
|
}; |
||||||
|
|
||||||
|
/* base64 decode a grpc_base64_decode_context util either input_end is reached
|
||||||
|
or output_end is reached. When input_end is reached, (input_end - input_cur) |
||||||
|
is less than 4. When output_end is reached, (output_end - output_cur) is less |
||||||
|
than 3. Returns false if decoding is failed. */ |
||||||
|
bool grpc_base64_decode_partial(struct grpc_base64_decode_context *ctx); |
||||||
|
|
||||||
|
/* base64 decode a slice with pad chars. Returns a new slice, does not take
|
||||||
|
ownership of the input. Returns an empty slice if decoding is failed. */ |
||||||
|
gpr_slice grpc_chttp2_base64_decode(gpr_slice input); |
||||||
|
|
||||||
|
/* base64 decode a slice without pad chars, data length is needed. Returns a new
|
||||||
|
slice, does not take ownership of the input. Returns an empty slice if |
||||||
|
decoding is failed. */ |
||||||
|
gpr_slice grpc_chttp2_base64_decode_with_length(gpr_slice input, |
||||||
|
size_t output_length); |
||||||
|
|
||||||
|
#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_DECODER_H */ |
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,357 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2015, Google Inc. |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are |
||||||
|
* met: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above |
||||||
|
* copyright notice, this list of conditions and the following disclaimer |
||||||
|
* in the documentation and/or other materials provided with the |
||||||
|
* distribution. |
||||||
|
* * Neither the name of Google Inc. nor the names of its |
||||||
|
* contributors may be used to endorse or promote products derived from |
||||||
|
* this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "src/core/lib/http/parser.h" |
||||||
|
|
||||||
|
#include <string.h> |
||||||
|
|
||||||
|
#include <grpc/support/alloc.h> |
||||||
|
#include <grpc/support/log.h> |
||||||
|
#include <grpc/support/useful.h> |
||||||
|
|
||||||
|
int grpc_http1_trace = 0; |
||||||
|
|
||||||
|
static char *buf2str(void *buffer, size_t length) { |
||||||
|
char *out = gpr_malloc(length + 1); |
||||||
|
memcpy(out, buffer, length); |
||||||
|
out[length] = 0; |
||||||
|
return out; |
||||||
|
} |
||||||
|
|
||||||
|
static grpc_error *handle_response_line(grpc_http_parser *parser) { |
||||||
|
uint8_t *beg = parser->cur_line; |
||||||
|
uint8_t *cur = beg; |
||||||
|
uint8_t *end = beg + parser->cur_line_length; |
||||||
|
|
||||||
|
if (cur == end || *cur++ != 'H') return GRPC_ERROR_CREATE("Expected 'H'"); |
||||||
|
if (cur == end || *cur++ != 'T') return GRPC_ERROR_CREATE("Expected 'T'"); |
||||||
|
if (cur == end || *cur++ != 'T') return GRPC_ERROR_CREATE("Expected 'T'"); |
||||||
|
if (cur == end || *cur++ != 'P') return GRPC_ERROR_CREATE("Expected 'P'"); |
||||||
|
if (cur == end || *cur++ != '/') return GRPC_ERROR_CREATE("Expected '/'"); |
||||||
|
if (cur == end || *cur++ != '1') return GRPC_ERROR_CREATE("Expected '1'"); |
||||||
|
if (cur == end || *cur++ != '.') return GRPC_ERROR_CREATE("Expected '.'"); |
||||||
|
if (cur == end || *cur < '0' || *cur++ > '1') { |
||||||
|
return GRPC_ERROR_CREATE("Expected HTTP/1.0 or HTTP/1.1"); |
||||||
|
} |
||||||
|
if (cur == end || *cur++ != ' ') return GRPC_ERROR_CREATE("Expected ' '"); |
||||||
|
if (cur == end || *cur < '1' || *cur++ > '9') |
||||||
|
return GRPC_ERROR_CREATE("Expected status code"); |
||||||
|
if (cur == end || *cur < '0' || *cur++ > '9') |
||||||
|
return GRPC_ERROR_CREATE("Expected status code"); |
||||||
|
if (cur == end || *cur < '0' || *cur++ > '9') |
||||||
|
return GRPC_ERROR_CREATE("Expected status code"); |
||||||
|
parser->http.response->status = |
||||||
|
(cur[-3] - '0') * 100 + (cur[-2] - '0') * 10 + (cur[-1] - '0'); |
||||||
|
if (cur == end || *cur++ != ' ') return GRPC_ERROR_CREATE("Expected ' '"); |
||||||
|
|
||||||
|
/* we don't really care about the status code message */ |
||||||
|
|
||||||
|
return GRPC_ERROR_NONE; |
||||||
|
} |
||||||
|
|
||||||
|
static grpc_error *handle_request_line(grpc_http_parser *parser) { |
||||||
|
uint8_t *beg = parser->cur_line; |
||||||
|
uint8_t *cur = beg; |
||||||
|
uint8_t *end = beg + parser->cur_line_length; |
||||||
|
uint8_t vers_major = 0; |
||||||
|
uint8_t vers_minor = 0; |
||||||
|
|
||||||
|
while (cur != end && *cur++ != ' ') |
||||||
|
; |
||||||
|
if (cur == end) return GRPC_ERROR_CREATE("No method on HTTP request line"); |
||||||
|
parser->http.request->method = buf2str(beg, (size_t)(cur - beg - 1)); |
||||||
|
|
||||||
|
beg = cur; |
||||||
|
while (cur != end && *cur++ != ' ') |
||||||
|
; |
||||||
|
if (cur == end) return GRPC_ERROR_CREATE("No path on HTTP request line"); |
||||||
|
parser->http.request->path = buf2str(beg, (size_t)(cur - beg - 1)); |
||||||
|
|
||||||
|
if (cur == end || *cur++ != 'H') return GRPC_ERROR_CREATE("Expected 'H'"); |
||||||
|
if (cur == end || *cur++ != 'T') return GRPC_ERROR_CREATE("Expected 'T'"); |
||||||
|
if (cur == end || *cur++ != 'T') return GRPC_ERROR_CREATE("Expected 'T'"); |
||||||
|
if (cur == end || *cur++ != 'P') return GRPC_ERROR_CREATE("Expected 'P'"); |
||||||
|
if (cur == end || *cur++ != '/') return GRPC_ERROR_CREATE("Expected '/'"); |
||||||
|
vers_major = (uint8_t)(*cur++ - '1' + 1); |
||||||
|
++cur; |
||||||
|
if (cur == end) |
||||||
|
return GRPC_ERROR_CREATE("End of line in HTTP version string"); |
||||||
|
vers_minor = (uint8_t)(*cur++ - '1' + 1); |
||||||
|
|
||||||
|
if (vers_major == 1) { |
||||||
|
if (vers_minor == 0) { |
||||||
|
parser->http.request->version = GRPC_HTTP_HTTP10; |
||||||
|
} else if (vers_minor == 1) { |
||||||
|
parser->http.request->version = GRPC_HTTP_HTTP11; |
||||||
|
} else { |
||||||
|
return GRPC_ERROR_CREATE( |
||||||
|
"Expected one of HTTP/1.0, HTTP/1.1, or HTTP/2.0"); |
||||||
|
} |
||||||
|
} else if (vers_major == 2) { |
||||||
|
if (vers_minor == 0) { |
||||||
|
parser->http.request->version = GRPC_HTTP_HTTP20; |
||||||
|
} else { |
||||||
|
return GRPC_ERROR_CREATE( |
||||||
|
"Expected one of HTTP/1.0, HTTP/1.1, or HTTP/2.0"); |
||||||
|
} |
||||||
|
} else { |
||||||
|
return GRPC_ERROR_CREATE("Expected one of HTTP/1.0, HTTP/1.1, or HTTP/2.0"); |
||||||
|
} |
||||||
|
|
||||||
|
return GRPC_ERROR_NONE; |
||||||
|
} |
||||||
|
|
||||||
|
static grpc_error *handle_first_line(grpc_http_parser *parser) { |
||||||
|
switch (parser->type) { |
||||||
|
case GRPC_HTTP_REQUEST: |
||||||
|
return handle_request_line(parser); |
||||||
|
case GRPC_HTTP_RESPONSE: |
||||||
|
return handle_response_line(parser); |
||||||
|
} |
||||||
|
GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE("Should never reach here")); |
||||||
|
} |
||||||
|
|
||||||
|
static grpc_error *add_header(grpc_http_parser *parser) { |
||||||
|
uint8_t *beg = parser->cur_line; |
||||||
|
uint8_t *cur = beg; |
||||||
|
uint8_t *end = beg + parser->cur_line_length; |
||||||
|
size_t *hdr_count = NULL; |
||||||
|
grpc_http_header **hdrs = NULL; |
||||||
|
grpc_http_header hdr = {NULL, NULL}; |
||||||
|
grpc_error *error = GRPC_ERROR_NONE; |
||||||
|
|
||||||
|
GPR_ASSERT(cur != end); |
||||||
|
|
||||||
|
if (*cur == ' ' || *cur == '\t') { |
||||||
|
error = GRPC_ERROR_CREATE("Continued header lines not supported yet"); |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
while (cur != end && *cur != ':') { |
||||||
|
cur++; |
||||||
|
} |
||||||
|
if (cur == end) { |
||||||
|
<<<<<<< HEAD |
||||||
|
error = GRPC_ERROR_CREATE("Didn't find ':' in header string"); |
||||||
|
goto done; |
||||||
|
======= |
||||||
|
if (grpc_http1_trace) { |
||||||
|
gpr_log(GPR_ERROR, "Didn't find ':' in header string"); |
||||||
|
} |
||||||
|
goto error; |
||||||
|
>>>>>>> a709afe241d8b264a1c326315f757b4a8d330207 |
||||||
|
} |
||||||
|
GPR_ASSERT(cur >= beg); |
||||||
|
hdr.key = buf2str(beg, (size_t)(cur - beg)); |
||||||
|
cur++; /* skip : */ |
||||||
|
|
||||||
|
while (cur != end && (*cur == ' ' || *cur == '\t')) { |
||||||
|
cur++; |
||||||
|
} |
||||||
|
GPR_ASSERT((size_t)(end - cur) >= parser->cur_line_end_length); |
||||||
|
hdr.value = buf2str(cur, (size_t)(end - cur) - parser->cur_line_end_length); |
||||||
|
|
||||||
|
switch (parser->type) { |
||||||
|
case GRPC_HTTP_RESPONSE: |
||||||
|
hdr_count = &parser->http.response->hdr_count; |
||||||
|
hdrs = &parser->http.response->hdrs; |
||||||
|
break; |
||||||
|
case GRPC_HTTP_REQUEST: |
||||||
|
hdr_count = &parser->http.request->hdr_count; |
||||||
|
hdrs = &parser->http.request->hdrs; |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
if (*hdr_count == parser->hdr_capacity) { |
||||||
|
parser->hdr_capacity = |
||||||
|
GPR_MAX(parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2); |
||||||
|
*hdrs = gpr_realloc(*hdrs, parser->hdr_capacity * sizeof(**hdrs)); |
||||||
|
} |
||||||
|
(*hdrs)[(*hdr_count)++] = hdr; |
||||||
|
|
||||||
|
done: |
||||||
|
if (error != GRPC_ERROR_NONE) { |
||||||
|
gpr_free(hdr.key); |
||||||
|
gpr_free(hdr.value); |
||||||
|
} |
||||||
|
return error; |
||||||
|
} |
||||||
|
|
||||||
|
static grpc_error *finish_line(grpc_http_parser *parser) { |
||||||
|
grpc_error *err; |
||||||
|
switch (parser->state) { |
||||||
|
case GRPC_HTTP_FIRST_LINE: |
||||||
|
err = handle_first_line(parser); |
||||||
|
if (err != GRPC_ERROR_NONE) return err; |
||||||
|
parser->state = GRPC_HTTP_HEADERS; |
||||||
|
break; |
||||||
|
case GRPC_HTTP_HEADERS: |
||||||
|
if (parser->cur_line_length == parser->cur_line_end_length) { |
||||||
|
parser->state = GRPC_HTTP_BODY; |
||||||
|
break; |
||||||
|
} |
||||||
|
err = add_header(parser); |
||||||
|
if (err != GRPC_ERROR_NONE) { |
||||||
|
return err; |
||||||
|
} |
||||||
|
break; |
||||||
|
case GRPC_HTTP_BODY: |
||||||
|
GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE("Should never reach here")); |
||||||
|
} |
||||||
|
|
||||||
|
parser->cur_line_length = 0; |
||||||
|
return GRPC_ERROR_NONE; |
||||||
|
} |
||||||
|
|
||||||
|
static grpc_error *addbyte_body(grpc_http_parser *parser, uint8_t byte) { |
||||||
|
size_t *body_length = NULL; |
||||||
|
char **body = NULL; |
||||||
|
|
||||||
|
if (parser->type == GRPC_HTTP_RESPONSE) { |
||||||
|
body_length = &parser->http.response->body_length; |
||||||
|
body = &parser->http.response->body; |
||||||
|
} else if (parser->type == GRPC_HTTP_REQUEST) { |
||||||
|
body_length = &parser->http.request->body_length; |
||||||
|
body = &parser->http.request->body; |
||||||
|
} else { |
||||||
|
GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE("Should never reach here")); |
||||||
|
} |
||||||
|
|
||||||
|
if (*body_length == parser->body_capacity) { |
||||||
|
parser->body_capacity = GPR_MAX(8, parser->body_capacity * 3 / 2); |
||||||
|
*body = gpr_realloc((void *)*body, parser->body_capacity); |
||||||
|
} |
||||||
|
(*body)[*body_length] = (char)byte; |
||||||
|
(*body_length)++; |
||||||
|
|
||||||
|
return GRPC_ERROR_NONE; |
||||||
|
} |
||||||
|
|
||||||
|
static bool check_line(grpc_http_parser *parser) { |
||||||
|
if (parser->cur_line_length >= 2 && |
||||||
|
parser->cur_line[parser->cur_line_length - 2] == '\r' && |
||||||
|
parser->cur_line[parser->cur_line_length - 1] == '\n') { |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
// HTTP request with \n\r line termiantors.
|
||||||
|
else if (parser->cur_line_length >= 2 && |
||||||
|
parser->cur_line[parser->cur_line_length - 2] == '\n' && |
||||||
|
parser->cur_line[parser->cur_line_length - 1] == '\r') { |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
// HTTP request with only \n line terminators.
|
||||||
|
else if (parser->cur_line_length >= 1 && |
||||||
|
parser->cur_line[parser->cur_line_length - 1] == '\n') { |
||||||
|
parser->cur_line_end_length = 1; |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
static grpc_error *addbyte(grpc_http_parser *parser, uint8_t byte) { |
||||||
|
switch (parser->state) { |
||||||
|
case GRPC_HTTP_FIRST_LINE: |
||||||
|
case GRPC_HTTP_HEADERS: |
||||||
|
if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) { |
||||||
|
if (grpc_http1_trace) |
||||||
|
gpr_log(GPR_ERROR, "HTTP client max line length (%d) exceeded", |
||||||
|
GRPC_HTTP_PARSER_MAX_HEADER_LENGTH); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
parser->cur_line[parser->cur_line_length] = byte; |
||||||
|
parser->cur_line_length++; |
||||||
|
if (check_line(parser)) { |
||||||
|
return finish_line(parser); |
||||||
|
} else { |
||||||
|
return GRPC_ERROR_NONE; |
||||||
|
} |
||||||
|
GPR_UNREACHABLE_CODE(return 0); |
||||||
|
case GRPC_HTTP_BODY: |
||||||
|
return addbyte_body(parser, byte); |
||||||
|
} |
||||||
|
GPR_UNREACHABLE_CODE(return 0); |
||||||
|
} |
||||||
|
|
||||||
|
void grpc_http_parser_init(grpc_http_parser *parser, grpc_http_type type, |
||||||
|
void *request_or_response) { |
||||||
|
memset(parser, 0, sizeof(*parser)); |
||||||
|
parser->state = GRPC_HTTP_FIRST_LINE; |
||||||
|
parser->type = type; |
||||||
|
parser->http.request_or_response = request_or_response; |
||||||
|
parser->cur_line_end_length = 2; |
||||||
|
} |
||||||
|
|
||||||
|
void grpc_http_parser_destroy(grpc_http_parser *parser) {} |
||||||
|
|
||||||
|
void grpc_http_request_destroy(grpc_http_request *request) { |
||||||
|
size_t i; |
||||||
|
gpr_free(request->body); |
||||||
|
for (i = 0; i < request->hdr_count; i++) { |
||||||
|
gpr_free(request->hdrs[i].key); |
||||||
|
gpr_free(request->hdrs[i].value); |
||||||
|
} |
||||||
|
gpr_free(request->hdrs); |
||||||
|
gpr_free(request->method); |
||||||
|
gpr_free(request->path); |
||||||
|
} |
||||||
|
|
||||||
|
void grpc_http_response_destroy(grpc_http_response *response) { |
||||||
|
size_t i; |
||||||
|
gpr_free(response->body); |
||||||
|
for (i = 0; i < response->hdr_count; i++) { |
||||||
|
gpr_free(response->hdrs[i].key); |
||||||
|
gpr_free(response->hdrs[i].value); |
||||||
|
} |
||||||
|
gpr_free(response->hdrs); |
||||||
|
} |
||||||
|
|
||||||
|
grpc_error *grpc_http_parser_parse(grpc_http_parser *parser, gpr_slice slice) { |
||||||
|
size_t i; |
||||||
|
|
||||||
|
for (i = 0; i < GPR_SLICE_LENGTH(slice); i++) { |
||||||
|
grpc_error *err = addbyte(parser, GPR_SLICE_START_PTR(slice)[i]); |
||||||
|
if (err != GRPC_ERROR_NONE) return err; |
||||||
|
} |
||||||
|
|
||||||
|
return GRPC_ERROR_NONE; |
||||||
|
} |
||||||
|
|
||||||
|
grpc_error *grpc_http_parser_eof(grpc_http_parser *parser) { |
||||||
|
if (parser->state != GRPC_HTTP_BODY) { |
||||||
|
return GRPC_ERROR_CREATE("Did not finish headers"); |
||||||
|
} |
||||||
|
return GRPC_ERROR_NONE; |
||||||
|
} |
||||||
@ -0,0 +1,535 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2016, Google Inc. |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are |
||||||
|
* met: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above |
||||||
|
* copyright notice, this list of conditions and the following disclaimer |
||||||
|
* in the documentation and/or other materials provided with the |
||||||
|
* distribution. |
||||||
|
* * Neither the name of Google Inc. nor the names of its |
||||||
|
* contributors may be used to endorse or promote products derived from |
||||||
|
* this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "src/core/lib/iomgr/error.h" |
||||||
|
|
||||||
|
#include <inttypes.h> |
||||||
|
#include <stdbool.h> |
||||||
|
#include <string.h> |
||||||
|
|
||||||
|
#include <grpc/support/alloc.h> |
||||||
|
#include <grpc/support/avl.h> |
||||||
|
#include <grpc/support/log.h> |
||||||
|
#include <grpc/support/string_util.h> |
||||||
|
#include <grpc/support/useful.h> |
||||||
|
|
||||||
|
#ifdef GPR_WINDOWS |
||||||
|
#include <grpc/support/log_windows.h> |
||||||
|
#endif |
||||||
|
|
||||||
|
static void destroy_integer(void *key) {} |
||||||
|
|
||||||
|
static void *copy_integer(void *key) { return key; } |
||||||
|
|
||||||
|
static long compare_integers(void *key1, void *key2) { |
||||||
|
return GPR_ICMP((uintptr_t)key1, (uintptr_t)key2); |
||||||
|
} |
||||||
|
|
||||||
|
static void destroy_string(void *str) { gpr_free(str); } |
||||||
|
|
||||||
|
static void *copy_string(void *str) { return gpr_strdup(str); } |
||||||
|
|
||||||
|
static void destroy_err(void *err) { GRPC_ERROR_UNREF(err); } |
||||||
|
|
||||||
|
static void *copy_err(void *err) { return GRPC_ERROR_REF(err); } |
||||||
|
|
||||||
|
static void destroy_time(void *tm) { gpr_free(tm); } |
||||||
|
|
||||||
|
static gpr_timespec *box_time(gpr_timespec tm) { |
||||||
|
gpr_timespec *out = gpr_malloc(sizeof(*out)); |
||||||
|
*out = tm; |
||||||
|
return out; |
||||||
|
} |
||||||
|
|
||||||
|
static void *copy_time(void *tm) { return box_time(*(gpr_timespec *)tm); } |
||||||
|
|
||||||
|
static const gpr_avl_vtable avl_vtable_ints = {destroy_integer, copy_integer, |
||||||
|
compare_integers, |
||||||
|
destroy_integer, copy_integer}; |
||||||
|
|
||||||
|
static const gpr_avl_vtable avl_vtable_strs = {destroy_integer, copy_integer, |
||||||
|
compare_integers, destroy_string, |
||||||
|
copy_string}; |
||||||
|
|
||||||
|
static const gpr_avl_vtable avl_vtable_times = { |
||||||
|
destroy_integer, copy_integer, compare_integers, destroy_time, copy_time}; |
||||||
|
|
||||||
|
static const gpr_avl_vtable avl_vtable_errs = { |
||||||
|
destroy_integer, copy_integer, compare_integers, destroy_err, copy_err}; |
||||||
|
|
||||||
|
static const char *error_int_name(grpc_error_ints key) { |
||||||
|
switch (key) { |
||||||
|
case GRPC_ERROR_INT_ERRNO: |
||||||
|
return "errno"; |
||||||
|
case GRPC_ERROR_INT_FILE_LINE: |
||||||
|
return "file_line"; |
||||||
|
case GRPC_ERROR_INT_STREAM_ID: |
||||||
|
return "stream_id"; |
||||||
|
case GRPC_ERROR_INT_GRPC_STATUS: |
||||||
|
return "grpc_status"; |
||||||
|
case GRPC_ERROR_INT_OFFSET: |
||||||
|
return "offset"; |
||||||
|
case GRPC_ERROR_INT_INDEX: |
||||||
|
return "index"; |
||||||
|
case GRPC_ERROR_INT_SIZE: |
||||||
|
return "size"; |
||||||
|
case GRPC_ERROR_INT_HTTP2_ERROR: |
||||||
|
return "http2_error"; |
||||||
|
case GRPC_ERROR_INT_TSI_CODE: |
||||||
|
return "tsi_code"; |
||||||
|
case GRPC_ERROR_INT_SECURITY_STATUS: |
||||||
|
return "security_status"; |
||||||
|
case GRPC_ERROR_INT_FD: |
||||||
|
return "fd"; |
||||||
|
case GRPC_ERROR_INT_WSA_ERROR: |
||||||
|
return "wsa_error"; |
||||||
|
case GRPC_ERROR_INT_HTTP_STATUS: |
||||||
|
return "http_status"; |
||||||
|
} |
||||||
|
GPR_UNREACHABLE_CODE(return "unknown"); |
||||||
|
} |
||||||
|
|
||||||
|
static const char *error_str_name(grpc_error_strs key) { |
||||||
|
switch (key) { |
||||||
|
case GRPC_ERROR_STR_DESCRIPTION: |
||||||
|
return "description"; |
||||||
|
case GRPC_ERROR_STR_OS_ERROR: |
||||||
|
return "os_error"; |
||||||
|
case GRPC_ERROR_STR_TARGET_ADDRESS: |
||||||
|
return "target_address"; |
||||||
|
case GRPC_ERROR_STR_SYSCALL: |
||||||
|
return "syscall"; |
||||||
|
case GRPC_ERROR_STR_FILE: |
||||||
|
return "file"; |
||||||
|
case GRPC_ERROR_STR_GRPC_MESSAGE: |
||||||
|
return "grpc_message"; |
||||||
|
case GRPC_ERROR_STR_RAW_BYTES: |
||||||
|
return "raw_bytes"; |
||||||
|
case GRPC_ERROR_STR_TSI_ERROR: |
||||||
|
return "tsi_error"; |
||||||
|
case GRPC_ERROR_STR_FILENAME: |
||||||
|
return "filename"; |
||||||
|
} |
||||||
|
GPR_UNREACHABLE_CODE(return "unknown"); |
||||||
|
} |
||||||
|
|
||||||
|
static const char *error_time_name(grpc_error_times key) { |
||||||
|
switch (key) { |
||||||
|
case GRPC_ERROR_TIME_CREATED: |
||||||
|
return "created"; |
||||||
|
} |
||||||
|
GPR_UNREACHABLE_CODE(return "unknown"); |
||||||
|
} |
||||||
|
|
||||||
|
struct grpc_error { |
||||||
|
gpr_refcount refs; |
||||||
|
gpr_avl ints; |
||||||
|
gpr_avl strs; |
||||||
|
gpr_avl times; |
||||||
|
gpr_avl errs; |
||||||
|
uintptr_t next_err; |
||||||
|
}; |
||||||
|
|
||||||
|
static bool is_special(grpc_error *err) { |
||||||
|
return err == GRPC_ERROR_NONE || err == GRPC_ERROR_OOM || |
||||||
|
err == GRPC_ERROR_CANCELLED; |
||||||
|
} |
||||||
|
|
||||||
|
#ifdef GRPC_ERROR_REFCOUNT_DEBUG |
||||||
|
grpc_error *grpc_error_ref(grpc_error *err, const char *file, int line, |
||||||
|
const char *func) { |
||||||
|
if (is_special(err)) return err; |
||||||
|
gpr_log(GPR_DEBUG, "%p: %d -> %d [%s:%d %s]", err, err->refs.count, |
||||||
|
err->refs.count + 1, file, line, func); |
||||||
|
gpr_ref(&err->refs); |
||||||
|
return err; |
||||||
|
} |
||||||
|
#else |
||||||
|
grpc_error *grpc_error_ref(grpc_error *err) { |
||||||
|
if (is_special(err)) return err; |
||||||
|
gpr_ref(&err->refs); |
||||||
|
return err; |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
static void error_destroy(grpc_error *err) { |
||||||
|
GPR_ASSERT(!is_special(err)); |
||||||
|
gpr_avl_unref(err->ints); |
||||||
|
gpr_avl_unref(err->strs); |
||||||
|
gpr_avl_unref(err->errs); |
||||||
|
gpr_avl_unref(err->times); |
||||||
|
gpr_free(err); |
||||||
|
} |
||||||
|
|
||||||
|
#ifdef GRPC_ERROR_REFCOUNT_DEBUG |
||||||
|
void grpc_error_unref(grpc_error *err, const char *file, int line, |
||||||
|
const char *func) { |
||||||
|
if (is_special(err)) return; |
||||||
|
gpr_log(GPR_DEBUG, "%p: %d -> %d [%s:%d %s]", err, err->refs.count, |
||||||
|
err->refs.count - 1, file, line, func); |
||||||
|
if (gpr_unref(&err->refs)) { |
||||||
|
error_destroy(err); |
||||||
|
} |
||||||
|
} |
||||||
|
#else |
||||||
|
void grpc_error_unref(grpc_error *err) { |
||||||
|
if (is_special(err)) return; |
||||||
|
if (gpr_unref(&err->refs)) { |
||||||
|
error_destroy(err); |
||||||
|
} |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
grpc_error *grpc_error_create(const char *file, int line, const char *desc, |
||||||
|
grpc_error **referencing, |
||||||
|
size_t num_referencing) { |
||||||
|
grpc_error *err = gpr_malloc(sizeof(*err)); |
||||||
|
if (err == NULL) { // TODO(ctiller): make gpr_malloc return NULL
|
||||||
|
return GRPC_ERROR_OOM; |
||||||
|
} |
||||||
|
#ifdef GRPC_ERROR_REFCOUNT_DEBUG |
||||||
|
gpr_log(GPR_DEBUG, "%p create [%s:%d]", err, file, line); |
||||||
|
#endif |
||||||
|
err->ints = gpr_avl_add(gpr_avl_create(&avl_vtable_ints), |
||||||
|
(void *)(uintptr_t)GRPC_ERROR_INT_FILE_LINE, |
||||||
|
(void *)(uintptr_t)line); |
||||||
|
err->strs = gpr_avl_add( |
||||||
|
gpr_avl_add(gpr_avl_create(&avl_vtable_strs), |
||||||
|
(void *)(uintptr_t)GRPC_ERROR_STR_FILE, gpr_strdup(file)), |
||||||
|
(void *)(uintptr_t)GRPC_ERROR_STR_DESCRIPTION, gpr_strdup(desc)); |
||||||
|
err->errs = gpr_avl_create(&avl_vtable_errs); |
||||||
|
err->next_err = 0; |
||||||
|
for (size_t i = 0; i < num_referencing; i++) { |
||||||
|
if (referencing[i] == GRPC_ERROR_NONE) continue; |
||||||
|
err->errs = gpr_avl_add(err->errs, (void *)(err->next_err++), |
||||||
|
GRPC_ERROR_REF(referencing[i])); |
||||||
|
} |
||||||
|
err->times = gpr_avl_add(gpr_avl_create(&avl_vtable_times), |
||||||
|
(void *)(uintptr_t)GRPC_ERROR_TIME_CREATED, |
||||||
|
box_time(gpr_now(GPR_CLOCK_REALTIME))); |
||||||
|
gpr_ref_init(&err->refs, 1); |
||||||
|
return err; |
||||||
|
} |
||||||
|
|
||||||
|
static grpc_error *copy_error_and_unref(grpc_error *in) { |
||||||
|
if (is_special(in)) { |
||||||
|
if (in == GRPC_ERROR_NONE) return GRPC_ERROR_CREATE("no error"); |
||||||
|
if (in == GRPC_ERROR_OOM) return GRPC_ERROR_CREATE("oom"); |
||||||
|
if (in == GRPC_ERROR_CANCELLED) return GRPC_ERROR_CREATE("cancelled"); |
||||||
|
return GRPC_ERROR_CREATE("unknown"); |
||||||
|
} |
||||||
|
grpc_error *out = gpr_malloc(sizeof(*out)); |
||||||
|
#ifdef GRPC_ERROR_REFCOUNT_DEBUG |
||||||
|
gpr_log(GPR_DEBUG, "%p create copying", out); |
||||||
|
#endif |
||||||
|
out->ints = gpr_avl_ref(in->ints); |
||||||
|
out->strs = gpr_avl_ref(in->strs); |
||||||
|
out->errs = gpr_avl_ref(in->errs); |
||||||
|
out->times = gpr_avl_ref(in->times); |
||||||
|
out->next_err = in->next_err; |
||||||
|
gpr_ref_init(&out->refs, 1); |
||||||
|
GRPC_ERROR_UNREF(in); |
||||||
|
return out; |
||||||
|
} |
||||||
|
|
||||||
|
grpc_error *grpc_error_set_int(grpc_error *src, grpc_error_ints which, |
||||||
|
intptr_t value) { |
||||||
|
grpc_error *new = copy_error_and_unref(src); |
||||||
|
new->ints = gpr_avl_add(new->ints, (void *)(uintptr_t)which, (void *)value); |
||||||
|
return new; |
||||||
|
} |
||||||
|
|
||||||
|
bool grpc_error_get_int(grpc_error *err, grpc_error_ints which, intptr_t *p) { |
||||||
|
void *pp; |
||||||
|
if (gpr_avl_maybe_get(err->ints, (void *)(uintptr_t)which, &pp)) { |
||||||
|
if (p != NULL) *p = (intptr_t)pp; |
||||||
|
return true; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
grpc_error *grpc_error_set_str(grpc_error *src, grpc_error_strs which, |
||||||
|
const char *value) { |
||||||
|
grpc_error *new = copy_error_and_unref(src); |
||||||
|
new->strs = |
||||||
|
gpr_avl_add(new->strs, (void *)(uintptr_t)which, gpr_strdup(value)); |
||||||
|
return new; |
||||||
|
} |
||||||
|
|
||||||
|
grpc_error *grpc_error_add_child(grpc_error *src, grpc_error *child) { |
||||||
|
grpc_error *new = copy_error_and_unref(src); |
||||||
|
new->errs = gpr_avl_add(new->errs, (void *)(new->next_err++), child); |
||||||
|
return new; |
||||||
|
} |
||||||
|
|
||||||
|
static const char *no_error_string = "null"; |
||||||
|
static const char *oom_error_string = "\"Out of memory\""; |
||||||
|
static const char *cancelled_error_string = "\"Cancelled\""; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
char *key; |
||||||
|
char *value; |
||||||
|
} kv_pair; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
kv_pair *kvs; |
||||||
|
size_t num_kvs; |
||||||
|
size_t cap_kvs; |
||||||
|
} kv_pairs; |
||||||
|
|
||||||
|
static void append_kv(kv_pairs *kvs, char *key, char *value) { |
||||||
|
if (kvs->num_kvs == kvs->cap_kvs) { |
||||||
|
kvs->cap_kvs = GPR_MAX(3 * kvs->cap_kvs / 2, 4); |
||||||
|
kvs->kvs = gpr_realloc(kvs->kvs, sizeof(*kvs->kvs) * kvs->cap_kvs); |
||||||
|
} |
||||||
|
kvs->kvs[kvs->num_kvs].key = key; |
||||||
|
kvs->kvs[kvs->num_kvs].value = value; |
||||||
|
kvs->num_kvs++; |
||||||
|
} |
||||||
|
|
||||||
|
static void collect_kvs(gpr_avl_node *node, char *key(void *k), |
||||||
|
char *fmt(void *v), kv_pairs *kvs) { |
||||||
|
if (node == NULL) return; |
||||||
|
append_kv(kvs, key(node->key), fmt(node->value)); |
||||||
|
collect_kvs(node->left, key, fmt, kvs); |
||||||
|
collect_kvs(node->right, key, fmt, kvs); |
||||||
|
} |
||||||
|
|
||||||
|
static char *key_int(void *p) { |
||||||
|
return gpr_strdup(error_int_name((grpc_error_ints)(uintptr_t)p)); |
||||||
|
} |
||||||
|
|
||||||
|
static char *key_str(void *p) { |
||||||
|
return gpr_strdup(error_str_name((grpc_error_strs)(uintptr_t)p)); |
||||||
|
} |
||||||
|
|
||||||
|
static char *key_time(void *p) { |
||||||
|
return gpr_strdup(error_time_name((grpc_error_times)(uintptr_t)p)); |
||||||
|
} |
||||||
|
|
||||||
|
static char *fmt_int(void *p) { |
||||||
|
char *s; |
||||||
|
gpr_asprintf(&s, "%" PRIdPTR, (intptr_t)p); |
||||||
|
return s; |
||||||
|
} |
||||||
|
|
||||||
|
static void append_chr(char c, char **s, size_t *sz, size_t *cap) { |
||||||
|
if (*sz == *cap) { |
||||||
|
*cap = GPR_MAX(8, 3 * *cap / 2); |
||||||
|
*s = gpr_realloc(*s, *cap); |
||||||
|
} |
||||||
|
(*s)[(*sz)++] = c; |
||||||
|
} |
||||||
|
|
||||||
|
static void append_str(const char *str, char **s, size_t *sz, size_t *cap) { |
||||||
|
for (const char *c = str; *c; c++) { |
||||||
|
append_chr(*c, s, sz, cap); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
static void append_esc_str(const char *str, char **s, size_t *sz, size_t *cap) { |
||||||
|
static const char *hex = "0123456789abcdef"; |
||||||
|
append_chr('"', s, sz, cap); |
||||||
|
for (const uint8_t *c = (const uint8_t *)str; *c; c++) { |
||||||
|
if (*c < 32 || *c >= 127) { |
||||||
|
append_chr('\\', s, sz, cap); |
||||||
|
switch (*c) { |
||||||
|
case '\b': |
||||||
|
append_chr('b', s, sz, cap); |
||||||
|
break; |
||||||
|
case '\f': |
||||||
|
append_chr('f', s, sz, cap); |
||||||
|
break; |
||||||
|
case '\n': |
||||||
|
append_chr('n', s, sz, cap); |
||||||
|
break; |
||||||
|
case '\r': |
||||||
|
append_chr('r', s, sz, cap); |
||||||
|
break; |
||||||
|
case '\t': |
||||||
|
append_chr('t', s, sz, cap); |
||||||
|
break; |
||||||
|
default: |
||||||
|
append_chr('u', s, sz, cap); |
||||||
|
append_chr('0', s, sz, cap); |
||||||
|
append_chr('0', s, sz, cap); |
||||||
|
append_chr(hex[*c >> 4], s, sz, cap); |
||||||
|
append_chr(hex[*c & 0x0f], s, sz, cap); |
||||||
|
break; |
||||||
|
} |
||||||
|
} else { |
||||||
|
append_chr((char)*c, s, sz, cap); |
||||||
|
} |
||||||
|
} |
||||||
|
append_chr('"', s, sz, cap); |
||||||
|
} |
||||||
|
|
||||||
|
static char *fmt_str(void *p) { |
||||||
|
char *s = NULL; |
||||||
|
size_t sz = 0; |
||||||
|
size_t cap = 0; |
||||||
|
append_esc_str(p, &s, &sz, &cap); |
||||||
|
append_chr(0, &s, &sz, &cap); |
||||||
|
return s; |
||||||
|
} |
||||||
|
|
||||||
|
static char *fmt_time(void *p) { |
||||||
|
gpr_timespec tm = *(gpr_timespec *)p; |
||||||
|
char *out; |
||||||
|
char *pfx = "!!"; |
||||||
|
switch (tm.clock_type) { |
||||||
|
case GPR_CLOCK_MONOTONIC: |
||||||
|
pfx = "@monotonic:"; |
||||||
|
break; |
||||||
|
case GPR_CLOCK_REALTIME: |
||||||
|
pfx = "@"; |
||||||
|
break; |
||||||
|
case GPR_CLOCK_PRECISE: |
||||||
|
pfx = "@precise:"; |
||||||
|
break; |
||||||
|
case GPR_TIMESPAN: |
||||||
|
pfx = ""; |
||||||
|
break; |
||||||
|
} |
||||||
|
gpr_asprintf(&out, "\"%s%" PRId64 ".%09d\"", pfx, tm.tv_sec, tm.tv_nsec); |
||||||
|
return out; |
||||||
|
} |
||||||
|
|
||||||
|
static void add_errs(gpr_avl_node *n, char **s, size_t *sz, size_t *cap) { |
||||||
|
if (n == NULL) return; |
||||||
|
add_errs(n->left, s, sz, cap); |
||||||
|
const char *e = grpc_error_string(n->value); |
||||||
|
append_str(e, s, sz, cap); |
||||||
|
grpc_error_free_string(e); |
||||||
|
add_errs(n->right, s, sz, cap); |
||||||
|
} |
||||||
|
|
||||||
|
static char *errs_string(grpc_error *err) { |
||||||
|
char *s = NULL; |
||||||
|
size_t sz = 0; |
||||||
|
size_t cap = 0; |
||||||
|
append_chr('[', &s, &sz, &cap); |
||||||
|
add_errs(err->errs.root, &s, &sz, &cap); |
||||||
|
append_chr(']', &s, &sz, &cap); |
||||||
|
append_chr(0, &s, &sz, &cap); |
||||||
|
return s; |
||||||
|
} |
||||||
|
|
||||||
|
static int cmp_kvs(const void *a, const void *b) { |
||||||
|
const kv_pair *ka = a; |
||||||
|
const kv_pair *kb = b; |
||||||
|
return strcmp(ka->key, kb->key); |
||||||
|
} |
||||||
|
|
||||||
|
static const char *finish_kvs(kv_pairs *kvs) { |
||||||
|
char *s = NULL; |
||||||
|
size_t sz = 0; |
||||||
|
size_t cap = 0; |
||||||
|
|
||||||
|
append_chr('{', &s, &sz, &cap); |
||||||
|
for (size_t i = 0; i < kvs->num_kvs; i++) { |
||||||
|
if (i != 0) append_chr(',', &s, &sz, &cap); |
||||||
|
append_esc_str(kvs->kvs[i].key, &s, &sz, &cap); |
||||||
|
gpr_free(kvs->kvs[i].key); |
||||||
|
append_chr(':', &s, &sz, &cap); |
||||||
|
append_str(kvs->kvs[i].value, &s, &sz, &cap); |
||||||
|
gpr_free(kvs->kvs[i].value); |
||||||
|
} |
||||||
|
append_chr('}', &s, &sz, &cap); |
||||||
|
append_chr(0, &s, &sz, &cap); |
||||||
|
|
||||||
|
gpr_free(kvs->kvs); |
||||||
|
return s; |
||||||
|
} |
||||||
|
|
||||||
|
void grpc_error_free_string(const char *str) { |
||||||
|
if (str == no_error_string) return; |
||||||
|
if (str == oom_error_string) return; |
||||||
|
if (str == cancelled_error_string) return; |
||||||
|
gpr_free((char *)str); |
||||||
|
} |
||||||
|
|
||||||
|
const char *grpc_error_string(grpc_error *err) { |
||||||
|
if (err == GRPC_ERROR_NONE) return no_error_string; |
||||||
|
if (err == GRPC_ERROR_OOM) return oom_error_string; |
||||||
|
if (err == GRPC_ERROR_CANCELLED) return cancelled_error_string; |
||||||
|
|
||||||
|
kv_pairs kvs; |
||||||
|
memset(&kvs, 0, sizeof(kvs)); |
||||||
|
|
||||||
|
collect_kvs(err->ints.root, key_int, fmt_int, &kvs); |
||||||
|
collect_kvs(err->strs.root, key_str, fmt_str, &kvs); |
||||||
|
collect_kvs(err->times.root, key_time, fmt_time, &kvs); |
||||||
|
if (!gpr_avl_is_empty(err->errs)) { |
||||||
|
append_kv(&kvs, gpr_strdup("referenced_errors"), errs_string(err)); |
||||||
|
} |
||||||
|
|
||||||
|
qsort(kvs.kvs, kvs.num_kvs, sizeof(kv_pair), cmp_kvs); |
||||||
|
|
||||||
|
return finish_kvs(&kvs); |
||||||
|
} |
||||||
|
|
||||||
|
grpc_error *grpc_os_error(const char *file, int line, int err, |
||||||
|
const char *call_name) { |
||||||
|
return grpc_error_set_str( |
||||||
|
grpc_error_set_str( |
||||||
|
grpc_error_set_int(grpc_error_create(file, line, "OS Error", NULL, 0), |
||||||
|
GRPC_ERROR_INT_ERRNO, err), |
||||||
|
GRPC_ERROR_STR_OS_ERROR, strerror(err)), |
||||||
|
GRPC_ERROR_STR_SYSCALL, call_name); |
||||||
|
} |
||||||
|
|
||||||
|
#ifdef GPR_WINDOWS |
||||||
|
grpc_error *grpc_wsa_error(const char *file, int line, int err, |
||||||
|
const char *call_name) { |
||||||
|
char *utf8_message = gpr_format_message(err); |
||||||
|
grpc_error *error = grpc_error_set_str( |
||||||
|
grpc_error_set_str( |
||||||
|
grpc_error_set_int(grpc_error_create(file, line, "OS Error", NULL, 0), |
||||||
|
GRPC_ERROR_INT_WSA_ERROR, err), |
||||||
|
GRPC_ERROR_STR_OS_ERROR, utf8_message), |
||||||
|
GRPC_ERROR_STR_SYSCALL, call_name); |
||||||
|
gpr_free(utf8_message); |
||||||
|
return error; |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
bool grpc_log_if_error(const char *what, grpc_error *error, const char *file, |
||||||
|
int line) { |
||||||
|
if (error == GRPC_ERROR_NONE) return true; |
||||||
|
const char *msg = grpc_error_string(error); |
||||||
|
gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "%s: %s", what, msg); |
||||||
|
grpc_error_free_string(msg); |
||||||
|
GRPC_ERROR_UNREF(error); |
||||||
|
return false; |
||||||
|
} |
||||||
@ -0,0 +1,192 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2016, Google Inc. |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are |
||||||
|
* met: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* * Redistributions in binary form must reproduce the above |
||||||
|
* copyright notice, this list of conditions and the following disclaimer |
||||||
|
* in the documentation and/or other materials provided with the |
||||||
|
* distribution. |
||||||
|
* * Neither the name of Google Inc. nor the names of its |
||||||
|
* contributors may be used to endorse or promote products derived from |
||||||
|
* this software without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef GRPC_CORE_LIB_IOMGR_ERROR_H |
||||||
|
#define GRPC_CORE_LIB_IOMGR_ERROR_H |
||||||
|
|
||||||
|
#include <stdbool.h> |
||||||
|
#include <stdint.h> |
||||||
|
|
||||||
|
#include <grpc/support/time.h> |
||||||
|
|
||||||
|
/// Opaque representation of an error.
|
||||||
|
/// Errors are refcounted objects that represent the result of an operation.
|
||||||
|
/// Ownership laws:
|
||||||
|
/// if a grpc_error is returned by a function, the caller owns a ref to that
|
||||||
|
/// instance
|
||||||
|
/// if a grpc_error is passed to a grpc_closure callback function (functions
|
||||||
|
/// with the signature:
|
||||||
|
/// void (*f)(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error))
|
||||||
|
/// then those functions do not automatically own a ref to error
|
||||||
|
/// if a grpc_error is passed to *ANY OTHER FUNCTION* then that function takes
|
||||||
|
/// ownership of the error
|
||||||
|
/// Errors have:
|
||||||
|
/// a set of ints, strings, and timestamps that describe the error
|
||||||
|
/// always present are:
|
||||||
|
/// GRPC_ERROR_STR_FILE, GRPC_ERROR_INT_FILE_LINE - source location the error
|
||||||
|
/// was generated
|
||||||
|
/// GRPC_ERROR_STR_DESCRIPTION - a human readable description of the error
|
||||||
|
/// GRPC_ERROR_TIME_CREATED - a timestamp indicating when the error happened
|
||||||
|
/// an error can also have children; these are other errors that are believed
|
||||||
|
/// to have contributed to this one. By accumulating children, we can begin
|
||||||
|
/// to root cause high level failures from low level failures, without having
|
||||||
|
/// to derive execution paths from log lines
|
||||||
|
typedef struct grpc_error grpc_error; |
||||||
|
|
||||||
|
typedef enum { |
||||||
|
/// 'errno' from the operating system
|
||||||
|
GRPC_ERROR_INT_ERRNO, |
||||||
|
/// __LINE__ from the call site creating the error
|
||||||
|
GRPC_ERROR_INT_FILE_LINE, |
||||||
|
/// stream identifier: for errors that are associated with an individual
|
||||||
|
/// wire stream
|
||||||
|
GRPC_ERROR_INT_STREAM_ID, |
||||||
|
/// grpc status code representing this error
|
||||||
|
GRPC_ERROR_INT_GRPC_STATUS, |
||||||
|
/// offset into some binary blob (usually represented by
|
||||||
|
/// GRPC_ERROR_STR_RAW_BYTES) where the error occurred
|
||||||
|
GRPC_ERROR_INT_OFFSET, |
||||||
|
/// context sensitive index associated with the error
|
||||||
|
GRPC_ERROR_INT_INDEX, |
||||||
|
/// context sensitive size associated with the error
|
||||||
|
GRPC_ERROR_INT_SIZE, |
||||||
|
/// http2 error code associated with the error (see the HTTP2 RFC)
|
||||||
|
GRPC_ERROR_INT_HTTP2_ERROR, |
||||||
|
/// TSI status code associated with the error
|
||||||
|
GRPC_ERROR_INT_TSI_CODE, |
||||||
|
/// grpc_security_status associated with the error
|
||||||
|
GRPC_ERROR_INT_SECURITY_STATUS, |
||||||
|
/// WSAGetLastError() reported when this error occurred
|
||||||
|
GRPC_ERROR_INT_WSA_ERROR, |
||||||
|
/// File descriptor associated with this error
|
||||||
|
GRPC_ERROR_INT_FD, |
||||||
|
/// HTTP status (i.e. 404)
|
||||||
|
GRPC_ERROR_INT_HTTP_STATUS, |
||||||
|
} grpc_error_ints; |
||||||
|
|
||||||
|
typedef enum { |
||||||
|
/// top-level textual description of this error
|
||||||
|
GRPC_ERROR_STR_DESCRIPTION, |
||||||
|
/// source file in which this error occurred
|
||||||
|
GRPC_ERROR_STR_FILE, |
||||||
|
/// operating system description of this error
|
||||||
|
GRPC_ERROR_STR_OS_ERROR, |
||||||
|
/// syscall that generated this error
|
||||||
|
GRPC_ERROR_STR_SYSCALL, |
||||||
|
/// peer that we were trying to communicate when this error occurred
|
||||||
|
GRPC_ERROR_STR_TARGET_ADDRESS, |
||||||
|
/// grpc status message associated with this error
|
||||||
|
GRPC_ERROR_STR_GRPC_MESSAGE, |
||||||
|
/// hex dump (or similar) with the data that generated this error
|
||||||
|
GRPC_ERROR_STR_RAW_BYTES, |
||||||
|
/// tsi error string associated with this error
|
||||||
|
GRPC_ERROR_STR_TSI_ERROR, |
||||||
|
/// filename that we were trying to read/write when this error occurred
|
||||||
|
GRPC_ERROR_STR_FILENAME, |
||||||
|
} grpc_error_strs; |
||||||
|
|
||||||
|
typedef enum { |
||||||
|
/// timestamp of error creation
|
||||||
|
GRPC_ERROR_TIME_CREATED, |
||||||
|
} grpc_error_times; |
||||||
|
|
||||||
|
#define GRPC_ERROR_NONE ((grpc_error *)NULL) |
||||||
|
#define GRPC_ERROR_OOM ((grpc_error *)1) |
||||||
|
#define GRPC_ERROR_CANCELLED ((grpc_error *)2) |
||||||
|
|
||||||
|
const char *grpc_error_string(grpc_error *error); |
||||||
|
void grpc_error_free_string(const char *str); |
||||||
|
|
||||||
|
/// Create an error - but use GRPC_ERROR_CREATE instead
|
||||||
|
grpc_error *grpc_error_create(const char *file, int line, const char *desc, |
||||||
|
grpc_error **referencing, size_t num_referencing); |
||||||
|
/// Create an error (this is the preferred way of generating an error that is
|
||||||
|
/// not due to a system call - for system calls, use GRPC_OS_ERROR or
|
||||||
|
/// GRPC_WSA_ERROR as appropriate)
|
||||||
|
/// \a referencing is an array of num_referencing elements indicating one or
|
||||||
|
/// more errors that are believed to have contributed to this one
|
||||||
|
/// err = grpc_error_create(x, y, z, r, nr) is equivalent to:
|
||||||
|
/// err = grpc_error_create(x, y, z, NULL, 0);
|
||||||
|
/// for (i=0; i<nr; i++) err = grpc_error_add_child(err, r[i]);
|
||||||
|
#define GRPC_ERROR_CREATE(desc) \ |
||||||
|
grpc_error_create(__FILE__, __LINE__, desc, NULL, 0) |
||||||
|
|
||||||
|
// Create an error that references some other errors. This function adds a
|
||||||
|
// reference to each error in errs - it does not consume an existing reference
|
||||||
|
#define GRPC_ERROR_CREATE_REFERENCING(desc, errs, count) \ |
||||||
|
grpc_error_create(__FILE__, __LINE__, desc, errs, count) |
||||||
|
|
||||||
|
//#define GRPC_ERROR_REFCOUNT_DEBUG
|
||||||
|
#ifdef GRPC_ERROR_REFCOUNT_DEBUG |
||||||
|
grpc_error *grpc_error_ref(grpc_error *err, const char *file, int line, |
||||||
|
const char *func); |
||||||
|
void grpc_error_unref(grpc_error *err, const char *file, int line, |
||||||
|
const char *func); |
||||||
|
#define GRPC_ERROR_REF(err) grpc_error_ref(err, __FILE__, __LINE__, __func__) |
||||||
|
#define GRPC_ERROR_UNREF(err) \ |
||||||
|
grpc_error_unref(err, __FILE__, __LINE__, __func__) |
||||||
|
#else |
||||||
|
grpc_error *grpc_error_ref(grpc_error *err); |
||||||
|
void grpc_error_unref(grpc_error *err); |
||||||
|
#define GRPC_ERROR_REF(err) grpc_error_ref(err) |
||||||
|
#define GRPC_ERROR_UNREF(err) grpc_error_unref(err) |
||||||
|
#endif |
||||||
|
|
||||||
|
grpc_error *grpc_error_set_int(grpc_error *src, grpc_error_ints which, |
||||||
|
intptr_t value); |
||||||
|
bool grpc_error_get_int(grpc_error *error, grpc_error_ints which, intptr_t *p); |
||||||
|
grpc_error *grpc_error_set_time(grpc_error *src, grpc_error_times which, |
||||||
|
gpr_timespec value); |
||||||
|
grpc_error *grpc_error_set_str(grpc_error *src, grpc_error_strs which, |
||||||
|
const char *value); |
||||||
|
/// Add a child error: an error that is believed to have contributed to this
|
||||||
|
/// error occurring. Allows root causing high level errors from lower level
|
||||||
|
/// errors that contributed to them.
|
||||||
|
grpc_error *grpc_error_add_child(grpc_error *src, grpc_error *child); |
||||||
|
grpc_error *grpc_os_error(const char *file, int line, int err, |
||||||
|
const char *call_name); |
||||||
|
/// create an error associated with errno!=0 (an 'operating system' error)
|
||||||
|
#define GRPC_OS_ERROR(err, call_name) \ |
||||||
|
grpc_os_error(__FILE__, __LINE__, err, call_name) |
||||||
|
grpc_error *grpc_wsa_error(const char *file, int line, int err, |
||||||
|
const char *call_name); |
||||||
|
/// windows only: create an error associated with WSAGetLastError()!=0
|
||||||
|
#define GRPC_WSA_ERROR(err, call_name) \ |
||||||
|
grpc_wsa_error(__FILE__, __LINE__, err, call_name) |
||||||
|
|
||||||
|
bool grpc_log_if_error(const char *what, grpc_error *error, const char *file, |
||||||
|
int line); |
||||||
|
#define GRPC_LOG_IF_ERROR(what, error) \ |
||||||
|
grpc_log_if_error((what), (error), __FILE__, __LINE__) |
||||||
|
|
||||||
|
#endif /* GRPC_CORE_LIB_IOMGR_ERROR_H */ |
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue