feat: add configuration for Prakasa Git branch in config manager

ai-chen2050 · ai-chen2050 · commit 8e9b9460056b · 2026-01-16T19:57:36.000+08:00
diff --git a/src/parallax/config/config_manager.cpp b/src/parallax/config/config_manager.cpp
@@ -17,6 +17,7 @@ namespace parallax
         const std::string KEY_WSL_INSTALLER_URL = "wsl_installer_url";
         const std::string KEY_WSL_KERNEL_URL = "wsl_kernel_url";
         const std::string KEY_PRAKASA_GIT_REPO_URL = "prakasa_git_repo_url";
+        const std::string KEY_PRAKASA_GIT_BRANCH = "prakasa_git_branch";
 
         // Default configuration file name
         const std::string ConfigManager::DEFAULT_CONFIG_PATH = "parallax_config.txt";
@@ -60,6 +61,7 @@ namespace parallax
                 "wsl_update_x64.msi";
             config_values_[KEY_PRAKASA_GIT_REPO_URL] =
                 "https://github.com/hetu-project/prakasa.git";
+            config_values_[KEY_PRAKASA_GIT_BRANCH] = "main";
             // proxy_url has no default value
         }
 
@@ -106,7 +108,8 @@ namespace parallax
                 {KEY_WSL_LINUX_DISTRO, config_values_[KEY_WSL_LINUX_DISTRO]},
                 {KEY_WSL_INSTALLER_URL, config_values_[KEY_WSL_INSTALLER_URL]},
                 {KEY_WSL_KERNEL_URL, config_values_[KEY_WSL_KERNEL_URL]},
-                {KEY_PRAKASA_GIT_REPO_URL, config_values_[KEY_PRAKASA_GIT_REPO_URL]}};
+                {KEY_PRAKASA_GIT_REPO_URL, config_values_[KEY_PRAKASA_GIT_REPO_URL]},
+                {KEY_PRAKASA_GIT_BRANCH, config_values_[KEY_PRAKASA_GIT_BRANCH]}};
 
             std::string line;
             while (std::getline(file, line))
@@ -322,7 +325,7 @@ namespace parallax
         {
             static const std::set<std::string> valid_keys = {
                 KEY_PROXY_URL, KEY_WSL_LINUX_DISTRO, KEY_WSL_INSTALLER_URL,
-                KEY_WSL_KERNEL_URL, KEY_PRAKASA_GIT_REPO_URL};
+                KEY_WSL_KERNEL_URL, KEY_PRAKASA_GIT_REPO_URL, KEY_PRAKASA_GIT_BRANCH};
 
             return valid_keys.find(key) != valid_keys.end();
         }
diff --git a/src/parallax/config/config_manager.h b/src/parallax/config/config_manager.h
@@ -14,6 +14,7 @@ namespace parallax
       extern const std::string KEY_WSL_INSTALLER_URL;
       extern const std::string KEY_WSL_KERNEL_URL;
       extern const std::string KEY_PRAKASA_GIT_REPO_URL;
+      extern const std::string KEY_PRAKASA_GIT_BRANCH;
 
       // Configuration file manager class
       class ConfigManager
diff --git a/src/parallax/environment/software_installer2.cpp b/src/parallax/environment/software_installer2.cpp
@@ -172,6 +172,9 @@ namespace parallax
             std::string repo_url =
                 parallax::config::ConfigManager::GetInstance().GetConfigValue(
                     parallax::config::KEY_PRAKASA_GIT_REPO_URL);
+            std::string git_branch =
+                parallax::config::ConfigManager::GetInstance().GetConfigValue(
+                    parallax::config::KEY_PRAKASA_GIT_BRANCH);
 
             const std::string &proxy_url = context_->GetProxyUrl();
 
@@ -185,26 +188,26 @@ namespace parallax
             if (is_update_mode)
             {
                 // Project is installed and has updates, only execute git pull update
-                std::string pull_cmd = "cd ~/prakasa && git pull";
+                std::string pull_cmd = "cd ~/prakasa && git checkout " + git_branch + " && git pull";
                 if (!proxy_url.empty())
                 {
-                    pull_cmd = "cd ~/prakasa && ALL_PROXY=" + proxy_url + " git pull";
+                    pull_cmd = "cd ~/prakasa && git checkout " + git_branch + " && ALL_PROXY=" + proxy_url + " git pull";
                 }
                 commands.emplace_back("update_parallax", pull_cmd, 300, false);
             }
             else
             {
-                // Project not installed, check if parallax directory exists, decide
+                // Project not installed, check if prakasa directory exists, decide
                 // whether to clone or pull
                 auto [check_dir_code, check_dir_output] = executor_->ExecuteWSL(
-                    "ls -la ~/parallax/.git 2>/dev/null || echo 'not found'", 30);
+                    "ls -la ~/prakasa/.git 2>/dev/null || echo 'not found'", 30);
 
                 if (check_dir_code == 0 &&
                     check_dir_output.find("not found") == std::string::npos)
                 {
                     // Directory exists, check if it's a git repository
                     auto [check_git_code, check_git_output] = executor_->ExecuteWSL(
-                        "cd ~/parallax && git branch 2>/dev/null || echo 'not git'",
+                        "cd ~/prakasa && git branch 2>/dev/null || echo 'not git'",
                         30);
 
                     if (check_git_code == 0 &&
@@ -214,11 +217,11 @@ namespace parallax
                         info_log(
                             "[ENV] Prakasa directory exists, updating with git "
                             "pull...");
-                        std::string pull_cmd = "cd ~/prakasa && git pull";
+                        std::string pull_cmd = "cd ~/prakasa && git checkout " + git_branch + " && git pull";
                         if (!proxy_url.empty())
                         {
                             pull_cmd =
-                                "cd ~/prakasa && ALL_PROXY=" + proxy_url + " git pull";
+                                "cd ~/prakasa && git checkout " + git_branch + " && ALL_PROXY=" + proxy_url + " git pull";
                         }
                         commands.emplace_back("update_parallax", pull_cmd, 300, false);
                     }
@@ -237,7 +240,7 @@ namespace parallax
                         {
                             clone_cmd += "ALL_PROXY=" + proxy_url + " ";
                         }
-                        clone_cmd += "git clone " + repo_url;
+                        clone_cmd += "git clone -b " + git_branch + " " + repo_url;
                         commands.emplace_back("clone_prakasa", clone_cmd, 600, false);
                     }
                 }
@@ -251,7 +254,7 @@ namespace parallax
                     {
                         clone_cmd += "ALL_PROXY=" + proxy_url + " ";
                     }
-                    clone_cmd += "git clone " + repo_url;
+                    clone_cmd += "git clone -b " + git_branch + " " + repo_url;
                     commands.emplace_back("clone_prakasa", clone_cmd, 600, false);
                 }
             }
@@ -368,22 +371,25 @@ namespace parallax
 
         bool ParallaxProjectInstaller::IsParallaxProjectInstalled()
         {
-            // Check if parallax project is installed (need to check in virtual
+            // Check if prakasa project is installed (need to check in virtual
             // environment)
             auto [check_code, check_output] = executor_->ExecuteWSL(
-                "cd ~/parallax && [ -d ./venv ] && source ./venv/bin/activate && pip "
-                "list | grep parallax");
+                "cd ~/prakasa && [ -d ./venv ] && source ./venv/bin/activate && pip "
+                "list | grep prakasa");
             return (check_code == 0 && !check_output.empty());
         }
 
         bool ParallaxProjectInstaller::HasParallaxProjectGitUpdates()
         {
             const std::string &proxy_url = context_->GetProxyUrl();
+            std::string git_branch =
+                parallax::config::ConfigManager::GetInstance().GetConfigValue(
+                    parallax::config::KEY_PRAKASA_GIT_BRANCH);
 
-            // Check if Parallax project has git updates
+            // Check if Prakasa project has git updates
             // First check if git repository exists
             auto [check_git_code, check_git_output] = executor_->ExecuteWSL(
-                "cd ~/parallax && git rev-parse --is-inside-work-tree 2>/dev/null", 30);
+                "cd ~/prakasa && git rev-parse --is-inside-work-tree 2>/dev/null", 30);
 
             if (check_git_code != 0)
             {
@@ -408,7 +414,7 @@ namespace parallax
 
             // Check if there are differences between local and remote
             auto [diff_code, diff_output] = executor_->ExecuteWSL(
-                "cd ~/prakasa && git rev-list HEAD...origin/main --count 2>/dev/null",
+                "cd ~/prakasa && git rev-list HEAD...origin/" + git_branch + " --count 2>/dev/null",
                 30);
 
             if (diff_code == 0 && !diff_output.empty())

Original file line number	Diff line number	Diff line change
`@@ -172,6 +172,9 @@ namespace parallax`
`172`	`172`	`std::string repo_url =`
`173`	`173`	`parallax::config::ConfigManager::GetInstance().GetConfigValue(`
`174`	`174`	`parallax::config::KEY_PRAKASA_GIT_REPO_URL);`
	`175`	`+ std::string git_branch =`
	`176`	`+ parallax::config::ConfigManager::GetInstance().GetConfigValue(`
	`177`	`+ parallax::config::KEY_PRAKASA_GIT_BRANCH);`
`175`	`178`
`176`	`179`	`const std::string &proxy_url = context_->GetProxyUrl();`
`177`	`180`
`@@ -185,26 +188,26 @@ namespace parallax`
`185`	`188`	`if (is_update_mode)`
`186`	`189`	`{`
`187`	`190`	`// Project is installed and has updates, only execute git pull update`
`188`		`- std::string pull_cmd = "cd ~/prakasa && git pull";`
	`191`	`+ std::string pull_cmd = "cd ~/prakasa && git checkout " + git_branch + " && git pull";`
`189`	`192`	`if (!proxy_url.empty())`
`190`	`193`	`{`
`191`		`- pull_cmd = "cd ~/prakasa && ALL_PROXY=" + proxy_url + " git pull";`
	`194`	`+ pull_cmd = "cd ~/prakasa && git checkout " + git_branch + " && ALL_PROXY=" + proxy_url + " git pull";`
`192`	`195`	`}`
`193`	`196`	`commands.emplace_back("update_parallax", pull_cmd, 300, false);`
`194`	`197`	`}`
`195`	`198`	`else`
`196`	`199`	`{`
`197`		`- // Project not installed, check if parallax directory exists, decide`
	`200`	`+ // Project not installed, check if prakasa directory exists, decide`
`198`	`201`	`// whether to clone or pull`
`199`	`202`	`auto [check_dir_code, check_dir_output] = executor_->ExecuteWSL(`
`200`		`- "ls -la ~/parallax/.git 2>/dev/null \|\| echo 'not found'", 30);`
	`203`	`+ "ls -la ~/prakasa/.git 2>/dev/null \|\| echo 'not found'", 30);`
`201`	`204`
`202`	`205`	`if (check_dir_code == 0 &&`
`203`	`206`	`check_dir_output.find("not found") == std::string::npos)`
`204`	`207`	`{`
`205`	`208`	`// Directory exists, check if it's a git repository`
`206`	`209`	`auto [check_git_code, check_git_output] = executor_->ExecuteWSL(`
`207`		`- "cd ~/parallax && git branch 2>/dev/null \|\| echo 'not git'",`
	`210`	`+ "cd ~/prakasa && git branch 2>/dev/null \|\| echo 'not git'",`
`208`	`211`	`30);`
`209`	`212`
`210`	`213`	`if (check_git_code == 0 &&`
`@@ -214,11 +217,11 @@ namespace parallax`
`214`	`217`	`info_log(`
`215`	`218`	`"[ENV] Prakasa directory exists, updating with git "`
`216`	`219`	`"pull...");`
`217`		`- std::string pull_cmd = "cd ~/prakasa && git pull";`
	`220`	`+ std::string pull_cmd = "cd ~/prakasa && git checkout " + git_branch + " && git pull";`
`218`	`221`	`if (!proxy_url.empty())`
`219`	`222`	`{`
`220`	`223`	`pull_cmd =`
`221`		`- "cd ~/prakasa && ALL_PROXY=" + proxy_url + " git pull";`
	`224`	`+ "cd ~/prakasa && git checkout " + git_branch + " && ALL_PROXY=" + proxy_url + " git pull";`
`222`	`225`	`}`
`223`	`226`	`commands.emplace_back("update_parallax", pull_cmd, 300, false);`
`224`	`227`	`}`
`@@ -237,7 +240,7 @@ namespace parallax`
`237`	`240`	`{`
`238`	`241`	`clone_cmd += "ALL_PROXY=" + proxy_url + " ";`
`239`	`242`	`}`
`240`		`- clone_cmd += "git clone " + repo_url;`
	`243`	`+ clone_cmd += "git clone -b " + git_branch + " " + repo_url;`
`241`	`244`	`commands.emplace_back("clone_prakasa", clone_cmd, 600, false);`
`242`	`245`	`}`
`243`	`246`	`}`
`@@ -251,7 +254,7 @@ namespace parallax`
`251`	`254`	`{`
`252`	`255`	`clone_cmd += "ALL_PROXY=" + proxy_url + " ";`
`253`	`256`	`}`
`254`		`- clone_cmd += "git clone " + repo_url;`
	`257`	`+ clone_cmd += "git clone -b " + git_branch + " " + repo_url;`
`255`	`258`	`commands.emplace_back("clone_prakasa", clone_cmd, 600, false);`
`256`	`259`	`}`
`257`	`260`	`}`
`@@ -368,22 +371,25 @@ namespace parallax`
`368`	`371`
`369`	`372`	`bool ParallaxProjectInstaller::IsParallaxProjectInstalled()`
`370`	`373`	`{`
`371`		`- // Check if parallax project is installed (need to check in virtual`
	`374`	`+ // Check if prakasa project is installed (need to check in virtual`
`372`	`375`	`// environment)`
`373`	`376`	`auto [check_code, check_output] = executor_->ExecuteWSL(`
`374`		`- "cd ~/parallax && [ -d ./venv ] && source ./venv/bin/activate && pip "`
`375`		`- "list \| grep parallax");`
	`377`	`+ "cd ~/prakasa && [ -d ./venv ] && source ./venv/bin/activate && pip "`
	`378`	`+ "list \| grep prakasa");`
`376`	`379`	`return (check_code == 0 && !check_output.empty());`
`377`	`380`	`}`
`378`	`381`
`379`	`382`	`bool ParallaxProjectInstaller::HasParallaxProjectGitUpdates()`
`380`	`383`	`{`
`381`	`384`	`const std::string &proxy_url = context_->GetProxyUrl();`
	`385`	`+ std::string git_branch =`
	`386`	`+ parallax::config::ConfigManager::GetInstance().GetConfigValue(`
	`387`	`+ parallax::config::KEY_PRAKASA_GIT_BRANCH);`
`382`	`388`
`383`		`- // Check if Parallax project has git updates`
	`389`	`+ // Check if Prakasa project has git updates`
`384`	`390`	`// First check if git repository exists`
`385`	`391`	`auto [check_git_code, check_git_output] = executor_->ExecuteWSL(`
`386`		`- "cd ~/parallax && git rev-parse --is-inside-work-tree 2>/dev/null", 30);`
	`392`	`+ "cd ~/prakasa && git rev-parse --is-inside-work-tree 2>/dev/null", 30);`
`387`	`393`
`388`	`394`	`if (check_git_code != 0)`
`389`	`395`	`{`
`@@ -408,7 +414,7 @@ namespace parallax`
`408`	`414`
`409`	`415`	`// Check if there are differences between local and remote`
`410`	`416`	`auto [diff_code, diff_output] = executor_->ExecuteWSL(`
`411`		`- "cd ~/prakasa && git rev-list HEAD...origin/main --count 2>/dev/null",`
	`417`	`+ "cd ~/prakasa && git rev-list HEAD...origin/" + git_branch + " --count 2>/dev/null",`
`412`	`418`	`30);`
`413`	`419`
`414`	`420`	`if (diff_code == 0 && !diff_output.empty())`