commit 64a553bd28340227b214588b9dea0cfe43f0ce0e Author: Sahil Takiar Date: Wed Nov 28 17:27:36 2018 -0500 Thrift 0.11.0 upgrade diff --git a/be/src/benchmarks/network-perf-benchmark.cc b/be/src/benchmarks/network-perf-benchmark.cc index 251399e..fdb5d6a 100644 --- a/be/src/benchmarks/network-perf-benchmark.cc +++ b/be/src/benchmarks/network-perf-benchmark.cc @@ -218,10 +218,10 @@ int main(int argc, char** argv) { } // Start up server and client shell - boost::shared_ptr handler(new TestServer); - boost::shared_ptr thread_factory( + std::shared_ptr handler(new TestServer); + std::shared_ptr thread_factory( new ThriftThreadFactory("test", "test")); - boost::shared_ptr processor(new NetworkTestServiceProcessor(handler)); + std::shared_ptr processor(new NetworkTestServiceProcessor(handler)); ThriftServer* server; ABORT_IF_ERROR(ThriftServerBuilder("Network Test Server", processor, FLAGS_port) .max_concurrent_connections(100) diff --git a/be/src/catalog/catalog-server.h b/be/src/catalog/catalog-server.h index 76ec2be..84b8253 100644 --- a/be/src/catalog/catalog-server.h +++ b/be/src/catalog/catalog-server.h @@ -69,7 +69,7 @@ class CatalogServer { void RegisterWebpages(Webserver* webserver); /// Returns the Thrift API interface that proxies requests onto the local CatalogService. - const boost::shared_ptr& thrift_iface() const { + const std::shared_ptr& thrift_iface() const { return thrift_iface_; } Catalog* catalog() const { return catalog_.get(); } @@ -81,7 +81,7 @@ class CatalogServer { private: /// Thrift API implementation which proxies requests onto this CatalogService. - boost::shared_ptr thrift_iface_; + std::shared_ptr thrift_iface_; ThriftSerializer thrift_serializer_; MetricGroup* metrics_; boost::scoped_ptr catalog_; diff --git a/be/src/catalog/catalog-service-client-wrapper.h b/be/src/catalog/catalog-service-client-wrapper.h index 653d5ed..f6a7853 100644 --- a/be/src/catalog/catalog-service-client-wrapper.h +++ b/be/src/catalog/catalog-service-client-wrapper.h @@ -25,13 +25,13 @@ namespace impala { class CatalogServiceClientWrapper : public CatalogServiceClient { public: CatalogServiceClientWrapper( - boost::shared_ptr<::apache::thrift::protocol::TProtocol> prot) + std::shared_ptr<::apache::thrift::protocol::TProtocol> prot) : CatalogServiceClient(prot) { } CatalogServiceClientWrapper( - boost::shared_ptr<::apache::thrift::protocol::TProtocol> iprot, - boost::shared_ptr<::apache::thrift::protocol::TProtocol> oprot) + std::shared_ptr<::apache::thrift::protocol::TProtocol> iprot, + std::shared_ptr<::apache::thrift::protocol::TProtocol> oprot) : CatalogServiceClient(iprot, oprot) { } diff --git a/be/src/catalog/catalogd-main.cc b/be/src/catalog/catalogd-main.cc index 250f27a..fc23414 100644 --- a/be/src/catalog/catalogd-main.cc +++ b/be/src/catalog/catalogd-main.cc @@ -86,9 +86,9 @@ int CatalogdMain(int argc, char** argv) { CatalogServer catalog_server(metrics.get()); ABORT_IF_ERROR(catalog_server.Start()); catalog_server.RegisterWebpages(webserver.get()); - boost::shared_ptr processor( + std::shared_ptr processor( new CatalogServiceProcessor(catalog_server.thrift_iface())); - boost::shared_ptr event_handler( + std::shared_ptr event_handler( new RpcEventHandler("catalog-server", metrics.get())); processor->setEventHandler(event_handler); diff --git a/be/src/rpc/TAcceptQueueServer.cpp b/be/src/rpc/TAcceptQueueServer.cpp index 730901b..8a3bcf7 100644 --- a/be/src/rpc/TAcceptQueueServer.cpp +++ b/be/src/rpc/TAcceptQueueServer.cpp @@ -39,7 +39,7 @@ namespace apache { namespace thrift { namespace server { -using boost::shared_ptr; +using std::shared_ptr; using namespace std; using namespace apache::thrift; using namespace apache::thrift::protocol; @@ -61,7 +61,7 @@ class TAcceptQueueServer::Task : public Runnable { ~Task() override = default; void run() override { - boost::shared_ptr eventHandler = server_.getEventHandler(); + std::shared_ptr eventHandler = server_.getEventHandler(); void* connectionContext = nullptr; if (eventHandler != nullptr) { connectionContext = eventHandler->createContext(input_, output_); @@ -122,11 +122,11 @@ class TAcceptQueueServer::Task : public Runnable { shared_ptr transport_; }; -TAcceptQueueServer::TAcceptQueueServer(const boost::shared_ptr& processor, - const boost::shared_ptr& serverTransport, - const boost::shared_ptr& transportFactory, - const boost::shared_ptr& protocolFactory, - const boost::shared_ptr& threadFactory, +TAcceptQueueServer::TAcceptQueueServer(const std::shared_ptr& processor, + const std::shared_ptr& serverTransport, + const std::shared_ptr& transportFactory, + const std::shared_ptr& protocolFactory, + const std::shared_ptr& threadFactory, int32_t maxTasks) : TServer(processor, serverTransport, transportFactory, protocolFactory), threadFactory_(threadFactory), maxTasks_(maxTasks) { @@ -144,7 +144,7 @@ void TAcceptQueueServer::init() { } // New. -void TAcceptQueueServer::SetupConnection(boost::shared_ptr client) { +void TAcceptQueueServer::SetupConnection(std::shared_ptr client) { if (metrics_enabled_) queue_size_metric_->Increment(-1); shared_ptr inputTransport; shared_ptr outputTransport; diff --git a/be/src/rpc/TAcceptQueueServer.h b/be/src/rpc/TAcceptQueueServer.h index 4d066ca..e63cee4 100644 --- a/be/src/rpc/TAcceptQueueServer.h +++ b/be/src/rpc/TAcceptQueueServer.h @@ -52,11 +52,11 @@ using apache::thrift::concurrency::ThreadFactory; class TAcceptQueueServer : public TServer { public: class Task; - TAcceptQueueServer(const boost::shared_ptr& processor, - const boost::shared_ptr& serverTransport, - const boost::shared_ptr& transportFactory, - const boost::shared_ptr& protocolFactory, - const boost::shared_ptr& threadFactory, + TAcceptQueueServer(const std::shared_ptr& processor, + const std::shared_ptr& serverTransport, + const std::shared_ptr& transportFactory, + const std::shared_ptr& protocolFactory, + const std::shared_ptr& threadFactory, int32_t maxTasks = 0); ~TAcceptQueueServer() override = default; @@ -78,9 +78,9 @@ class TAcceptQueueServer : public TServer { // This is the work function for the thread pool, which does the work of setting up the // connection and starting a thread to handle it. Will block if there are currently // maxTasks_ connections and maxTasks_ is non-zero. - void SetupConnection(boost::shared_ptr client); + void SetupConnection(std::shared_ptr client); - boost::shared_ptr threadFactory_; + std::shared_ptr threadFactory_; volatile bool stop_; // Monitor protecting tasks_, notified on removal. diff --git a/be/src/rpc/auth-provider.h b/be/src/rpc/auth-provider.h index f3180d5..83e6853 100644 --- a/be/src/rpc/auth-provider.h +++ b/be/src/rpc/auth-provider.h @@ -41,15 +41,15 @@ class AuthProvider { /// Creates a new Thrift transport factory in the out parameter that performs /// authorisation per this provider's protocol. virtual Status GetServerTransportFactory( - boost::shared_ptr* factory) + std::shared_ptr* factory) WARN_UNUSED_RESULT = 0; /// Called by Thrift clients to wrap a raw transport with any intermediate transport /// that an auth protocol requires. virtual Status WrapClientTransport(const std::string& hostname, - boost::shared_ptr raw_transport, + std::shared_ptr raw_transport, const std::string& service_name, - boost::shared_ptr* wrapped_transport) + std::shared_ptr* wrapped_transport) WARN_UNUSED_RESULT = 0; /// Returns true if this provider uses Sasl at the transport layer. @@ -76,9 +76,9 @@ class SaslAuthProvider : public AuthProvider { /// we can go straight to Kerberos. /// This is only applicable to Thrift connections and not KRPC connections. virtual Status WrapClientTransport(const std::string& hostname, - boost::shared_ptr raw_transport, + std::shared_ptr raw_transport, const std::string& service_name, - boost::shared_ptr* wrapped_transport); + std::shared_ptr* wrapped_transport); /// This sets up a mapping between auth types (PLAIN and GSSAPI) and callbacks. /// When a connection comes in, thrift will see one of the above on the wire, do @@ -86,7 +86,7 @@ class SaslAuthProvider : public AuthProvider { /// Then presto! You've got authentication for the connection. /// This is only applicable to Thrift connections and not KRPC connections. virtual Status GetServerTransportFactory( - boost::shared_ptr* factory); + std::shared_ptr* factory); virtual bool is_sasl() { return true; } @@ -152,12 +152,12 @@ class NoAuthProvider : public AuthProvider { virtual Status Start() { return Status::OK(); } virtual Status GetServerTransportFactory( - boost::shared_ptr* factory); + std::shared_ptr* factory); virtual Status WrapClientTransport(const std::string& hostname, - boost::shared_ptr raw_transport, + std::shared_ptr raw_transport, const std::string& service_name, - boost::shared_ptr* wrapped_transport); + std::shared_ptr* wrapped_transport); virtual bool is_sasl() { return false; } }; diff --git a/be/src/rpc/authentication.cc b/be/src/rpc/authentication.cc index 0b5b5d9..aa243d2 100644 --- a/be/src/rpc/authentication.cc +++ b/be/src/rpc/authentication.cc @@ -821,7 +821,7 @@ Status SaslAuthProvider::Start() { } Status SaslAuthProvider::GetServerTransportFactory( - boost::shared_ptr* factory) { + std::shared_ptr* factory) { DCHECK(!principal_.empty() || has_ldap_); // This is the heart of the link between this file and thrift. Here we @@ -859,10 +859,10 @@ Status SaslAuthProvider::GetServerTransportFactory( } Status SaslAuthProvider::WrapClientTransport(const string& hostname, - boost::shared_ptr raw_transport, const string& service_name, - boost::shared_ptr* wrapped_transport) { + std::shared_ptr raw_transport, const string& service_name, + std::shared_ptr* wrapped_transport) { - boost::shared_ptr sasl_client; + std::shared_ptr sasl_client; const map props; // Empty; unused by thrift const string auth_id; // Empty; unused by thrift @@ -890,15 +890,15 @@ Status SaslAuthProvider::WrapClientTransport(const string& hostname, } Status NoAuthProvider::GetServerTransportFactory( - boost::shared_ptr* factory) { + std::shared_ptr* factory) { // No Sasl - yawn. Here, have a regular old buffered transport. factory->reset(new ThriftServer::BufferedTransportFactory()); return Status::OK(); } Status NoAuthProvider::WrapClientTransport(const string& hostname, - boost::shared_ptr raw_transport, const string& dummy_service, - boost::shared_ptr* wrapped_transport) { + std::shared_ptr raw_transport, const string& dummy_service, + std::shared_ptr* wrapped_transport) { // No Sasl - yawn. Don't do any transport wrapping for clients. *wrapped_transport = raw_transport; return Status::OK(); diff --git a/be/src/rpc/thrift-client.h b/be/src/rpc/thrift-client.h index 8194016..8722f50 100644 --- a/be/src/rpc/thrift-client.h +++ b/be/src/rpc/thrift-client.h @@ -87,7 +87,7 @@ class ThriftClientImpl { /// Sasl Client object. Contains client kerberos identification data. /// Will be NULL if kerberos is not being used. - boost::shared_ptr sasl_client_; + std::shared_ptr sasl_client_; /// This factory sets up the openSSL library state and needs to be alive as long as its /// owner(a ThriftClientImpl instance) does. Otherwise the OpenSSL state is lost @@ -95,9 +95,9 @@ class ThriftClientImpl { boost::scoped_ptr ssl_factory_; /// All shared pointers, because Thrift requires them to be - boost::shared_ptr socket_; - boost::shared_ptr transport_; - boost::shared_ptr protocol_; + std::shared_ptr socket_; + std::shared_ptr transport_; + std::shared_ptr protocol_; }; @@ -122,7 +122,7 @@ class ThriftClient : public ThriftClientImpl { InterfaceType* iface() { return iface_.get(); } private: - boost::shared_ptr iface_; + std::shared_ptr iface_; AuthProvider* auth_provider_; }; diff --git a/be/src/rpc/thrift-server-test.cc b/be/src/rpc/thrift-server-test.cc index 621f557..4d6baa9 100644 --- a/be/src/rpc/thrift-server-test.cc +++ b/be/src/rpc/thrift-server-test.cc @@ -78,9 +78,9 @@ class DummyStatestoreService : public StatestoreServiceIf { } }; -boost::shared_ptr MakeProcessor() { - boost::shared_ptr service(new DummyStatestoreService()); - return boost::shared_ptr(new StatestoreServiceProcessor(service)); +std::shared_ptr MakeProcessor() { + std::shared_ptr service(new DummyStatestoreService()); + return std::shared_ptr(new StatestoreServiceProcessor(service)); } int GetServerPort() { diff --git a/be/src/rpc/thrift-server.cc b/be/src/rpc/thrift-server.cc index 62b11fd..b29f0a8 100644 --- a/be/src/rpc/thrift-server.cc +++ b/be/src/rpc/thrift-server.cc @@ -120,15 +120,15 @@ class ThriftServer::ThriftServerEventProcessor : public TServerEventHandler { // Called when a client connects; we create per-client state and call any // ConnectionHandlerIf handler. - virtual void* createContext(boost::shared_ptr input, - boost::shared_ptr output); + virtual void* createContext(std::shared_ptr input, + std::shared_ptr output); // Called when a client starts an RPC; we set the thread-local connection context. - virtual void processContext(void* context, boost::shared_ptr output); + virtual void processContext(void* context, std::shared_ptr output); // Called when a client disconnects; we call any ConnectionHandlerIf handler. - virtual void deleteContext(void* serverContext, boost::shared_ptr input, - boost::shared_ptr output); + virtual void deleteContext(void* serverContext, std::shared_ptr input, + std::shared_ptr output); // Waits for a timeout of TIMEOUT_MS for a server to signal that it has started // correctly. @@ -249,11 +249,11 @@ const ThriftServer::ConnectionContext* ThriftServer::GetThreadConnectionContext( } void* ThriftServer::ThriftServerEventProcessor::createContext( - boost::shared_ptr input, boost::shared_ptr output) { + std::shared_ptr input, std::shared_ptr output) { TSocket* socket = NULL; TTransport* transport = input->getTransport().get(); - boost::shared_ptr connection_ptr = - boost::shared_ptr(new ConnectionContext); + std::shared_ptr connection_ptr = + std::shared_ptr(new ConnectionContext); TTransport* underlying_transport = (static_cast(transport))->getUnderlyingTransport().get(); if (!thrift_server_->auth_provider_->is_sasl()) { @@ -297,12 +297,12 @@ void* ThriftServer::ThriftServerEventProcessor::createContext( } void ThriftServer::ThriftServerEventProcessor::processContext(void* context, - boost::shared_ptr transport) { + std::shared_ptr transport) { __connection_context__ = reinterpret_cast(context); } void ThriftServer::ThriftServerEventProcessor::deleteContext(void* serverContext, - boost::shared_ptr input, boost::shared_ptr output) { + std::shared_ptr input, std::shared_ptr output) { __connection_context__ = (ConnectionContext*) serverContext; if (thrift_server_->connection_handler_ != NULL) { @@ -320,7 +320,7 @@ void ThriftServer::ThriftServerEventProcessor::deleteContext(void* serverContext } ThriftServer::ThriftServer(const string& name, - const boost::shared_ptr& processor, int port, AuthProvider* auth_provider, + const std::shared_ptr& processor, int port, AuthProvider* auth_provider, MetricGroup* metrics, int max_concurrent_connections) : started_(false), port_(port), @@ -406,7 +406,7 @@ class ImpalaSslSocketFactory : public TSSLSocketFactory { const string password_; }; } -Status ThriftServer::CreateSocket(boost::shared_ptr* socket) { +Status ThriftServer::CreateSocket(std::shared_ptr* socket) { if (ssl_enabled()) { if (!SSLProtoVersions::IsSupported(version_)) { return Status(TErrorCode::SSL_SOCKET_CREATION_FAILED, @@ -416,7 +416,7 @@ Status ThriftServer::CreateSocket(boost::shared_ptr* socket) { try { // This 'factory' is only called once, since CreateSocket() is only called from // Start(). The c'tor may throw if there is an error initializing the SSL context. - boost::shared_ptr socket_factory( + std::shared_ptr socket_factory( new ImpalaSslSocketFactory(version_, key_password_)); socket_factory->overrideDefaultPasswordCallback(); @@ -470,14 +470,14 @@ Status ThriftServer::EnableSsl(SSLProtocol version, const string& certificate, Status ThriftServer::Start() { DCHECK(!started_); - boost::shared_ptr protocol_factory(new TBinaryProtocolFactory()); - boost::shared_ptr thread_factory( + std::shared_ptr protocol_factory(new TBinaryProtocolFactory()); + std::shared_ptr thread_factory( new ThriftThreadFactory("thrift-server", name_)); // Note - if you change the transport types here, you must check that the // logic in createContext is still accurate. - boost::shared_ptr server_socket; - boost::shared_ptr transport_factory; + std::shared_ptr server_socket; + std::shared_ptr transport_factory; RETURN_IF_ERROR(CreateSocket(&server_socket)); RETURN_IF_ERROR(auth_provider_->GetServerTransportFactory(&transport_factory)); server_.reset(new TAcceptQueueServer(processor_, server_socket, transport_factory, @@ -486,7 +486,7 @@ Status ThriftServer::Start() { (static_cast(server_.get()))->InitMetrics(metrics_, Substitute("impala.thrift-server.$0", name_)); } - boost::shared_ptr event_processor( + std::shared_ptr event_processor( new ThriftServer::ThriftServerEventProcessor(this)); server_->setServerEventHandler(event_processor); diff --git a/be/src/rpc/thrift-server.h b/be/src/rpc/thrift-server.h index 866d9c5..e79bfed 100644 --- a/be/src/rpc/thrift-server.h +++ b/be/src/rpc/thrift-server.h @@ -55,9 +55,9 @@ class ThriftServer { BufferedTransportFactory(uint32_t buffer_size = DEFAULT_BUFFER_SIZE_BYTES) : buffer_size_(buffer_size) { } - virtual boost::shared_ptr getTransport( - boost::shared_ptr trans) { - return boost::shared_ptr( + virtual std::shared_ptr getTransport( + std::shared_ptr trans) { + return std::shared_ptr( new apache::thrift::transport::TBufferedTransport(trans, buffer_size_)); } private: @@ -143,7 +143,7 @@ class ThriftServer { /// - max_concurrent_connections: The maximum number of concurrent connections allowed. /// If 0, there will be no enforced limit on the number of concurrent connections. ThriftServer(const std::string& name, - const boost::shared_ptr& processor, int port, + const std::shared_ptr& processor, int port, AuthProvider* auth_provider = nullptr, MetricGroup* metrics = nullptr, int max_concurrent_connections = 0); @@ -160,7 +160,7 @@ class ThriftServer { /// Creates the server socket on which this server listens. May be SSL enabled. Returns /// OK unless there was a Thrift error. - Status CreateSocket(boost::shared_ptr* socket); + Status CreateSocket(std::shared_ptr* socket); /// True if the server has been successfully started, for internal use only bool started_; @@ -201,7 +201,7 @@ class ThriftServer { /// Thrift housekeeping boost::scoped_ptr server_; - boost::shared_ptr processor_; + std::shared_ptr processor_; /// If not nullptr, called when connection events happen. Not owned by us. ConnectionHandlerIf* connection_handler_; @@ -211,7 +211,7 @@ class ThriftServer { /// Map of active connection context to a shared_ptr containing that context; when an /// item is removed from the map, it is automatically freed. - typedef boost::unordered_map> + typedef boost::unordered_map> ConnectionContextSet; ConnectionContextSet connection_contexts_; @@ -243,7 +243,7 @@ class ThriftServer { class ThriftServerBuilder { public: ThriftServerBuilder(const std::string& name, - const boost::shared_ptr& processor, int port) + const std::shared_ptr& processor, int port) : name_(name), processor_(processor), port_(port) {} /// Sets the auth provider for this server. Default is the system global auth provider. @@ -313,7 +313,7 @@ class ThriftServerBuilder { private: int max_concurrent_connections_ = 0; std::string name_; - boost::shared_ptr processor_; + std::shared_ptr processor_; int port_ = 0; AuthProvider* auth_provider_ = nullptr; diff --git a/be/src/rpc/thrift-thread.cc b/be/src/rpc/thrift-thread.cc index ef2144d..fb7dd39 100644 --- a/be/src/rpc/thrift-thread.cc +++ b/be/src/rpc/thrift-thread.cc @@ -54,17 +54,17 @@ void ThriftThread::join() { impala_thread_->Join(); } -boost::shared_ptr ThriftThreadFactory::newThread( - boost::shared_ptr runnable) const { +std::shared_ptr ThriftThreadFactory::newThread( + std::shared_ptr runnable) const { stringstream name; name << prefix_ << "-" << count_++; - boost::shared_ptr result = - boost::shared_ptr(new ThriftThread(group_, name.str(), runnable)); + std::shared_ptr result = + std::shared_ptr(new ThriftThread(group_, name.str(), runnable)); runnable->thread(result); return result; } -void ThriftThread::RunRunnable(boost::shared_ptr runnable, +void ThriftThread::RunRunnable(std::shared_ptr runnable, Promise* promise) { promise->Set(get_current()); // Passing runnable in to this method (rather than reading from this->runnable()) @@ -79,7 +79,7 @@ atc::Thread::id_t ThriftThreadFactory::getCurrentThreadId() const { } ThriftThread::ThriftThread(const string& group, const string& name, - boost::shared_ptr runnable) + std::shared_ptr runnable) : group_(group), name_(name) { // Sets this::runnable (and no, I don't know why it's not protected in atc::Thread) this->Thread::runnable(runnable); diff --git a/be/src/rpc/thrift-thread.h b/be/src/rpc/thrift-thread.h index 468964b..b946f52 100644 --- a/be/src/rpc/thrift-thread.h +++ b/be/src/rpc/thrift-thread.h @@ -36,11 +36,11 @@ class ThriftThreadFactory : public apache::thrift::concurrency::ThreadFactory { /// Group is the thread group for new threads to be assigned to, and prefix is the /// per-thread prefix (threads are named "prefix--"). ThriftThreadFactory(const std::string& group, const std::string& prefix) - : group_(group), prefix_(prefix), count_(0) { } + : ThreadFactory(false), group_(group), prefix_(prefix), count_(0) { } /// (From ThreadFactory) - creates a new ThriftThread to run the supplied Runnable. - virtual boost::shared_ptr newThread( - boost::shared_ptr runnable) const; + virtual std::shared_ptr newThread( + std::shared_ptr runnable) const; /// (From ThreadFactory) - returns the *current* thread ID, i.e. the ID of the executing /// thread (which may not have been created by this factory). @@ -63,7 +63,7 @@ class ThriftThreadFactory : public apache::thrift::concurrency::ThreadFactory { class ThriftThread : public apache::thrift::concurrency::Thread { public: ThriftThread(const std::string& group, const std::string& name, - boost::shared_ptr runnable); + std::shared_ptr runnable); /// (From Thread) - starts execution of the runnable in a separate thread, returning once /// execution has begun. @@ -81,7 +81,7 @@ class ThriftThread : public apache::thrift::concurrency::Thread { /// Method executed on impala_thread_. Runs the Runnable once promise has been set to the /// current thread ID. The runnable parameter is a shared_ptr so that is always valid /// even after the ThriftThread may have been terminated. - void RunRunnable(boost::shared_ptr runnable, + void RunRunnable(std::shared_ptr runnable, Promise* promise); /// Impala thread that runs the runnable and registers itself with the global diff --git a/be/src/rpc/thrift-util.cc b/be/src/rpc/thrift-util.cc index a9fd0dc..257b5e8 100644 --- a/be/src/rpc/thrift-util.cc +++ b/be/src/rpc/thrift-util.cc @@ -62,10 +62,11 @@ using namespace apache::thrift::concurrency; // functions may change between different versions of Thrift. static_assert(PACKAGE_VERSION[0] == '0', ""); static_assert(PACKAGE_VERSION[1] == '.', ""); -static_assert(PACKAGE_VERSION[2] == '9', ""); -static_assert(PACKAGE_VERSION[3] == '.', ""); -static_assert(PACKAGE_VERSION[4] == '3', ""); -static_assert(PACKAGE_VERSION[5] == '\0', ""); +static_assert(PACKAGE_VERSION[2] == '1', ""); +static_assert(PACKAGE_VERSION[3] == '1', ""); +static_assert(PACKAGE_VERSION[4] == '.', ""); +static_assert(PACKAGE_VERSION[5] == '0', ""); +static_assert(PACKAGE_VERSION[6] == '\0', ""); // Thrift defines operator< but does not implement it. This is a stub // implementation so we can link. @@ -88,8 +89,8 @@ ThriftSerializer::ThriftSerializer(bool compact, int initial_buffer_size) : } } -boost::shared_ptr CreateDeserializeProtocol( - boost::shared_ptr mem, bool compact) { +std::shared_ptr CreateDeserializeProtocol( + std::shared_ptr mem, bool compact) { if (compact) { TCompactProtocolFactoryT tproto_factory; return tproto_factory.getProtocol(mem); diff --git a/be/src/rpc/thrift-util.h b/be/src/rpc/thrift-util.h index bd15491..f2b2151 100644 --- a/be/src/rpc/thrift-util.h +++ b/be/src/rpc/thrift-util.h @@ -89,14 +89,14 @@ class ThriftSerializer { } private: - boost::shared_ptr mem_buffer_; - boost::shared_ptr protocol_; + std::shared_ptr mem_buffer_; + std::shared_ptr protocol_; }; /// Utility to create a protocol (deserialization) object for 'mem'. -boost::shared_ptr +std::shared_ptr CreateDeserializeProtocol( - boost::shared_ptr mem, bool compact); + std::shared_ptr mem, bool compact); /// Deserialize a thrift message from buf/len. buf/len must at least contain /// all the bytes needed to store the thrift message. On return, len will be @@ -107,9 +107,9 @@ Status DeserializeThriftMsg(const uint8_t* buf, uint32_t* len, bool compact, /// Deserialize msg bytes into c++ thrift msg using memory /// transport. TMemoryBuffer is not const-safe, although we use it in /// a const-safe way, so we have to explicitly cast away the const. - boost::shared_ptr tmem_transport( + std::shared_ptr tmem_transport( new apache::thrift::transport::TMemoryBuffer(const_cast(buf), *len)); - boost::shared_ptr tproto = + std::shared_ptr tproto = CreateDeserializeProtocol(tmem_transport, compact); try { deserialized_msg->read(tproto.get()); diff --git a/be/src/runtime/backend-client.h b/be/src/runtime/backend-client.h index 977049a..5f468c3 100644 --- a/be/src/runtime/backend-client.h +++ b/be/src/runtime/backend-client.h @@ -31,12 +31,12 @@ namespace impala { /// between backends in a query can be measured. class ImpalaBackendClient : public ImpalaInternalServiceClient { public: - ImpalaBackendClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) + ImpalaBackendClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : ImpalaInternalServiceClient(prot), transmit_csw_(NULL) { } - ImpalaBackendClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, - boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) + ImpalaBackendClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, + std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : ImpalaInternalServiceClient(iprot, oprot), transmit_csw_(NULL) { } diff --git a/be/src/service/impala-server.cc b/be/src/service/impala-server.cc index ec39b04..5a0c7c2 100644 --- a/be/src/service/impala-server.cc +++ b/be/src/service/impala-server.cc @@ -2220,10 +2220,10 @@ Status ImpalaServer::Start(int32_t thrift_be_port, int32_t beeswax_port, // Start the internal service. if (thrift_be_port > 0 || (TestInfo::is_test() && thrift_be_port == 0)) { - boost::shared_ptr thrift_if(new ImpalaInternalService()); - boost::shared_ptr be_processor( + std::shared_ptr thrift_if(new ImpalaInternalService()); + std::shared_ptr be_processor( new ImpalaInternalServiceProcessor(thrift_if)); - boost::shared_ptr event_handler( + std::shared_ptr event_handler( new RpcEventHandler("backend", exec_env_->metrics())); be_processor->setEventHandler(event_handler); @@ -2246,11 +2246,11 @@ Status ImpalaServer::Start(int32_t thrift_be_port, int32_t beeswax_port, << TNetworkAddressToString(GetThriftBackendAddress()); } else { // Initialize the client servers. - boost::shared_ptr handler = shared_from_this(); + std::shared_ptr handler = shared_from_this(); if (beeswax_port > 0 || (TestInfo::is_test() && beeswax_port == 0)) { - boost::shared_ptr beeswax_processor( + std::shared_ptr beeswax_processor( new ImpalaServiceProcessor(handler)); - boost::shared_ptr event_handler( + std::shared_ptr event_handler( new RpcEventHandler("beeswax", exec_env_->metrics())); beeswax_processor->setEventHandler(event_handler); ThriftServerBuilder builder(BEESWAX_SERVER_NAME, beeswax_processor, beeswax_port); @@ -2274,9 +2274,9 @@ Status ImpalaServer::Start(int32_t thrift_be_port, int32_t beeswax_port, } if (hs2_port > 0 || (TestInfo::is_test() && hs2_port == 0)) { - boost::shared_ptr hs2_fe_processor( + std::shared_ptr hs2_fe_processor( new ImpalaHiveServer2ServiceProcessor(handler)); - boost::shared_ptr event_handler( + std::shared_ptr event_handler( new RpcEventHandler("hs2", exec_env_->metrics())); hs2_fe_processor->setEventHandler(event_handler); diff --git a/be/src/service/impala-server.h b/be/src/service/impala-server.h index 0f4392e..f9723e5 100644 --- a/be/src/service/impala-server.h +++ b/be/src/service/impala-server.h @@ -158,7 +158,7 @@ class QuerySchedule; class ImpalaServer : public ImpalaServiceIf, public ImpalaHiveServer2ServiceIf, public ThriftServer::ConnectionHandlerIf, - public boost::enable_shared_from_this, + public std::enable_shared_from_this, public CacheLineAligned { public: diff --git a/be/src/service/impalad-main.cc b/be/src/service/impalad-main.cc index 2b7cc95..b58ec45 100644 --- a/be/src/service/impalad-main.cc +++ b/be/src/service/impalad-main.cc @@ -83,7 +83,7 @@ int ImpaladMain(int argc, char** argv) { StartThreadInstrumentation(exec_env.metrics(), exec_env.webserver(), true)); InitRpcEventTracing(exec_env.webserver(), exec_env.rpc_mgr()); - boost::shared_ptr impala_server(new ImpalaServer(&exec_env)); + std::shared_ptr impala_server(new ImpalaServer(&exec_env)); Status status = impala_server->Start(FLAGS_be_port, FLAGS_beeswax_port, FLAGS_hs2_port); if (!status.ok()) { diff --git a/be/src/statestore/statestore-service-client-wrapper.h b/be/src/statestore/statestore-service-client-wrapper.h index 79068a2..2c77cbc 100644 --- a/be/src/statestore/statestore-service-client-wrapper.h +++ b/be/src/statestore/statestore-service-client-wrapper.h @@ -25,13 +25,13 @@ namespace impala { class StatestoreServiceClientWrapper : public StatestoreServiceClient { public: StatestoreServiceClientWrapper( - boost::shared_ptr<::apache::thrift::protocol::TProtocol> prot) + std::shared_ptr<::apache::thrift::protocol::TProtocol> prot) : StatestoreServiceClient(prot) { } StatestoreServiceClientWrapper( - boost::shared_ptr<::apache::thrift::protocol::TProtocol> iprot, - boost::shared_ptr<::apache::thrift::protocol::TProtocol> oprot) + std::shared_ptr<::apache::thrift::protocol::TProtocol> iprot, + std::shared_ptr<::apache::thrift::protocol::TProtocol> oprot) : StatestoreServiceClient(iprot, oprot) { } diff --git a/be/src/statestore/statestore-subscriber-client-wrapper.h b/be/src/statestore/statestore-subscriber-client-wrapper.h index 2d40031..b5f66be 100644 --- a/be/src/statestore/statestore-subscriber-client-wrapper.h +++ b/be/src/statestore/statestore-subscriber-client-wrapper.h @@ -25,13 +25,13 @@ namespace impala { class StatestoreSubscriberClientWrapper : public StatestoreSubscriberClient { public: StatestoreSubscriberClientWrapper( - boost::shared_ptr<::apache::thrift::protocol::TProtocol> prot) + std::shared_ptr<::apache::thrift::protocol::TProtocol> prot) : StatestoreSubscriberClient(prot) { } StatestoreSubscriberClientWrapper( - boost::shared_ptr<::apache::thrift::protocol::TProtocol> iprot, - boost::shared_ptr<::apache::thrift::protocol::TProtocol> oprot) + std::shared_ptr<::apache::thrift::protocol::TProtocol> iprot, + std::shared_ptr<::apache::thrift::protocol::TProtocol> oprot) : StatestoreSubscriberClient(iprot, oprot) { } diff --git a/be/src/statestore/statestore-subscriber.cc b/be/src/statestore/statestore-subscriber.cc index c83b520..23514f6 100644 --- a/be/src/statestore/statestore-subscriber.cc +++ b/be/src/statestore/statestore-subscriber.cc @@ -206,9 +206,9 @@ Status StatestoreSubscriber::Start() { LOG(INFO) << "Starting statestore subscriber"; // Backend must be started before registration - boost::shared_ptr processor( + std::shared_ptr processor( new StatestoreSubscriberProcessor(thrift_iface_)); - boost::shared_ptr event_handler( + std::shared_ptr event_handler( new RpcEventHandler("statestore-subscriber", metrics_)); processor->setEventHandler(event_handler); diff --git a/be/src/statestore/statestore-subscriber.h b/be/src/statestore/statestore-subscriber.h index 016343f..6df1e3d 100644 --- a/be/src/statestore/statestore-subscriber.h +++ b/be/src/statestore/statestore-subscriber.h @@ -136,7 +136,7 @@ class StatestoreSubscriber { /// Implementation of the heartbeat thrift interface, which proxies /// calls onto this object. - boost::shared_ptr thrift_iface_; + std::shared_ptr thrift_iface_; /// Container for the heartbeat server. std::shared_ptr heartbeat_server_; diff --git a/be/src/statestore/statestore.cc b/be/src/statestore/statestore.cc index 234c63c..3606b33 100644 --- a/be/src/statestore/statestore.cc +++ b/be/src/statestore/statestore.cc @@ -453,8 +453,8 @@ Statestore::~Statestore() { } Status Statestore::Init(int32_t state_store_port) { - boost::shared_ptr processor(new StatestoreServiceProcessor(thrift_iface())); - boost::shared_ptr event_handler( + std::shared_ptr processor(new StatestoreServiceProcessor(thrift_iface())); + std::shared_ptr event_handler( new RpcEventHandler("statestore", metrics_)); processor->setEventHandler(event_handler); ThriftServerBuilder builder("StatestoreService", processor, state_store_port); diff --git a/be/src/statestore/statestore.h b/be/src/statestore/statestore.h index 871494c..7f3b9a4 100644 --- a/be/src/statestore/statestore.h +++ b/be/src/statestore/statestore.h @@ -163,7 +163,7 @@ class Statestore : public CacheLineAligned { void ShutdownForTesting(); /// Returns the Thrift API interface that proxies requests onto the local Statestore. - const boost::shared_ptr& thrift_iface() const { + const std::shared_ptr& thrift_iface() const { return thrift_iface_; } @@ -579,7 +579,7 @@ class Statestore : public CacheLineAligned { MetricGroup* metrics_; /// Thrift API implementation which proxies requests onto this Statestore - boost::shared_ptr thrift_iface_; + std::shared_ptr thrift_iface_; /// Failure detector for subscribers. If a subscriber misses a configurable number of /// consecutive heartbeat messages, it is considered failed and a) its transient topic diff --git a/be/src/statestore/statestored-main.cc b/be/src/statestore/statestored-main.cc index d7db794..5458b0f 100644 --- a/be/src/statestore/statestored-main.cc +++ b/be/src/statestore/statestored-main.cc @@ -79,7 +79,7 @@ int StatestoredMain(int argc, char** argv) { statestore.RegisterWebpages(webserver.get()); boost::shared_ptr processor( new StatestoreServiceProcessor(statestore.thrift_iface())); - boost::shared_ptr event_handler( + std::shared_ptr event_handler( new RpcEventHandler("statestore", metrics.get())); processor->setEventHandler(event_handler); diff --git a/be/src/testutil/in-process-servers.h b/be/src/testutil/in-process-servers.h index f863650..f4022e5 100644 --- a/be/src/testutil/in-process-servers.h +++ b/be/src/testutil/in-process-servers.h @@ -87,7 +87,7 @@ class InProcessImpalaServer { uint32_t hs2_port_; /// The ImpalaServer that handles client and backend requests. - boost::shared_ptr impala_server_; + std::shared_ptr impala_server_; /// ExecEnv holds much of the per-service state boost::scoped_ptr exec_env_; diff --git a/be/src/transport/TSaslClientTransport.cpp b/be/src/transport/TSaslClientTransport.cpp index 5d20e63..89ecff7 100644 --- a/be/src/transport/TSaslClientTransport.cpp +++ b/be/src/transport/TSaslClientTransport.cpp @@ -32,8 +32,8 @@ using namespace sasl; namespace apache { namespace thrift { namespace transport { -TSaslClientTransport::TSaslClientTransport(boost::shared_ptr saslClient, - boost::shared_ptr transport) +TSaslClientTransport::TSaslClientTransport(std::shared_ptr saslClient, + std::shared_ptr transport) : TSaslTransport(saslClient, transport) { } diff --git a/be/src/transport/TSaslClientTransport.h b/be/src/transport/TSaslClientTransport.h index f23a3c0..01e8230 100644 --- a/be/src/transport/TSaslClientTransport.h +++ b/be/src/transport/TSaslClientTransport.h @@ -44,8 +44,8 @@ class TSaslClientTransport : public TSaslTransport { * saslClient: the sasl object implimenting the underlying authentication handshake * transport: the transport to read and write data. */ - TSaslClientTransport(boost::shared_ptr saslClient, - boost::shared_ptr transport); + TSaslClientTransport(std::shared_ptr saslClient, + std::shared_ptr transport); protected: /* Set up the Sasl server state for a connection. */ diff --git a/be/src/transport/TSaslServerTransport.cpp b/be/src/transport/TSaslServerTransport.cpp index 15d548e..a008a8e 100644 --- a/be/src/transport/TSaslServerTransport.cpp +++ b/be/src/transport/TSaslServerTransport.cpp @@ -43,7 +43,7 @@ DEFINE_int32(sasl_connect_tcp_timeout_ms, 300000, "(Advanced) The underlying TSo using namespace sasl; namespace apache { namespace thrift { namespace transport { -TSaslServerTransport::TSaslServerTransport(boost::shared_ptr transport) +TSaslServerTransport::TSaslServerTransport(std::shared_ptr transport) : TSaslTransport(transport) { } @@ -54,7 +54,7 @@ TSaslServerTransport::TSaslServerTransport(const string& mechanism, unsigned flags, const map& props, const vector& callbacks, - boost::shared_ptr transport) + std::shared_ptr transport) : TSaslTransport(transport) { addServerDefinition(mechanism, protocol, serverName, realm, flags, props, callbacks); @@ -62,7 +62,7 @@ TSaslServerTransport::TSaslServerTransport(const string& mechanism, TSaslServerTransport:: TSaslServerTransport( const std::map& serverMap, - boost::shared_ptr transport) + std::shared_ptr transport) : TSaslTransport(transport) { serverDefinitionMap_.insert(serverMap.begin(), serverMap.end()); } @@ -128,8 +128,8 @@ void TSaslServerTransport::handleSaslStartMessage() { } -boost::shared_ptr TSaslServerTransport::Factory::getTransport( - boost::shared_ptr trans) { +std::shared_ptr TSaslServerTransport::Factory::getTransport( + std::shared_ptr trans) { // Thrift servers use both an input and an output transport to communicate with // clients. In principal, these can be different, but for SASL clients we require them // to be the same so that the authentication state is identical for communication in @@ -150,7 +150,7 @@ boost::shared_ptr TSaslServerTransport::Factory::getTransport( // ensure that when ret_transport is eventually deleted, its corresponding map entry is // removed. That is likely to be error prone given the locking involved; for now we go // with the simple solution. - boost::shared_ptr ret_transport; + std::shared_ptr ret_transport; { lock_guard l(transportMap_mutex_); TransportMap::iterator trans_map = transportMap_.find(trans); @@ -162,7 +162,7 @@ boost::shared_ptr TSaslServerTransport::Factory::getTransport( // This method should never be called concurrently with the same 'trans' object. // Therefore, it is safe to drop the transportMap_mutex_ here. } - boost::shared_ptr wrapped( + std::shared_ptr wrapped( new TSaslServerTransport(serverDefinitionMap_, trans)); // Set socket timeouts to prevent TSaslServerTransport->open from blocking the server // from accepting new connections if a read/write blocks during the handshake diff --git a/be/src/transport/TSaslServerTransport.h b/be/src/transport/TSaslServerTransport.h index b01fcf3..6d3e42c 100644 --- a/be/src/transport/TSaslServerTransport.h +++ b/be/src/transport/TSaslServerTransport.h @@ -100,7 +100,7 @@ class TSaslServerTransport : public TSaslTransport { /* Wrap the passed transport in a transport for the defined server. */ TSaslServerTransport(const std::map& serverMap, - boost::shared_ptr transport); + std::shared_ptr transport); public: @@ -109,7 +109,7 @@ class TSaslServerTransport : public TSaslTransport { * transport: the underlying transport used to read and write data. * */ - TSaslServerTransport(boost::shared_ptr transport); + TSaslServerTransport(std::shared_ptr transport); /** * Construct a new TSaslTrasnport, passing in the components of the definition. @@ -121,7 +121,7 @@ class TSaslServerTransport : public TSaslTransport { unsigned flags, const std::map& props, const std::vector& callbacks, - boost::shared_ptr transport); + std::shared_ptr transport); /* Add a definition to a server transport */ void addServerDefinition(const std::string& mechanism, @@ -166,8 +166,8 @@ class TSaslServerTransport : public TSaslTransport { /** * Wraps the transport with the Sasl protocol. */ - virtual boost::shared_ptr getTransport( - boost::shared_ptr trans); + virtual std::shared_ptr getTransport( + std::shared_ptr trans); /* Add a definition to a server transport factory */ void addServerDefinition(const std::string& mechanism, @@ -187,8 +187,8 @@ class TSaslServerTransport : public TSaslTransport { std::map serverDefinitionMap_; /* Map from a transport to its Sasl Transport (wrapped by a TBufferedTransport). */ - typedef std::map, - boost::shared_ptr> TransportMap; + typedef std::map, + std::shared_ptr> TransportMap; TransportMap transportMap_; /* Lock to synchronize the transport map. */ diff --git a/be/src/transport/TSaslTransport.cpp b/be/src/transport/TSaslTransport.cpp index 20eaef7..2575261 100644 --- a/be/src/transport/TSaslTransport.cpp +++ b/be/src/transport/TSaslTransport.cpp @@ -36,7 +36,7 @@ const int32_t DEFAULT_MEM_BUF_SIZE = 32 * 1024; namespace apache { namespace thrift { namespace transport { - TSaslTransport::TSaslTransport(boost::shared_ptr transport) + TSaslTransport::TSaslTransport(std::shared_ptr transport) : transport_(transport), memBuf_(new TMemoryBuffer(DEFAULT_MEM_BUF_SIZE)), sasl_(NULL), @@ -44,8 +44,8 @@ namespace apache { namespace thrift { namespace transport { isClient_(false) { } - TSaslTransport::TSaslTransport(boost::shared_ptr saslClient, - boost::shared_ptr transport) + TSaslTransport::TSaslTransport(std::shared_ptr saslClient, + std::shared_ptr transport) : transport_(transport), memBuf_(new TMemoryBuffer()), sasl_(saslClient), diff --git a/be/src/transport/TSaslTransport.h b/be/src/transport/TSaslTransport.h index 368f680..d3d1baf 100644 --- a/be/src/transport/TSaslTransport.h +++ b/be/src/transport/TSaslTransport.h @@ -61,14 +61,14 @@ class TSaslTransport : public TVirtualTransport { * transport. * */ - TSaslTransport(boost::shared_ptr transport); + TSaslTransport(std::shared_ptr transport); /** * Constructs a new TSaslTransport to act as a client. * */ - TSaslTransport(boost::shared_ptr saslClient, - boost::shared_ptr transport); + TSaslTransport(std::shared_ptr saslClient, + std::shared_ptr transport); /** * Destroys the TSasl object. @@ -133,7 +133,7 @@ class TSaslTransport : public TVirtualTransport { /** * Returns the transport underlying this one */ - boost::shared_ptr getUnderlyingTransport() { + std::shared_ptr getUnderlyingTransport() { return transport_; } @@ -146,14 +146,14 @@ class TSaslTransport : public TVirtualTransport { protected: /// Underlying transport - boost::shared_ptr transport_; + std::shared_ptr transport_; /// Buffer for reading and writing. TMemoryBuffer* memBuf_; /// Sasl implementation class. This is passed in to the transport constructor /// initialized for either a client or a server. - boost::shared_ptr sasl_; + std::shared_ptr sasl_; /// IF true we wrap data in encryption. bool shouldWrap_; diff --git a/be/src/util/parquet-reader.cc b/be/src/util/parquet-reader.cc index 8bb7665..e8b16cf 100644 --- a/be/src/util/parquet-reader.cc +++ b/be/src/util/parquet-reader.cc @@ -54,8 +54,8 @@ using std::min; using impala::PARQUET_VERSION_NUMBER; -boost::shared_ptr CreateDeserializeProtocol( - boost::shared_ptr mem, bool compact) { +std::shared_ptr CreateDeserializeProtocol( + std::shared_ptr mem, bool compact) { if (compact) { TCompactProtocolFactoryT tproto_factory; return tproto_factory.getProtocol(mem); @@ -72,8 +72,8 @@ template bool DeserializeThriftMsg( uint8_t* buf, uint32_t* len, bool compact, T* deserialized_msg) { // Deserialize msg bytes into c++ thrift msg using memory transport. - boost::shared_ptr tmem_transport(new TMemoryBuffer(buf, *len)); - boost::shared_ptr tproto = + std::shared_ptr tmem_transport(new TMemoryBuffer(buf, *len)); + std::shared_ptr tproto = CreateDeserializeProtocol(tmem_transport, compact); try { deserialized_msg->read(tproto.get()); diff --git a/bin/impala-config.sh b/bin/impala-config.sh index 32df25d..419b584 100755 --- a/bin/impala-config.sh +++ b/bin/impala-config.sh @@ -68,7 +68,7 @@ fi # moving to a different build of the toolchain, e.g. when a version is bumped or a # compile option is changed. The build id can be found in the output of the toolchain # build jobs, it is constructed from the build number and toolchain git hash prefix. -export IMPALA_TOOLCHAIN_BUILD_ID=210-5033cfcc59 +export IMPALA_TOOLCHAIN_BUILD_ID=215-1feafed70a # Versions of toolchain dependencies. # ----------------------------------- export IMPALA_AVRO_VERSION=1.7.4-p4 @@ -141,7 +141,7 @@ export IMPALA_TPC_DS_VERSION=2.1.0 unset IMPALA_TPC_DS_URL export IMPALA_TPC_H_VERSION=2.17.0 unset IMPALA_TPC_H_URL -export IMPALA_THRIFT_VERSION=0.9.3-p4 +export IMPALA_THRIFT_VERSION=0.11.0-p2 unset IMPALA_THRIFT_URL export IMPALA_ZLIB_VERSION=1.2.8 unset IMPALA_ZLIB_URL diff --git a/impala-parent/pom.xml b/impala-parent/pom.xml index dbdf165..2080d26 100644 --- a/impala-parent/pom.xml +++ b/impala-parent/pom.xml @@ -42,7 +42,7 @@ under the License. ${env.IMPALA_HBASE_VERSION} ${env.IMPALA_PARQUET_VERSION} ${env.IMPALA_KITE_VERSION} - 0.9.3 + 0.11.0 1.0-SNAPSHOT UTF-8 ${env.KUDU_JAVA_VERSION} diff --git a/infra/python/deps/compiled-requirements.txt b/infra/python/deps/compiled-requirements.txt index 72e939a..8cf961d 100644 --- a/infra/python/deps/compiled-requirements.txt +++ b/infra/python/deps/compiled-requirements.txt @@ -19,7 +19,7 @@ # after the toolchain is bootstrapped. Installed after requirements.txt argparse == 1.4.0 -impyla == 0.14.0 +git+git://github.com/sahilTakiar/impyla.git@thrift-0.11-upgrade#egg=impala bitarray == 0.8.1 sasl == 0.1.3 six == 1.11.0