external/fastocloud
1
0
Fork 0
mirror of https://github.com/fastogt/fastocloud.git synced 2025-02-12 09:51:58 +00:00
Code Issues Releases Wiki Activity

New protocol

Browse source
This commit is contained in:
Topilski 2024-12-26 09:06:54 +03:00
parent 1156584283
commit 9bbf38717a
33 changed files with 846 additions and 1321 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -1,7 +1,7 @@
CMAKE_MINIMUM_REQUIRED(VERSION 3.16 FATAL_ERROR)
SET(BRANDING_PROJECT_NAME "fastocloud" CACHE STRING "Branding for ${BRANDING_PROJECT_NAME}") #default
SET(BRANDING_PROJECT_VERSION "1.4.4.17" CACHE STRING "Branding version for ${BRANDING_PROJECT_NAME}") #default
SET(BRANDING_PROJECT_VERSION "1.5.0.18" CACHE STRING "Branding version for ${BRANDING_PROJECT_NAME}") #default
SET(BRANDING_PROJECT_BUILD_TYPE_VERSION "release" CACHE STRING "Build version type for ${BRANDING_PROJECT_NAME}") #default alfa,beta,rc,release
SET(BRANDING_PROJECT_DOMAIN "www.fastogt.com" CACHE STRING "Branding domain url for ${BRANDING_PROJECT_NAME}") #default
SET(BRANDING_PROJECT_COMPANYNAME "FastoGT" CACHE STRING "Company name for ${BRANDING_PROJECT_NAME}") #default

2
src/server/CMakeLists.txt
View file

@ -109,7 +109,6 @@ SET(SERVER_DAEMON_HEADERS
${CMAKE_SOURCE_DIR}/src/server/daemon/client.h
${CMAKE_SOURCE_DIR}/src/server/daemon/server.h
${CMAKE_SOURCE_DIR}/src/server/daemon/commands.h
${CMAKE_SOURCE_DIR}/src/server/daemon/commands_factory.h
${CMAKE_SOURCE_DIR}/src/server/daemon/commands_info/service/details/shots.h
${CMAKE_SOURCE_DIR}/src/server/daemon/commands_info/service/server_info.h
@ -126,7 +125,6 @@ SET(SERVER_DAEMON_SOURCES
${CMAKE_SOURCE_DIR}/src/server/daemon/client.cpp
${CMAKE_SOURCE_DIR}/src/server/daemon/server.cpp
${CMAKE_SOURCE_DIR}/src/server/daemon/commands.cpp
${CMAKE_SOURCE_DIR}/src/server/daemon/commands_factory.cpp
${CMAKE_SOURCE_DIR}/src/server/daemon/commands_info/service/details/shots.cpp
${CMAKE_SOURCE_DIR}/src/server/daemon/commands_info/service/server_info.cpp

417
src/server/daemon/client.cpp
View file

@ -12,259 +12,326 @@
along with fastocloud. If not, see <http://www.gnu.org/licenses/>.
*/
#include <memory>
#include "server/daemon/client.h"
#include "server/daemon/commands_factory.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <common/json/json.h>
#include <common/daemon/commands/restart_info.h>
#include <common/daemon/commands/stop_info.h>
namespace {
const std::string kErrorInvalid = "{\"error\":{\"code\":-1, \"message\":\"NOTREACHED\"}}";
const auto kDataOK = common::json::MakeSuccessDataJson();
} // namespace
namespace fastocloud {
namespace server {
ProtocoledDaemonClient::ProtocoledDaemonClient(common::libev::IoLoop* server, const common::net::socket_info& info)
: base_class(std::make_shared<fastotv::protocol::FastoTVCompressor>(), server, info) {}
: base_class(server, info), is_verified_(false), exp_time_(0) {}
common::ErrnoError ProtocoledDaemonClient::StopMe() {
const common::daemon::commands::StopInfo stop_req;
fastotv::protocol::request_t req;
common::Error err_ser = StopServiceRequest(NextRequestID(), stop_req, &req);
bool ProtocoledDaemonClient::IsVerified() const {
return is_verified_;
}
common::time64_t ProtocoledDaemonClient::GetExpTime() const {
return exp_time_;
}
void ProtocoledDaemonClient::SetVerified(bool verified, common::time64_t exp_time) {
is_verified_ = verified;
exp_time_ = exp_time;
}
bool ProtocoledDaemonClient::IsExpired() const {
return exp_time_ < common::time::current_utc_mstime();
}
bool ProtocoledDaemonClient::HaveFullAccess() const {
return IsVerified() && !IsExpired();
}
common::http::http_protocol ProtocoledDaemonClient::GetProtocol() const {
return common::http::HP_1_0;
}
common::libev::http::HttpServerInfo ProtocoledDaemonClient::GetServerInfo() const {
return common::libev::http::HttpServerInfo();
}
common::ErrnoError ProtocoledDaemonClient::StopMe(const common::uri::GURL& url) {
const common::daemon::commands::StopInfo params;
std::string result;
common::Error err_ser = params.SerializeToString(&result);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteRequest(req);
return PostJson(url, result.c_str(), result.size(), false);
}
common::ErrnoError ProtocoledDaemonClient::RestartMe() {
const common::daemon::commands::RestartInfo stop_req;
fastotv::protocol::request_t req;
common::Error err_ser = RestartServiceRequest(NextRequestID(), stop_req, &req);
common::ErrnoError ProtocoledDaemonClient::Broadcast(const common::json::WsDataJson& request) {
std::string result;
ignore_result(request.SerializeToString(&result));
return SendFrame(result.c_str(), result.size());
}
common::ErrnoError ProtocoledDaemonClient::RestartMe(const common::uri::GURL& url) {
const common::daemon::commands::RestartInfo params;
std::string result;
common::Error err_ser = params.SerializeToString(&result);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteRequest(req);
return PostJson(url, result.c_str(), result.size(), false);
}
common::ErrnoError ProtocoledDaemonClient::StopFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = StopServiceResponseFail(id, error_str, &resp);
common::ErrnoError ProtocoledDaemonClient::StopFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::StopSuccess() {
return SendDataJson(common::http::HS_OK, kDataOK);
}
common::ErrnoError ProtocoledDaemonClient::RestartFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::RestartSuccess() {
return SendDataJson(common::http::HS_OK, kDataOK);
}
common::ErrnoError ProtocoledDaemonClient::GetHardwareHashFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::GetHardwareHashSuccess(
const common::daemon::commands::HardwareHashInfo& params) {
json_object* jrequest_init = nullptr;
common::Error err_ser = params.Serialize(&jrequest_init);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
return GetHardwareHashFail(common::http::HS_INTERNAL_ERROR, err_ser);
}
return WriteResponse(resp);
}
common::ErrnoError ProtocoledDaemonClient::StopSuccess(fastotv::protocol::sequance_id_t id) {
fastotv::protocol::response_t resp;
common::Error err_ser = StopServiceResponseSuccess(id, &resp);
std::string result;
common::json::DataJson js = common::json::MakeSuccessDataJson(jrequest_init); // take ownerships
err_ser = js.SerializeToString(&result);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
return GetHardwareHashFail(common::http::HS_INTERNAL_ERROR, err_ser);
}
return WriteResponse(resp);
return SendDataJson(common::http::HS_OK, js);
}
common::ErrnoError ProtocoledDaemonClient::Ping() {
common::daemon::commands::ClientPingInfo server_ping_info;
return Ping(server_ping_info);
common::ErrnoError ProtocoledDaemonClient::GetStatsFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::Ping(const common::daemon::commands::ClientPingInfo& server_ping_info) {
fastotv::protocol::request_t ping_request;
common::Error err_ser = PingRequest(NextRequestID(), server_ping_info, &ping_request);
common::ErrnoError ProtocoledDaemonClient::GetStatsSuccess(const service::FullServiceInfo& stats) {
json_object* jrequest_init = nullptr;
common::Error err_ser = stats.Serialize(&jrequest_init);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
return GetHardwareHashFail(common::http::HS_INTERNAL_ERROR, err_ser);
}
return WriteRequest(ping_request);
}
common::ErrnoError ProtocoledDaemonClient::PongFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = PingServiceResponseFail(id, error_str, &resp);
std::string result;
common::json::DataJson js = common::json::MakeSuccessDataJson(jrequest_init); // take ownerships
err_ser = js.SerializeToString(&result);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
return GetStatsFail(common::http::HS_INTERNAL_ERROR, err_ser);
}
return WriteResponse(resp);
return SendDataJson(common::http::HS_OK, js);
}
common::ErrnoError ProtocoledDaemonClient::Pong(fastotv::protocol::sequance_id_t id) {
common::daemon::commands::ServerPingInfo server_ping_info;
return Pong(id, server_ping_info);
common::ErrnoError ProtocoledDaemonClient::GetLogServiceFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::Pong(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::ServerPingInfo& pong) {
fastotv::protocol::response_t resp;
common::Error err_ser = PingServiceResponseSuccess(id, pong, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteResponse(resp);
}
common::ErrnoError ProtocoledDaemonClient::ActivateFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = ActivateResponseFail(id, error_str, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
common::ErrnoError ProtocoledDaemonClient::GetLogServiceSuccess(const std::string& path) {
const char* file_path_str_ptr = path.c_str();
struct stat sb;
if (stat(file_path_str_ptr, &sb) < 0) {
return GetLogServiceFail(common::http::HS_FORBIDDEN, common::make_error("File not found."));
}
return WriteResponse(resp);
}
common::ErrnoError ProtocoledDaemonClient::ActivateSuccess(fastotv::protocol::sequance_id_t id,
const std::string& result) {
fastotv::protocol::response_t resp;
common::Error err_ser = ActivateResponseSuccess(id, result, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
if (S_ISDIR(sb.st_mode)) {
return GetLogServiceFail(common::http::HS_FORBIDDEN, common::make_error("Bad filename."));
}
return WriteResponse(resp);
}
common::ErrnoError ProtocoledDaemonClient::GetLogServiceFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = GetLogServiceResponseFail(id, error_str, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
int file = open(file_path_str_ptr, O_RDONLY);
if (file == INVALID_DESCRIPTOR) { /* open the file for reading */
return GetLogServiceFail(common::http::HS_FORBIDDEN, common::make_error("File is protected."));
}
return WriteResponse(resp);
}
common::ErrnoError ProtocoledDaemonClient::GetLogServiceSuccess(fastotv::protocol::sequance_id_t id) {
fastotv::protocol::response_t resp;
common::Error err_ser = GetLogServiceResponseSuccess(id, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
size_t cast = sb.st_size;
common::ErrnoError err = SendHeadersInternal(common::http::HS_OK, "text/plain", &cast, &sb.st_mtime);
if (err) {
::close(file);
return GetLogServiceFail(common::http::HS_INTERNAL_ERROR, common::make_error(err->GetDescription()));
}
return WriteResponse(resp);
err = SendFileByFd(file, sb.st_size);
::close(file);
return err;
}
common::ErrnoError ProtocoledDaemonClient::GetLogStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = GetLogStreamResponseFail(id, error_str, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteResponse(resp);
common::ErrnoError ProtocoledDaemonClient::GetLogStreamFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::GetLogStreamSuccess(fastotv::protocol::sequance_id_t id) {
fastotv::protocol::response_t resp;
common::Error err_ser = GetLogStreamResponseSuccess(id, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
common::ErrnoError ProtocoledDaemonClient::GetLogStreamSuccess(const std::string& path) {
const char* file_path_str_ptr = path.c_str();
struct stat sb;
if (stat(file_path_str_ptr, &sb) < 0) {
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("File not found."));
}
return WriteResponse(resp);
if (S_ISDIR(sb.st_mode)) {
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("Bad filename."));
}
int file = open(file_path_str_ptr, O_RDONLY);
if (file == INVALID_DESCRIPTOR) { /* open the file for reading */
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("File is protected."));
}
size_t cast = sb.st_size;
common::ErrnoError err = SendHeadersInternal(common::http::HS_OK, "text/plain", &cast, &sb.st_mtime);
if (err) {
::close(file);
return GetLogStreamFail(common::http::HS_INTERNAL_ERROR, common::make_error(err->GetDescription()));
}
err = SendFileByFd(file, sb.st_size);
::close(file);
return err;
}
common::ErrnoError ProtocoledDaemonClient::GetPipeStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = GetPipeStreamResponseFail(id, error_str, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteResponse(resp);
common::ErrnoError ProtocoledDaemonClient::GetPipeStreamFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::GetPipeStreamSuccess(fastotv::protocol::sequance_id_t id) {
fastotv::protocol::response_t resp;
common::Error err_ser = GetPipeStreamResponseSuccess(id, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
common::ErrnoError ProtocoledDaemonClient::GetPipeStreamSuccess(const std::string& path) {
const char* file_path_str_ptr = path.c_str();
struct stat sb;
if (stat(file_path_str_ptr, &sb) < 0) {
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("File not found."));
}
return WriteResponse(resp);
if (S_ISDIR(sb.st_mode)) {
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("Bad filename."));
}
int file = open(file_path_str_ptr, O_RDONLY);
if (file == INVALID_DESCRIPTOR) { /* open the file for reading */
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("File is protected."));
}
size_t cast = sb.st_size;
common::ErrnoError err = SendHeadersInternal(common::http::HS_OK, "text/plain", &cast, &sb.st_mtime);
if (err) {
::close(file);
return GetLogStreamFail(common::http::HS_INTERNAL_ERROR, common::make_error(err->GetDescription()));
}
err = SendFileByFd(file, sb.st_size);
::close(file);
return err;
}
common::ErrnoError ProtocoledDaemonClient::StartStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = StartStreamResponseFail(id, error_str, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteResponse(resp);
common::ErrnoError ProtocoledDaemonClient::GetConfigStreamFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::StartStreamSuccess(fastotv::protocol::sequance_id_t id) {
fastotv::protocol::response_t resp;
common::Error err_ser = StartStreamResponseSuccess(id, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
common::ErrnoError ProtocoledDaemonClient::GetConfigStreamSuccess(const std::string& path) {
const char* file_path_str_ptr = path.c_str();
struct stat sb;
if (stat(file_path_str_ptr, &sb) < 0) {
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("File not found."));
}
return WriteResponse(resp);
if (S_ISDIR(sb.st_mode)) {
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("Bad filename."));
}
int file = open(file_path_str_ptr, O_RDONLY);
if (file == INVALID_DESCRIPTOR) { /* open the file for reading */
return GetLogStreamFail(common::http::HS_FORBIDDEN, common::make_error("File is protected."));
}
size_t cast = sb.st_size;
common::ErrnoError err =
SendHeadersInternal(common::http::HS_OK, "text/plain", &cast, &sb.st_mtime); // "application/json"
if (err) {
::close(file);
return GetLogStreamFail(common::http::HS_INTERNAL_ERROR, common::make_error(err->GetDescription()));
}
err = SendFileByFd(file, sb.st_size);
::close(file);
return err;
}
common::ErrnoError ProtocoledDaemonClient::ReStartStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = RestartStreamResponseFail(id, error_str, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteResponse(resp);
common::ErrnoError ProtocoledDaemonClient::StartStreamFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::ReStartStreamSuccess(fastotv::protocol::sequance_id_t id) {
fastotv::protocol::response_t resp;
common::Error err_ser = RestartStreamResponseSuccess(id, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteResponse(resp);
common::ErrnoError ProtocoledDaemonClient::StartStreamSuccess() {
return SendDataJson(common::http::HS_OK, kDataOK);
}
common::ErrnoError ProtocoledDaemonClient::StopStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) {
const std::string error_str = err->GetDescription();
fastotv::protocol::response_t resp;
common::Error err_ser = StopStreamResponseFail(id, error_str, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteResponse(resp);
common::ErrnoError ProtocoledDaemonClient::ReStartStreamFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::StopStreamSuccess(fastotv::protocol::sequance_id_t id) {
fastotv::protocol::response_t resp;
common::Error err_ser = StopStreamResponseSuccess(id, &resp);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
}
return WriteResponse(resp);
common::ErrnoError ProtocoledDaemonClient::ReStartStreamSuccess() {
return SendDataJson(common::http::HS_OK, kDataOK);
}
common::ErrnoError ProtocoledDaemonClient::UnknownMethodError(fastotv::protocol::sequance_id_t id,
const std::string& method) {
fastotv::protocol::response_t resp;
common::Error err_ser = UnknownMethodResponse(id, method, &resp);
common::ErrnoError ProtocoledDaemonClient::StopStreamFail(common::http::http_status code, common::Error err) {
return SendErrorJson(code, err);
}
common::ErrnoError ProtocoledDaemonClient::StopStreamSuccess() {
return SendDataJson(common::http::HS_OK, kDataOK);
}
common::ErrnoError ProtocoledDaemonClient::UnknownMethodError(common::http::http_method method,
const std::string& route) {
common::Error err =
common::make_error(common::MemSPrintf("not handled %s for route: %s", common::ConvertToString(method), route));
return SendErrorJson(common::http::HS_NOT_FOUND, err);
}
common::ErrnoError ProtocoledDaemonClient::SendHeadersInternal(common::http::http_status code,
const char* mime_type,
size_t* length,
time_t* mod) {
return SendHeaders(GetProtocol(), code, {}, mime_type, length, mod, false, GetServerInfo());
}
common::ErrnoError ProtocoledDaemonClient::SendErrorJson(common::http::http_status code, common::Error err) {
auto errj = common::json::ErrorJson(common::json::MakeErrorJsonMessage(code, err));
std::string result = kErrorInvalid;
ignore_result(errj.SerializeToString(&result));
return SendJson(GetProtocol(), code, {}, result.c_str(), result.size(), false, GetServerInfo());
}
common::ErrnoError ProtocoledDaemonClient::SendDataJson(common::http::http_status code,
const common::json::DataJson& data) {
std::string result;
common::Error err_ser = data.SerializeToString(&result);
if (err_ser) {
return common::make_errno_error(err_ser->GetDescription(), EAGAIN);
return SendErrorJson(common::http::HS_INTERNAL_ERROR, err_ser);
}
return WriteResponse(resp);
return SendJson(GetProtocol(), code, {}, result.c_str(), result.size(), false, GetServerInfo());
}
} // namespace server

93
src/server/daemon/client.h
View file

@ -14,61 +14,86 @@
#pragma once
#include <string>
#include <common/daemon/client.h>
#include <common/daemon/commands/license_info.h>
#include <common/daemon/commands/ping_info.h>
#include <common/daemon/commands/hhash_info.h>
#include <common/json/json.h>
#include <common/libev/websocket/websocket_client.h>
#include <common/license/types.h>
#include <fastotv/protocol/protocol.h>
#include <fastotv/protocol/types.h>
#include <string>
#include "server/daemon/commands_info/service/server_info.h"
namespace fastocloud {
namespace server {
class ProtocoledDaemonClient : public fastotv::protocol::ProtocolClient<common::daemon::DaemonClient> {
class ProtocoledDaemonClient : public common::libev::websocket::WebSocketServerClient {
public:
typedef fastotv::protocol::ProtocolClient<common::daemon::DaemonClient> base_class;
typedef common::libev::websocket::WebSocketServerClient base_class;
ProtocoledDaemonClient(common::libev::IoLoop* server, const common::net::socket_info& info);
common::ErrnoError StopMe() WARN_UNUSED_RESULT;
common::ErrnoError RestartMe() WARN_UNUSED_RESULT;
bool IsVerified() const;
void SetVerified(bool verified, common::time64_t exp_time);
common::ErrnoError StopFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError StopSuccess(fastotv::protocol::sequance_id_t id) WARN_UNUSED_RESULT;
common::time64_t GetExpTime() const;
bool IsExpired() const;
bool HaveFullAccess() const;
common::ErrnoError Ping() WARN_UNUSED_RESULT;
common::ErrnoError Ping(const common::daemon::commands::ClientPingInfo& server_ping_info) WARN_UNUSED_RESULT;
common::http::http_protocol GetProtocol() const;
common::libev::http::HttpServerInfo GetServerInfo() const;
common::ErrnoError PongFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError Pong(fastotv::protocol::sequance_id_t id) WARN_UNUSED_RESULT;
common::ErrnoError Pong(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::ServerPingInfo& pong) WARN_UNUSED_RESULT;
common::ErrnoError StopMe(const common::uri::GURL& url) WARN_UNUSED_RESULT;
common::ErrnoError RestartMe(const common::uri::GURL& url) WARN_UNUSED_RESULT;
common::ErrnoError ActivateFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError ActivateSuccess(fastotv::protocol::sequance_id_t id, const std::string& result) WARN_UNUSED_RESULT;
common::ErrnoError StopFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError StopSuccess() WARN_UNUSED_RESULT;
common::ErrnoError GetLogServiceFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetLogServiceSuccess(fastotv::protocol::sequance_id_t id) WARN_UNUSED_RESULT;
common::ErrnoError RestartFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError RestartSuccess() WARN_UNUSED_RESULT;
common::ErrnoError GetLogStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetLogStreamSuccess(fastotv::protocol::sequance_id_t id) WARN_UNUSED_RESULT;
common::ErrnoError GetHardwareHashFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetHardwareHashSuccess(const common::daemon::commands::HardwareHashInfo& params)
WARN_UNUSED_RESULT;
common::ErrnoError GetPipeStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetPipeStreamSuccess(fastotv::protocol::sequance_id_t id) WARN_UNUSED_RESULT;
common::ErrnoError GetStatsFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetStatsSuccess(const service::FullServiceInfo& stats) WARN_UNUSED_RESULT;
common::ErrnoError StartStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError StartStreamSuccess(fastotv::protocol::sequance_id_t id) WARN_UNUSED_RESULT;
common::ErrnoError GetLogServiceFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetLogServiceSuccess(const std::string& path) WARN_UNUSED_RESULT;
common::ErrnoError ReStartStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError ReStartStreamSuccess(fastotv::protocol::sequance_id_t id) WARN_UNUSED_RESULT;
common::ErrnoError GetLogStreamFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetLogStreamSuccess(const std::string& path) WARN_UNUSED_RESULT;
common::ErrnoError StopStreamFail(fastotv::protocol::sequance_id_t id, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError StopStreamSuccess(fastotv::protocol::sequance_id_t id) WARN_UNUSED_RESULT;
common::ErrnoError GetPipeStreamFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetPipeStreamSuccess(const std::string& path) WARN_UNUSED_RESULT;
common::ErrnoError UnknownMethodError(fastotv::protocol::sequance_id_t id,
const std::string& method) WARN_UNUSED_RESULT;
common::ErrnoError StartStreamFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError StartStreamSuccess() WARN_UNUSED_RESULT;
common::ErrnoError ReStartStreamFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError ReStartStreamSuccess() WARN_UNUSED_RESULT;
common::ErrnoError StopStreamFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError StopStreamSuccess() WARN_UNUSED_RESULT;
common::ErrnoError GetConfigStreamFail(common::http::http_status code, common::Error err) WARN_UNUSED_RESULT;
common::ErrnoError GetConfigStreamSuccess(const std::string& path) WARN_UNUSED_RESULT;
common::ErrnoError UnknownMethodError(common::http::http_method method, const std::string& route) WARN_UNUSED_RESULT;
common::ErrnoError Broadcast(const common::json::WsDataJson& request) WARN_UNUSED_RESULT;
private:
common::ErrnoError SendDataJson(common::http::http_status code, const common::json::DataJson& data);
common::ErrnoError SendErrorJson(common::http::http_status code, common::Error err);
common::ErrnoError SendHeadersInternal(common::http::http_status code,
const char* mime_type,
size_t* length,
time_t* mod);
bool is_verified_;
common::time64_t exp_time_;
};
} // namespace server

52
src/server/daemon/commands.cpp
View file

@ -14,36 +14,39 @@
#include "server/daemon/commands.h"
// broadcast
#define SERVICE_STATISTIC_SERVICE "statistic_service"
namespace fastocloud {
namespace server {
common::Error ChangedSourcesStreamBroadcast(const ChangedSouresInfo& params, fastotv::protocol::request_t* req) {
common::Error ChangedSourcesStreamBroadcast(const ChangedSouresInfo& params, common::json::WsDataJson* req) {
if (!req) {
return common::make_error_inval();
}
std::string changed_json;
common::Error err_ser = params.SerializeToString(&changed_json);
json_object* result_json = nullptr;
common::Error err_ser = params.Serialize(&result_json);
if (err_ser) {
return err_ser;
}
*req = fastotv::protocol::request_t::MakeNotification(STREAM_CHANGED_SOURCES_STREAM, changed_json);
*req = common::json::WsDataJson(BROADCAST_CHANGED_SOURCES_STREAM, result_json);
return common::Error();
}
common::Error StatisitcStreamBroadcast(const StatisticInfo& params, fastotv::protocol::request_t* req) {
common::Error StatisitcStreamBroadcast(const StatisticInfo& params, common::json::WsDataJson* req) {
if (!req) {
return common::make_error_inval();
}
std::string stat_json;
common::Error err_ser = params.SerializeToString(&stat_json);
json_object* result_json = nullptr;
common::Error err_ser = params.Serialize(&result_json);
if (err_ser) {
return err_ser;
}
*req = fastotv::protocol::request_t::MakeNotification(STREAM_STATISTIC_STREAM, stat_json);
*req = common::json::WsDataJson(BROADCAST_STATISTIC_STREAM, result_json);
return common::Error();
}
@ -65,28 +68,33 @@ common::Error MlNotificationStreamBroadcast(const fastotv::commands_info::ml::No
}
#endif
common::Error StatisitcServiceBroadcast(fastotv::protocol::serializet_params_t params,
fastotv::protocol::request_t* req) {
common::Error StatisitcServiceBroadcast(const service::ServerInfo& params, common::json::WsDataJson* req) {
if (!req) {
return common::make_error_inval();
}
*req = fastotv::protocol::request_t::MakeNotification(STREAM_STATISTIC_SERVICE, params);
return common::Error();
}
common::Error QuitStatusStreamBroadcast(const stream::QuitStatusInfo& params, fastotv::protocol::request_t* req) {
if (!req) {
return common::make_error_inval();
}
std::string quit_json;
common::Error err_ser = params.SerializeToString(&quit_json);
json_object* stat_json = nullptr;
common::Error err_ser = params.Serialize(&stat_json);
if (err_ser) {
return err_ser;
}
*req = fastotv::protocol::request_t::MakeNotification(STREAM_QUIT_STATUS_STREAM, quit_json);
*req = common::json::WsDataJson(SERVICE_STATISTIC_SERVICE, stat_json);
return common::Error();
}
common::Error QuitStatusStreamBroadcast(const stream::QuitStatusInfo& params, common::json::WsDataJson* req) {
if (!req) {
return common::make_error_inval();
}
json_object* quit_json = nullptr;
common::Error err_ser = params.Serialize(&quit_json);
if (err_ser) {
return err_ser;
}
*req = common::json::WsDataJson(STREAM_QUIT_STATUS_STREAM, quit_json);
return common::Error();
}

29
src/server/daemon/commands.h
View file

@ -14,15 +14,19 @@
#pragma once
#include <fastotv/protocol/types.h>
#include <string>
#include <fastotv/protocol/types.h>
#include <common/json/json.h>
#if defined(MACHINE_LEARNING)
#include <fastotv/commands_info/ml/notification_info.h>
#endif
#include "server/daemon/commands_info/service/server_info.h"
#include "server/daemon/commands_info/stream/quit_status_info.h"
#include "stream_commands/commands_info/changed_sources_info.h"
#include "stream_commands/commands_info/statistic_info.h"
@ -34,20 +38,17 @@
#define DAEMON_RESTART_STREAM "restart_stream"
#define DAEMON_GET_LOG_STREAM "get_log_stream"
#define DAEMON_GET_PIPELINE_STREAM "get_pipeline_stream"
#define DAEMON_GET_CONFIG_JSON_STREAM "get_config_json_stream"
#define DAEMON_ACTIVATE "activate_request" // {"key": "XXXXXXXXXXXXXXXXXX"}
#define DAEMON_STOP_SERVICE "stop_service" // {"delay": 0 }
#define DAEMON_RESTART_SERVICE "restart_service" // {"delay": 0 }
#define DAEMON_STATS_SERVICE "stats"
#define DAEMON_GET_CONFIG_JSON_STREAM "get_config_json_stream"
#define DAEMON_PING_SERVICE "ping_service"
#define DAEMON_GET_LOG_SERVICE "get_log_service" // {"path":"http://localhost/service/id"}
#define DAEMON_SERVER_PING "ping_client"
// Broadcast
#define STREAM_CHANGED_SOURCES_STREAM "changed_source_stream"
#define STREAM_STATISTIC_STREAM "statistic_stream"
#define BROADCAST_CHANGED_SOURCES_STREAM "changed_source_stream"
#define BROADCAST_STATISTIC_STREAM "statistic_stream"
#define STREAM_QUIT_STATUS_STREAM "quit_status_stream"
#if defined(MACHINE_LEARNING)
#define STREAM_ML_NOTIFICATION_STREAM "ml_notification_stream"
@ -58,15 +59,17 @@ namespace fastocloud {
namespace server {
// Broadcast
common::Error ChangedSourcesStreamBroadcast(const ChangedSouresInfo& params, fastotv::protocol::request_t* req);
common::Error StatisitcStreamBroadcast(const StatisticInfo& params, fastotv::protocol::request_t* req);
common::Error ChangedSourcesStreamBroadcast(const ChangedSouresInfo& params,
common::json::WsDataJson* req) WARN_UNUSED_RESULT;
common::Error StatisitcStreamBroadcast(const StatisticInfo& params, common::json::WsDataJson* req) WARN_UNUSED_RESULT;
#if defined(MACHINE_LEARNING)
common::Error MlNotificationStreamBroadcast(const fastotv::commands_info::ml::NotificationInfo& params,
fastotv::protocol::request_t* req);
#endif
common::Error StatisitcServiceBroadcast(fastotv::protocol::serializet_params_t params,
fastotv::protocol::request_t* req);
common::Error QuitStatusStreamBroadcast(const stream::QuitStatusInfo& params, fastotv::protocol::request_t* req);
common::Error StatisitcServiceBroadcast(const service::ServerInfo& params,
common::json::WsDataJson* req) WARN_UNUSED_RESULT;
common::Error QuitStatusStreamBroadcast(const stream::QuitStatusInfo& params, common::json::WsDataJson* req) WARN_UNUSED_RESULT;
} // namespace server
} // namespace fastocloud

311
src/server/daemon/commands_factory.cpp
View file

@ -1,311 +0,0 @@
/* Copyright (C) 2014-2022 FastoGT. All right reserved.
This file is part of fastocloud.
fastocloud is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
fastocloud is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with fastocloud. If not, see <http://www.gnu.org/licenses/>.
*/
#include "server/daemon/commands_factory.h"
#include <common/sprintf.h>
#include "server/daemon/commands.h"
namespace fastocloud {
namespace server {
common::Error StopServiceRequest(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::StopInfo& params,
fastotv::protocol::request_t* req) {
if (!req) {
return common::make_error_inval();
}
std::string req_str;
common::Error err_ser = params.SerializeToString(&req_str);
if (err_ser) {
return err_ser;
}
fastotv::protocol::request_t lreq;
lreq.id = id;
lreq.method = DAEMON_STOP_SERVICE;
lreq.params = req_str;
*req = lreq;
return common::Error();
}
common::Error RestartServiceRequest(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::RestartInfo& params,
fastotv::protocol::request_t* req) {
if (!req) {
return common::make_error_inval();
}
std::string req_str;
common::Error err_ser = params.SerializeToString(&req_str);
if (err_ser) {
return err_ser;
}
fastotv::protocol::request_t lreq;
lreq.id = id;
lreq.method = DAEMON_RESTART_SERVICE;
lreq.params = req_str;
*req = lreq;
return common::Error();
}
common::Error PingRequest(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::ClientPingInfo& params,
fastotv::protocol::request_t* req) {
if (!req) {
return common::make_error_inval();
}
std::string req_str;
common::Error err_ser = params.SerializeToString(&req_str);
if (err_ser) {
return err_ser;
}
fastotv::protocol::request_t lreq;
lreq.id = id;
lreq.method = DAEMON_SERVER_PING;
lreq.params = req_str;
*req = lreq;
return common::Error();
}
common::Error StopServiceResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp =
fastotv::protocol::response_t::MakeMessage(id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage());
return common::Error();
}
common::Error StopServiceResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error GetLogServiceResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp =
fastotv::protocol::response_t::MakeMessage(id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage());
return common::Error();
}
common::Error GetLogServiceResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error ActivateResponseSuccess(fastotv::protocol::sequance_id_t id,
const std::string& result,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeMessage(
id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage(result));
return common::Error();
}
common::Error ActivateResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error StartStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp =
fastotv::protocol::response_t::MakeMessage(id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage());
return common::Error();
}
common::Error StartStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error StopStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp =
fastotv::protocol::response_t::MakeMessage(id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage());
return common::Error();
}
common::Error StopStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error RestartStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp =
fastotv::protocol::response_t::MakeMessage(id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage());
return common::Error();
}
common::Error RestartStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error GetLogStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp =
fastotv::protocol::response_t::MakeMessage(id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage());
return common::Error();
}
common::Error GetLogStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error GetPipeStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp =
fastotv::protocol::response_t::MakeMessage(id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage());
return common::Error();
}
common::Error GetPipeStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error PingServiceResponseSuccess(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::ServerPingInfo& ping,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
std::string ping_server_json;
common::Error err_ser = ping.SerializeToString(&ping_server_json);
if (err_ser) {
return err_ser;
}
*resp = fastotv::protocol::response_t::MakeMessage(
id, common::protocols::json_rpc::JsonRPCMessage::MakeSuccessMessage(ping_server_json));
return common::Error();
}
common::Error PingServiceResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp = fastotv::protocol::response_t::MakeError(
id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(error_text));
return common::Error();
}
common::Error UnknownMethodResponse(fastotv::protocol::sequance_id_t id,
const std::string& method,
fastotv::protocol::response_t* resp) {
if (!resp) {
return common::make_error_inval();
}
*resp =
fastotv::protocol::response_t::MakeError(id, common::protocols::json_rpc::JsonRPCError::MakeServerErrorFromText(
common::MemSPrintf("Unknown method: %s", method)));
return common::Error();
}
} // namespace server
} // namespace fastocloud

96
src/server/daemon/commands_factory.h
View file

@ -1,96 +0,0 @@
/* Copyright (C) 2014-2022 FastoGT. All right reserved.
This file is part of fastocloud.
fastocloud is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
fastocloud is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with fastocloud. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <string>
#include <common/daemon/commands/activate_info.h>
#include <common/daemon/commands/ping_info.h>
#include <common/daemon/commands/restart_info.h>
#include <common/daemon/commands/stop_info.h>
#include <fastotv/protocol/types.h>
namespace fastocloud {
namespace server {
// requests
common::Error StopServiceRequest(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::StopInfo& params,
fastotv::protocol::request_t* req);
common::Error RestartServiceRequest(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::RestartInfo& params,
fastotv::protocol::request_t* req);
common::Error PingRequest(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::ClientPingInfo& params,
fastotv::protocol::request_t* req);
// responses service
common::Error StopServiceResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp);
common::Error StopServiceResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
common::Error GetLogServiceResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp);
common::Error GetLogServiceResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
common::Error ActivateResponseSuccess(fastotv::protocol::sequance_id_t id,
const std::string& result,
fastotv::protocol::response_t* resp);
common::Error ActivateResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
common::Error PingServiceResponseSuccess(fastotv::protocol::sequance_id_t id,
const common::daemon::commands::ServerPingInfo& ping,
fastotv::protocol::response_t* resp);
common::Error PingServiceResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
common::Error UnknownMethodResponse(fastotv::protocol::sequance_id_t id,
const std::string& method,
fastotv::protocol::response_t* resp) WARN_UNUSED_RESULT;
// responces streams
common::Error StartStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp);
common::Error StartStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
common::Error StopStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp);
common::Error StopStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
common::Error RestartStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp);
common::Error RestartStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
common::Error GetLogStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp);
common::Error GetLogStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
common::Error GetPipeStreamResponseSuccess(fastotv::protocol::sequance_id_t id, fastotv::protocol::response_t* resp);
common::Error GetPipeStreamResponseFail(fastotv::protocol::sequance_id_t id,
const std::string& error_text,
fastotv::protocol::response_t* resp);
} // namespace server
} // namespace fastocloud

20
src/server/daemon/commands_info/stream/get_log_info.cpp
View file

@ -16,21 +16,16 @@
#include <string>
#define PATH_FIELD "path"
#define FEEDBACK_DIR_FIELD "feedback_directory"
namespace fastocloud {
namespace server {
namespace stream {
GetLogInfo::GetLogInfo() : base_class(), feedback_dir_(), path_() {}
GetLogInfo::GetLogInfo() : base_class(), feedback_dir_() {}
GetLogInfo::GetLogInfo(const fastotv::stream_id_t& stream_id, const std::string& feedback_dir, const url_t& path)
: base_class(stream_id), feedback_dir_(feedback_dir), path_(path) {}
GetLogInfo::url_t GetLogInfo::GetLogPath() const {
return path_;
}
GetLogInfo::GetLogInfo(const fastotv::stream_id_t& stream_id, const std::string& feedback_dir)
: base_class(stream_id), feedback_dir_(feedback_dir) {}
std::string GetLogInfo::GetFeedbackDir() const {
return feedback_dir_;
@ -50,20 +45,11 @@ common::Error GetLogInfo::DoDeSerialize(json_object* serialized) {
}
inf.feedback_dir_ = feedback_dir;
std::string path;
err = GetStringField(serialized, PATH_FIELD, &path);
if (err) {
return err;
}
inf.path_ = url_t(path);
*this = inf;
return common::Error();
}
common::Error GetLogInfo::SerializeFields(json_object* out) const {
const std::string path_str = path_.spec();
ignore_result(SetStringField(out, PATH_FIELD, path_str));
ignore_result(SetStringField(out, FEEDBACK_DIR_FIELD, feedback_dir_));
return base_class::SerializeFields(out);
}

9
src/server/daemon/commands_info/stream/get_log_info.h
View file

@ -14,10 +14,10 @@
#pragma once
#include <string>
#include <common/uri/gurl.h>
#include <string>
#include "server/daemon/commands_info/stream/stream_info.h"
namespace fastocloud {
@ -27,12 +27,10 @@ namespace stream {
class GetLogInfo : public StreamInfo {
public:
typedef StreamInfo base_class;
typedef common::uri::GURL url_t;
GetLogInfo();
explicit GetLogInfo(const fastotv::stream_id_t& stream_id, const std::string& feedback_dir, const url_t& log_path);
explicit GetLogInfo(const fastotv::stream_id_t& stream_id, const std::string& feedback_dir);
url_t GetLogPath() const;
std::string GetFeedbackDir() const;
protected:
@ -41,7 +39,6 @@ class GetLogInfo : public StreamInfo {
private:
std::string feedback_dir_;
url_t path_;
};
typedef GetLogInfo GetPipelineInfo;

8
src/server/daemon/commands_info/stream/restart_info.cpp
View file

@ -16,12 +16,6 @@
namespace fastocloud {
namespace server {
namespace stream {
RestartInfo::RestartInfo() : base_class() {}
RestartInfo::RestartInfo(const fastotv::stream_id_t& stream_id) : base_class(stream_id) {}
} // namespace stream
namespace stream {} // namespace stream
} // namespace server
} // namespace fastocloud

8
src/server/daemon/commands_info/stream/restart_info.h
View file

@ -20,13 +20,7 @@ namespace fastocloud {
namespace server {
namespace stream {
class RestartInfo : public StreamInfo {
public:
typedef StreamInfo base_class;
RestartInfo();
explicit RestartInfo(const fastotv::stream_id_t& stream_id);
};
typedef StreamInfo RestartInfo;
} // namespace stream
} // namespace server

5
src/server/daemon/commands_info/stream/stream_info.h
View file

@ -14,12 +14,11 @@
#pragma once
#include <string>
#include <common/serializer/json_serializer.h>
#include <fastotv/types.h>
#include <string>
namespace fastocloud {
namespace server {
namespace stream {

6
src/server/daemon/server.h
View file

@ -14,14 +14,14 @@
#pragma once
#include <common/daemon/server.h>
#include <common/libev/tcp/tcp_server.h>
namespace fastocloud {
namespace server {
class DaemonServer : public common::daemon::DaemonServer {
class DaemonServer : public common::libev::tcp::TcpServer {
public:
typedef common::daemon::DaemonServer base_class;
typedef common::libev::tcp::TcpServer base_class;
explicit DaemonServer(const common::net::HostAndPort& host, common::libev::IoLoopObserver* observer = nullptr);
private:

4
src/server/daemon_slave.cpp
View file

@ -76,7 +76,7 @@ int main(int argc, char** argv, char** envp) {
return EXIT_FAILURE;
}
err = fastocloud::server::ProcessSlaveWrapper::SendStopDaemonRequest(config);
err = fastocloud::server::ProcessSlaveWrapper::SendStopDaemonRequest(config.host);
sleep(fastocloud::server::ProcessSlaveWrapper::cleanup_seconds + 1);
if (err) {
std::cerr << "Stop command failed error: " << err->GetDescription() << std::endl;
@ -92,7 +92,7 @@ int main(int argc, char** argv, char** envp) {
return EXIT_FAILURE;
}
err = fastocloud::server::ProcessSlaveWrapper::SendRestartDaemonRequest(config);
err = fastocloud::server::ProcessSlaveWrapper::SendRestartDaemonRequest(config.host);
sleep(fastocloud::server::ProcessSlaveWrapper::cleanup_seconds + 1);
if (err) {
std::cerr << "Reload command failed error: " << err->GetDescription() << std::endl;

8
src/server/http/client.h
View file

@ -21,18 +21,18 @@ typedef struct ssl_st SSL;
namespace fastocloud {
namespace server {
class HttpClient : public common::libev::http::HttpClient {
class HttpClient : public common::libev::http::HttpServerClient {
public:
typedef common::libev::http::HttpClient base_class;
typedef common::libev::http::HttpServerClient base_class;
HttpClient(common::libev::IoLoop* server, const common::net::socket_info& info);
const char* ClassName() const override;
};
class HttpsClient : public common::libev::http::HttpClient {
class HttpsClient : public common::libev::http::HttpServerClient {
public:
typedef common::libev::http::HttpClient base_class;
typedef common::libev::http::HttpServerClient base_class;
HttpsClient(common::libev::IoLoop* server, const common::net::socket_info& info, SSL* ssl);

7
src/server/http/handler.cpp
View file

@ -112,8 +112,9 @@ void HttpHandler::ProcessReceived(HttpClient* hclient, const char* request, size
// keep alive
common::http::header_t connection_field;
bool is_find_connection = hrequest.FindHeaderByKey("Connection", false, &connection_field);
bool IsKeepAlive = is_find_connection ? common::EqualsASCII(connection_field.value, "Keep-Alive", false) : false;
// bool is_find_connection = hrequest.FindHeaderByKey("Connection", false, &connection_field);
bool IsKeepAlive =
false; // is_find_connection ? common::EqualsASCII(connection_field.value, "Keep-Alive", false) : false;
const common::http::http_protocol protocol = hrequest.GetProtocol();
const common::http::http_method method = hrequest.GetMethod();
if (method == common::http::http_method::HM_GET || method == common::http::http_method::HM_HEAD) {
@ -181,7 +182,7 @@ void HttpHandler::ProcessReceived(HttpClient* hclient, const char* request, size
}
if (hrequest.GetMethod() == common::http::http_method::HM_GET) {
common::ErrnoError err = hclient->SendFileByFd(protocol, file, sb.st_size);
common::ErrnoError err = hclient->SendFileByFd(protocol, file);
if (err) {
DEBUG_MSG_ERROR(err, common::logging::LOG_LEVEL_ERR);
} else {

9
src/server/pipe/client.h
View file

@ -14,10 +14,15 @@
#pragma once
#include <common/libev/pipe_client.h>
#include <fastotv/protocol/protocol.h>
namespace common {
namespace libev {
class PipeReadClient;
class PipeWriteClient;
} // namespace libev
} // namespace common
namespace fastocloud {
namespace server {
namespace pipe {

955
src/server/process_slave_wrapper.cpp
View file

File diff suppressed because it is too large Load diff

56
src/server/process_slave_wrapper.h
View file

@ -14,10 +14,8 @@
#pragma once
#include <map>
#include <string>
#include <vector>
#include <common/http/http.h>
#include <common/json/json.h>
#include <common/libev/io_loop_observer.h>
#include <common/net/types.h>
#include <common/threads/ts_queue.h>
@ -29,6 +27,7 @@
#include "base/stream_info.h"
#include "server/config.h"
#include "server/daemon/commands_info/service/server_info.h"
namespace fastocloud {
namespace server {
@ -38,6 +37,7 @@ class ProtocoledDaemonClient;
class ProcessSlaveWrapper : public common::libev::IoLoopObserver {
public:
enum { BUF_SIZE = 4096 };
enum {
node_stats_send_seconds = 10,
ping_timeout_clients_seconds = 60,
@ -51,9 +51,8 @@ class ProcessSlaveWrapper : public common::libev::IoLoopObserver {
explicit ProcessSlaveWrapper(const Config& config);
~ProcessSlaveWrapper() override;
static common::ErrnoError SendStopDaemonRequest(const Config& config);
static common::ErrnoError SendRestartDaemonRequest(const Config& config);
common::net::HostAndPort GetServerHostAndPort();
static common::ErrnoError SendStopDaemonRequest(const common::net::HostAndPort& host);
static common::ErrnoError SendRestartDaemonRequest(const common::net::HostAndPort& host);
int Exec(int argc, char** argv) WARN_UNUSED_RESULT;
@ -75,11 +74,6 @@ class ProcessSlaveWrapper : public common::libev::IoLoopObserver {
void DataReadyToWrite(common::libev::IoClient* client) override;
void PostLooped(common::libev::IoLoop* server) override;
virtual common::ErrnoError HandleRequestServiceCommand(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
virtual common::ErrnoError HandleResponceServiceCommand(ProtocoledDaemonClient* dclient,
const fastotv::protocol::response_t* resp) WARN_UNUSED_RESULT;
virtual common::ErrnoError HandleRequestStreamsCommand(stream_client_t* pclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
virtual common::ErrnoError HandleResponceStreamsCommand(stream_client_t* pclient,
@ -91,15 +85,18 @@ class ProcessSlaveWrapper : public common::libev::IoLoopObserver {
void StopImpl();
ChildStream* FindChildByID(fastotv::stream_id_t cid) const;
void BroadcastClients(const fastotv::protocol::request_t& req);
void BroadcastClients(const common::json::WsDataJson& req);
common::ErrnoError DaemonDataReceived(ProtocoledDaemonClient* dclient) WARN_UNUSED_RESULT;
common::ErrnoError ProcessReceived(ProtocoledDaemonClient* hclient, const char* request, size_t req_len);
common::ErrnoError StreamDataReceived(stream_client_t* pclient) WARN_UNUSED_RESULT;
common::ErrnoError CreateChildStream(const serialized_stream_t& config_args) WARN_UNUSED_RESULT;
common::ErrnoError CreateChildStreamImpl(const serialized_stream_t& config_args,
const StreamInfo& sha) WARN_UNUSED_RESULT;
common::ErrnoError StopChildStreamImpl(fastotv::stream_id_t sid, bool force) WARN_UNUSED_RESULT;
common::ErrnoError RestartChildStreamImpl(fastotv::stream_id_t sid) WARN_UNUSED_RESULT;
// stream
common::ErrnoError HandleRequestChangedSourcesStream(stream_client_t* pclient,
@ -113,35 +110,30 @@ class ProcessSlaveWrapper : public common::libev::IoLoopObserver {
#endif
common::ErrnoError HandleRequestClientStartStream(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientStopStream(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientRestartStream(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientGetLogStream(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientGetPipelineStream(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientGetConfigJsonStream(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientActivate(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientPingService(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientGetLogService(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientRestartService(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientStopService(ProtocoledDaemonClient* dclient,
const fastotv::protocol::request_t* req) WARN_UNUSED_RESULT;
common::ErrnoError HandleResponcePingService(ProtocoledDaemonClient* dclient,
const fastotv::protocol::response_t* resp) WARN_UNUSED_RESULT;
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientRestartService(ProtocoledDaemonClient* dclient,
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
common::ErrnoError HandleRequestClientGetStats(ProtocoledDaemonClient* dclient,
const common::http::HttpRequest& req) WARN_UNUSED_RESULT;
void CheckLicenseExpired(common::libev::IoLoop* server);
std::string MakeServiceStats(common::Optional<common::time64_t> expiration_time) const;
service::FullServiceInfo MakeServiceStats(common::time64_t expiration_time) const;
service::ServerInfo MakeServiceInfoStats() const;
struct NodeStats;
const Config config_;

8
src/server/process_slave_wrapper_posix.cpp
View file

@ -18,17 +18,15 @@
#include <sys/prctl.h>
#endif
#include <common/file_system/file_system.h>
#include <common/file_system/string_path_utils.h>
#include <common/libev/tcp/tcp_server.h>
#include <dlfcn.h>
#include <sys/wait.h>
#include <unistd.h>
#include <common/file_system/file_system.h>
#include <common/file_system/string_path_utils.h>
#include "base/stream_info.h"
#include "server/child_stream.h"
#include "server/daemon/server.h"
#include "server/utils/utils.h"
#define PIPE

2
src/server/tcp/client.cpp
View file

@ -14,6 +14,8 @@
#include "server/tcp/client.h"
#include <common/libev/tcp/tcp_client.h>
#include <memory>
namespace fastocloud {

11
src/server/tcp/client.h
View file

@ -14,10 +14,17 @@
#pragma once
#include <common/libev/tcp/tcp_client.h>
#include <common/net/socket_info.h>
#include <fastotv/protocol/protocol.h>
namespace common {
namespace libev {
namespace tcp {
class TcpClient;
}
} // namespace libev
} // namespace common
namespace fastocloud {
namespace server {
namespace tcp {

5
src/server/utils/utils.h
View file

@ -22,9 +22,10 @@ namespace server {
#if defined(OS_POSIX)
common::ErrnoError CreatePipe(common::net::socket_descr_t* read_client_fd,
common::net::socket_descr_t* write_client_fd);
common::net::socket_descr_t* write_client_fd) WARN_UNUSED_RESULT;
#endif
common::ErrnoError CreateSocketPair(common::net::socket_descr_t* parent_sock, common::net::socket_descr_t* child_sock);
common::ErrnoError CreateSocketPair(common::net::socket_descr_t* parent_sock,
common::net::socket_descr_t* child_sock) WARN_UNUSED_RESULT;
} // namespace server
} // namespace fastocloud

15
src/stream/dumpers/htmldump.cpp
View file

@ -42,29 +42,20 @@ bool HtmlDump::Dump(GstBin* pipeline, const common::file_system::ascii_file_stri
return false;
}
#if GST_CHECK_VERSION(1, 11, 1)
char* dot_description = gst_debug_bin_to_dot_data(pipeline, GST_DEBUG_GRAPH_SHOW_ALL);
if (!dot_description) {
return false;
}
std::string pipeline_description(dot_description);
dumpfile << "<html><head></head>"
<< "<body>"
<< " <script type=\"text/javascript\" src=\"" JS_LIB "\"></script>"
<< " <script>"
<< " document.body.innerHTML += Viz(String.raw`" << pipeline_description << "`);"
<< " </script>"
<< "</body>"
<< "</html>";
dumpfile << "<html><head></head>" << "<body>" << " <script type=\"text/javascript\" src=\"" JS_LIB "\"></script>"
<< " <script>" << " document.body.innerHTML += Viz(String.raw`" << pipeline_description << "`);"
<< " </script>" << "</body>" << "</html>";
g_free(dot_description);
return true;
#else
return false;
#endif
#else
return false;
#endif
}
} // namespace dumper

2
src/stream/dumpers/htmldump.h
View file

@ -22,7 +22,7 @@ namespace dumper {
class HtmlDump : public IDumper {
public:
bool Dump(GstBin* pipeline, const common::file_system::ascii_file_string_path& path) override;
bool Dump(GstBin* pipeline, const common::file_system::ascii_file_string_path& path) override WARN_UNUSED_RESULT;
};
} // namespace dumper

2
src/stream/dumpers/idumper.h
View file

@ -24,7 +24,7 @@ namespace dumper {
class IDumper {
public:
virtual bool Dump(GstBin* pipeline, const common::file_system::ascii_file_string_path& path) = 0;
virtual bool Dump(GstBin* pipeline, const common::file_system::ascii_file_string_path& path) WARN_UNUSED_RESULT = 0;
virtual ~IDumper();
};

5
src/stream/elements/depay/audio.h
View file

@ -14,14 +14,13 @@
#pragma once
#include <string>
#include <common/sprintf.h>
#include "stream/stypes.h"
#include <string>
#include "stream/elements/depay/depay.h" // for ElementRtpPay
#include "stream/elements/element.h" // for Element (ptr only), SupportedElements:...
#include "stream/stypes.h"
namespace fastocloud {
namespace stream {

4
src/stream/stream_controller.cpp
View file

@ -400,9 +400,9 @@ void StreamController::ChildStatusChanged(common::libev::IoChild* child, int sta
common::ErrnoError StreamController::HandleRequestCommand(common::libev::IoClient* client,
const fastotv::protocol::request_t* req) {
if (req->method == STOP_STREAM) {
if (req->method == REQUEST_STOP_STREAM) {
return HandleRequestStopStream(client, req);
} else if (req->method == RESTART_STREAM) {
} else if (req->method == REQUEST_RESTART_STREAM) {
return HandleRequestRestartStream(client, req);
}

4
src/stream_commands/commands.h
View file

@ -14,8 +14,8 @@
#pragma once
#define STOP_STREAM "stop"
#define RESTART_STREAM "restart"
#define REQUEST_STOP_STREAM "stop"
#define REQUEST_RESTART_STREAM "restart"
#define CHANGED_SOURCES_STREAM "changed_source_stream"
#define STATISTIC_STREAM "statistic_stream"

4
src/stream_commands/commands_factory.cpp
View file

@ -45,7 +45,7 @@ common::Error RestartStreamRequest(fastotv::protocol::sequance_id_t id, fastotv:
fastotv::protocol::request_t lreq;
lreq.id = id;
lreq.method = RESTART_STREAM;
lreq.method = REQUEST_RESTART_STREAM;
*req = lreq;
return common::Error();
}
@ -57,7 +57,7 @@ common::Error StopStreamRequest(fastotv::protocol::sequance_id_t id, fastotv::pr
fastotv::protocol::request_t lreq;
lreq.id = id;
lreq.method = STOP_STREAM;
lreq.method = REQUEST_STOP_STREAM;
*req = lreq;
return common::Error();
}

4
src/utils/m3u8_reader.cpp
View file

@ -14,11 +14,11 @@
#include "utils/m3u8_reader.h"
#include <common/convert2string.h>
#include <regex>
#include <string>
#include <common/convert2string.h>
#define CHUNK_EXT ".ts"
#define CHUNK_EXT_RE "\\" CHUNK_EXT

4
src/utils/m3u8_reader.h
View file

@ -14,11 +14,11 @@
#pragma once
#include <common/file_system/path.h>
#include <string>
#include <vector>
#include <common/file_system/path.h>
#include "utils/chunk_info.h"
namespace fastocloud {