diff --git a/src/envoy/prototype/BUILD b/src/envoy/prototype/BUILD new file mode 100644 index 000000000000..e5cbaeba10c6 --- /dev/null +++ b/src/envoy/prototype/BUILD @@ -0,0 +1,34 @@ +# Copyright 2016 Google Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +################################################################################ +# + +cc_binary( + name = "envoy_esp", + srcs = [ + "api_manager_filter.cc", + "api_manager_env.cc", + "api_manager_env.h", + ], + deps = [ + "//external:protobuf", + "//contrib/endpoints/include:api_manager", + "//contrib/endpoints/src/grpc/transcoding:transcoding", + "//external:servicecontrol", + "@envoy_git//:envoy-common", + "@envoy_git//:envoy-main" + ], + linkstatic=1, +) diff --git a/src/envoy/prototype/api_manager_env.cc b/src/envoy/prototype/api_manager_env.cc new file mode 100644 index 000000000000..d694fab49a25 --- /dev/null +++ b/src/envoy/prototype/api_manager_env.cc @@ -0,0 +1,132 @@ +#include "api_manager_env.h" + +#include "common/http/headers.h" +#include "common/http/message_impl.h" +#include "envoy/event/timer.h" + +namespace Http { +namespace ApiManager { + +void Http::ApiManager::Env::Log(LogLevel level, const char *message) { + switch (level) { + case LogLevel::DEBUG: + log().debug("{}", message); + break; + case LogLevel::INFO: + log().debug("{}", message); + break; + case LogLevel::WARNING: + log().warn("{}", message); + break; + case LogLevel::ERROR: + log().error("{}", message); + break; + } +} + + +class PeriodicTimer : public google::api_manager::PeriodicTimer, + public Logger::Loggable { + private: + Server::Instance &server_; + Event::TimerPtr timer_; + + public: + PeriodicTimer(Server::Instance &server) : server_(server) {} + ~PeriodicTimer() { Stop(); } + void Stop() { + if (timer_) { + timer_->disableTimer(); + timer_ = nullptr; + } + } + void Schedule(std::chrono::milliseconds interval, + std::function continuation) { + Stop(); + timer_ = server_.dispatcher().createTimer([this, continuation, interval]() { + continuation(); + Schedule(interval, continuation); + }); + timer_->enableTimer(interval); + } +}; + +std::unique_ptr Env::StartPeriodicTimer( + std::chrono::milliseconds interval, std::function continuation) { + log().debug("start periodic timer"); + auto single = new PeriodicTimer(server); + single->Schedule(interval, continuation); + std::unique_ptr timer(single); + return timer; +} + +class HTTPRequest : public Http::Message { + private: + HeaderMapImpl header_map_; + Buffer::OwnedImpl body_; + + public: + HTTPRequest(google::api_manager::HTTPRequest *request) + : body_(request->body()) { + header_map_.addStatic(Headers::get().Method, request->method()); + header_map_.addStatic(Headers::get().Path, "/"); + header_map_.addStatic(Headers::get().Scheme, "http"); + header_map_.addStatic(Headers::get().Host, "localhost"); + header_map_.addStatic(Headers::get().ContentLength, + std::to_string(body_.length())); + header_map_.addStatic(LowerCaseString("x-api-manager-url"), + request->url()); + for (auto header : request->request_headers()) { + LowerCaseString key(header.first); + header_map_.addStatic(key, header.second); + } + } + virtual HeaderMap &headers() override { return header_map_; } + virtual Buffer::Instance *body() override { return &body_; } + virtual void body(Buffer::InstancePtr &&body) override {} + virtual HeaderMap *trailers() override { return nullptr; } + virtual void trailers(HeaderMapPtr &&trailers) override {} + virtual std::string bodyAsString() override { return ""; } +}; + +class RequestCallbacks : public AsyncClient::Callbacks { + private: + std::unique_ptr request_; + std::unique_ptr sent_request_; + + public: + RequestCallbacks(std::unique_ptr &&request) + : request_(std::move(request)) {} + virtual void onSuccess(MessagePtr &&response) override { + google::api_manager::utils::Status status( + std::stoi(response->headers().Status()->value().c_str()), ""); + std::map headers; + response->headers().iterate( + [&](const HeaderEntry& header, void*) -> void { + // TODO: fix it + // headers.emplace(header.key().c_str(), header.value().c_str()); + }, nullptr); + request_->OnComplete(status, std::move(headers), response->bodyAsString()); + delete this; + } + virtual void onFailure(AsyncClient::FailureReason reason) override { + google::api_manager::utils::Status status = + google::api_manager::utils::Status::OK; + std::map headers; + request_->OnComplete(status, std::move(headers), ""); + delete this; + } +}; + +void Env::RunHTTPRequest( + std::unique_ptr request) { + auto &client = cm_.httpAsyncClientForCluster("api_manager"); + + MessagePtr message{new HTTPRequest(request.get())}; + RequestCallbacks *callbacks = new RequestCallbacks(std::move(request)); + client.send( + std::move(message), *callbacks, + Optional(std::chrono::milliseconds(10000))); +} +} +} diff --git a/src/envoy/prototype/api_manager_env.h b/src/envoy/prototype/api_manager_env.h new file mode 100644 index 000000000000..ea045532ae20 --- /dev/null +++ b/src/envoy/prototype/api_manager_env.h @@ -0,0 +1,31 @@ +#pragma once + +#include "precompiled/precompiled.h" + +#include "common/common/logger.h" +#include "envoy/upstream/cluster_manager.h" +#include "contrib/endpoints/include/api_manager/env_interface.h" +#include "server/server.h" + +namespace Http { +namespace ApiManager { + +class Env : public google::api_manager::ApiManagerEnvInterface, + public Logger::Loggable { + private: + Server::Instance& server; + Upstream::ClusterManager& cm_; + + public: + Env(Server::Instance& server) + : server(server), cm_(server.clusterManager()){}; + + virtual void Log(LogLevel level, const char* message) override; + virtual std::unique_ptr + StartPeriodicTimer(std::chrono::milliseconds interval, + std::function continuation) override; + virtual void RunHTTPRequest( + std::unique_ptr request) override; +}; +} +} diff --git a/src/envoy/prototype/api_manager_filter.cc b/src/envoy/prototype/api_manager_filter.cc new file mode 100644 index 000000000000..d54258e30c49 --- /dev/null +++ b/src/envoy/prototype/api_manager_filter.cc @@ -0,0 +1,251 @@ +#include "precompiled/precompiled.h" + +#include "api_manager_env.h" +#include "common/grpc/common.h" +#include "common/common/logger.h" +#include "common/http/filter/ratelimit.h" +#include "common/http/headers.h" +#include "common/http/utility.h" +#include "envoy/server/instance.h" +#include "contrib/endpoints/include/api_manager/api_manager.h" +#include "server/config/network/http_connection_manager.h" +#include "contrib/endpoints/src/grpc/transcoding/transcoder.h" + +namespace Http { +namespace ApiManager { + +std::string ReadFile(const std::string& file_name) { + std::ifstream t(file_name); + std::string content((std::istreambuf_iterator(t)), + std::istreambuf_iterator()); + return content; +} + +class Config : public Logger::Loggable { + private: + google::api_manager::ApiManagerFactory api_manager_factory_; + std::shared_ptr api_manager_; + Upstream::ClusterManager& cm_; + + public: + Config(const Json::Object& config, Server::Instance& server) + : cm_(server.clusterManager()) { + const std::string service_config = config.getString("service_config"); + + std::string service_config_content = ReadFile(service_config); + + std::unique_ptr env( + new Env(server)); + + api_manager_ = api_manager_factory_.GetOrCreateApiManager( + std::move(env), service_config_content, ""); + + api_manager_->Init(); + log().debug("Called ApiManager::Config constructor: {}", __func__); + } + + std::shared_ptr& api_manager() { + return api_manager_; + } +}; + +typedef std::shared_ptr ConfigPtr; + +class Request : public google::api_manager::Request { + private: + HeaderMap& header_map_; + + public: + Request(HeaderMap& header_map) : header_map_(header_map) {} + virtual std::string GetRequestHTTPMethod() override { + return header_map_.Method()->value().c_str(); + } + virtual std::string GetRequestPath() override { + return header_map_.Path()->value().c_str(); + } + virtual std::string GetUnparsedRequestPath() override { + return header_map_.Path()->value().c_str(); + } + virtual std::string GetClientIP() override { return ""; } + virtual bool FindQuery(const std::string& name, std::string* query) override { + return false; + } + + virtual bool FindHeader(const std::string& name, + std::string* header) override { + // TODO: find header with header_map + return true; + } + + virtual google::api_manager::protocol::Protocol GetRequestProtocol() + override { + return google::api_manager::protocol::Protocol::HTTP; + } + virtual google::api_manager::utils::Status AddHeaderToBackend( + const std::string& key, const std::string& value) override { + header_map_.addStatic(LowerCaseString(key), value); + return google::api_manager::utils::Status::OK; + } + virtual void SetAuthToken(const std::string& auth_token) override {} + + virtual int64_t GetGrpcRequestBytes() { return 0; } + virtual int64_t GetGrpcResponseBytes() { return 0; } + virtual int64_t GetGrpcRequestMessageCounts() { return 0; } + virtual int64_t GetGrpcResponseMessageCounts() { return 0; } + virtual std::string GetQueryParameters() { return ""; } +}; + +class Response : public google::api_manager::Response { + google::api_manager::utils::Status GetResponseStatus() { + return google::api_manager::utils::Status::OK; + } + + std::size_t GetRequestSize() { return 0; } + + std::size_t GetResponseSize() { return 0; } + + google::api_manager::utils::Status GetLatencyInfo( + google::api_manager::service_control::LatencyInfo* info) { + return google::api_manager::utils::Status::OK; + } +}; + +const Http::HeaderMapImpl BadRequest{{Http::Headers::get().Status, "400"}}; + +class Instance : public Http::StreamFilter, + public Logger::Loggable { + private: + std::shared_ptr api_manager_; + std::unique_ptr + request_handler_; + + enum State { NotStarted, Calling, Complete, Responded }; + State state_; + + StreamDecoderFilterCallbacks* decoder_callbacks_; + StreamEncoderFilterCallbacks* encoder_callbacks_; + + bool initiating_call_; + + public: + Instance(ConfigPtr config) + : api_manager_(config->api_manager()), + state_(NotStarted), + initiating_call_(false) { + log().debug("Called ApiManager::Instance : {}", __func__); + } + + FilterHeadersStatus decodeHeaders(HeaderMap& headers, + bool end_stream) override { + log().debug("Called ApiManager::Instance : {}", __func__); + std::unique_ptr request(new Request(headers)); + request_handler_ = api_manager_->CreateRequestHandler(std::move(request)); + state_ = Calling; + initiating_call_ = true; + request_handler_->Check([this](google::api_manager::utils::Status status) { + completeCheck(status); + }); + initiating_call_ = false; + + if (state_ == Complete) { + return FilterHeadersStatus::Continue; + } + log().debug("Called ApiManager::Instance : {} Stop", __func__); + return FilterHeadersStatus::StopIteration; + } + + FilterDataStatus decodeData(Buffer::Instance& data, + bool end_stream) override { + log().debug("Called ApiManager::Instance : {} ({}, {})", __func__, + data.length(), end_stream); + if (state_ == Calling) { + return FilterDataStatus::StopIterationAndBuffer; + } + return FilterDataStatus::Continue; + } + + FilterTrailersStatus decodeTrailers(HeaderMap& trailers) override { + log().debug("Called ApiManager::Instance : {}", __func__); + if (state_ == Calling) { + return FilterTrailersStatus::StopIteration; + } + return FilterTrailersStatus::Continue; + } + void setDecoderFilterCallbacks( + StreamDecoderFilterCallbacks& callbacks) override { + log().debug("Called ApiManager::Instance : {}", __func__); + decoder_callbacks_ = &callbacks; + decoder_callbacks_->addResetStreamCallback( + [this]() { state_ = Responded; }); + } + void completeCheck(const google::api_manager::utils::Status& status) { + log().debug("Called ApiManager::Instance : check complete {}", + status.ToJson()); + if (!status.ok() && state_ != Responded) { + state_ = Responded; + Utility::sendLocalReply(*decoder_callbacks_, Code(status.HttpCode()), + status.ToJson()); + return; + } + state_ = Complete; + if (!initiating_call_) { + decoder_callbacks_->continueDecoding(); + } + } + + virtual FilterHeadersStatus encodeHeaders(HeaderMap& headers, + bool end_stream) override { + log().debug("Called ApiManager::Instance : {}", __func__); + return FilterHeadersStatus::Continue; + } + virtual FilterDataStatus encodeData(Buffer::Instance& data, + bool end_stream) override { + log().debug("Called ApiManager::Instance : {}", __func__); + return FilterDataStatus::Continue; + } + virtual FilterTrailersStatus encodeTrailers(HeaderMap& trailers) override { + log().debug("Called ApiManager::Instance : {}", __func__); + return FilterTrailersStatus::Continue; + } + virtual void setEncoderFilterCallbacks( + StreamEncoderFilterCallbacks& callbacks) override { + log().debug("Called ApiManager::Instance : {}", __func__); + encoder_callbacks_ = &callbacks; + } + + // note: cannot extend ~ActiveStream for access log, placing it here + ~Instance() { + log().debug("Called ApiManager::Instance : {}", __func__); + std::unique_ptr response(new Response()); + request_handler_->Report(std::move(response), + [this]() { log().debug("Report returns"); }); + } +}; +} +} + +namespace Server { +namespace Configuration { + +class ApiManagerConfig : public HttpFilterConfigFactory { + public: + HttpFilterFactoryCb tryCreateFilterFactory( + HttpFilterType type, const std::string& name, const Json::Object& config, + const std::string&, Server::Instance& server) override { + if (type != HttpFilterType::Both || name != "esp") { + return nullptr; + } + + Http::ApiManager::ConfigPtr api_manager_config( + new Http::ApiManager::Config(config, server)); + return [api_manager_config]( + Http::FilterChainFactoryCallbacks& callbacks) -> void { + auto instance = new Http::ApiManager::Instance(api_manager_config); + callbacks.addStreamFilter(Http::StreamFilterPtr{instance}); + }; + } +}; + +static RegisterHttpFilterConfigFactory register_; +} +} diff --git a/src/envoy/prototype/dummy_api_manager_cluster.py b/src/envoy/prototype/dummy_api_manager_cluster.py new file mode 100644 index 000000000000..3f83476aae87 --- /dev/null +++ b/src/envoy/prototype/dummy_api_manager_cluster.py @@ -0,0 +1,91 @@ +from BaseHTTPServer import BaseHTTPRequestHandler +from BaseHTTPServer import HTTPServer +from subprocess import Popen, PIPE, STDOUT + +PUBLIC_KEY = '''{ + "keys": [ + { + "kty": "RSA", + "alg": "RS256", + "use": "sig", + "kid": "686f442dead739e241342519849bd0d140707a86", + "n": "yVGRzBnVmCHC9uMH_mCna7FiSKOjMEsDdgf8hds41KYfUHH9cp4P41iQEBnqPYvQiMYaZDuatkMDh25ukmkSyfLwJIVQpnHgMDwoZ1cx83Z0PwC8wAAJYqKyItKNfFN4UJ6DZIOVU-Iqgxi8VOtGwMNx2LiD1NoFVfXyz52UJ_QLiUGzErVwTGv4UD6NtaWKFkctTnEG-9rZvDF8QknnzxAomVa2OcV8OHeszx6N8UE1tm9Kq4xj2Uu8D3dDrfu2jr45Pi6RHIZOTAnu8G7wTDNaiGbENrbHSk6WAjLZBOcWZj9SDlDlwH2xFoKdpNKRmLKpPQblHem_y1KRYwvJTw", + "e": "AQAB" + }, + { + "kty": "RSA", + "alg": "RS256", + "use": "sig", + "kid": "d57d66bfbff089769e3545589572d3b53955a8cb", + "n": "zX99YCqicbn_j-5YTJ-2FsgONUg7cmqJiwvHXrUopRvn2Tukrd0B5Sg-Rq1hdZTYgIym7lSMw_zLxIQCH54sUfydX5MMWr6FOxVUbYl-E0Oko85Yer9dFv61rN0USj_A12QRMmjCZkcqH_6MWWuA1QWaejyStopjpLEYnUD3bP6oS604eZWkkOp8Nu-Vg4NqqX7ZClIcQqe03xv3sFHiPuhB-qaifhpIPpKCiYSKxAY4_GxwCJ_ml_uJ5k1tIrDykAlie6aWxv8hogOXrQmNRCO2Qcumwb7d9cci1UxsEYOtpZxhTiZqWsbrBxwfvLqU_rvsCT8vOjrBPOkTtYl22w", + "e": "AQAB" + }, + { + "kty": "RSA", + "alg": "RS256", + "use": "sig", + "kid": "516ca9a83b130d4b605684fe7df83b43f33fba43", + "n": "rSLxCvtRLoJUt2xPTSjDgN8_7kuBLsZz0JD4HRiwvId_IYY-T5MsUirBx01AtI3KRlmeQ-1QIvET4cNN99QL8U6e7Hh75VWJvQhh0_TFdKbv_75b81-rzx-EvIoVe0czeY3QeRp3DDORRk9o7xgri6U3VfT2zcQIDAPY14h3wLHE5DQuH9EpbxjS_wNrQxRYZH_mWgmWU7h001WHWRDKdEIgtzQkinKOTig90Wy4pt_vgMGcv0mh_wYvIcmB62Qj1sHUUOa5NJWUaZLC4Stj7CH0dLiBrVqg3JFqvO60Oo3wrcdmNQl0RaRHFjBYLameUPSP6M2BevfCRx8-Ix26rw", + "e": "AQAB" + }, + { + "kty": "RSA", + "alg": "RS256", + "use": "sig", + "kid": "33a681b36b8983913b05f8d5eab165c60694b6fc", + "n": "pRbWhLXIOvF1Naxh5n2evZqpJ3kPEFL4b-jHRHOhMnzqsi_aeQtIwYLVM8zdYYfgCxRq8umG1YwMenBKKPzRWr4MkFAB64O3UPgdyg-3je-fgCMziqS_3KH7AXHekxG_ZHpwbkgilRMtJNiDnSZWGad8XAfW3VFct4RqRAaf7h-6Za0IM7R3u4VYkUfosNqKtoDJDQrng9Nbv9ryUk8u1WikKF0M1r-wrZoDA7QFRAFkbdfYyvHL2daUflNDIXmFkUeHGGApMlJQ3wJk7Tln4txGMSUdJoD3JWEyKa2W1WshtqBHnQb8VlL77H-ch9zbn5pGZCoJ0MsgJr0vjoea8w", + "e": "AQAB" + }, + { + "kty": "RSA", + "alg": "RS256", + "use": "sig", + "kid": "986f2c30b9843defdc8f8debe138d640d1d67d9d", + "n": "qfE-u8I60zP_Vg3UsP_X9Qv1idkrnsXKkcQcsGWUdqs4jM2VixGBJDMJWbP55aJA93Sl49_dzAv_lr5-ctc1L04ke6nHX19EEBDtFTjGKyEdI-X1C-6HXCQmpI1XvUA8DzTOIZd5KEXJgBA9tpn6qkMAHzXyMHOfg8nhW36She4QggFjfF_RDKOA2-jRXDIjinOmIaLhVq4hsC9hCshhsfreLPw3HH8UhRONbkoFU_8ZBgAQLdVB1TQwp-ZDiVyh9od9a-RmfIiUl27AK5LDrtpVRCtXj6bv9OMx4QWVX8G-NfQexDwAp1pICaE5qYyJbiIK25E07vPTJ1ZtMpodFQ", + "e": "AQAB" + } + ] +} +''' + +def print_body(binary, expected): + p = Popen(['bazel-bin/src/tools/service_control_json_gen', + '--text', + '--'+expected, + '--stdin'], stdin=PIPE) + p.communicate(input=binary) + +class Handler(BaseHTTPRequestHandler): + def do_GET(self): + self.handle_request("GET") + + def do_POST(self): + self.handle_request("POST") + + + + def handle_request(self, method): + print(method, self.path, self.headers.items()) + url = self.headers.get('x-api-manager-url', '') + if url == 'https://www.googleapis.com/service_accounts/v1/jwk/loadtest@esp-test-client.iam.gserviceaccount.com': + self.send_response(200) + self.send_header('Content-Length', str(len(PUBLIC_KEY))) + self.end_headers() + self.wfile.write(PUBLIC_KEY) + else: + #content_len = self.headers.getheader('content-length', 0) + #post_body = self.rfile.read(int(content_len)) + if url.endswith(":report"): + print_body(post_body, "report_request") + elif url.endswith(":check"): + print_body(post_body, "check_request") + + self.send_response(200) + self.send_header('Content-Length', "0") + self.end_headers() + + +if __name__ == '__main__': + server = HTTPServer(('localhost', 8081), Handler) + print 'Starting server, use to stop' + server.serve_forever() diff --git a/src/envoy/prototype/envoy-esp.conf b/src/envoy/prototype/envoy-esp.conf new file mode 100644 index 000000000000..00a981833daa --- /dev/null +++ b/src/envoy/prototype/envoy-esp.conf @@ -0,0 +1,82 @@ +{ + "listeners": [ + { + "port": 9090, + "filters": [ + { + "type": "read", + "name": "http_connection_manager", + "config": { + "codec_type": "auto", + "stat_prefix": "ingress_http", + "route_config": { + "virtual_hosts": [ + { + "name": "backend", + "domains": ["*"], + "routes": [ + { + "timeout_ms": 0, + "prefix": "/", + "cluster": "service1" + } + ] + } + ] + }, + "access_log": [ + { + "path": "/tmp/access.envoy" + } + ], + "filters": [ + { + "type": "both", + "name": "esp", + "config": { + "service_config": "src/envoy/prototype/service_config.json" + } + }, + { + "type": "decoder", + "name": "router", + "config": {} + } + ] + } + } + ] + } + ], + "admin": { + "access_log_path": "/tmp/access.envoy", + "port": 9001 + }, + "cluster_manager": { + "clusters": [ + { + "name": "service1", + "connect_timeout_ms": 5000, + "type": "strict_dns", + "lb_type": "round_robin", + "hosts": [ + { + "url": "tcp://localhost:8080" + } + ] + }, + { + "name": "api_manager", + "connect_timeout_ms": 5000, + "type": "strict_dns", + "lb_type": "round_robin", + "hosts": [ + { + "url": "tcp://localhost:8081" + } + ] + } + ] + }, + "tracing_enabled": "true" +} diff --git a/src/envoy/prototype/service_config.json b/src/envoy/prototype/service_config.json new file mode 100644 index 000000000000..ecc46beb7397 --- /dev/null +++ b/src/envoy/prototype/service_config.json @@ -0,0 +1,816 @@ +{ + "apis": [ + { + "methods": [ + { + "name": "GetMessage", + "requestTypeUrl": "type.googleapis.com/google.protobuf.Empty", + "responseTypeUrl": "type.googleapis.com/google.protobuf.Value" + }, + { + "name": "DeleteMessage", + "requestTypeUrl": "type.googleapis.com/google.protobuf.Empty", + "responseTypeUrl": "type.googleapis.com/google.protobuf.Value" + }, + { + "name": "PatchMessage", + "requestTypeUrl": "type.googleapis.com/google.protobuf.Empty", + "responseTypeUrl": "type.googleapis.com/google.protobuf.Value" + }, + { + "name": "PostMessage", + "requestTypeUrl": "type.googleapis.com/google.protobuf.Empty", + "responseTypeUrl": "type.googleapis.com/google.protobuf.Value" + }, + { + "name": "PutMessage", + "requestTypeUrl": "type.googleapis.com/google.protobuf.Empty", + "responseTypeUrl": "type.googleapis.com/google.protobuf.Value" + }, + { + "name": "GetMessageAuthed", + "requestTypeUrl": "type.googleapis.com/google.protobuf.Empty", + "responseTypeUrl": "type.googleapis.com/google.protobuf.Value" + }, + { + "name": "PostMessageAuthed", + "requestTypeUrl": "type.googleapis.com/google.protobuf.Empty", + "responseTypeUrl": "type.googleapis.com/google.protobuf.Value" + } + ], + "sourceContext": {}, + "version": "v1" + } + ], + "authentication": { + "providers": [ + { + "id": "test_jwk", + "issuer": "loadtest@esp-test-client.iam.gserviceaccount.com", + "jwksUri": "https://www.googleapis.com/service_accounts/v1/jwk/loadtest@esp-test-client.iam.gserviceaccount.com" + }, + { + "id": "test_symmetric", + "issuer": "https://test.echo.client", + "jwksUri": "http://169.254.169.254/computeMetadata/v1/project/attributes/auth-key-test_echo_client" + }, + { + "id": "test_x509", + "issuer": "account-1@esp-echo.iam.gserviceaccount.com", + "jwksUri": "https://www.googleapis.com/service_accounts/v1/metadata/x509/account-1@esp-echo.iam.gserviceaccount.com" + } + ], + "rules": [ + { + "requirements": [ + { + "providerId": "test_jwk" + }, + { + "providerId": "test_x509" + }, + { + "audiences": "test.echo.audience", + "providerId": "test_symmetric" + } + ], + "selector": "GetMessageAuthed" + }, + { + "requirements": [ + { + "providerId": "test_jwk" + }, + { + "providerId": "test_x509" + }, + { + "audiences": "test.echo.audience", + "providerId": "test_symmetric" + } + ], + "selector": "PostMessageAuthed" + } + ] + }, + "backend": { + "rules": [ + { + "selector": "GetMessage" + }, + { + "selector": "DeleteMessage" + }, + { + "selector": "PatchMessage" + }, + { + "selector": "PostMessage" + }, + { + "selector": "PutMessage" + }, + { + "selector": "GetMessageAuthed" + }, + { + "selector": "PostMessageAuthed" + } + ] + }, + "configVersion": 3, + "context": {}, + "control": { + "environment": "servicecontrol.googleapis.com" + }, + "customError": {}, + "documentation": { + "summary": "A simple Echo example." + }, + "endpoints": [ + { + "apis": [ + "" + ], + "features": [ + "googleapis.com/endpoint/grpc-autobahn" + ], + "name": "echo-dot-zlizan-dev.appspot.com" + } + ], + "enums": [ + { + "enumvalue": [ + { + "name": "NULL_VALUE" + } + ], + "name": "google.protobuf.NullValue", + "sourceContext": { + "fileName": "struct.proto" + } + } + ], + "features": [ + "googleprod.com/service/use-monarch" + ], + "http": { + "rules": [ + { + "get": "/echo", + "selector": "GetMessage" + }, + { + "delete": "/echo", + "selector": "DeleteMessage" + }, + { + "patch": "/echo", + "selector": "PatchMessage" + }, + { + "post": "/echo", + "selector": "PostMessage" + }, + { + "put": "/echo", + "selector": "PutMessage" + }, + { + "get": "/echo/auth", + "selector": "GetMessageAuthed" + }, + { + "post": "/echo/auth", + "selector": "PostMessageAuthed" + } + ] + }, + "legacy": { + "apiV1Name": "echo-dot-zlizan-dev.appspot.com" + }, + "logging": { + "producerDestinations": [ + { + "logs": [ + "endpoints_log" + ], + "monitoredResource": "api" + } + ] + }, + "logs": [ + { + "name": "endpoints_log" + } + ], + "metrics": [ + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/protocol" + }, + { + "key": "/response_code" + }, + { + "key": "/response_code_class" + }, + { + "key": "/status_code" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/request_count", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/error_type" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/error_count", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/total_latencies", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/protocol" + }, + { + "key": "/response_code" + }, + { + "key": "/response_code_class" + }, + { + "key": "/status_code" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/request_count", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/error_type" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/error_count", + "valueType": "INT64" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/total_latencies", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/end_user" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/top_request_count_by_end_user", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/end_user_country" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/top_request_count_by_end_user_country", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/referer" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/top_request_count_by_referer", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/protocol" + }, + { + "key": "/response_code" + }, + { + "key": "/consumer_id" + }, + { + "key": "/status_code" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/top_request_count_by_consumer", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/quota_group_name" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/quota_used_count", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/quota_group_name" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/quota_billable_count", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/request_overhead_latencies", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/backend_latencies", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/request_sizes", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/response_sizes", + "valueType": "DISTRIBUTION" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/request_overhead_latencies", + "valueType": "DISTRIBUTION" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/backend_latencies", + "valueType": "DISTRIBUTION" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/request_sizes", + "valueType": "DISTRIBUTION" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/response_sizes", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/consumer_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/top_request_sizes_by_consumer", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/consumer_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/top_response_sizes_by_consumer", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/protocol" + }, + { + "key": "/response_code" + }, + { + "key": "/response_code_class" + }, + { + "key": "/status_code" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/by_consumer/request_count", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/error_type" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/by_consumer/error_count", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/by_consumer/total_latencies", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + }, + { + "key": "/quota_group_name" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/by_consumer/quota_used_count", + "valueType": "INT64" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/by_consumer/request_overhead_latencies", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/by_consumer/backend_latencies", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/by_consumer/request_sizes", + "valueType": "DISTRIBUTION" + }, + { + "labels": [ + { + "key": "/credential_id" + } + ], + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/by_consumer/response_sizes", + "valueType": "DISTRIBUTION" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/streaming_request_message_count", + "valueType": "INT64" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/streaming_response_message_count", + "valueType": "INT64" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/streaming_request_message_count", + "valueType": "INT64" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/streaming_response_message_count", + "valueType": "INT64" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/streaming_request_durations", + "valueType": "DISTRIBUTION" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/producer/streaming_response_durations", + "valueType": "DISTRIBUTION" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/streaming_request_durations", + "valueType": "DISTRIBUTION" + }, + { + "metricKind": "DELTA", + "name": "serviceruntime.googleapis.com/api/consumer/streaming_response_durations", + "valueType": "DISTRIBUTION" + } + ], + "migration": {}, + "monitoredResources": [ + { + "labels": [ + { + "key": "cloud.googleapis.com/location" + }, + { + "key": "cloud.googleapis.com/uid" + }, + { + "key": "serviceruntime.googleapis.com/api_version" + }, + { + "key": "serviceruntime.googleapis.com/api_method" + }, + { + "key": "serviceruntime.googleapis.com/consumer_project" + }, + { + "key": "cloud.googleapis.com/project" + }, + { + "key": "cloud.googleapis.com/service" + } + ], + "type": "api" + } + ], + "monitoring": { + "consumerDestinations": [ + { + "metrics": [ + "serviceruntime.googleapis.com/api/consumer/request_count", + "serviceruntime.googleapis.com/api/consumer/error_count", + "serviceruntime.googleapis.com/api/consumer/quota_used_count", + "serviceruntime.googleapis.com/api/consumer/total_latencies", + "serviceruntime.googleapis.com/api/consumer/request_overhead_latencies", + "serviceruntime.googleapis.com/api/consumer/backend_latencies", + "serviceruntime.googleapis.com/api/consumer/request_sizes", + "serviceruntime.googleapis.com/api/consumer/response_sizes", + "serviceruntime.googleapis.com/api/consumer/top_request_count_by_end_user", + "serviceruntime.googleapis.com/api/consumer/top_request_count_by_end_user_country", + "serviceruntime.googleapis.com/api/consumer/top_request_count_by_referer", + "serviceruntime.googleapis.com/api/consumer/streaming_request_message_count", + "serviceruntime.googleapis.com/api/consumer/streaming_response_message_count", + "serviceruntime.googleapis.com/api/consumer/streaming_request_durations", + "serviceruntime.googleapis.com/api/consumer/streaming_response_durations" + ], + "monitoredResource": "api" + } + ], + "producerDestinations": [ + { + "metrics": [ + "serviceruntime.googleapis.com/api/producer/request_count", + "serviceruntime.googleapis.com/api/producer/error_count", + "serviceruntime.googleapis.com/api/producer/total_latencies", + "serviceruntime.googleapis.com/api/producer/request_overhead_latencies", + "serviceruntime.googleapis.com/api/producer/backend_latencies", + "serviceruntime.googleapis.com/api/producer/request_sizes", + "serviceruntime.googleapis.com/api/producer/response_sizes", + "serviceruntime.googleapis.com/api/producer/top_request_count_by_consumer", + "serviceruntime.googleapis.com/api/producer/top_request_sizes_by_consumer", + "serviceruntime.googleapis.com/api/producer/top_response_sizes_by_consumer", + "serviceruntime.googleapis.com/api/producer/streaming_request_message_count", + "serviceruntime.googleapis.com/api/producer/streaming_response_message_count", + "serviceruntime.googleapis.com/api/producer/streaming_request_durations", + "serviceruntime.googleapis.com/api/producer/streaming_response_durations", + "serviceruntime.googleapis.com/api/producer/by_consumer/request_count", + "serviceruntime.googleapis.com/api/producer/by_consumer/error_count", + "serviceruntime.googleapis.com/api/producer/by_consumer/total_latencies", + "serviceruntime.googleapis.com/api/producer/by_consumer/quota_used_count", + "serviceruntime.googleapis.com/api/producer/by_consumer/request_overhead_latencies", + "serviceruntime.googleapis.com/api/producer/by_consumer/backend_latencies", + "serviceruntime.googleapis.com/api/producer/by_consumer/request_sizes", + "serviceruntime.googleapis.com/api/producer/by_consumer/response_sizes" + ], + "monitoredResource": "api" + } + ] + }, + "name": "echo-dot-zlizan-dev.appspot.com", + "quota": {}, + "systemParameters": {}, + "title": "echo", + "types": [ + { + "fields": [ + { + "cardinality": "CARDINALITY_REPEATED", + "jsonName": "values", + "kind": "TYPE_MESSAGE", + "name": "values", + "number": 1, + "typeUrl": "type.googleapis.com/google.protobuf.Value" + } + ], + "name": "google.protobuf.ListValue", + "sourceContext": { + "fileName": "struct.proto" + } + }, + { + "fields": [ + { + "cardinality": "CARDINALITY_REPEATED", + "jsonName": "fields", + "kind": "TYPE_MESSAGE", + "name": "fields", + "number": 1, + "typeUrl": "type.googleapis.com/google.protobuf.Struct.FieldsEntry" + } + ], + "name": "google.protobuf.Struct", + "sourceContext": { + "fileName": "struct.proto" + } + }, + { + "fields": [ + { + "cardinality": "CARDINALITY_OPTIONAL", + "jsonName": "key", + "kind": "TYPE_STRING", + "name": "key", + "number": 1 + }, + { + "cardinality": "CARDINALITY_OPTIONAL", + "jsonName": "value", + "kind": "TYPE_MESSAGE", + "name": "value", + "number": 2, + "typeUrl": "type.googleapis.com/google.protobuf.Value" + } + ], + "name": "google.protobuf.Struct.FieldsEntry", + "sourceContext": { + "fileName": "struct.proto" + } + }, + { + "name": "google.protobuf.Empty", + "sourceContext": { + "fileName": "struct.proto" + } + }, + { + "fields": [ + { + "cardinality": "CARDINALITY_OPTIONAL", + "jsonName": "nullValue", + "kind": "TYPE_ENUM", + "name": "null_value", + "number": 1, + "typeUrl": "type.googleapis.com/google.protobuf.NullValue" + }, + { + "cardinality": "CARDINALITY_OPTIONAL", + "jsonName": "numberValue", + "kind": "TYPE_DOUBLE", + "name": "number_value", + "number": 2 + }, + { + "cardinality": "CARDINALITY_OPTIONAL", + "jsonName": "stringValue", + "kind": "TYPE_STRING", + "name": "string_value", + "number": 3 + }, + { + "cardinality": "CARDINALITY_OPTIONAL", + "jsonName": "boolValue", + "kind": "TYPE_BOOL", + "name": "bool_value", + "number": 4 + }, + { + "cardinality": "CARDINALITY_OPTIONAL", + "jsonName": "structValue", + "kind": "TYPE_MESSAGE", + "name": "struct_value", + "number": 5, + "typeUrl": "type.googleapis.com/google.protobuf.Struct" + }, + { + "cardinality": "CARDINALITY_OPTIONAL", + "jsonName": "listValue", + "kind": "TYPE_MESSAGE", + "name": "list_value", + "number": 6, + "typeUrl": "type.googleapis.com/google.protobuf.ListValue" + } + ], + "name": "google.protobuf.Value", + "sourceContext": { + "fileName": "struct.proto" + } + } + ], + "usage": { + "rules": [ + { + "allowUnregisteredCalls": true, + "selector": "GetMessage" + }, + { + "selector": "DeleteMessage" + }, + { + "selector": "PatchMessage" + }, + { + "selector": "PostMessage" + }, + { + "selector": "PutMessage" + }, + { + "selector": "GetMessageAuthed" + }, + { + "selector": "PostMessageAuthed" + } + ] + }, + "visibility": {} +} diff --git a/src/envoy/repositories.bzl b/src/envoy/repositories.bzl index 807caecbc8e3..49a603d10835 100644 --- a/src/envoy/repositories.bzl +++ b/src/envoy/repositories.bzl @@ -526,10 +526,12 @@ cc_library( "source/common/version_generated.cc", ], copts = [ - "-I./external/envoy_git/include", "-I./external/envoy_git/source", "-include ./external/envoy_git/source/precompiled/precompiled.h", ], + includes = [ + "include", + ], linkopts = [ "-lpthread", "-lanl", @@ -553,6 +555,21 @@ cc_library( ], ) +cc_library( + name = "envoy-main", + srcs = [ + "source/exe/main.cc", + ], + copts = [ + "-I./external/envoy_git/source", + "-include ./external/envoy_git/source/precompiled/precompiled.h", + ], + deps = [ + ":envoy-common", + ], + linkstatic=1, +) + cc_binary( name = "envoy", srcs = [