github/falco
1
0
Fork 0
mirror of https://github.com/falcosecurity/falco.git synced 2025-07-06 11:26:44 +00:00
Code Issues Projects Releases Wiki Activity

update(userspace/falco): falco_grpc_server is now just server

Browse Source 
Co-Authored-By: Leonardo Di Donato <leodidonato@gmail.com>
Signed-off-by: Lorenzo Fontana <lo@linux.com>
This commit is contained in:
Lorenzo Fontana 2019-09-24 15:41:39 +02:00 committed by Leo Di Donato
parent 203226d347
commit 6cf2ccf857
5 changed files with 31 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
userspace/falco/falco.cpp
View File

@ -455,7 +455,7 @@ int falco_init(int argc, char **argv)
scap_stats cstats;
falco_webserver webserver;
falco::grpc::falco_grpc_server grpc_server;
falco::grpc::server grpc_server;
std::thread grpc_server_thread;
static struct option long_options[] =

26
userspace/falco/grpc_server.cpp
View File

@ -28,7 +28,7 @@ limitations under the License.
#include "utils.h"
template<>
void falco::grpc::request_stream_context<falco::output::request, falco::output::response>::start(falco_grpc_server* srv)
void falco::grpc::request_stream_context<falco::output::request, falco::output::response>::start(server* srv)
{
m_state = request_context_base::REQUEST;
m_srv_ctx.reset(new ::grpc::ServerContext);
@ -41,7 +41,7 @@ void falco::grpc::request_stream_context<falco::output::request, falco::output::
}
template<>
void falco::grpc::request_stream_context<falco::output::request, falco::output::response>::process(falco_grpc_server* srv)
void falco::grpc::request_stream_context<falco::output::request, falco::output::response>::process(server* srv)
{
// When it is the 1st process call
if(m_state == request_context_base::REQUEST)
@ -70,7 +70,7 @@ void falco::grpc::request_stream_context<falco::output::request, falco::output::
}
template<>
void falco::grpc::request_stream_context<falco::output::request, falco::output::response>::end(falco_grpc_server* srv, bool errored)
void falco::grpc::request_stream_context<falco::output::request, falco::output::response>::end(server* srv, bool errored)
{
if(m_stream_ctx)
{
@ -84,7 +84,7 @@ void falco::grpc::request_stream_context<falco::output::request, falco::output::
start(srv);
}
void falco::grpc::falco_grpc_server::thread_process(int thread_index)
void falco::grpc::server::thread_process(int thread_index)
{
void* tag = nullptr;
@ -140,12 +140,12 @@ void falco::grpc::falco_grpc_server::thread_process(int thread_index)
std::vector<request_stream_context<REQ, RESP>> RPC##_contexts(CONTEXT_COUNT); \
for(request_stream_context<REQ, RESP> & ctx : RPC##_contexts) \
{ \
ctx.m_process_func = &falco_grpc_server::IMPL; \
ctx.m_process_func = &server::IMPL; \
ctx.m_request_func = &service::AsyncService::Request##RPC; \
ctx.start(this); \
}
void falco::grpc::falco_grpc_server::init(std::string server_addr, int threadiness, std::string private_key, std::string cert_chain, std::string root_certs)
void falco::grpc::server::init(std::string server_addr, int threadiness, std::string private_key, std::string cert_chain, std::string root_certs)
{
m_server_addr = server_addr;
m_threadiness = threadiness;
@ -154,7 +154,7 @@ void falco::grpc::falco_grpc_server::init(std::string server_addr, int threadine
m_root_certs = root_certs;
}
void falco::grpc::falco_grpc_server::run()
void falco::grpc::server::run()
{
string private_key;
string cert_chain;
@ -181,12 +181,12 @@ void falco::grpc::falco_grpc_server::run()
m_completion_queue = builder.AddCompletionQueue();
m_server = builder.BuildAndStart();
falco_logger::log(LOG_INFO, "Starting gRPC webserver at " + m_server_addr + "\n");
falco_logger::log(LOG_INFO, "Starting gRPC server at " + m_server_addr + "\n");
// Create context for server threads
// The number of contexts is multiple of the number of threads
// This defines the number of simultaneous completion queue requests of the same type (service::AsyncService::Request##RPC)
// For this approach to be sufficient falco_grpc_server::IMPL have to be fast
// For this approach to be sufficient server::IMPL have to be fast
int context_count = m_threadiness * 10;
PROCESS_STREAM(request, response, subscribe, subscribe, context_count)
@ -194,17 +194,17 @@ void falco::grpc::falco_grpc_server::run()
int thread_idx = 0;
for(std::thread& thread : m_threads)
{
thread = std::thread(&falco_grpc_server::thread_process, this, thread_idx++);
thread = std::thread(&server::thread_process, this, thread_idx++);
}
while(falco_grpc_server_impl::is_running())
while(server_impl::is_running())
{
sleep(1);
}
stop();
}
void falco::grpc::falco_grpc_server::stop()
void falco::grpc::server::stop()
{
falco_logger::log(LOG_INFO, "Shutting down gRPC server. Waiting until external connections are closed by clients\n");
m_server->Shutdown();
@ -228,5 +228,5 @@ void falco::grpc::falco_grpc_server::stop()
{
}
falco_logger::log(LOG_INFO, "gRPC shutdown is now complete\n");
falco_logger::log(LOG_INFO, "Shutting down gRPC server complete\n");
}

22
userspace/falco/grpc_server.h
View File

@ -27,13 +27,13 @@ namespace falco
{
namespace grpc
{
class falco_grpc_server : public falco_grpc_server_impl
class server : public server_impl
{
public:
falco_grpc_server()
server()
{
}
falco_grpc_server(std::string server_addr, int threadiness, std::string private_key, std::string cert_chain, std::string root_certs):
server(std::string server_addr, int threadiness, std::string private_key, std::string cert_chain, std::string root_certs):
m_server_addr(server_addr),
m_threadiness(threadiness),
m_private_key(private_key),
@ -41,7 +41,7 @@ public:
m_root_certs(root_certs)
{
}
virtual ~falco_grpc_server() = default;
virtual ~server() = default;
void init(std::string server_addr, int threadiness, std::string private_key, std::string cert_chain, std::string root_certs);
void thread_process(int thread_index);
@ -76,9 +76,9 @@ public:
WRITE,
FINISH
} m_state = UNKNOWN;
virtual void start(falco_grpc_server* srv) = 0;
virtual void process(falco_grpc_server* srv) = 0;
virtual void end(falco_grpc_server* srv, bool isError) = 0;
virtual void start(server* srv) = 0;
virtual void process(server* srv) = 0;
virtual void end(server* srv, bool isError) = 0;
};
//
@ -94,14 +94,14 @@ public:
~request_stream_context() = default;
// Pointer to function that does actual processing
void (falco_grpc_server::*m_process_func)(const stream_context&, const Request&, Response&);
void (server::*m_process_func)(const stream_context&, const Request&, Response&);
// Pointer to function that requests the system to start processing given requests
void (service::AsyncService::*m_request_func)(::grpc::ServerContext*, Request*, ::grpc::ServerAsyncWriter<Response>*, ::grpc::CompletionQueue*, ::grpc::ServerCompletionQueue*, void*);
void start(falco_grpc_server* srv);
void process(falco_grpc_server* srv);
void end(falco_grpc_server* srv, bool isError);
void start(server* srv);
void process(server* srv);
void end(server* srv, bool isError);
private:
std::unique_ptr<::grpc::ServerAsyncWriter<Response>> m_res_writer;

6
userspace/falco/grpc_server_impl.cpp
View File

@ -18,7 +18,7 @@ limitations under the License.
#include "grpc_server_impl.h"
bool falco::grpc::falco_grpc_server_impl::is_running()
bool falco::grpc::server_impl::is_running()
{
if(m_stop)
{
@ -27,7 +27,7 @@ bool falco::grpc::falco_grpc_server_impl::is_running()
return true;
}
void falco::grpc::falco_grpc_server_impl::subscribe(const stream_context& ctx, const output::request& req, output::response& res)
void falco::grpc::server_impl::subscribe(const stream_context& ctx, const output::request& req, output::response& res)
{
if(ctx.m_status == stream_context::SUCCESS || ctx.m_status == stream_context::ERROR)
{
@ -52,7 +52,7 @@ void falco::grpc::falco_grpc_server_impl::subscribe(const stream_context& ctx, c
}
}
void falco::grpc::falco_grpc_server_impl::shutdown()
void falco::grpc::server_impl::shutdown()
{
m_stop = true;
}

6
userspace/falco/grpc_server_impl.h
View File

@ -28,11 +28,11 @@ namespace falco
{
namespace grpc
{
class falco_grpc_server_impl
class server_impl
{
public:
falco_grpc_server_impl() = default;
~falco_grpc_server_impl() = default;
server_impl() = default;
~server_impl() = default;
void shutdown();