HappyTanuki/BumbleCee
1
0
Fork 0
mirror of https://github.com/HappyTanuki/BumbleCee.git synced 2025-10-25 17:35:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

ytdlp 자동 다운로드 및 업데이트 로직 구현

Browse Source
This commit is contained in:
HappyTanuki
2025-08-30 02:51:58 +09:00
parent 177221bf73
commit 0bff043d6e
36 changed files with 351 additions and 1625 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.vscode/c_cpp_properties.json vendored
View File

@@ -12,10 +12,7 @@
"compilerPath": "/usr/bin/gcc",
"cStandard": "c17",
"cppStandard": "c++20",
"intelliSenseMode": "linux-gcc-x64",
"compilerArgs": [
"-DDPP_CORO"
]
"intelliSenseMode": "linux-gcc-x64"
}
],
"version": 4

49
.vscode/settings.json vendored
View File

@@ -1,11 +1,9 @@
{
"C_Cpp.default.compileCommands": "${workspaceFolder}/build/compile_commands.json",
"files.associations": {
"iosfwd": "cpp",
"sstream": "cpp",
"cctype": "cpp",
"clocale": "cpp",
"cmath": "cpp",
"csignal": "cpp",
"cstdarg": "cpp",
"cstddef": "cpp",
"cstdio": "cpp",
@@ -14,27 +12,20 @@
"ctime": "cpp",
"cwchar": "cpp",
"cwctype": "cpp",
"any": "cpp",
"array": "cpp",
"atomic": "cpp",
"strstream": "cpp",
"bit": "cpp",
"*.tcc": "cpp",
"bitset": "cpp",
"charconv": "cpp",
"chrono": "cpp",
"codecvt": "cpp",
"compare": "cpp",
"complex": "cpp",
"concepts": "cpp",
"condition_variable": "cpp",
"coroutine": "cpp",
"cstdint": "cpp",
"deque": "cpp",
"forward_list": "cpp",
"list": "cpp",
"map": "cpp",
"set": "cpp",
"string": "cpp",
"unordered_map": "cpp",
"vector": "cpp",
@@ -44,66 +35,36 @@
"iterator": "cpp",
"memory": "cpp",
"memory_resource": "cpp",
"numeric": "cpp",
"optional": "cpp",
"random": "cpp",
"ratio": "cpp",
"source_location": "cpp",
"string_view": "cpp",
"system_error": "cpp",
"tuple": "cpp",
"type_traits": "cpp",
"utility": "cpp",
"format": "cpp",
"fstream": "cpp",
"future": "cpp",
"initializer_list": "cpp",
"iomanip": "cpp",
"iosfwd": "cpp",
"iostream": "cpp",
"istream": "cpp",
"limits": "cpp",
"mutex": "cpp",
"new": "cpp",
"numbers": "cpp",
"ostream": "cpp",
"ranges": "cpp",
"semaphore": "cpp",
"shared_mutex": "cpp",
"sstream": "cpp",
"stdexcept": "cpp",
"stop_token": "cpp",
"streambuf": "cpp",
"thread": "cpp",
"cinttypes": "cpp",
"typeindex": "cpp",
"typeinfo": "cpp",
"valarray": "cpp",
"variant": "cpp",
"*.ipp": "cpp",
"format": "cpp",
"span": "cpp",
"__bit_reference": "cpp",
"__bits": "cpp",
"__config": "cpp",
"__debug": "cpp",
"__errc": "cpp",
"__hash_table": "cpp",
"__locale": "cpp",
"__mutex_base": "cpp",
"__node_handle": "cpp",
"__nullptr": "cpp",
"__split_buffer": "cpp",
"__string": "cpp",
"__threading_support": "cpp",
"__tree": "cpp",
"__tuple": "cpp",
"ios": "cpp",
"locale": "cpp",
"queue": "cpp",
"hash_map": "cpp",
"hash_set": "cpp",
"regex": "cpp",
"stack": "cpp",
"__memory": "cpp",
"__verbose_abort": "cpp",
"print": "cpp"
"rope": "cpp"
}
}

28
CMakeLists.txt
View File

@@ -92,24 +92,18 @@ if(NOT AVCODEC_LIBRARY OR NOT AVFORMAT_LIBRARY OR NOT AVUTIL_LIBRARY)
message(FATAL_ERROR "FFmpeg 라이브러리를 찾을 수 없습니다. 다운로드 경로를 확인해주세요.")
endif()
#file(GLOB_RECURSE CORES "src/*.cpp" "src/*.cxx" "src/*.cc")
#file(GLOB_RECURSE AUDIO_SOURCES "src/Audio/*.cpp" "src/Audio/*.cxx" "src/Audio/*.cc")
#file(GLOB_RECURSE COMMANDS_SOURCES "src/Commands/*.cpp" "src/Commands/*.cxx" "src/Commands/*.cc")
#file(GLOB_RECURSE QUEUE_SOURCES "src/Queue/*.cpp" "src/Queue/*.cxx" "src/Queue/*.cc")
#file(GLOB_RECURSE SETTINGS_SOURCES "src/Settings/*.cpp" "src/Settings/*.cxx" "src/Settings/*.cc")
#file(GLOB_RECURSE UTILS_SOURCES "src/Utils/*.cpp" "src/Utils/*.cxx" "src/Utils/*.cc")
file(GLOB_RECURSE CORES "src/*.cpp" "src/*.cxx" "src/*.cc")
# Combine all found source files into a single list
#set(ALL_SOURCE_FILES
# ${CORES}
# ${AUDIO_SOURCES}
# ${COMMANDS_SOURCES}
# ${QUEUE_SOURCES}
# ${SETTINGS_SOURCES}
# ${UTILS_SOURCES}
#)
set(ALL_SOURCE_FILES
${CORES}
${AUDIO_SOURCES}
${COMMANDS_SOURCES}
${QUEUE_SOURCES}
${SETTINGS_SOURCES}
${UTILS_SOURCES}
)
add_executable(${BOT_NAME} src/main.cpp)
add_executable(${BOT_NAME} ${ALL_SOURCE_FILES})
target_link_libraries(${BOT_NAME} PRIVATE dpp)
target_link_libraries(${BOT_NAME} PRIVATE Boost::filesystem)
@@ -140,6 +134,8 @@ target_include_directories(${BOT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/includ
target_include_directories(${BOT_NAME} PRIVATE ${OpenSSL_INCLUDE_DIRS})
target_include_directories(${BOT_NAME} PRIVATE ${FFMPEG_INCLUDE_PATH})
target_precompile_headers(${BOT_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include/precomp.h")
add_custom_command(TARGET ${BOT_NAME} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_directory
"$<TARGET_FILE_DIR:Boost::filesystem>"

67
include/Audio/MusicPlayManager.hpp
View File

@@ -1,67 +0,0 @@
#pragma once
#include <dpp/dpp.h>
#include <Queue/MusicQueue.hpp>
#include <condition_variable>
namespace bumbleBee {
class MusicPlayManager {
public:
MusicPlayManager(std::shared_ptr<dpp::cluster> cluster, std::vector<dpp::snowflake> GIDs) :
cluster(cluster), GIDs(GIDs) {
queueMap = std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>>();
queueEmptyMutex = std::unordered_map<dpp::snowflake, std::shared_ptr<std::mutex>>();
cluster->on_voice_ready([this](const dpp::voice_ready_t &event){on_voice_ready(event);});
cluster->on_voice_track_marker([this](const dpp::voice_track_marker_t &event){on_voice_track_marker(event);});
cluster->on_voice_client_disconnect([this](const dpp::voice_client_disconnect_t& event){on_voice_client_disconnect(event);});
for (auto GID : GIDs) {
queueMap[GID] = std::make_shared<MusicQueue>();
queueEmptyMutex[GID] = std::make_shared<std::mutex>();
}
}
/**
* @brief voice_ready 이벤트 인지시 콜백되는 함수
* @param event const dpp::voice_ready_t&
**/
void on_voice_ready(const dpp::voice_ready_t& event);
/**
* @brief voice_track_marker 이벤트 인지시 콜백되는 함수
* @param event const dpp::voice_track_marker_t&
**/
void on_voice_track_marker(const dpp::voice_track_marker_t& event);
/**
* @brief voice_client_disconnect 이벤트 인지시 콜백되는 함수
* @param event const dpp::voice_client_disconnect_t&
**/
void on_voice_client_disconnect(const dpp::voice_client_disconnect_t& event);
void play(dpp::discord_voice_client* client);
void queue_music(const dpp::snowflake guildId, const std::shared_ptr<MusicQueueElement> music);
void clear(const dpp::snowflake guildId);
std::shared_ptr<MusicQueueElement> remove(const dpp::snowflake guildId, dpp::discord_voice_client* client, int index);
int size(const dpp::snowflake guildId);
void setRepeat(const dpp::snowflake guildId, const bool value);
bool getRepeat(const dpp::snowflake guildId);
std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator> getQueue(const dpp::snowflake guildId);
MusicQueueElement getNowPlaying(const dpp::snowflake guildId);
std::condition_variable queuedCondition;
private:
std::shared_ptr<dpp::cluster> cluster;
std::vector<dpp::snowflake> GIDs;
/// @brief 음악 큐
std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> queueMap;
std::unordered_map<dpp::snowflake, std::shared_ptr<std::mutex>> queueEmptyMutex;
void send_audio_to_voice(std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client);
};
}

18
include/Audio/MusicPlayerThreadManager.hpp
View File

@@ -1,18 +0,0 @@
#pragma once
#include <memory>
#include <dpp/dpp.h>
#include <Queue/MusicQueueElement.hpp>
#include "Utils/ThreadPool.hpp"
namespace bumbleBee {
class ThreadManager : public ThreadPool<dpp::snowflake, int, int> {
public:
bool addMusic(std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client);
void stopSending(dpp::snowflake gid);
private:
// GID, 쓰레드
std::unordered_map<dpp::snowflake, std::thread> threadPool;
// GID, 쓰레드 종료
std::unordered_map<dpp::snowflake, bool> terminating;
};
}

54
include/BumbleBee.hpp
View File

@@ -1,54 +0,0 @@
#pragma once
#ifndef _BUMBLEBEE_HPP_
#define _BUMBLEBEE_HPP_
#include <dpp/dpp.h>
#include <dpp/nlohmann/json.hpp>
#include <memory>
#include <Commands/BumbleBeeCommand.hpp>
namespace bumbleBee {
/**
* @file BumbleBee.hpp
* @brief 메인 봇 클래스
**/
class BumbleBee {
public:
/**
* @brief 생성자
**/
BumbleBee();
/**
* @brief 파괴자
* @details BumbleBee의 모든 Property를 책임지고 파괴합니다
**/
~BumbleBee() {}
/**
* @brief 봇 시작
**/
void start();
/**
* @brief slashcommand 이벤트 인지시 콜백되는 함수
* @param event const dpp::slashcommand_t&
**/
void on_slashcommand(const dpp::slashcommand_t& event);
/**
* @brief ready 이벤트 인지시 콜백되는 함수
* @param event const dpp::ready_t&
**/
void on_ready(const dpp::ready_t& event);
/// @brief DPP 기본 클러스터 객체
std::shared_ptr<dpp::cluster> cluster;
/// @brief guild id 배열
std::vector<dpp::snowflake> GIDs;
private:
/// @brief Command 목록
std::unordered_map<std::string, std::shared_ptr<commands::ICommand>> commands;
/// @brief voiceclient 관련 event 처리기 <guild id, 각 길드별 MusicPlayManager 인스턴스>
std::shared_ptr<MusicPlayManager> musicManager;
};
}
#endif

69
include/Commands/BumbleBeeCommand.hpp
View File

@@ -1,69 +0,0 @@
#pragma once
#include <dpp/dpp.h>
#include <Audio/MusicPlayManager.hpp>
#include <functional>
namespace bumbleBee::commands {
class ICommand : public dpp::slashcommand {
public:
/**
* @brief 기본 생성자
* @param botID 봇 아이디
* @param manager 음악재생 매니저
**/
ICommand(dpp::snowflake botID, std::shared_ptr<MusicPlayManager> manager) {
this->botID = botID;
this->musicManager = manager;
}
/**
* @brief 명령어 호출 시에 콜백될 메소드
* @param event dpp::slashcommand_t
**/
virtual void execute(const dpp::slashcommand_t &event){};
/// @brief 명령어 별명
std::vector<std::string> aliases;
private:
/// @brief 봇 ID
dpp::snowflake botID;
protected:
/// @brief 음악재생 매니저
std::shared_ptr<MusicPlayManager> musicManager;
protected:
/// @brief concrete class에서 구현해야 하는 init 이벤트트
virtual void init() = 0;
};
}
/**
* @brief 명령어 인자가 없는 명령어의 boilerplate 대체 매크로
* @param name 명령어 이름 및 클래스명
* @param description 명령어 설명
**/
#define _DECLARE_BUMBLEBEE_COMMAND(CLASS, NAME, DESCRIPTION) \
namespace bumbleBee::commands { \
class CLASS : public ICommand { \
public: \
CLASS (dpp::snowflake botID, std::shared_ptr<MusicPlayManager> manager) \
: ICommand(botID, manager) { \
name = #NAME; \
description = DESCRIPTION; \
init(); \
} \
void execute(const dpp::slashcommand_t &event) override; \
\
protected: \
void init() override; \
}; \
}
_DECLARE_BUMBLEBEE_COMMAND(Delete, d, "큐의 해당하는 번호의 노래를 지웁니다")
_DECLARE_BUMBLEBEE_COMMAND(Leave, l, "음성 채팅방을 떠납니다")
_DECLARE_BUMBLEBEE_COMMAND(Play, p, "노래 재생")
_DECLARE_BUMBLEBEE_COMMAND(Queue, q, "노래 예약 큐를 확인합니다")
_DECLARE_BUMBLEBEE_COMMAND(Repeat, r, "반복을 켜거나 끕니다")
_DECLARE_BUMBLEBEE_COMMAND(Skip, s, "현재 재생중인 곡을 스킵합니다")
_DECLARE_BUMBLEBEE_COMMAND(Shuffle, shuffle, "큐를 섞습니다")

51
include/Queue/MusicQueue.hpp
View File

@@ -1,51 +0,0 @@
#pragma once
#include <memory>
#include <functional>
#include <condition_variable>
#include <list>
#include <dpp/dpp.h>
#include <Queue/MusicQueueElement.hpp>
namespace bumbleBee {
class MusicQueue {
public:
MusicQueue() {
queue = std::list<std::shared_ptr<MusicQueueElement>>();
currentPlayingPosition = queue.begin();
repeat = true;
}
void
enqueue(std::shared_ptr<MusicQueueElement> Element);
std::shared_ptr<MusicQueueElement>
dequeue();
std::list<std::shared_ptr<MusicQueueElement>>::iterator
findById(std::string id);
std::list<std::shared_ptr<MusicQueueElement>>::iterator
findByIndex(int index);
std::shared_ptr<MusicQueueElement>
nowplaying();
std::list<std::shared_ptr<MusicQueueElement>>::iterator
next_music();
std::shared_ptr<MusicQueueElement>
jump_to_index(int idx);
void
clear();
std::shared_ptr<MusicQueueElement>
erase(std::list<std::shared_ptr<MusicQueueElement>>::iterator it);
std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
getQueueCopy();
int
size();
std::list<std::shared_ptr<MusicQueueElement>>::iterator
end();
bool repeat;
std::list<std::shared_ptr<MusicQueueElement>>::iterator currentPlayingPosition;
private:
std::list<std::shared_ptr<MusicQueueElement>> queue;
std::mutex queueMutex;
};
}

20
include/Queue/MusicQueueElement.hpp
View File

@@ -1,20 +0,0 @@
#pragma once
#include <dpp/dpp.h>
namespace bumbleBee {
class MusicQueueElement {
public:
MusicQueueElement(
std::string id,
std::string query,
dpp::user issuingUser,
dpp::embed embed) :
id(id), query(query), issuingUser(issuingUser), embed(embed) {}
const std::string id;
const std::string query;
const dpp::user issuingUser;
const dpp::embed embed;
};
}

34
include/Settings/SettingsManager.hpp
View File

@@ -1,34 +0,0 @@
#pragma once
#include <dpp/dpp.h>
#define _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(type, name, Name)\
private:\
static type name;\
public:\
static type get##Name() {return name;}\
static void set##Name(const type& value) {name = value; saveToFile();}
namespace bumbleBee {
/// @brief 모든 설정은 이 객체를 통해 스태틱하게 제공됨.
class SettingsManager {
/// @brief 봇 토큰
_DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, TOKEN, TOKEN)
/// @brief yt-dlp 실행 명령어
_DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, YTDLP_CMD, YTDLP_CMD)
/// @brief ffmpeg 실행 명령어
_DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, FFMPEG_CMD, FFMPEG_CMD)
/// @brief 로그레벨
_DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(dpp::loglevel, LOGLEVEL, LOGLEVEL)
/// @brief 이전에 있던 명령을 지우고 등록할지 선택합니다.
_DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(bool, REGISTER_COMMAND, REGISTER_COMMAND)
public:
/// @brief 설정 로드하기, 설정은 이 load()를 부르기 전까지는 적절하지 못한 값을 가지고 있음.
/// @return 로드 성공 시 true, 실패 시 false 반환.
static bool load();
/// @brief 설정 변경사항 저장
static void saveToFile();
/// @brief 토큰이 유효한지 체크합니다.
/// @return 유효한 토큰이면 true, 아니면 false를 반환합니다.
static bool validateToken();
};
}

56
include/Utils/AsyncDownloadManager.hpp
View File

@@ -1,56 +0,0 @@
#pragma once
#include <queue>
#include <string>
#include <thread>
#include <condition_variable>
#include <dpp/dpp.h>
#include <Queue/MusicQueue.hpp>
namespace bumbleBee {
/// @brief 싱글톤 멀티스레딩 다운로드 매니저
class [[deprecated]] AsyncDownloadManager {
public:
static AsyncDownloadManager& getInstance(int worker_count, std::weak_ptr<dpp::cluster> weak_cluster) {
static AsyncDownloadManager dl(worker_count);
dl.weak_cluster = weak_cluster;
return dl;
}
void enqueue(std::pair<std::string, dpp::message> query) {
std::thread th(&bumbleBee::AsyncDownloadManager::enqueueAsyncDL, this, query);
th.detach();
}
void stop() {
auto cluster = weak_cluster.lock();
cluster->log(dpp::ll_info, "AsyncDownloadManager stop/destructor called.");
terminate = true;
dlQueueCondition.notify_all();
for (auto& t : worker_thread) {
t.join();
}
}
~AsyncDownloadManager(){
stop();
}
private:
AsyncDownloadManager(int worker_count){
worker_thread.reserve(worker_count);
terminate = false;
for (int i=0; i<worker_count; i++) {
worker_thread.emplace_back([this](){this->downloadWorker();});
}
}
void enqueueAsyncDL(std::pair<std::string, dpp::message> query);
void downloadWorker();
std::queue<std::pair<std::string, dpp::message>> downloadQueue;
std::condition_variable dlQueueCondition;
std::mutex dlQueueMutex;
std::weak_ptr<dpp::cluster> weak_cluster;
std::vector<std::thread> worker_thread;
bool terminate;
};
}

46
include/Utils/ConsoleUtils.hpp
View File

@@ -1,46 +0,0 @@
#pragma once
#include <iostream>
#include <sstream>
#include <queue>
#include <regex>
#include <boost/process.hpp>
namespace bumbleBee {
class ConsoleUtils {
public:
/**
* @brief 명령어를 쉘에서 실행하고 결과를 EOF 전까지 읽어 \n을 구분자로 토큰화하여 반환합니다
* @param cmd 실행할 명령
* @param args 아규먼트
* @return std::queue<std::string> tokens
*/
static std::queue<std::string> safe_execute_command(const std::string& cmd, const std::vector<std::string>& args) {
std::queue<std::string> tokens;
try {
boost::process::ipstream output; // 명령의 출력을 받을 스트림
boost::process::child c(cmd, boost::process::args(args), boost::process::std_out > output);
std::string line;
while (!output.eof() && std::getline(output, line))
tokens.push(line);
c.wait(); // 프로세스가 종료될 때까지 대기
return tokens;
} catch (const std::exception& e) {
return tokens;
}
}
/**
* @brief 명령어를 쉘에서 실행하고 결과를 파이프로 연결하여 반환합니다
* @param cmd 실행할 명령
* @param args 아규먼트
* @return FILE* fd
*/
static FILE* safe_open_pipe(const std::string& cmd, const std::vector<std::string>& args) {
boost::process::pipe pipe;
boost::process::child c(cmd, boost::process::args(args), boost::process::std_out > pipe);
return fdopen(pipe.native_source(), "r");
}
};
}

77
include/Utils/QueuedMusicListEmbedProvider.hpp
View File

@@ -1,77 +0,0 @@
#pragma once
#include <dpp/dpp.h>
#include <Queue/MusicQueueElement.hpp>
#include <cmath>
namespace bumbleBee {
class QueuedMusicListEmbedProvider {
public:
static std::queue<dpp::embed> makeEmbed(std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> queue, std::list<std::shared_ptr<MusicQueueElement>>::iterator np, bool repeat) {
std::queue<dpp::embed> returnValue;
std::list<std::shared_ptr<MusicQueueElement>>::iterator it = queue->begin();
if (queue->size() == 0) {
dpp::embed embed = makeEmbedPart(queue, np, repeat, it);
returnValue.push(embed);
return returnValue;
}
for (int i = 0; i < std::ceil(queue->size() / 5.0) && it != queue->end(); i++) {
dpp::embed embed = makeEmbedPart(queue, np, repeat, it);
returnValue.push(embed);
}
return returnValue;
}
private:
static dpp::embed makeEmbedPart(
std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> queue,
std::list<std::shared_ptr<MusicQueueElement>>::iterator np,
bool repeat,
std::list<std::shared_ptr<MusicQueueElement>>::iterator &startIter) {
dpp::embed embed = dpp::embed()
.set_color(dpp::colors::sti_blue);
if (queue->begin() == queue->end()) {
embed
.set_title("큐가 비었습니다!")
.set_timestamp(time(0));
if (repeat)
embed.add_field(":repeat:","");
return embed;
}
int startIndex = std::distance(queue->begin(), startIter) + 1;
int index = startIndex;
for (; (index < startIndex + 5) && startIter != queue->end() && index < queue->size()+1; startIter++, index++) { //iter로 순회하면 왠지 모르게 이상한 값을 읽을 때가 있음 이유는 나도 몰?루
if (*startIter == *np)
embed.add_field (
"np",
"",
true
);
else
embed.add_field (
std::to_string(index),
"",
true
);
embed.add_field (
(*startIter)->embed.title,
(*startIter)->embed.description,
true
)
.add_field("","");
}
if (startIter == queue->end() || index >= queue->size()+1) {
embed.set_timestamp(time(0));
if (repeat)
embed.add_field(":repeat:","");
}
return embed;
}
};
}

83
include/Utils/VersionsCheckUtils.hpp
View File

@@ -1,83 +0,0 @@
#pragma once
#include <dpp/dpp.h>
#include "ConsoleUtils.hpp"
#include "../Settings/SettingsManager.hpp"
namespace bumbleBee {
class VersionsCheckUtils {
public:
static bool isThereCMD(std::shared_ptr<dpp::cluster> cluster, std::string cmd) {
if (ConsoleUtils::safe_execute_command("/usr/bin/which", {cmd}).size() == 0) {
cluster->log(dpp::ll_error, cmd + " is unavaliable. unresolable error please install " + cmd);
return false;
}
else
return true;
}
static void validateFFMPEG(std::shared_ptr<dpp::cluster> cluster) {
std::queue<std::string> result = ConsoleUtils::safe_execute_command(SettingsManager::getFFMPEG_CMD(), {"-version"});
std::string front = result.front();
if (front[0] != 'f' ||
front[1] != 'f' ||
front[2] != 'm' ||
front[3] != 'p' ||
front[4] != 'e' ||
front[5] != 'g') {
cluster->log(dpp::ll_warning, "ffmpeg is unavailable. downloading ffmpeg...");
if (!isThereCMD(cluster, "curl")) {
exit(1);
}
if (!isThereCMD(cluster, "tar")) {
exit(1);
}
system("curl -LO https://github.com/BtbN/FFmpeg-Builds/releases/latest/download/ffmpeg-master-latest-linux64-gpl.tar.xz");
system("tar -xf ffmpeg-master-latest-linux64-gpl.tar.xz");
system("rm ffmpeg-master-latest-linux64-gpl.tar.xz");
system("mv ffmpeg-master-latest-linux64-gpl/bin/ffmpeg .");
system("rm -rf ffmpeg-master-latest-linux64-gpl");
SettingsManager::setFFMPEG_CMD("./ffmpeg");
}
}
static void validateYTDLP(std::shared_ptr<dpp::cluster> cluster) {
std::queue<std::string> result = ConsoleUtils::safe_execute_command(SettingsManager::getYTDLP_CMD(), {"--version"});
std::string front = result.front();
if ((front[0]-'0' < 0 || front[0]-'0' > 9) ||
(front[1]-'0' < 0 || front[1]-'0' > 9) ||
(front[2]-'0' < 0 || front[2]-'0' > 9) ||
(front[3]-'0' < 0 || front[3]-'0' > 9)) {
cluster->log(dpp::ll_warning, "ytdlp is unavailable. downloading ytdlp...");
if (!isThereCMD(cluster, "curl")) {
exit(1);
}
if (!isThereCMD(cluster, "tar")) {
exit(1);
}
system("curl -LO https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp");
system("chmod +x ./yt-dlp");
SettingsManager::setYTDLP_CMD("./yt-dlp");
}
}
static void validateYTDLPFFMPEGBinary(std::shared_ptr<dpp::cluster> cluster) {
cluster->log(dpp::ll_info, "Checking if yt-dlp and ffmpeg is available...");
validateFFMPEG(cluster);
validateYTDLP(cluster);
}
static void updateytdlp(std::shared_ptr<dpp::cluster> cluster) {
cluster->log(dpp::ll_info, "Checking if yt-dlp update is available...");
std::queue<std::string> result = ConsoleUtils::safe_execute_command("./yt-dlp", {"-U"});
while(!result.empty()) {
std::string front = result.front();
result.pop();
cluster->log(dpp::ll_info, front);
}
}
};
}

23
include/precomp.h Normal file
View File

@@ -0,0 +1,23 @@
#ifndef BUMBLEBEE_INCLUDE_PRECOMP_H_
#define BUMBLEBEE_INCLUDE_PRECOMP_H_
#ifdef WIN32
#include <winsock2.h>
#endif
#include <iostream>
#include <queue>
#include "boost/asio.hpp"
#include "boost/beast/http.hpp"
#include "boost/beast/ssl.hpp"
#include "boost/log/trivial.hpp"
#include "boost/process.hpp"
extern "C" {
#include "libavformat/avformat.h"
#include "libavutil/avutil.h"
#include "libswresample/swresample.h"
#include "libswscale/swscale.h"
}
#endif // BUMBLEBEE_INCLUDE_PRECOMP_H_

38
include/utils/console.h Normal file
View File

@@ -0,0 +1,38 @@
#ifndef BUMBLEBEE_INCLUDE_UTILS_CONSOLE_H_
#define BUMBLEBEE_INCLUDE_UTILS_CONSOLE_H_
#include "precomp.h"
namespace utils {
// @brief 명령어가 실행 가능한지 체크합니다
// @param cmd 실행할 명령
// @return int error_code
int ValidateCommand(std::string cmd);
// @brief 명령어를 쉘에서 실행하고 결과를 EOF 전까지 읽어 반환합니다
// @param cmd 실행할 명령
// @param args 아규먼트
// @return int error_code
int ExecuteCommand(
const std::string& cmd,
const std::vector<std::string>& args = std::vector<std::string>());
// @brief 명령어를 쉘에서 실행하고 결과를 EOF 전까지 읽어 반환합니다
// @param cmd 실행할 명령
// @param result 실행결과
// @return int error_code
int ExecuteCommand(const std::string& cmd, std::string& result);
// @brief 명령어를 쉘에서 실행하고 결과를 EOF 전까지 읽어 반환합니다
// @param cmd 실행할 명령
// @param args 아규먼트
// @param result 실행결과
// @return int error_code
int ExecuteCommand(const std::string& cmd, const std::vector<std::string>& args,
std::string& result);
// @brief 명령어를 쉘에서 실행하고 결과를 파이프로 연결하여 반환합니다
// @param cmd 실행할 명령
// @param args 아규먼트
// @return boost::process::popen
boost::process::popen OpenPipe(
const std::string& cmd,
const std::vector<std::string>& args = std::vector<std::string>());
} // namespace utils
#endif

10
include/utils/file_downloader.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef BUMBLEBEE_INCLUDE_UTILS_FILE_DOWNLOADER_H_
#define BUMBLEBEE_INCLUDE_UTILS_FILE_DOWNLOADER_H_
#include "precomp.h"
namespace utils {
void DownloadFileFromHTTPS(std::string url, std::string filename);
}
#endif

14
include/utils/update_checker.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef BUMBLEBEE_INCLUDE_UTILS_UPDATE_CHECKER_H_
#define BUMBLEBEE_INCLUDE_UTILS_UPDATE_CHECKER_H_
#include "precomp.h"
namespace utils {
int InstallYtdlp();
int CheckUpdate();
} // namespace utils
#endif

138
src/Audio/MusicPlayManager.cpp
View File

@@ -1,138 +0,0 @@
#include <Audio/MusicPlayManager.hpp>
#include <ogg/ogg.h>
#include <oggz/oggz.h>
#include <algorithm>
#include <Settings/SettingsManager.hpp>
namespace bumbleBee {
void MusicPlayManager::on_voice_ready(const dpp::voice_ready_t& event) {
play(event.voice_client);
}
void MusicPlayManager::on_voice_track_marker(const dpp::voice_track_marker_t& event) {
dpp::snowflake gid = dpp::find_channel(event.voice_client->channel_id)->guild_id;
queueMap[gid]->next_music(); // TODO("repeat가 꺼져 있을 때 노래 큐에서 지우기")
play(event.voice_client);
}
void MusicPlayManager::on_voice_client_disconnect(const dpp::voice_client_disconnect_t& event) { // 이거 봇이 나갈 때가 아니고 같이 있는 유저가 나갈 때였고
// dpp::snowflake gid = dpp::find_channel(event.voice_client->channel_id)->guild_id;
// event.voice_client->stop_audio();
// queueMap[gid]->clear();
}
void MusicPlayManager::play(dpp::discord_voice_client* client) {
std::thread t([&](dpp::discord_voice_client* client){
dpp::snowflake gid = dpp::find_channel(client->channel_id)->guild_id;
std::unique_lock<std::mutex> queueEmptyLock(*queueEmptyMutex[gid]);
queuedCondition.wait(queueEmptyLock, [&]{
return queueMap[gid]->size() != 0 && queueMap[gid]->currentPlayingPosition != queueMap[gid]->end();
});
auto next = queueMap[gid]->currentPlayingPosition;
send_audio_to_voice(*next, client);
}, client);
t.detach();
}
void MusicPlayManager::queue_music(const dpp::snowflake guildId, const std::shared_ptr<MusicQueueElement> music) {
queueMap[guildId]->enqueue(music);
}
void MusicPlayManager::clear(const dpp::snowflake guildId) {
queueMap[guildId]->clear();
}
std::shared_ptr<MusicQueueElement> MusicPlayManager::remove(const dpp::snowflake guildId, dpp::discord_voice_client* client, int index) {
auto queue = queueMap[guildId];
auto foundIterator = queue->findByIndex(index);
if (queue->currentPlayingPosition == foundIterator) {
auto removed = queue->erase(queue->findByIndex(0));
if (client == nullptr)
return removed;
client->pause_audio(true);
client->stop_audio();
client->pause_audio(false);
client->insert_marker("end");
return removed;
}
return queue->erase(queue->findByIndex(index));
}
int MusicPlayManager::size(const dpp::snowflake guildId) {
return queueMap[guildId]->size();
}
void MusicPlayManager::setRepeat(const dpp::snowflake guildId, const bool value) {
queueMap[guildId]->repeat = value;
}
bool MusicPlayManager::getRepeat(const dpp::snowflake guildId) {
return queueMap[guildId]->repeat;
}
std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
MusicPlayManager::getQueue(const dpp::snowflake guildId){
auto returnValue = queueMap[guildId]->getQueueCopy();
return returnValue;
}
MusicQueueElement MusicPlayManager::getNowPlaying(const dpp::snowflake guildId) {
std::shared_ptr<MusicQueueElement> nowplaying = queueMap[guildId]->nowplaying();
if (nowplaying == nullptr)
return MusicQueueElement("", "", dpp::user(), dpp::embed());
MusicQueueElement returnValue(*nowplaying);
return returnValue;
}
void MusicPlayManager::send_audio_to_voice(std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client) {
std::thread t([](std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client) { // TODO: thread 벡터 만들고 delete, leave, skip시에 전송 중지하도록 만들고. 또 노래 캐싱하고 ytdlp를 버퍼링하여 혹시 있을지 모르는 음성의 끊김을 방지할 것것
std::string command = "./streamOpus.sh ";
command += SettingsManager::getYTDLP_CMD() + " ";
command += SettingsManager::getFFMPEG_CMD() + " ";
command += "https://youtu.be/";
command += music->id;
OGGZ* og = oggz_open_stdio(popen(command.c_str(), "r"), OGGZ_READ);
// client->stop_audio(); //이거 필요함??
oggz_set_read_callback(
og, -1,
[](OGGZ *oggz, oggz_packet *packet, long serialno, void *user_data) {
auto voiceConn = (dpp::discord_voice_client *)user_data;
voiceConn->send_audio_opus(packet->op.packet, packet->op.bytes);
return 0;
},
(void *)client
);
while (client && !client->terminating && music != nullptr) {
static const constexpr long CHUNK_READ = BUFSIZ * 2;
const long read_bytes = oggz_read(og, CHUNK_READ);
/* break on eof */
if (!read_bytes) {
break;
}
}
if (music != nullptr)
client->creator->log(dpp::ll_info, "Sending " + music->embed.title + " - " + music->id + " complete!");
else {
client->stop_audio();
client->pause_audio(true);
}
oggz_close(og);
client->insert_marker();
}, music, client);
t.detach();
}
}

80
src/BumbleBee.cpp
View File

@@ -1,80 +0,0 @@
#include <BumbleBee.hpp>
#include <memory>
#include <Settings/SettingsManager.hpp>
#include <Utils/VersionsCheckUtils.hpp>
#include <Audio/MusicPlayManager.hpp>
#include <Commands/BumbleBeeCommand.hpp>
namespace bumbleBee{
BumbleBee::BumbleBee() {
if (!SettingsManager::load()) {
std::cout << "Please configure confing.json" << std::endl;
exit(1);
}
cluster = std::make_shared<dpp::cluster>(SettingsManager::getTOKEN());
cluster->on_log([](const dpp::log_t& event) {
if (event.severity >= SettingsManager::getLOGLEVEL()) {
std::cout << "[" << dpp::utility::current_date_time() << "] " << dpp::utility::loglevel(event.severity) << ": " << event.message << std::endl;
}
});
cluster->on_slashcommand([this](const dpp::slashcommand_t& event){on_slashcommand(event);});
cluster->on_ready([this](const dpp::ready_t &event){on_ready(event);});
VersionsCheckUtils::validateYTDLPFFMPEGBinary(cluster);
VersionsCheckUtils::updateytdlp(cluster);
}
void BumbleBee::start() { this->cluster->start(dpp::st_wait); }
void BumbleBee::on_slashcommand(const dpp::slashcommand_t &event) {
if (commands.find(event.command.get_command_name()) != commands.end()) {
event.thinking();
auto command = commands.at(event.command.get_command_name());
std::thread t([](const dpp::slashcommand_t &event, std::shared_ptr<commands::ICommand> command){
command->execute(event);
}, event, command);
t.detach();
}
}
void BumbleBee::on_ready(const dpp::ready_t &event) {
GIDs = event.guilds;
musicManager = std::make_shared<MusicPlayManager>(cluster, GIDs);
commands["d"] = std::make_shared<commands::Delete> (cluster->cluster_id, musicManager);
commands["l"] = std::make_shared<commands::Leave> (cluster->cluster_id, musicManager);
commands["p"] = std::make_shared<commands::Play> (cluster->cluster_id, musicManager);
commands["q"] = std::make_shared<commands::Queue> (cluster->cluster_id, musicManager);
commands["r"] = std::make_shared<commands::Repeat> (cluster->cluster_id, musicManager);
commands["s"] = std::make_shared<commands::Skip> (cluster->cluster_id, musicManager);
commands["shuffle"] = std::make_shared<commands::Shuffle> (cluster->cluster_id, musicManager);
if (event.guilds.size() == 0) {
cluster->log(dpp::loglevel::ll_info, "Bot is not on any server! Please invite this bot to any server.");
exit(1);
}
if (dpp::run_once<struct register_bot_commands>()) {
if (SettingsManager::getREGISTER_COMMAND()) {
cluster->log(dpp::loglevel::ll_info, "Clear Pre-installed commands");
cluster->global_bulk_command_create({
*commands["d"],
*commands["l"],
*commands["p"],
*commands["q"],
*commands["r"],
*commands["s"],
*commands["shuffle"]
}, [&](const dpp::confirmation_callback_t &t){
cluster->log(dpp::loglevel::ll_info, "Command created.");
SettingsManager::setREGISTER_COMMAND(false);
});
}
}
cluster->log(dpp::loglevel::ll_info, "Bot ready.");
}
}

32
src/Commands/Delete.cpp
View File

@@ -1,32 +0,0 @@
#include <Commands/BumbleBeeCommand.hpp>
#include <format>
namespace bumbleBee::commands {
void Delete::execute(const dpp::slashcommand_t &event) {
int pos = std::get<std::int64_t>(event.get_parameter("pos"));
if (pos < 0 || pos > musicManager->size(event.command.guild_id))
{
event.edit_original_response(dpp::message(std::string("이상한 인덱스 위치. Pos :") + std::to_string(pos)));
return;
}
dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
std::shared_ptr<MusicQueueElement> removed;
if (!v) // v-> 로 nullptr을 참조하면 안 되므로.
removed = musicManager->remove(event.command.guild_id, nullptr, pos);
else
removed = musicManager->remove(event.command.guild_id, v->voiceclient, pos);
dpp::message msg("다음 항목을 큐에서 삭제했습니다!:");
msg.add_embed(removed->embed);
event.edit_original_response(msg);
}
void Delete::init() {
add_option(dpp::command_option(dpp::co_integer, "pos", "지울 위치(위치는 1부터 시작, 현재 재생곡은 0)", true));
}
}

23
src/Commands/Leave.cpp
View File

@@ -1,23 +0,0 @@
#include <Commands/BumbleBeeCommand.hpp>
namespace bumbleBee::commands {
void Leave::execute(const dpp::slashcommand_t &event) {
dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
event.edit_original_response(dpp::message("현재 음성 채팅방에 있는 상태가 아닙니다!"));
return;
}
musicManager->clear(event.command.guild_id);
v->voiceclient->stop_audio();
v->voiceclient->pause_audio(true);
event.from->clear_queue();
event.from->disconnect_voice(event.command.guild_id);
event.edit_original_response(dpp::message("음성 채팅방을 떠납니다!"));
}
void Leave::init() {
}
}

240
src/Commands/Play.cpp
View File

@@ -1,240 +0,0 @@
#include <Commands/BumbleBeeCommand.hpp>
#include <Utils/ConsoleUtils.hpp>
#include <Settings/SettingsManager.hpp>
#include <dpp/nlohmann/json.hpp>
#include <Utils/QueuedMusicListEmbedProvider.hpp>
#include <Utils/ConsoleUtils.hpp>
#include <variant>
namespace bumbleBee::commands {
void Play::execute(const dpp::slashcommand_t &event) { // TODO : 길드 단위로 잠구고 메타데이터 로딩 중엔 로딩 중임을 표시할 수 있는 UI 만들 것것
dpp::guild *g = dpp::find_guild(event.command.guild_id);
if (!g) { //wtf?
event.edit_original_response(dpp::message("GUILD NOT FOUND!! WHAT IS THIS SORCERY??"));
return;
}
if (std::holds_alternative<std::monostate>(event.get_parameter("query"))) // 이거 필요한가???
{
event.reply("노래를 재생하려면 검색어 또는 링크를 입력해 주십시오.");
return;
}
if (!event.from->get_voice(event.command.guild_id) && !g->connect_member_voice(event.command.usr.id)) {
event.edit_original_response(dpp::message("노래를 재생할 음성 채팅방에 먼저 참가하고 신청해야 합니다!"));
return;
}
std::string query = std::get<std::string>(event.get_parameter("query"));
// query = "\"" + query + "\"";
std::queue<std::string> ids =
ConsoleUtils::safe_execute_command(
SettingsManager::getYTDLP_CMD(), {
"--default-search",
"ytsearch",
"--flat-playlist",
"--skip-download",
"--quiet",
"--ignore-errors",
"--print",
"id",
query});
std::queue<std::shared_ptr<MusicQueueElement>> musics;
int initialQueuedCount = musicManager->size(event.command.guild_id);
dpp::message msg;
if (musicManager->size(event.command.guild_id) == 0)
msg.content = "다음 곡을 재생합니다:";
else
msg.content = "큐에 다음 곡을 추가했습니다:";
if (!ids.empty()) { // TODO : 이거 멀티스레드로 바꿔서 더 빨리 정보를 받아올 수 있도록 개선할 것것
if (ids.front() == "") {
ids.pop();
}
std::string jsonData = ConsoleUtils::safe_execute_command(SettingsManager::getYTDLP_CMD(), {
"--default-search",
"ytsearch",
"--flat-playlist",
"--skip-download",
"--quiet",
"--ignore-errors",
"-J",
"http://youtu.be/" + ids.front()
}).front();
std::istringstream iss(jsonData);
nlohmann::json videoDataJson;
iss >> videoDataJson;
time_t SongLength = int(videoDataJson["duration"]);
char SongLengthStr[13];
tm t;
t.tm_mday = SongLength / 86400;
t.tm_hour = (SongLength % 86400)/3600;
t.tm_min = (SongLength % 3600)/60;
t.tm_sec = SongLength%60;
if (t.tm_mday > 0)
strftime(SongLengthStr, sizeof(SongLengthStr), "%d:%H:%M:%S", &t);
else if (t.tm_hour > 0)
strftime(SongLengthStr, sizeof(SongLengthStr), "%H:%M:%S", &t);
else
strftime(SongLengthStr, sizeof(SongLengthStr), "%M:%S", &t);
dpp::embed embed = dpp::embed()
.set_color(dpp::colors::sti_blue)
.set_title(std::string(videoDataJson["title"]))
.set_description(std::string(videoDataJson["uploader"]))
.set_url(std::string(videoDataJson["webpage_url"]))
.set_image(std::string(videoDataJson["thumbnail"]))
.add_field(
"길이",
SongLengthStr,
true
);
musics.push(std::make_shared<MusicQueueElement>(ids.front(), query, event.command.usr, embed));
ids.pop();
}
if (!ids.empty()) {
std::thread t([](
std::queue<std::string> ids,
dpp::snowflake guildId,
dpp::snowflake channelId,
std::string query,
dpp::user user,
dpp::cluster* cluster,
std::shared_ptr<MusicPlayManager> manager
) {
while (!ids.empty()) {
if (ids.front() == "") {
ids.pop();
continue;
}
std::string jsonData = ConsoleUtils::safe_execute_command(SettingsManager::getYTDLP_CMD(), {
"--default-search",
"ytsearch",
"--flat-playlist",
"--skip-download",
"--quiet",
"--ignore-errors",
"-J",
"http://youtu.be/" + ids.front()
}).front();
std::istringstream iss(jsonData);
nlohmann::json videoDataJson;
iss >> videoDataJson;
time_t SongLength = int(videoDataJson["duration"]);
char SongLengthStr[13];
tm t;
t.tm_mday = SongLength / 86400;
t.tm_hour = (SongLength % 86400)/3600;
t.tm_min = (SongLength % 3600)/60;
t.tm_sec = SongLength%60;
if (t.tm_mday > 0)
strftime(SongLengthStr, sizeof(SongLengthStr), "%d:%H:%M:%S", &t);
else if (t.tm_hour > 0)
strftime(SongLengthStr, sizeof(SongLengthStr), "%H:%M:%S", &t);
else
strftime(SongLengthStr, sizeof(SongLengthStr), "%M:%S", &t);
dpp::embed embed = dpp::embed()
.set_color(dpp::colors::sti_blue)
.set_title(std::string(videoDataJson["title"]))
.set_description(std::string(videoDataJson["uploader"]))
.set_url(std::string(videoDataJson["webpage_url"]))
.set_image(std::string(videoDataJson["thumbnail"]))
.add_field(
"길이",
SongLengthStr,
true
);
auto music = std::make_shared<MusicQueueElement>(ids.front(), query, user, embed);
cluster->log(dpp::ll_info, "Enqueuing " + music->embed.title + " - " + music->id);
manager->queue_music(guildId, music);
ids.pop();
}
std::mutex messageorder;
std::unique_lock lock(messageorder);
std::condition_variable messageSentCondition; // 개씨발 코드 개더러워 ;;
bool messagesent = false;
auto queue = manager->getQueue(guildId);
auto queued = QueuedMusicListEmbedProvider::makeEmbed(queue.first, queue.second, manager->getRepeat(guildId));
if (!queued.empty()) {
dpp::message followMsg(channelId, "현재 큐에 있는 항목:");
followMsg.add_embed(queued.front());
messagesent = false;
cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
messagesent = true;
messageSentCondition.notify_all();
});
messageSentCondition.wait(lock, [&](){ return messagesent; });
queued.pop();
}
while (!queued.empty()) {
dpp::message followMsg(channelId, "");
followMsg.add_embed(queued.front());
messagesent = false;
cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
messagesent = true;
messageSentCondition.notify_all();
});
messageSentCondition.wait(lock, [&](){ return messagesent; });
queued.pop();
}
},
ids,
event.command.guild_id,
event.command.channel_id,
query,
event.command.usr,
event.from->creator,
musicManager);
t.detach();
}
if (!musics.empty()) {
event.from->creator->log(dpp::ll_info, "Enqueuing " + musics.front()->embed.title + " - " + musics.front()->id);
musicManager->queue_music(event.command.guild_id, musics.front());
msg.add_embed(musics.front()->embed);
musics.pop();
event.edit_original_response(msg);
musicManager->queuedCondition.notify_all();
}
else {
msg.content = "검색 결과가 없습니다";
event.edit_original_response(msg);
}
if (musicManager->getNowPlaying(event.command.guild_id).id == "") {
dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
event.edit_original_response(dpp::message("현재 음성 채팅방에 있는 상태가 아닙니다!"));
return;
}
v->voiceclient->insert_marker();
v->voiceclient->pause_audio(false);
}
}
void Play::init() {
add_option(dpp::command_option(dpp::co_string, "query", "링크 또는 검색어", true));
}
}

73
src/Commands/Queue.cpp
View File

@@ -1,73 +0,0 @@
#include <Commands/BumbleBeeCommand.hpp>
#include <Utils/QueuedMusicListEmbedProvider.hpp>
namespace bumbleBee::commands {
void Queue::execute(const dpp::slashcommand_t &event) {
auto queue = musicManager->getQueue(event.command.guild_id);
dpp::message msg;
dpp::embed embed;
auto queued = QueuedMusicListEmbedProvider::makeEmbed(queue.first, queue.second, musicManager->getRepeat(event.command.guild_id));
// if (queue.first.size() == 0) {
// msg.add_embed(queued.front());
// event.edit_original_response(msg);
// return;
// }
// &&
// queue.first.size() != 0 &&
// *queue.second != nullptr &&
// (*queue.second)->id != ""
if (queue.first->size() != 0 && queue.first->end() != queue.second && (*queue.second)->id != "") {
msg.content = "지금 재생 중:";
msg.add_embed((*queue.second)->embed);
event.edit_original_response(msg);
}
else {
msg.content = "재생 중인 노래가 없습니다";
event.edit_original_response(msg);
}
std::thread t([](std::queue<dpp::embed> queued, dpp::snowflake channel_id, dpp::cluster* cluster) {
std::mutex messageorder;
std::unique_lock lock(messageorder);
std::condition_variable messageSentCondition;
bool messagesent = false;
if (!queued.empty()) {
dpp::message followMsg(channel_id, "현재 큐에 있는 항목:");
followMsg.add_embed(queued.front());
messagesent = false;
cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
messagesent = true;
messageSentCondition.notify_all();
});
messageSentCondition.wait(lock, [&](){ return messagesent; });
queued.pop();
}
while (!queued.empty()) {
dpp::message followMsg(channel_id, "");
followMsg.add_embed(queued.front());
messagesent = false;
cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
messagesent = true;
messageSentCondition.notify_all();
});
messageSentCondition.wait(lock, [&](){ return messagesent; });
queued.pop();
}
}, queued, event.command.channel_id, event.from->creator);
t.detach();
}
void Queue::init() {
}
}

16
src/Commands/Repeat.cpp
View File

@@ -1,16 +0,0 @@
#include <Commands/BumbleBeeCommand.hpp>
namespace bumbleBee::commands {
void Repeat::execute(const dpp::slashcommand_t &event) {
if (musicManager->getRepeat(event.command.guild_id)) {
event.edit_original_response(dpp::message("반복을 껐습니다."));
musicManager->setRepeat(event.command.guild_id, false);
}
else {
event.edit_original_response(dpp::message("반복을 켰습니다."));
musicManager->setRepeat(event.command.guild_id, true);
}
}
void Repeat::init() {}
}

11
src/Commands/Shuffle.cpp
View File

@@ -1,11 +0,0 @@
#include <Commands/BumbleBeeCommand.hpp>
namespace bumbleBee::commands {
void Shuffle::execute(const dpp::slashcommand_t &event) {
event.edit_original_response(dpp::message("shuffle"));
// TODO : 구현
}
void Shuffle::init() {
}
}

19
src/Commands/Skip.cpp
View File

@@ -1,19 +0,0 @@
#include <Commands/BumbleBeeCommand.hpp>
namespace bumbleBee::commands {
void Skip::execute(const dpp::slashcommand_t &event) {
dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
event.edit_original_response(dpp::message("스킵하려면 음악을 재생중이어야 합니다!"));
return;
}
v->voiceclient->stop_audio();
v->voiceclient->insert_marker();
event.edit_original_response(dpp::message("스킵했습니다!"));
}
void Skip::init() {
}
}

0
src/Manager/ThreadManager.cpp
View File

115
src/Queue/MusicQueue.cpp
View File

@@ -1,115 +0,0 @@
#include <Queue/MusicQueue.hpp>
#include <iostream>
#include <algorithm>
#include <Utils/QueuedMusicListEmbedProvider.hpp>
namespace bumbleBee {
void MusicQueue::enqueue(std::shared_ptr<MusicQueueElement> Element) {
std::lock_guard<std::mutex> lock(queueMutex);
queue.push_back(Element);
if (queue.size() == 1) // 이전에 하나도 없었다는 말이므로.
currentPlayingPosition = queue.begin(); // 첫번째 곡으로 iterator를 옮겨준다.
}
std::shared_ptr<MusicQueueElement> MusicQueue::dequeue() {
std::lock_guard<std::mutex> lock(queueMutex);
auto value = queue.front();
queue.pop_front();
return value;
}
std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::findById(std::string id) {
std::lock_guard<std::mutex> lock(queueMutex);
int index = 0;
for (auto iter = queue.begin(); iter != queue.end(); iter++) {
if ((*iter).get()->id == id)
return iter;
}
return queue.end();
}
std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::findByIndex(int index) {
std::lock_guard<std::mutex> lock(queueMutex);
if (index < 0)
return queue.end();
if (index == 0)
return currentPlayingPosition;
return std::next(queue.begin(), index - 1);
}
std::shared_ptr<MusicQueueElement> MusicQueue::nowplaying() {
std::lock_guard<std::mutex> lock(queueMutex);
if (currentPlayingPosition == queue.end())
return nullptr;
else
return *currentPlayingPosition;
}
std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::next_music() {
std::lock_guard<std::mutex> lock(queueMutex);
if (currentPlayingPosition == --queue.end() && repeat)
currentPlayingPosition = queue.begin();
else if (currentPlayingPosition == --queue.end() && !repeat) // 반복이 꺼져있을 때 큐 재생이 끝난 경우
currentPlayingPosition = queue.end();
else if (currentPlayingPosition == queue.end() && !repeat) // 반복이 꺼져있고 현재 재생 곡이 없는데 새 곡이 들어왔을 경우
currentPlayingPosition = --queue.end();
else
++currentPlayingPosition;
return currentPlayingPosition;
}
std::shared_ptr<MusicQueueElement> MusicQueue::jump_to_index(int idx) {
std::lock_guard<std::mutex> lock(queueMutex);
int index = 0;
for (auto iter = queue.begin(); iter != queue.end(); iter++) {
if (idx == index++) {
currentPlayingPosition = iter;
return *iter;
}
}
return std::shared_ptr<MusicQueueElement>();
}
void MusicQueue::clear() {
std::lock_guard<std::mutex> lock(queueMutex);
queue.clear();
currentPlayingPosition = queue.begin();
}
std::shared_ptr<MusicQueueElement> MusicQueue::erase(std::list<std::shared_ptr<MusicQueueElement>>::iterator it) {
std::lock_guard<std::mutex> lock(queueMutex);
if (it == queue.end())
return nullptr;
if (currentPlayingPosition == it) {
auto removedValue = *it;
auto after = queue.erase(currentPlayingPosition++);
if (after == queue.end())
currentPlayingPosition = --queue.end();
return removedValue;
}
else {
auto removedValue = *it;
queue.erase(it);
return removedValue;
}
}
std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
MusicQueue::getQueueCopy() {
std::lock_guard<std::mutex> lock(queueMutex);
std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> returnValue = std::make_shared<std::list<std::shared_ptr<MusicQueueElement>>>();
for (auto i = queue.begin(); i != queue.end(); i++)
returnValue->push_back(*i);
if (returnValue->begin() == returnValue->end() || currentPlayingPosition == queue.end())
return std::make_pair(returnValue, returnValue->end());
std::list<std::shared_ptr<MusicQueueElement>>::iterator iter = returnValue->begin();
std::advance(iter, std::distance(queue.begin(), currentPlayingPosition));
return std::make_pair(returnValue, iter);
}
int MusicQueue::size() {
std::lock_guard<std::mutex> lock(queueMutex);
return queue.size();
}
std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::end() {
std::lock_guard<std::mutex> lock(queueMutex);
return queue.end();
}
}

124
src/Settings/SettingsManager.cpp
View File

@@ -1,124 +0,0 @@
#include <Settings/SettingsManager.hpp>
#include <dpp/nlohmann/json.hpp>
#include <Utils/ConsoleUtils.hpp>
#include <fstream>
#include <sstream>
namespace bumbleBee {
std::string SettingsManager::TOKEN = "";
std::string SettingsManager::YTDLP_CMD = "./yt-dlp";
std::string SettingsManager::FFMPEG_CMD = "./ffmpeg";
dpp::loglevel SettingsManager::LOGLEVEL = dpp::ll_debug;
bool SettingsManager::REGISTER_COMMAND = false;
bool SettingsManager::validateToken() {
nlohmann::json response;
std::string curl = ConsoleUtils::safe_execute_command("/usr/bin/which", {"curl"}).front();
if (curl == "") {
std::cout << "curl is unavaliable. unresolable error please install curl." << std::endl;
return false;
}
std::string stresult = ConsoleUtils::safe_execute_command(curl, {
"-sX",
"GET",
"https://discord.com/api/v10/users/@me",
"-H",
"Authorization: Bot " + TOKEN + ""
}).front();
std::stringstream ss(stresult);
ss >> response;
if (response.contains("message") && response["message"] == "401: Unauthorized") {
std::cout << "Token is invalid" << std::endl;
return false;
}
else
return true;
}
bool SettingsManager::load() {
nlohmann::json configdocument;
try {
std::ifstream configfile("config.json");
if (!configfile) {
saveToFile();
return false;
}
configfile >> configdocument;
TOKEN = configdocument["TOKEN"];
if (!validateToken())
return false;
YTDLP_CMD = configdocument["YTDLP_CMD"];
FFMPEG_CMD = configdocument["FFMPEG_CMD"];
std::string level = configdocument["LOGLEVEL"];
std::transform(level.begin(), level.end(), level.begin(), ::tolower);
if (level == "trace")
LOGLEVEL = dpp::ll_trace;
else if (level == "debug")
LOGLEVEL = dpp::ll_debug;
else if (level == "warning")
LOGLEVEL = dpp::ll_warning;
else if (level == "error")
LOGLEVEL = dpp::ll_error;
else if (level == "critical")
LOGLEVEL = dpp::ll_critical;
else // 값이 병신같을때 기본값으로 ll_info 부여
LOGLEVEL = dpp::ll_info;
REGISTER_COMMAND = configdocument["CLEAR_PREVIOUS_COMMAND"];
}
catch (const nlohmann::json::type_error& e) {
saveToFile();
return load();
}
catch (const nlohmann::json::parse_error& e) {
saveToFile();
return load();
}
return true;
}
void SettingsManager::saveToFile() {
nlohmann::json configdocument;
configdocument["TOKEN"] = TOKEN;
configdocument["YTDLP_CMD"] = YTDLP_CMD;
configdocument["FFMPEG_CMD"] = FFMPEG_CMD;
switch (LOGLEVEL) {
case dpp::ll_trace:
configdocument["LOGLEVEL"] = "trace";
break;
case dpp::ll_debug:
configdocument["LOGLEVEL"] = "debug";
break;
case dpp::ll_info:
configdocument["LOGLEVEL"] = "info";
break;
case dpp::ll_warning:
configdocument["LOGLEVEL"] = "warning";
break;
case dpp::ll_error:
configdocument["LOGLEVEL"] = "error";
break;
default:
configdocument["LOGLEVEL"] = "critical";
break;
}
configdocument["CLEAR_PREVIOUS_COMMAND"] = REGISTER_COMMAND;
std::ofstream configFile("config.json");
if (configFile.is_open()) {
configFile << configdocument.dump(4);
configFile.close();
}
}
}

103
src/Utils/AsyncDownloadManager.cpp
View File

@@ -1,103 +0,0 @@
#include <Utils/AsyncDownloadManager.hpp>
#include <sstream>
#include "Utils/ConsoleUtils.hpp"
#include "Settings/SettingsManager.hpp"
#include <ogg/ogg.h>
#include <oggz/oggz.h>
#include <opus/opusfile.h>
#include <memory>
namespace bumbleBee {
void AsyncDownloadManager::enqueueAsyncDL(std::pair<std::string, dpp::message> query) {
std::lock_guard<std::mutex> lock(dlQueueMutex);
downloadQueue.push(query);
dlQueueCondition.notify_one();
}
void AsyncDownloadManager::downloadWorker() {
std::ostringstream tid;
tid << std::this_thread::get_id();
while (true) {
//mutex lock
std::unique_lock<std::mutex> dlQueueLock(dlQueueMutex);
dlQueueCondition.wait(dlQueueLock, [&]{ return !downloadQueue.empty() || terminate; });
auto cluster = weak_cluster.lock();
if (weak_cluster.expired()) {
cluster->log(dpp::ll_error, "Missing cluster, terminating thread " + tid.str());
break;
}
if (terminate) {
cluster->log(dpp::ll_info, "Terminating thread " + tid.str());
break;
}
std::string query = downloadQueue.front().first;
dpp::message oRes = downloadQueue.front().second;
downloadQueue.pop();
dlQueueLock.unlock();
cluster->log(dpp::ll_info, "AsyncDownloadManager: " + query + " accepted.");
std::queue<std::string> ids =
ConsoleUtils::safe_execute_command(
SettingsManager::getYTDLP_CMD(), {
"--default-search",
"ytsearch",
"--flat-playlist",
"--skip-download",
"--quiet",
"--ignore-errors",
"--print",
"id",
query});
if (ids.size() >= 2) {
cluster->log(dpp::ll_info, query + " is playlist");
while (!ids.empty()) {
if (ids.front() == "") {
ids.pop();
continue;
}
cluster->log(dpp::ll_info, "Enqueuing playlist element " + ids.front());
enqueue(std::make_pair("https://youtu.be/" + ids.front(), oRes));
ids.pop();
}
continue;
}
std::queue<std::string> urls =
ConsoleUtils::safe_execute_command(SettingsManager::getYTDLP_CMD(), {
"-f",
"ba*",
"--print",
"urls",
"https://youtu.be/" + ids.front()
});
cluster->log(dpp::ll_debug, "url: " + urls.front());
FILE* stream;
// musicQueue->enqueue(std::make_shared<MusicQueueElement>(oRes, ids.front(), urls.front(), stream));
std::string downloadID = ids.front();
std::thread th([&, downloadID](){
if (terminate)
return;
std::ostringstream tid;
tid << std::this_thread::get_id();
cluster->log(dpp::ll_info, "Thread id: " + tid.str() + ": " + downloadID + " accepted.");
stream = ConsoleUtils::safe_open_pipe("./streamOpus.sh", {
SettingsManager::getYTDLP_CMD(),
downloadID,
SettingsManager::getFFMPEG_CMD()
});
cluster->log(dpp::ll_info, "Thread id: " + tid.str() + " Opened stream: " + downloadID);
});
th.detach();
}
}
}

35
src/main.cc Normal file
View File

@@ -0,0 +1,35 @@
#include "precomp.h"
#include "utils/console.h"
#include "utils/update_checker.h"
int main(int argc, char* argv[]) {
boost::system::error_code ec;
char buf[16384];
std::string output;
utils::CheckUpdate();
// utils::ExecuteCommand("yt-dlp", {"-U"}, output);
// std::cout << output;
// auto ytdlp_pipe = utils::OpenPipe(
// "yt-dlp", {"-o", "-", "--quiet", "--ignore-errors", "-f", "bestaudio",
// "https://youtu.be/9_bTl2vvYQg?si=IVhvpDhnpPvziwQR"});
// while (true) {
// boost::system::error_code read_ec;
// size_t bytes_read =
// boost::asio::read(ytdlp_pipe, boost::asio::buffer(buf, 16384),
// read_ec);
// if (bytes_read > 0) {
// std::cout.write(buf, bytes_read);
// }
// if (read_ec == boost::asio::error::eof || read_ec) {
// break;
// }
// }
return 0;
}

12
src/main.cpp
View File

@@ -1,12 +0,0 @@
#include <boost/process.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/ssl.hpp>
extern "C" {
#include <libavformat/avformat.h>
}
#include <iostream>
int main(int argc, char* argv[]) {
std::cout << "FFmpeg version: " << av_version_info() << std::endl;
return 0;
}

53
src/utils/console.cc Normal file
View File

@@ -0,0 +1,53 @@
#include "utils/console.h"
#include "precomp.h"
namespace utils {
int ValidateCommand(std::string cmd) {
try {
ExecuteCommand(cmd);
} catch (const boost::process::system_error& e) {
return -1;
}
return 0;
}
int ExecuteCommand(const std::string& cmd,
const std::vector<std::string>& args) {
std::string ignored;
return ExecuteCommand(cmd, args, ignored);
}
int ExecuteCommand(const std::string& cmd, std::string& result) {
std::vector<std::string> ignored;
return ExecuteCommand(cmd, ignored, result);
}
int ExecuteCommand(const std::string& cmd, const std::vector<std::string>& args,
std::string& result) {
boost::system::error_code ec;
boost::asio::io_context ctx;
boost::process::popen proc(
ctx, cmd, args, boost::process::process_stdio{{}, nullptr, nullptr});
boost::asio::read(proc, boost::asio::dynamic_buffer(result), ec);
if (ec != boost::asio::error::eof) {
return -1;
}
proc.wait();
return proc.exit_code();
}
boost::process::popen OpenPipe(const std::string& cmd,
const std::vector<std::string>& args) {
boost::asio::io_context ctx;
boost::process::popen proc(
ctx, cmd, args, boost::process::process_stdio{{}, nullptr, nullptr});
return proc;
};
} // namespace utils

109
src/utils/file_downloader.cc Normal file
View File

@@ -0,0 +1,109 @@
#include "utils/file_downloader.h"
#include <fstream>
#include "boost/asio/ssl.hpp"
#include "boost/beast.hpp"
#include "precomp.h"
namespace utils {
void DownloadFileFromHTTPS(std::string url, std::string filename) {
int max_redirects = 5;
std::string current_host;
std::string current_path;
if (url.find("https://") == 0) {
url.erase(0, 8); // https:// 제거
auto pos = url.find('/');
if (pos != std::string::npos) {
current_host = url.substr(0, pos);
current_path = url.substr(pos);
} else {
current_host = url;
current_path = "/";
}
} else {
// 상대 경로일 경우
current_path = url;
}
for (int redirect = 0; redirect < max_redirects; ++redirect) {
boost::asio::io_context ioc;
boost::asio::ssl::context ctx(boost::asio::ssl::context::tlsv12_client);
ctx.set_default_verify_paths();
boost::beast::ssl_stream<boost::beast::tcp_stream> stream(ioc, ctx);
// DNS 해석
boost::asio::ip::tcp::resolver resolver(ioc);
auto const results = resolver.resolve(current_host, "443");
// TCP 연결
boost::beast::get_lowest_layer(stream).connect(results);
// SSL 핸드셰이크
stream.handshake(boost::asio::ssl::stream_base::client);
// HTTP GET 요청
boost::beast::http::request<boost::beast::http::string_body> req{
boost::beast::http::verb::get, current_path, 11};
req.set(boost::beast::http::field::host, current_host);
req.set(boost::beast::http::field::user_agent, "Mozilla/5.0");
boost::beast::http::write(stream, req);
boost::beast::flat_buffer buffer;
boost::beast::http::response<boost::beast::http::dynamic_body> res;
boost::beast::http::read(stream, buffer, res);
int status = res.result_int();
if (status / 100 == 3) {
// 리다이렉트 처리
auto loc = res[boost::beast::http::field::location];
if (loc.empty()) {
throw std::runtime_error("Redirect without Location header");
}
// 새 호스트/경로 파싱
std::string new_url(loc);
if (new_url.find("https://") == 0) {
new_url.erase(0, 8); // https:// 제거
auto pos = new_url.find('/');
if (pos != std::string::npos) {
current_host = new_url.substr(0, pos);
current_path = new_url.substr(pos);
} else {
current_host = new_url;
current_path = "/";
}
} else {
// 상대 경로일 경우
current_path = new_url;
}
continue;
}
if (status != 200) {
throw std::runtime_error("HTTP request failed with status " +
std::to_string(status));
}
// 파일 저장
std::ofstream file(filename, std::ios::binary);
if (!file) {
throw std::runtime_error("Could not open file for writing: " + filename);
}
for (auto const& buffer_part : res.body().data()) {
file.write(reinterpret_cast<const char*>(buffer_part.data()),
buffer_part.size());
}
return;
}
throw std::runtime_error("Too many redirects");
}
} // namespace utils

51
src/utils/update_checker.cc Normal file
View File

@@ -0,0 +1,51 @@
#include "utils/update_checker.h"
#include "precomp.h"
#include "utils/console.h"
#include "utils/file_downloader.h"
namespace utils {
int InstallYtdlp() {
BOOST_LOG_TRIVIAL(warning) << "ytdlp is unavailable. downloading ytdlp...";
#ifdef WIN32
DownloadFileFromHTTPS(
"https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe",
"yt-dlp.exe");
#else
DownloadFileFromHTTPS(
"https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp",
"yt-dlp");
ExecuteCommand(boost::process::environment::find_executable("chmod").c_str(),
{"+x", "yt-dlp"});
#endif
return 0;
}
int CheckUpdate() {
char buf[16384];
if (ValidateCommand("yt-dlp") != 0) {
InstallYtdlp();
return 0;
}
auto ytdlp_pipe = utils::OpenPipe("yt-dlp", {"-U"});
while (true) {
boost::system::error_code read_ec;
size_t bytes_read =
boost::asio::read(ytdlp_pipe, boost::asio::buffer(buf, 16384), read_ec);
if (bytes_read > 0) {
BOOST_LOG_TRIVIAL(info) << buf;
}
if (read_ec == boost::asio::error::eof || read_ec) {
break;
}
}
return 0;
}
} // namespace utils