git,gitea - tool - creat Gitea Empty Rep Dir

[复制链接]
发表于 2025-10-29 08:06:06 | 显示全部楼层 |阅读模式
git,gitea - tool - creat Gitea Empty Rep Dir

概述

如今想采取小库的方式来使用gitea.
如许就涉及到开小库时,要用gitea下令行来做新的小库的目次。
从前做了实验,如许的脚本已经有了。
但是以这些脚本为模板,创建新的gitea库的目次时,须要改多个脚本中的绝对路径,很繁琐,容易错。
如果用git bash, 写一个脚本(e.g. sed), 来更换.bat中的绝对路径,控制的不过细。如果想控制的过细,对bash编程也没有那么熟悉。
那就用C来手搓一个工具,花了1天,挺好使的。
条记

编译输出

就一个 creatGiteaEmptyRepDir.exe,拷贝到自己的gitea库的根目次

使用方式

  1. creatGiteaEmptyRepDir.exe <新的小库名称 e.g. my_test>
复制代码
由于使用的是gitea小库的初始目次,为了安全,如果库目次中已经有预期的文件夹,不会再使用,会提示并退出。没啥风险。
天生完的目次在./creatGiteaEmptyRepDir_out中的子目次中(e.g. ./creatGiteaEmptyRepDir_out/rep_my_test), 由用户(me)手工拷贝到gitea库的根目次,规避风险。
天生后的子库目次


使用阐明

用写好的bat来创建gitea库的步调

step1

关掉其他gitea控制台(由于端口都是3000)
运行 a1_run_gitea_rep_console.bat, 等候服务启动完成
step2

在欣赏器中运行网页 http://localhost:3000/
选择sqlite3作为数据库, 将网页拉到底部,点击"立即安装"
等候安装完成,出现登录页面为止。
step3

创建库的用户
运行 a2_create_rep_user_pwd.bat 创建库用户
运行 b1_list_rep_user.bat 检察用户是否创建乐成
step4

登录gitea库网页
在网页右上角的用户头像处点击下拉列表,选择设置 => SSH密钥 => 增长密钥,将天生在 C:\Users\me\.ssh 中的公钥id_rsa.pub内容增长未SSH密钥
创建堆栈(只须要给出堆栈名), 网页拉到尾部,点击"创建堆栈"
step5

复制堆栈所在, 似乎当地ssh库所在欠好使,只能复制http的库所在。
step6

迁出库所在。
初次迁出时,有告诫,说库是空的,这是正常的,不消分析。
正常git提交。
other

如果要修改用户名和口令, 实行 b2_modify_rep_user_pwd.bat
如果要查抄库的康健度, 实行 b3_run_gitea_doctor.bat
如果要检察gitea版本,实行 b4_show_git_env_info.bat
如果要打开一个cmd窗口, 实行 c1_call_cmd_here.bat
如果要手工实行git下令, 实行 c2_env_git.bat
工具源码

VS2019 c++ console
800行代码
  1. // @file creatGiteaEmptyRepDir.cpp
  2. // 生成gitea用的库目录脚本, 用户自己拷贝生成的子目录(e.g. <./creatGiteaEmptyRepDir_out/sub_rep_dir>)到总的库目录(e.g. E:\my_git_rep), 防止意外操作或程序bug
  3. #include <windows.h>
  4. #include <iostream>
  5. #include <sstream>
  6. #include <iomanip>
  7. #include <fstream>
  8. #include "resource.h"
  9. #define MY_VER "1.0.0.0"
  10. #define DIR_OUT "creatGiteaEmptyRepDir_out"
  11. // 目录默认都要带尾巴上的\\
  12. #define SET_GIT_GITEA_PATH "set PATH=C:\\Program Files\\Git\\bin;C:\\Program Files\\Git\\cmd;C:\\soft\\gitea;%PATH%"
  13. #define MY_DEFAULT_GITEA_REP_ROOT_DIR "E:\\my_git_rep\"
  14. #define GIT_USER_NAME "name"
  15. #define GIT_USER_PWD "password"
  16. #define GIT_USER_EMAIL "me@x.com"
  17. void usage();
  18. void show_error(const char* psz_reason);
  19. bool check_param(int argc, char** argv);
  20. bool is_dir_exist(const char* psz_path_name);
  21. std::string get_cur_dir_path_name();
  22. bool create_dir(const char* pszPath);
  23. std::string Wstring2String(std::wstring strW);
  24. bool string_find(const std::string& strA, char c);
  25. bool write_res_file(const char* psz_write_to);
  26. bool write_ascii_file(const std::string& strFileName, const std::string& strText);
  27. bool DoTask();
  28. bool DoTask_a1_run_gitea_rep_console_bat();// a1_run_gitea_rep_console.bat
  29. bool DoTask_a2_create_rep_user_pwd_bat();// a2_create_rep_user_pwd.bat
  30. bool DoTask_b1_modify_rep_user_pwd_bat();// b1_list_rep_user.bat
  31. bool DoTask_b2_modify_rep_user_pwd_bat();// b2_modify_rep_user_pwd.bat
  32. bool DoTask_b3_run_gitea_doctor_bat();// b3_run_gitea_doctor.bat
  33. bool DoTask_b4_show_git_env_info_bat();// b4_show_git_env_info.bat
  34. bool DoTask_c1_call_cmd_here_bat();// c1_call_cmd_here.bat
  35. bool DoTask_c2_env_git_bat();// c2_env_git.bat
  36. bool DoTask_Readme_md(); // readme.md(在资源中, BIN_RES/IDR_BIN_RES_README_MD)
  37. std::string g_new_sub_rep_name;
  38. std::string g_cur_dir;
  39. std::string g_dir_out; // 当前目录下的输出目录
  40. std::string g_dir_out_obj; // 在当前输出目录中的目标目录, 需要用户手工拷贝到总库目录下 e.g. debug/out/rep_my_test
  41. std::string g_dir_out_obj_rep; // 在当前输出目录中的目标目录中的库目录中的实际库目录 e.g. debug/out/rep_my_test/my_test
  42. std::string g_dir_obj; // 要拷贝到的总目录下的子库目录
  43. std::string g_dir_obj_rep; // 要拷贝到的总目录下的子库目录中的gitea库目录
  44. int main(int argc, char** argv)
  45. {
  46.     do {
  47.         if (!check_param(argc, argv))
  48.         {
  49.             usage();
  50.             break;
  51.         }
  52.         if (!DoTask())
  53.         {
  54.             break;
  55.         }
  56.         printf("do task ok\r\n");
  57.     } while (false);
  58.     printf("\r\n");
  59.     printf("END\r\n");
  60.     system("pause");
  61.     return 0;
  62. }
  63. bool DoTask()
  64. {
  65.     bool b_rc = false;
  66.     do {
  67.         if (!DoTask_a1_run_gitea_rep_console_bat())
  68.         {
  69.             break;
  70.         }
  71.         if (!DoTask_a2_create_rep_user_pwd_bat())
  72.         {
  73.             break;
  74.         }
  75.         if (!DoTask_b1_modify_rep_user_pwd_bat())
  76.         {
  77.             break;
  78.         }
  79.         if (!DoTask_b2_modify_rep_user_pwd_bat())
  80.         {
  81.             break;
  82.         }
  83.         if (!DoTask_b3_run_gitea_doctor_bat())
  84.         {
  85.             break;
  86.         }
  87.         if (!DoTask_b4_show_git_env_info_bat())
  88.         {
  89.             break;
  90.         }
  91.         if (!DoTask_c1_call_cmd_here_bat())
  92.         {
  93.             break;
  94.         }
  95.         if (!DoTask_c2_env_git_bat())
  96.         {
  97.             break;
  98.         }
  99.         if (!DoTask_Readme_md())
  100.         {
  101.             break;
  102.         }
  103.         b_rc = true;
  104.     } while (false);
  105.     return b_rc;
  106. }
  107. bool DoTask_a1_run_gitea_rep_console_bat()
  108. {// a1_run_gitea_rep_console.bat
  109.     bool b_rc = false;
  110.     std::string strFileName;
  111.     std::string strText;
  112.     const char* pszShortFileName = "a1_run_gitea_rep_console.bat";
  113.     do {
  114.         strFileName = g_dir_out_obj;
  115.         strFileName += pszShortFileName;
  116.         std::stringstream ss;
  117.         // @echo off
  118.         ss << "@echo off\r\n";
  119.         
  120.         // rem a1_run_gitea_rep_console.bat
  121.         ss << "rem " << pszShortFileName << "\r\n";
  122.         // set PATH=C:\\Program Files\\Git\\bin;C:\\Program Files\\Git\\cmd;C:\\soft\\gitea;%PATH%
  123.         ss << SET_GIT_GITEA_PATH << "\r\n";
  124.         // call gitea --work - path E : \my_git_rep\rep_my_template\my_template
  125.         ss << "call gitea --work-path ";
  126.         ss << g_dir_obj_rep << "\r\n";
  127.         strText = ss.str();
  128.         if (!write_ascii_file(strFileName, strText))
  129.         {
  130.             break;
  131.         }
  132.         b_rc = true;
  133.     } while (false);
  134.     return b_rc;
  135. }
  136. bool DoTask_a2_create_rep_user_pwd_bat()
  137. {// a2_create_rep_user_pwd.bat
  138.     bool b_rc = false;
  139.     std::string strFileName;
  140.     std::string strText;
  141.     const char* pszShortFileName = "a2_create_rep_user_pwd.bat";
  142.     do {
  143.         strFileName = g_dir_out_obj;
  144.         strFileName += pszShortFileName;
  145.         std::stringstream ss;
  146.         // @echo off
  147.         ss << "@echo off\r\n";
  148.         //    rem a2_create_rep_user_pwd.bat
  149.         ss << "rem " << pszShortFileName << "\r\n";
  150.         //    set PATH = C:\Program Files\Git\bin; C:\Program Files\Git\cmd; C:\soft\gitea; % PATH%
  151.         ss << SET_GIT_GITEA_PATH << "\r\n";
  152.         
  153.         //    call gitea --work - path E : \my_git_rep\rep_my_template\my_template
  154.         ss << "call gitea --work-path ";
  155.         ss << g_dir_obj_rep << " ";
  156.         // admin user create --admin --username name --password pwd --email me@x.com --access-token
  157.         ss << "admin user create --admin --username " << GIT_USER_NAME << " ";
  158.         ss << "--password " << GIT_USER_PWD << " ";
  159.         ss << "--email " << GIT_USER_EMAIL << " --access-token\r\n";
  160.         //    PAUSE
  161.         ss << "PAUSE" << "\r\n";
  162.         strText = ss.str();
  163.         if (!write_ascii_file(strFileName, strText))
  164.         {
  165.             break;
  166.         }
  167.         b_rc = true;
  168.     } while (false);
  169.     return b_rc;
  170. }
  171. bool DoTask_b1_modify_rep_user_pwd_bat()
  172. {// b1_list_rep_user.bat
  173.     bool b_rc = false;
  174.     std::string strFileName;
  175.     std::string strText;
  176.     const char* pszShortFileName = "b1_list_rep_user.bat";
  177.     do {
  178.         strFileName = g_dir_out_obj;
  179.         strFileName += pszShortFileName;
  180.         std::stringstream ss;
  181.         //@echo off
  182.         ss << "@echo off" << "\r\n";
  183.         //    rem b1_list_rep_user.bat
  184.         ss << "rem b1_list_rep_user.bat" << "\r\n";
  185.         //    set PATH = C:\Program Files\Git\bin; C:\Program Files\Git\cmd; C:\soft\gitea; % PATH%
  186.         ss << SET_GIT_GITEA_PATH << "\r\n";
  187.         //    call gitea --work - path E : \my_git_rep\rep_my_tools\my_tools admin user list
  188.         ss << "call gitea --work-path " << g_dir_obj_rep << " admin user list" << "\r\n";
  189.         //    PAUSE
  190.         ss << "PAUSE" << "\r\n";
  191.         strText = ss.str();
  192.         if (!write_ascii_file(strFileName, strText))
  193.         {
  194.             break;
  195.         }
  196.         b_rc = true;
  197.     } while (false);
  198.     return b_rc;
  199. }
  200. bool DoTask_b2_modify_rep_user_pwd_bat()
  201. {// b2_modify_rep_user_pwd.bat
  202.     bool b_rc = false;
  203.     std::string strFileName;
  204.     std::string strText;
  205.     const char* pszShortFileName = "b2_modify_rep_user_pwd.bat";
  206.     do {
  207.         strFileName = g_dir_out_obj;
  208.         strFileName += pszShortFileName;
  209.         std::stringstream ss;
  210.         //@echo off
  211.         ss << "@echo off" << "\r\n";
  212.         //    rem b1_modify_rep_user_pwd.bat
  213.         ss << "rem " << pszShortFileName << "\r\n";
  214.         //    set PATH = C:\Program Files\Git\bin; C:\Program Files\Git\cmd; C:\soft\gitea; % PATH%
  215.         ss << SET_GIT_GITEA_PATH << "\r\n";
  216.         //    call gitea --work - path E : \my_git_rep\rep_my_template\my_template admin user change-password -u name -p pwd11111
  217.         // 修改密码时, 密码的最小长度要为8
  218.         ss << "call gitea --work-path " << g_dir_obj_rep << " ";
  219.         ss << "admin user change-password -u " << GIT_USER_NAME << " ";
  220.         ss << "-p " << " " << GIT_USER_PWD << "\r\n";
  221.         //    PAUSE
  222.         ss << "PAUSE" << "\r\n";
  223.         strText = ss.str();
  224.         if (!write_ascii_file(strFileName, strText))
  225.         {
  226.             break;
  227.         }
  228.         b_rc = true;
  229.     } while (false);
  230.     return b_rc;
  231. }
  232. bool DoTask_b3_run_gitea_doctor_bat()
  233. {// b3_run_gitea_doctor.bat
  234.     bool b_rc = false;
  235.     std::string strFileName;
  236.     std::string strText;
  237.     const char* pszShortFileName = "b3_run_gitea_doctor.bat";
  238.     do {
  239.         strFileName = g_dir_out_obj;
  240.         strFileName += pszShortFileName;
  241.         std::stringstream ss;
  242.         //@echo off
  243.         ss << "@echo off" << "\r\n";
  244.         //    rem b2_run_gitea_doctor.bat
  245.         ss << "rem " << pszShortFileName << "\r\n";
  246.         //    set PATH = C:\Program Files\Git\bin; C:\Program Files\Git\cmd; C:\soft\gitea; % PATH%
  247.         ss << SET_GIT_GITEA_PATH << "\r\n";
  248.         //    echo next, list gitea doctor runing
  249.         ss << "echo next, list gitea doctor runing" << "\r\n";
  250.         //    call gitea --work - path E : \my_git_rep\rep_my_template\my_template doctor check
  251.         ss << "call gitea --work-path " << g_dir_obj_rep << " ";
  252.         ss << "doctor check" << "\r\n";
  253.         //    echo END
  254.         ss << "echo END" << "\r\n";
  255.         //    PAUSE
  256.         ss << "PAUSE" << "\r\n";
  257.         strText = ss.str();
  258.         if (!write_ascii_file(strFileName, strText))
  259.         {
  260.             break;
  261.         }
  262.         b_rc = true;
  263.     } while (false);
  264.     return b_rc;
  265. }
  266. bool DoTask_b4_show_git_env_info_bat()
  267. {// b4_show_git_env_info.bat
  268.     bool b_rc = false;
  269.     std::string strFileName;
  270.     std::string strText;
  271.     const char* pszShortFileName = "b4_show_git_env_info.bat";
  272.     do {
  273.         strFileName = g_dir_out_obj;
  274.         strFileName += pszShortFileName;
  275.         std::stringstream ss;
  276.         //@echo off
  277.         ss << "@echo off" << "\r\n";
  278.         //    rem b4_show_git_env_info.bat
  279.         ss << "rem " << pszShortFileName << "\r\n";
  280.         //    set PATH = C:\Program Files\Git\bin; C:\Program Files\Git\cmd; C:\soft\gitea; % PATH%
  281.         ss << SET_GIT_GITEA_PATH << "\r\n";
  282.         //    gitea --version
  283.         ss << "gitea --version" << "\r\n";
  284.         //    PAUSE
  285.         ss << "PAUSE" << "\r\n";
  286.         strText = ss.str();
  287.         if (!write_ascii_file(strFileName, strText))
  288.         {
  289.             break;
  290.         }
  291.         b_rc = true;
  292.     } while (false);
  293.     return b_rc;
  294. }
  295. bool DoTask_c1_call_cmd_here_bat()
  296. {// c1_call_cmd_here.bat
  297.     bool b_rc = false;
  298.     std::string strFileName;
  299.     std::string strText;
  300.     const char* pszShortFileName = "c1_call_cmd_here.bat";
  301.     do {
  302.         strFileName = g_dir_out_obj;
  303.         strFileName += pszShortFileName;
  304.         std::stringstream ss;
  305.         //@echo off
  306.         ss << "@echo off" << "\r\n";
  307.         //    rem c1_call_cmd_here.bat
  308.         ss << "rem " << pszShortFileName << "\r\n";
  309.         //    call cmd.exe
  310.         ss << "call cmd.exe" << "\r\n";
  311.         //    PAUSE
  312.         ss << "PAUSE" << "\r\n";
  313.         strText = ss.str();
  314.         if (!write_ascii_file(strFileName, strText))
  315.         {
  316.             break;
  317.         }
  318.         b_rc = true;
  319.     } while (false);
  320.     return b_rc;
  321. }
  322. bool DoTask_c2_env_git_bat()
  323. {// c2_env_git.bat
  324.     bool b_rc = false;
  325.     std::string strFileName;
  326.     std::string strText;
  327.     const char* pszShortFileName = "c2_env_git.bat";
  328.     do {
  329.         strFileName = g_dir_out_obj;
  330.         strFileName += pszShortFileName;
  331.         std::stringstream ss;
  332.         //@echo off
  333.         ss << "@echo off" << "\r\n";
  334.         //    rem c2_env_git.bat
  335.         ss << "rem " << pszShortFileName << "\r\n";
  336.         //    set PATH = C:\Program Files\Git\bin; C:\Program Files\Git\cmd; C:\soft\gitea; % PATH%
  337.         ss << SET_GIT_GITEA_PATH << "\r\n";
  338.         //    call cmd.exe
  339.         ss << "call cmd.exe" << "\r\n";
  340.         strText = ss.str();
  341.         if (!write_ascii_file(strFileName, strText))
  342.         {
  343.             break;
  344.         }
  345.         b_rc = true;
  346.     } while (false);
  347.     return b_rc;
  348. }
  349. bool DoTask_Readme_md()
  350. {// readme.md(在资源中, BIN_RES/IDR_BIN_RES_README_MD)
  351.     bool b_rc = false;
  352.     std::string strFileName;
  353.     std::string strText;
  354.     const char* pszShortFileName = "readme.md";
  355.     do {
  356.         // 将嵌入资源中的readme.md写入输出文件夹中的库目录中
  357.         strFileName = g_dir_out_obj;
  358.         strFileName += pszShortFileName;
  359.         if (!write_res_file(strFileName.c_str()))
  360.         {
  361.             break;
  362.         }
  363.         b_rc = true;
  364.     } while (false);
  365.     return b_rc;
  366. }
  367. bool write_res_file(const char* psz_write_to)
  368. {
  369.     // 定义资源标识符(根据实际资源头文件中的定义)
  370.     const TCHAR* lpType = TEXT("BIN_RES");  // 自定义资源类型
  371.     const int resId = IDR_BIN_RES_README_MD; // 资源ID
  372.     if (NULL == psz_write_to) return false;
  373.     // 获取模块句柄
  374.     HMODULE hModule = GetModuleHandle(NULL);
  375.     if (!hModule) return false;
  376.     // 查找资源
  377.     HRSRC hRes = FindResource(hModule, MAKEINTRESOURCE(resId), lpType);
  378.     if (!hRes) return false;
  379.     // 获取资源大小
  380.     DWORD dwSize = SizeofResource(hModule, hRes);
  381.     if (dwSize == 0) return false;
  382.     // 加载资源
  383.     HGLOBAL hGlobal = LoadResource(hModule, hRes);
  384.     if (!hGlobal) return false;
  385.     // 锁定资源获取指针
  386.     LPVOID lpResData = LockResource(hGlobal);
  387.     if (!lpResData) return false;
  388.     // 创建输出文件
  389.     HANDLE hFile = CreateFileA(psz_write_to, GENERIC_WRITE, 0, NULL,
  390.         CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  391.     if (hFile == INVALID_HANDLE_VALUE) return false;
  392.     // 写入文件
  393.     DWORD dwWritten = 0;
  394.     BOOL bResult = WriteFile(hFile, lpResData, dwSize, &dwWritten, NULL);
  395.     // 清理资源
  396.     CloseHandle(hFile);
  397.     FreeResource(hGlobal);
  398.     return (bResult && (dwWritten == dwSize));
  399. }
  400. bool check_param(int argc, char** argv)
  401. {
  402.     bool b_rc = false;
  403.     std::string str_msg;
  404.     char* psz = NULL;
  405.     do {
  406.         if (2 != argc)
  407.         {
  408.             break;
  409.         }
  410.         // g_new_sub_rep_name
  411.         psz = argv[1];
  412.         if ((NULL == psz) || (strlen(psz) <= 0))
  413.         {
  414.             std::stringstream ss;
  415.             ss << "参数1是子库名称, 不能为空";
  416.             str_msg = ss.str();
  417.             show_error(str_msg.c_str());
  418.             break;
  419.         }
  420.         g_new_sub_rep_name = psz;
  421.         if (string_find(g_new_sub_rep_name, '/') || string_find(g_new_sub_rep_name, '\\'))
  422.         {
  423.             std::stringstream ss;
  424.             ss << "新建的子库名称不能包含路径字符";
  425.             str_msg = ss.str();
  426.             show_error(str_msg.c_str());
  427.             break;
  428.         }
  429.         g_cur_dir = get_cur_dir_path_name();
  430.         if (!is_dir_exist(g_cur_dir.c_str()))
  431.         {
  432.             break;
  433.         }
  434.         // param1 = for_test
  435.         g_dir_obj = MY_DEFAULT_GITEA_REP_ROOT_DIR;
  436.         g_dir_obj += "rep_";
  437.         g_dir_obj += g_new_sub_rep_name;
  438.         g_dir_obj += "\"; // E:\my_git_rep\rep_for_test\
  439.         g_dir_obj_rep = g_dir_obj;
  440.         g_dir_obj_rep += g_new_sub_rep_name;
  441.         g_dir_obj_rep += "\"; // E:\my_git_rep\rep_for_test\for_test\
  442.         if (is_dir_exist(g_dir_obj.c_str()))
  443.         {
  444.             std::stringstream ss;
  445.             ss << "总库下的子目录[" << g_dir_obj << "]已经存在, 为了安全, 请重新给定子库名称";
  446.             str_msg = ss.str();
  447.             show_error(str_msg.c_str());
  448.             break;
  449.         }
  450.         g_dir_out = g_cur_dir;
  451.         g_dir_out += DIR_OUT;
  452.         g_dir_out += "\";
  453.         // 如果输出目录不存在,就建立目录
  454.         if (!is_dir_exist(g_dir_out.c_str()))
  455.         {
  456.             // 建立输出目录
  457.             if (!create_dir(g_dir_out.c_str()))
  458.             {
  459.                 std::stringstream ss;
  460.                 ss << "目录[" << g_dir_out << "]建立失败";
  461.                 str_msg = ss.str();
  462.                 show_error(str_msg.c_str());
  463.                 break;
  464.             }
  465.         }
  466.         // 建立输出目录中的子库目录
  467.         g_dir_out_obj = g_dir_out;
  468.         g_dir_out_obj += "rep_";
  469.         g_dir_out_obj += g_new_sub_rep_name;
  470.         g_dir_out_obj += "\";
  471.         if (!is_dir_exist(g_dir_out_obj.c_str()))
  472.         {
  473.             // 建立输出目录
  474.             if (!create_dir(g_dir_out_obj.c_str()))
  475.             {
  476.                 std::stringstream ss;
  477.                 ss << "目录[" << g_dir_out << "]建立失败";
  478.                 str_msg = ss.str();
  479.                 show_error(str_msg.c_str());
  480.                 break;
  481.             }
  482.         }
  483.         else {
  484.             // 如果目录存在,就不干活了, 必须用户移走了目录,才能干活
  485.             std::stringstream ss;
  486.             ss << "目录[" << g_dir_out_obj << "]已经存在,请移动目录到总库目录 或者 删除输出目录中的子库目录再运行程序";
  487.             str_msg = ss.str();
  488.             show_error(str_msg.c_str());
  489.             break;
  490.         }
  491.         b_rc = true;
  492.     } while (false);
  493.     if (!b_rc)
  494.     {
  495.         show_error("命令行参数错误");
  496.     }
  497.     return b_rc;
  498. }
  499. std::string get_cur_dir_path_name() {
  500.     // 使用MAX_PATH+1确保足够缓冲区
  501.     char buffer[MAX_PATH + 1] = { 0 };
  502.     // 获取EXE完整路径(ANSI版本
  503.     DWORD ret = GetModuleFileNameA(nullptr, buffer, MAX_PATH);
  504.     if (ret == 0 || ret == MAX_PATH) { // 失败或路径过长
  505.         return "";
  506.     }
  507.     // 反向查找最后一个路径分隔符
  508.     char* last_sep = strrchr(buffer, '\\');
  509.     if (last_sep == nullptr) { // 异常情况处理
  510.         return "";
  511.     }
  512.     // 截断到目录部分(包含结尾反斜杠)
  513.     *(last_sep + 1) = '\0';
  514.     // 转换为标准字符串并返回
  515.     return std::string(buffer);
  516. }
  517. bool is_dir_exist(const char* psz_path_name) {
  518.     if (!psz_path_name) return false;
  519.     const char* path = psz_path_name;
  520.     struct _stat fileStat;
  521.     if (_stat(path, &fileStat) == 0) {
  522.         return (fileStat.st_mode & _S_IFDIR) != 0;
  523.     }
  524.     return false;
  525. }
  526. void show_error(const char* psz_reason)
  527. {
  528.     printf("error");
  529.     if ((NULL != psz_reason) && (strlen(psz_reason) > 0))
  530.     {
  531.         printf(" : %s\r\n", psz_reason);
  532.     }
  533.     else {
  534.         printf("\r\n");
  535.     }
  536.     printf("\r\n");
  537. }
  538. void usage()
  539. {
  540.     printf("-------- creatGiteaEmptyRepDir v%s --------\r\n", MY_VER);
  541.    
  542.     printf("usage :\r\n");
  543.     printf("\t<THE_EXE> <gitea_rep_name>\r\n");
  544.     printf("\tgitea_rep_name e.g. like my_gitea_study_rep\r\n");
  545.     printf("function :\r\n");
  546.     printf("\t生成gitea用的库目录脚本\r\n");
  547.     printf("\t用户自己拷贝生成的子目录(e.g. <./creatGiteaEmptyRepDir_out/sub_rep_dir>)\r\n");
  548.     printf("\t到总的库目录(e.g.E:/my_git_rep), 防止意外操作或程序bug\r\n");
  549. }
  550. bool create_dir(const char* pszPath) {
  551.     if (!pszPath || *pszPath == '\0') {
  552.         SetLastError(ERROR_INVALID_PARAMETER);
  553.         return false;
  554.     }
  555.     // 转换UTF-8到宽字符(支持中文路径)
  556.     const int bufferSize = MultiByteToWideChar(CP_UTF8, 0, pszPath, -1, nullptr, 0);
  557.     if (bufferSize == 0) return false;
  558.     std::wstring wPath(bufferSize, L'\0');
  559.     if (MultiByteToWideChar(CP_UTF8, 0, pszPath, -1, &wPath[0], bufferSize) == 0) {
  560.         return false;
  561.     }
  562.     // 检查路径有效性
  563.     DWORD attrs = GetFileAttributesW(wPath.c_str());
  564.     if (attrs != INVALID_FILE_ATTRIBUTES) {
  565.         if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
  566.             SetLastError(ERROR_ALREADY_EXISTS);
  567.             return false;
  568.         }
  569.         SetLastError(ERROR_FILE_EXISTS);
  570.         return false;
  571.     }
  572.     // 创建目录(含基础权限)
  573.     SECURITY_ATTRIBUTES sa = { sizeof(sa), nullptr, TRUE };
  574.     if (CreateDirectoryW(wPath.c_str(), &sa)) {
  575.         return true;
  576.     }
  577.     // 错误处理(可扩展记录日志日志
  578.     const DWORD err = GetLastError();
  579.     if (err != ERROR_PATH_NOT_FOUND) {
  580.         return false;
  581.     }
  582.     // 尝试创建父目录(可选递归)
  583.     const std::wstring parentDir = wPath.substr(0, wPath.find_last_of(L'\\'));
  584.     std::string parentDirA = Wstring2String(parentDir);
  585.     if (!parentDir.empty() && create_dir(parentDirA.c_str())) {
  586.         return CreateDirectoryW(wPath.c_str(), &sa) != 0;
  587.     }
  588.     return false;
  589. }
  590. std::string Wstring2String(std::wstring strW) {
  591.     if (strW.empty())  return std::string();
  592.     // 计算转换后需要的缓冲区大小
  593.     int len = WideCharToMultiByte(
  594.         CP_ACP,                // 使用系统默认 ANSI 编码(如中文系统下为 GBK)
  595.         0,                     // 无特殊标志
  596.         strW.c_str(),          // 输入宽字符串
  597.         (int)strW.size(),       // 输入字符串长度(不含终止符)
  598.         NULL, 0, NULL, NULL    // 输出缓冲区和长度置空以计算所需空间
  599.     );
  600.     if (len == 0) return std::string();
  601.     // 直接操作 std::string 的缓冲区
  602.     std::string result;
  603.     result.resize(len);
  604.     WideCharToMultiByte(
  605.         CP_ACP, 0,
  606.         strW.c_str(), (int)strW.size(),
  607.         &result[0], len,       // 输出到 result 的缓冲区
  608.         NULL, NULL
  609.     );
  610.     return result;
  611. }
  612. bool string_find(const std::string& strA, char c) {
  613.     return strA.find(c) != std::string::npos;
  614. }
  615. bool write_ascii_file(const std::string& strFileName, const std::string& strText) {
  616.     std::ofstream outFile;
  617.     outFile.open(strFileName, std::ios::out | std::ios::trunc); // 覆盖模式写入
  618.     if (!outFile.is_open()) { // 检查文件是否成功打开
  619.         return false;
  620.     }
  621.     outFile << strText; // 写入内容
  622.     outFile.close();     // 显式关闭文件
  623.     return !outFile.fail();  // 返回写入是否成功
  624. };
复制代码
END


免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。
继续阅读请点击广告

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?立即注册

×
回复

使用道具 举报

×
登录参与点评抽奖,加入IT实名职场社区
去登录
快速回复 返回顶部 返回列表