examples/darwin-framework-tool/commands/interactive/InteractiveCommands.mm - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *   Copyright (c) 2022 Project CHIP Authors
  *   All rights reserved.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
  *   You may obtain a copy of the License at
  *
  *       http://www.apache.org/licenses/LICENSE-2.0
  *
  *   Unless required by applicable law or agreed to in writing, software
  *   distributed under the License is distributed on an "AS IS" BASIS,
  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  *
  */

 #include "InteractiveCommands.h"

 #include <lib/support/Base64.h>
 #include <platform/logging/LogV.h>

 #include <editline.h>

 constexpr char kInteractiveModePrompt[] = "Stop and restart stack: [Ctrl+_] & [Ctrl+^] \nQuit Interactive: 'quit()'\n>>> ";
 constexpr char kInteractiveModeHistoryFilePath[] = "/tmp/darwin_framework_tool_history";
 constexpr char kInteractiveModeStopCommand[] = "quit()";
 constexpr char kCategoryError[] = "Error";
 constexpr char kCategoryProgress[] = "Info";
 constexpr char kCategoryDetail[] = "Debug";

 namespace {

 class RestartCommand : public CHIPCommandBridge {
 public:
     RestartCommand()
         : CHIPCommandBridge("restart")
     {
     }

     CHIP_ERROR RunCommand() override
     {
         RestartCommissioners();
         return CHIP_NO_ERROR;
     }

     chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(0); }
 };

 class StopCommand : public CHIPCommandBridge {
 public:
     StopCommand()
         : CHIPCommandBridge("stop")
     {
     }

     CHIP_ERROR RunCommand() override
     {
         StopCommissioners();
         return CHIP_NO_ERROR;
     }

     chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(0); }
 };

 void ClearLine()
 {
     printf("\r\x1B[0J"); // Move cursor to the beginning of the line and clear from cursor to end of the screen
 }

 void ENFORCE_FORMAT(3, 0) LoggingCallback(const char * module, uint8_t category, const char * msg, va_list args)
 {
     ClearLine();
     chip::Logging::Platform::LogV(module, category, msg, args);
     ClearLine();
 }

 class ScopedLock {
 public:
     ScopedLock(std::mutex & mutex)
         : mMutex(mutex)
     {
         mMutex.lock();
     }

     ~ScopedLock() { mMutex.unlock(); }

 private:
     std::mutex & mMutex;
 };

 struct InteractiveServerResultLog {
     std::string module;
     std::string message;
     std::string messageType;
 };

 struct InteractiveServerResult {
     bool mEnabled = false;
     uint16_t mTimeout = 0;
     int mStatus = EXIT_SUCCESS;
     bool mIsAsyncReport = false;
     std::vector<std::string> mResults;
     std::vector<InteractiveServerResultLog> mLogs;

     // The InteractiveServerResult instance (gInteractiveServerResult) is initially
     // accessed on the main thread in InteractiveServerCommand::RunCommand, which is
     // when chip-tool starts in 'interactive server' mode.
     //
     // Then command results are normally sent over the wire onto the main thread too
     // when a command is received over WebSocket in InteractiveServerCommand::OnWebSocketMessageReceived
     // which for most cases runs a command onto the chip thread and block until
     // it is resolved (or until it timeouts).
     //
     // But in the meantime, when some parts of the command result happens, it is appended
     // to the mResults vector onto the chip thread.
     //
     // For empty commands, which means that the test suite is *waiting* for some events
     // (e.g a subscription report), the command results are sent over the chip thread
     // (this is the isAsyncReport use case).
     //
     // Finally, logs can be appended from either the chip thread or the main thread.
     //
     // This class should be refactored to abstract that properly and reduce the scope of
     // of the mutex, but in the meantime, the access to the members of this class are
     // protected by a mutex.
     std::mutex mMutex;

     void Setup(bool isAsyncReport, uint16_t timeout)
     {
         auto lock = ScopedLock(mMutex);
         mEnabled = true;
         mIsAsyncReport = isAsyncReport;
         mTimeout = timeout;
     }

     void Reset()
     {
         auto lock = ScopedLock(mMutex);

         mEnabled = false;
         mIsAsyncReport = false;
         mTimeout = 0;
         mStatus = EXIT_SUCCESS;
         mResults.clear();
         mLogs.clear();
     }

     bool IsAsyncReport()
     {
         auto lock = ScopedLock(mMutex);
         return mIsAsyncReport;
     }

     void MaybeAddLog(const char * module, uint8_t category, const char * base64Message)
     {
         auto lock = ScopedLock(mMutex);
         VerifyOrReturn(mEnabled);

         const char * messageType = nullptr;
         switch (category) {
         case chip::Logging::kLogCategory_Error:
             messageType = kCategoryError;
             break;
         case chip::Logging::kLogCategory_Progress:
             messageType = kCategoryProgress;
             break;
         case chip::Logging::kLogCategory_Detail:
             messageType = kCategoryDetail;
             break;
         default:
             // This should not happen.
             chipDie();
             break;
         }

         mLogs.push_back(InteractiveServerResultLog({ module, base64Message, messageType }));
     }

     void MaybeAddResult(const char * result)
     {
         auto lock = ScopedLock(mMutex);
         VerifyOrReturn(mEnabled);

         mResults.push_back(result);
     }

     std::string AsJsonString()
     {
         auto lock = ScopedLock(mMutex);

         std::stringstream content;
         content << "{";

         content << "  \"results\": [";
         if (mResults.size()) {
             for (const auto & result : mResults) {
                 content << result << ",";
             }

             // Remove last comma.
             content.seekp(-1, std::ios_base::end);
         }

         if (mStatus != EXIT_SUCCESS) {
             if (mResults.size()) {
                 content << ",";
             }
             content << "{ \"error\": \"FAILURE\" }";
         }
         content << "],";

         content << "\"logs\": [";
         if (mLogs.size()) {
             for (const auto & log : mLogs) {
                 content << "{"
                            "  \"module\": \""
                         + log.module
                         + "\","
                           "  \"category\": \""
                         + log.messageType
                         + "\","
                           "  \"message\": \""
                         + log.message
                         + "\""
                           "},";
             }

             // Remove last comma.
             content.seekp(-1, std::ios_base::end);
         }
         content << "]";

         content << "}";
         return content.str();
     }
 };

 InteractiveServerResult gInteractiveServerResult;

 void ENFORCE_FORMAT(3, 0) InteractiveServerLoggingCallback(const char * module, uint8_t category, const char * msg, va_list args)
 {
     va_list args_copy;
     va_copy(args_copy, args);

     chip::Logging::Platform::LogV(module, category, msg, args);

     char message[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE];
     vsnprintf(message, sizeof(message), msg, args_copy);
     va_end(args_copy);

     char base64Message[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE * 2] = {};
     chip::Base64Encode(chip::Uint8::from_char(message), static_cast<uint16_t>(strlen(message)), base64Message);

     gInteractiveServerResult.MaybeAddLog(module, category, base64Message);
 }

 } // namespace

 char * GetCommand(const chip::Optional<char *> & mAdditionalPrompt, char * command)
 {
     if (command != nullptr) {
         free(command);
         command = nullptr;
     }

     if (mAdditionalPrompt.HasValue()) {
         ClearLine();
         printf("%s\n", mAdditionalPrompt.Value());
         ClearLine();
     }
     command = readline(kInteractiveModePrompt);

     // Do not save empty lines
     if (command != nullptr && *command) {
         add_history(command);
         write_history(kInteractiveModeHistoryFilePath);
     }

     return command;
 }

 el_status_t RestartFunction()
 {
     RestartCommand cmd;
     cmd.RunCommand();
     return CSstay;
 }

 el_status_t StopFunction()
 {
     StopCommand cmd;
     cmd.RunCommand();
     return CSstay;
 }

 CHIP_ERROR InteractiveStartCommand::RunCommand()
 {
     read_history(kInteractiveModeHistoryFilePath);

     // Logs needs to be redirected in order to refresh the screen appropriately when something
     // is dumped to stdout while the user is typing a command.
     chip::Logging::SetLogRedirectCallback(LoggingCallback);

     el_bind_key(CTL('^'), RestartFunction);
     el_bind_key(CTL('_'), StopFunction);

     char * command = nullptr;
     int status;
     while (YES) {
         command = GetCommand(mAdditionalPrompt, command);
         if (command != nullptr && !ParseCommand(command, &status)) {
             break;
         }
     }

     if (command != nullptr) {
         free(command);
         command = nullptr;
     }

     SetCommandExitStatus(CHIP_NO_ERROR);
     return CHIP_NO_ERROR;
 }

 CHIP_ERROR InteractiveServerCommand::RunCommand()
 {
     read_history(kInteractiveModeHistoryFilePath);

     // Logs needs to be redirected in order to refresh the screen appropriately when something
     // is dumped to stdout while the user is typing a command.
     chip::Logging::SetLogRedirectCallback(InteractiveServerLoggingCallback);

     RemoteDataModelLogger::SetDelegate(this);
     ReturnErrorOnFailure(mWebSocketServer.Run(mPort, this));

     gInteractiveServerResult.Reset();
     SetCommandExitStatus(CHIP_NO_ERROR);
     return CHIP_NO_ERROR;
 }

 bool InteractiveServerCommand::OnWebSocketMessageReceived(char * msg)
 {
     bool isAsyncReport = strlen(msg) == 0;
     uint16_t timeout = 0;
     if (!isAsyncReport && strlen(msg) <= 5 /* Only look for numeric values <= 65535 */) {
         std::stringstream ss;
         ss << msg;
         ss >> timeout;
         if (!ss.fail()) {
             isAsyncReport = true;
         }
     }
     gInteractiveServerResult.Setup(isAsyncReport, timeout);
     VerifyOrReturnValue(!isAsyncReport, true);

     auto shouldStop = ParseCommand(msg, &gInteractiveServerResult.mStatus);
     mWebSocketServer.Send(gInteractiveServerResult.AsJsonString().c_str());
     gInteractiveServerResult.Reset();
     return shouldStop;
 }

 CHIP_ERROR InteractiveServerCommand::LogJSON(const char * json)
 {
     gInteractiveServerResult.MaybeAddResult(json);
     if (gInteractiveServerResult.IsAsyncReport()) {
         mWebSocketServer.Send(gInteractiveServerResult.AsJsonString().c_str());
         gInteractiveServerResult.Reset();
     }
     return CHIP_NO_ERROR;
 }

 bool InteractiveCommand::ParseCommand(char * command, int * status)
 {
     if (strcmp(command, kInteractiveModeStopCommand) == 0) {
         ExecuteDeferredCleanups();
         return NO;
     }

     ClearLine();

     *status = mHandler->RunInteractive(command, GetStorageDirectory(), true);

     return YES;
 }
	/*
	* Copyright (c) 2022 Project CHIP Authors
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	#include "InteractiveCommands.h"

	#include <lib/support/Base64.h>
	#include <platform/logging/LogV.h>

	#include <editline.h>

	constexpr char kInteractiveModePrompt[] = "Stop and restart stack: [Ctrl+_] & [Ctrl+^] \nQuit Interactive: 'quit()'\n>>> ";
	constexpr char kInteractiveModeHistoryFilePath[] = "/tmp/darwin_framework_tool_history";
	constexpr char kInteractiveModeStopCommand[] = "quit()";
	constexpr char kCategoryError[] = "Error";
	constexpr char kCategoryProgress[] = "Info";
	constexpr char kCategoryDetail[] = "Debug";

	namespace {

	class RestartCommand : public CHIPCommandBridge {
	public:
	RestartCommand()
	: CHIPCommandBridge("restart")
	{
	}

	CHIP_ERROR RunCommand() override
	{
	RestartCommissioners();
	return CHIP_NO_ERROR;
	}

	chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(0); }
	};

	class StopCommand : public CHIPCommandBridge {
	public:
	StopCommand()
	: CHIPCommandBridge("stop")
	{
	}

	CHIP_ERROR RunCommand() override
	{
	StopCommissioners();
	return CHIP_NO_ERROR;
	}

	chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(0); }
	};

	void ClearLine()
	{
	printf("\r\x1B[0J"); // Move cursor to the beginning of the line and clear from cursor to end of the screen
	}

	void ENFORCE_FORMAT(3, 0) LoggingCallback(const char * module, uint8_t category, const char * msg, va_list args)
	{
	ClearLine();
	chip::Logging::Platform::LogV(module, category, msg, args);
	ClearLine();
	}

	class ScopedLock {
	public:
	ScopedLock(std::mutex & mutex)
	: mMutex(mutex)
	{
	mMutex.lock();
	}

	~ScopedLock() { mMutex.unlock(); }

	private:
	std::mutex & mMutex;
	};

	struct InteractiveServerResultLog {
	std::string module;
	std::string message;
	std::string messageType;
	};

	struct InteractiveServerResult {
	bool mEnabled = false;
	uint16_t mTimeout = 0;
	int mStatus = EXIT_SUCCESS;
	bool mIsAsyncReport = false;
	std::vector<std::string> mResults;
	std::vector<InteractiveServerResultLog> mLogs;

	// The InteractiveServerResult instance (gInteractiveServerResult) is initially
	// accessed on the main thread in InteractiveServerCommand::RunCommand, which is
	// when chip-tool starts in 'interactive server' mode.
	//
	// Then command results are normally sent over the wire onto the main thread too
	// when a command is received over WebSocket in InteractiveServerCommand::OnWebSocketMessageReceived
	// which for most cases runs a command onto the chip thread and block until
	// it is resolved (or until it timeouts).
	//
	// But in the meantime, when some parts of the command result happens, it is appended
	// to the mResults vector onto the chip thread.
	//
	// For empty commands, which means that the test suite is waiting for some events
	// (e.g a subscription report), the command results are sent over the chip thread
	// (this is the isAsyncReport use case).
	//
	// Finally, logs can be appended from either the chip thread or the main thread.
	//
	// This class should be refactored to abstract that properly and reduce the scope of
	// of the mutex, but in the meantime, the access to the members of this class are
	// protected by a mutex.
	std::mutex mMutex;

	void Setup(bool isAsyncReport, uint16_t timeout)
	{
	auto lock = ScopedLock(mMutex);
	mEnabled = true;
	mIsAsyncReport = isAsyncReport;
	mTimeout = timeout;
	}

	void Reset()
	{
	auto lock = ScopedLock(mMutex);

	mEnabled = false;
	mIsAsyncReport = false;
	mTimeout = 0;
	mStatus = EXIT_SUCCESS;
	mResults.clear();
	mLogs.clear();
	}

	bool IsAsyncReport()
	{
	auto lock = ScopedLock(mMutex);
	return mIsAsyncReport;
	}

	void MaybeAddLog(const char * module, uint8_t category, const char * base64Message)
	{
	auto lock = ScopedLock(mMutex);
	VerifyOrReturn(mEnabled);

	const char * messageType = nullptr;
	switch (category) {
	case chip::Logging::kLogCategory_Error:
	messageType = kCategoryError;
	break;
	case chip::Logging::kLogCategory_Progress:
	messageType = kCategoryProgress;
	break;
	case chip::Logging::kLogCategory_Detail:
	messageType = kCategoryDetail;
	break;
	default:
	// This should not happen.
	chipDie();
	break;
	}

	mLogs.push_back(InteractiveServerResultLog({ module, base64Message, messageType }));
	}

	void MaybeAddResult(const char * result)
	{
	auto lock = ScopedLock(mMutex);
	VerifyOrReturn(mEnabled);

	mResults.push_back(result);
	}

	std::string AsJsonString()
	{
	auto lock = ScopedLock(mMutex);

	std::stringstream content;
	content << "{";

	content << " \"results\": [";
	if (mResults.size()) {
	for (const auto & result : mResults) {
	content << result << ",";
	}

	// Remove last comma.
	content.seekp(-1, std::ios_base::end);
	}

	if (mStatus != EXIT_SUCCESS) {
	if (mResults.size()) {
	content << ",";
	}
	content << "{ \"error\": \"FAILURE\" }";
	}
	content << "],";

	content << "\"logs\": [";
	if (mLogs.size()) {
	for (const auto & log : mLogs) {
	content << "{"
	" \"module\": \""
	+ log.module
	+ "\","
	" \"category\": \""
	+ log.messageType
	+ "\","
	" \"message\": \""
	+ log.message
	+ "\""
	"},";
	}

	// Remove last comma.
	content.seekp(-1, std::ios_base::end);
	}
	content << "]";

	content << "}";
	return content.str();
	}
	};

	InteractiveServerResult gInteractiveServerResult;

	void ENFORCE_FORMAT(3, 0) InteractiveServerLoggingCallback(const char * module, uint8_t category, const char * msg, va_list args)
	{
	va_list args_copy;
	va_copy(args_copy, args);

	chip::Logging::Platform::LogV(module, category, msg, args);

	char message[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE];
	vsnprintf(message, sizeof(message), msg, args_copy);
	va_end(args_copy);

	char base64Message[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE * 2] = {};
	chip::Base64Encode(chip::Uint8::from_char(message), static_cast<uint16_t>(strlen(message)), base64Message);

	gInteractiveServerResult.MaybeAddLog(module, category, base64Message);
	}

	} // namespace

	char * GetCommand(const chip::Optional<char > & mAdditionalPrompt, char command)
	{
	if (command != nullptr) {
	free(command);
	command = nullptr;
	}

	if (mAdditionalPrompt.HasValue()) {
	ClearLine();
	printf("%s\n", mAdditionalPrompt.Value());
	ClearLine();
	}
	command = readline(kInteractiveModePrompt);

	// Do not save empty lines
	if (command != nullptr && *command) {
	add_history(command);
	write_history(kInteractiveModeHistoryFilePath);
	}

	return command;
	}

	el_status_t RestartFunction()
	{
	RestartCommand cmd;
	cmd.RunCommand();
	return CSstay;
	}

	el_status_t StopFunction()
	{
	StopCommand cmd;
	cmd.RunCommand();
	return CSstay;
	}

	CHIP_ERROR InteractiveStartCommand::RunCommand()
	{
	read_history(kInteractiveModeHistoryFilePath);

	// Logs needs to be redirected in order to refresh the screen appropriately when something
	// is dumped to stdout while the user is typing a command.
	chip::Logging::SetLogRedirectCallback(LoggingCallback);

	el_bind_key(CTL('^'), RestartFunction);
	el_bind_key(CTL('_'), StopFunction);

	char * command = nullptr;
	int status;
	while (YES) {
	command = GetCommand(mAdditionalPrompt, command);
	if (command != nullptr && !ParseCommand(command, &status)) {
	break;
	}
	}

	if (command != nullptr) {
	free(command);
	command = nullptr;
	}

	SetCommandExitStatus(CHIP_NO_ERROR);
	return CHIP_NO_ERROR;
	}

	CHIP_ERROR InteractiveServerCommand::RunCommand()
	{
	read_history(kInteractiveModeHistoryFilePath);

	// Logs needs to be redirected in order to refresh the screen appropriately when something
	// is dumped to stdout while the user is typing a command.
	chip::Logging::SetLogRedirectCallback(InteractiveServerLoggingCallback);

	RemoteDataModelLogger::SetDelegate(this);
	ReturnErrorOnFailure(mWebSocketServer.Run(mPort, this));

	gInteractiveServerResult.Reset();
	SetCommandExitStatus(CHIP_NO_ERROR);
	return CHIP_NO_ERROR;
	}

	bool InteractiveServerCommand::OnWebSocketMessageReceived(char * msg)
	{
	bool isAsyncReport = strlen(msg) == 0;
	uint16_t timeout = 0;
	if (!isAsyncReport && strlen(msg) <= 5 /* Only look for numeric values <= 65535 */) {
	std::stringstream ss;
	ss << msg;
	ss >> timeout;
	if (!ss.fail()) {
	isAsyncReport = true;
	}
	}
	gInteractiveServerResult.Setup(isAsyncReport, timeout);
	VerifyOrReturnValue(!isAsyncReport, true);

	auto shouldStop = ParseCommand(msg, &gInteractiveServerResult.mStatus);
	mWebSocketServer.Send(gInteractiveServerResult.AsJsonString().c_str());
	gInteractiveServerResult.Reset();
	return shouldStop;
	}

	CHIP_ERROR InteractiveServerCommand::LogJSON(const char * json)
	{
	gInteractiveServerResult.MaybeAddResult(json);
	if (gInteractiveServerResult.IsAsyncReport()) {
	mWebSocketServer.Send(gInteractiveServerResult.AsJsonString().c_str());
	gInteractiveServerResult.Reset();
	}
	return CHIP_NO_ERROR;
	}

	bool InteractiveCommand::ParseCommand(char * command, int * status)
	{
	if (strcmp(command, kInteractiveModeStopCommand) == 0) {
	ExecuteDeferredCleanups();
	return NO;
	}

	ClearLine();

	*status = mHandler->RunInteractive(command, GetStorageDirectory(), true);

	return YES;
	}