/**
* Hourly update remote repositories
*/
function ac_gitolite_handle_on_daily()
{
// pull repos with update type frequently.
$admin_obj = new GitoliteAdmin();
$admin_obj->call_events("3");
source_handle_on_daily();
}
function hooks_call()
{
$src_obj = new SourceRepositories();
$source_repo_table = TABLE_PREFIX . "source_repositories";
$res = $src_obj->findBySQL("select * from {$source_repo_table} where name = '" . trim($_GET["repo_name"]) . "'");
if ($res) {
$repo_array = $res->getRowAt(0);
GitoliteAdmin::update_remote_repo($repo_array->getId(), TRUE);
}
die;
}
/**
* render_conf_file
* Write repository and access levels in conf file
*
* @return boolean|string
*/
function render_conf_file()
{
$settings = GitoliteAdmin::get_admin_settings();
$conf_path = $settings['gitoliteadminpath'] . "/gitolite-admin/conf/gitolite.conf";
$webuser = exec("whoami");
$conf_file = $conf_path;
// create access array
$access_array = array(GITOLITE_READACCESS => 'R', GITOLITE_MANAGEACCESS => 'RW+');
$fh = fopen($conf_file, 'w');
if (file_exists($conf_path) && $fh) {
$repo_table_name = TABLE_PREFIX . 'rt_gitolite_repomaster';
$access_table_name = TABLE_PREFIX . 'rt_gitolite_access_master';
$public_key_table_name = TABLE_PREFIX . 'rt_gitolite_user_public_keys';
$source_table_name = TABLE_PREFIX . 'source_repositories';
$admin_settings_table_name = TABLE_PREFIX . 'rt_config_settings';
/** Defalut access to gitolite admin * */
$get_git_admins = DB::execute("SELECT * FROM " . $admin_settings_table_name);
fwrite($fh, "repo " . "@all" . "\n");
fwrite($fh, "RW+" . "\t" . "=" . "\t" . $webuser . "\n");
fwrite($fh, "repo " . "gitolite-admin" . "\n");
fwrite($fh, "RW+" . "\t" . "=" . "\t" . $webuser . "\n");
if ($get_git_admins) {
$admins_rec = $get_git_admins[0];
if (is_array($admins_rec)) {
$admins = @unserialize($admins_rec['gitoliteadmins']);
if ($admins !== false || $admins === 'b:0;') {
$admins_array = $admins;
} else {
$admins_array = array();
}
if (is_foreachable($admins_array)) {
foreach ($admins_array as $keyadmin => $valadmin) {
$pubkeys = DB::execute("SELECT * FROM " . $public_key_table_name . " where user_id = '" . $valadmin . "' and is_deleted = '0'");
if ($pubkeys) {
foreach ($pubkeys as $rowkeys) {
if ($rowkeys['pub_file_name'] != "") {
fwrite($fh, $access_array[GITOLITE_MANAGEACCESS] . "\t" . "=" . "\t" . $rowkeys['pub_file_name'] . "\n");
}
}
}
}
}
}
}
$sql = "SELECT a.* ,b.id FROM " . $repo_table_name . " a JOIN " . $source_table_name . " b ON a.repo_fk = b.id where gitolite_config is null limit 1";
$result_gitconfig_empty = DB::execute($sql);
$file_name = "/tmp/gitolite_" . microtime();
$file_name = str_replace(" ", "-", $file_name);
$file_name = str_replace(".", "_", $file_name);
$mysqlACLFlag = true;
if (!$result_gitconfig_empty) {
$sql = "SELECT CONCAT('repo ', repo_name),gitolite_config INTO OUTFILE '{$file_name}'\n FIELDS ESCAPED BY '' TERMINATED BY '\n' OPTIONALLY ENCLOSED BY ''\n LINES TERMINATED BY '\n' \n FROM {$repo_table_name} ";
try {
$result = DB::execute($sql);
} catch (Exception $e) {
$mysqlACLFlag = false;
}
if ($mysqlACLFlag && file_exists($file_name)) {
$conf_content = file_get_contents($file_name);
fwrite($fh, $conf_content);
fclose($fh);
@unlink($file_name);
return true;
} else {
$sql = "SELECT CONCAT('repo ', repo_name) as 'repo_name',gitolite_config FROM {$repo_table_name}";
$result = DB::execute($sql);
if ($result) {
foreach ($result as $row) {
$conf_content = "\n" . $row['repo_name'] . "\n" . $row['gitolite_config'];
fwrite($fh, $conf_content);
}
}
fclose($fh);
return true;
}
}
$result = DB::execute("SELECT a.* ,b.id FROM " . $repo_table_name . " a JOIN " . $source_table_name . " b ON a.repo_fk = b.id");
try {
if ($result) {
//fetch all gitolite repositories
foreach ($result as $row) {
$prjobj = new Project($row['project_id']);
// get project users
$prjusers = $prjobj->users()->getIdNameMap();
// get permissions
$permissions = DB::execute("SELECT * FROM " . $access_table_name . " where repo_id = '" . $row['repo_id'] . "'");
if ($permissions) {
// get repository permissions
$perm_row = $permissions["0"];
$permissions = @unserialize($perm_row['permissions']);
if ($permissions !== false || $permissions === 'b:0;') {
$permissions_array = $permissions;
} else {
$permissions_array = array();
}
} else {
$permissions_array = array();
}
// write repository name in conf file
fwrite($fh, "repo " . $row['repo_name'] . "\n");
$str_repo_conf = "";
if (is_foreachable($prjusers)) {
foreach ($prjusers as $keyusers => $valueusers) {
$pubkeys = DB::execute("SELECT * FROM " . $public_key_table_name . " where user_id = '" . $keyusers . "' and is_deleted = '0'");
if (is_array($pubkeys)) {
foreach ($pubkeys as $rowkeys) {
$access = isset($access_array[$permissions_array[$keyusers]]) ? $access_array[$permissions_array[$keyusers]] : "";
if ($access != "" && $rowkeys['pub_file_name'] != "") {
fwrite($fh, $access . "\t" . "=" . "\t" . $rowkeys['pub_file_name'] . "\n");
$str_repo_conf .= "\t" . $access . "\t" . "=" . "\t" . $rowkeys['pub_file_name'] . "\n";
}
}
// while
}
// if public keys added
}
// foreach
}
// if project user exists
$sql = "update " . $repo_table_name . " set gitolite_config='" . $str_repo_conf . "' where repo_id =" . $row['repo_id'];
DB::execute($sql);
}
// while
}
// repo exists
} catch (Exception $e) {
echo $e;
}
return true;
} else {
return "can't write file";
}
}
/**
* Clone remote repository independent of any project.
* @throws ValidationErrors
*/
function clone_source_git_repository()
{
$logged_user = $this->logged_user;
$user_id = $logged_user->getId();
$web_user = GitoliteAdmin::get_web_user();
$webuser_pub_key = GitoliteAdmin::get_web_user_key();
/* echo $webuser_pub_key;
print_r($webuser_pub_key);
//die(); */
$this->response->assign(array('form_action' => Router::assemble('clone_source_git_repository'), 'web_user' => $web_user, 'webuser_pub_key' => $webuser_pub_key));
if ($this->request->isSubmitted()) {
// check for form submission
try {
$repository_data = $this->request->post('repository');
$repo_name = trim($repository_data["name"]);
$repo_url = trim($this->request->post("remoteurl"));
$errors = new ValidationErrors();
$post_data = $this->request->post();
if ($repo_name == "") {
$errors->addError('Please enter repository name', 'repo_name');
}
if ($repo_url == "") {
$errors->addError('Please enter repository URL', 'repo_name');
}
$dup_cnt = ProjectGitolite::check_remote_duplication($project_id, $repository_data, $repo_url);
if (!$errors->hasErrors()) {
if (!preg_match("/^[A-Za-z0-9-]+\$/", $repo_name)) {
$errors->addError('Please enter valid repository name.', 'repo_name');
}
/* if(preg_match('|^[a-z]?:@[a-z0-9]+(.[a-z0-9-]+)*(:[0-9]+)?(/.*)?$|i', $url))
{
return ;
} */
if (strstr($repo_url, "http://") || strstr($repo_url, "https://")) {
$errors->addError('HTTP url not allowed to add remote repository', 'repo_url');
}
/* if(!strstr($repo_url, "git://github.com/"))
{
$errors->addError('Please enter valid Git URL', 'repo_url');
} */
if (count($dup_cnt) == 0) {
$errors->addError('Problem occured while saving data, please try again.');
} elseif (is_array($dup_cnt) && count($dup_cnt) > 0) {
if ($dup_cnt[0]['dup_name_cnt'] > 0) {
$errors->addError('Repository with same name is already added');
}
if ($dup_cnt[1]['dup_name_cnt'] > 0) {
$errors->addError('Remote URL already cloned under this project.');
}
}
}
if ($errors->hasErrors()) {
throw $errors;
}
try {
DB::beginWork('Creating a new remote repository @ ' . __CLASS__);
$actual_git_repo_name = ProjectGitolite::get_actual_repo_name($repo_url);
if (!$actual_git_repo_name) {
$errors->addError('Invalid Git Repository.');
throw $errors;
}
// clone remote repo
// path with folder name which is created as same as repo name to avoid same git repo collision
$work_git_path = GIT_FILES_PATH . "/";
// path with folder name which is created after repo is cloned
$git_ext = strpos($actual_git_repo_name, ".git");
if ($git_ext) {
$actual_git_repo_name = substr($actual_git_repo_name, 0, -4);
}
$actual_repo_path = GIT_FILES_PATH . "/" . $repo_name . "/" . $actual_git_repo_name . "/";
$folder_append = "";
$chk_actual_name_exists_cnt = ProjectGitolite::check_actual_name_count($actual_git_repo_name);
if (is_array($chk_actual_name_exists_cnt) && isset($chk_actual_name_exists_cnt["actual_name_cnt"])) {
$cnt = $chk_actual_name_exists_cnt["actual_name_cnt"] > 0 ? $chk_actual_name_exists_cnt["actual_name_cnt"] + 1 : "";
$folder_append = $cnt != "" ? "-{$cnt}" : "";
} else {
$folder_append = "-1";
}
// if git repsitory name is same , we need to change the folder name while cloning the repository
$folder_name = $actual_git_repo_name . $folder_append;
$actual_repo_path = GIT_FILES_PATH . "/" . $folder_name . "/";
$return_status = GitoliteAdmin::clone_remote_repo($repo_url, $work_git_path, $folder_name);
if (!$return_status) {
$errors->addError('Problem occured while cloning repository.');
throw $errors;
}
$repository_path_url = array('repository_path_url' => $actual_repo_path);
//echo $work_git_path;
$repository_data = array_merge($repository_data, $repository_path_url);
$this->active_repository = new GitRepository();
$this->active_repository->setAttributes($repository_data);
$this->active_repository->setCreatedBy($this->logged_user);
$this->active_repository->save();
$repo_fk = $this->active_repository->getId();
if ($repo_fk) {
$repo_id = ProjectGitolite::add_remote_repo_details($repo_fk, $user_id, $actual_repo_path, $repo_name, $repo_url, $actual_git_repo_name);
if ($repo_id) {
DB::commit('Repository created @ ' . __CLASS__);
//$out = $this->update_remote_repo($repo_fk);
$out = GitoliteAdmin::update_remote_repo($repo_fk);
$this->response->respondWithData($this->active_repository, array('as' => 'repository'));
} else {
@ProjectGitolite::remove_directory($work_git_path);
$errors->addError('Error while saving repository.');
throw $errors;
}
} else {
@ProjectGitolite::remove_directory($work_git_path);
$errors->addError('Error while saving repository.');
throw $errors;
}
} catch (Exception $e) {
DB::rollback('Failed to create a repository @ ' . __CLASS__);
$this->response->exception($e);
}
} catch (Exception $e) {
DB::rollback('Failed to create a repository @ ' . __CLASS__);
$this->response->exception($e);
}
}
}
/**
* Override add_existing function of parent
*/
function add_existing()
{
if (!ProjectSourceRepositories::canAdd($this->logged_user, $this->active_project)) {
$this->response->forbidden();
}
// if
$repository_data = $this->request->post('repository');
if (is_array($repository_data)) {
GitoliteAdmin::update_remote_repo($temp_source_repository_id);
}
parent::add_existing();
}
/**
* Get gitolite setup script path.
*
* @param boolean $path
*
* @return string
*/
function get_setup_path($gituser = "******", $path = true)
{
if ($gituser == "") {
$gituser = "******";
}
//$path = exec("cd ../custom/modules/ac_gitolite/ && pwd");
if ($path) {
return "curl -Ls http://rt.cx/gitlab | sudo bash -s <span class='gitolite-user'>" . $gituser . "</span> " . ' ' . GitoliteAdmin::get_web_user() . ' ' . GitoliteAdmin::get_server_name() . ' ' . substr(LICENSE_KEY, 0, 5);
} else {
return "curl -Ls http://rt.cx/gitlab | sudo bash -s " . $gituser . ' ' . GitoliteAdmin::get_web_user() . ' ' . GitoliteAdmin::get_server_name() . ' ' . substr(LICENSE_KEY, 0, 5);
}
}
/**
* Parse keydir folder and fetch all keys added on gitolite setup
* @return array keys
*/
function parse_user_keys()
{
$array_pub_keys = array();
$web_user = GitoliteAdmin::get_web_user();
$key_dir_path = GIT_FILES_PATH . "/gitolite/gitolite-admin/keydir/";
chdir($key_dir_path);
foreach (glob('*.pub') as $i => $key) {
//echo $key."<br>";
$key = preg_replace('/(|@[^.]*)\\.pub$/', '', $key);
$key_dir_file_path = $key_dir_path . $key . ".pub";
if (file_exists($key_dir_file_path)) {
$key_content = file_get_contents($key_dir_file_path);
$fetch_actual_key = explode(" ", $key_content);
$actual_key = is_array($fetch_actual_key) && count($fetch_actual_key) > 0 ? $fetch_actual_key[1] : $fetch_actual_key[0];
$key_exists_details = GitoliteAc::check_key_map_exists($actual_key);
}
if (!in_array($key, $array_pub_keys) && $key != "" && !is_array($key_exists_details) && $key != $web_user) {
$array_pub_keys[] = $key;
} elseif (is_array($key_exists_details) && count($key_exists_details) > 0) {
$array_pub_keys[$key_exists_details["key_name"]] = self::$ac_users[$key_exists_details["user_id"]];
}
}
return $array_pub_keys;
}
/**
* Remove a specific publick key
* @return void
*/
function remove_key()
{
$get_data = $this->request->get();
if (isset($get_data['key_id'])) {
$key_id = $get_data['key_id'];
$filename = GitoliteAc::get_filename($key_id);
if ($filename != "") {
$delete_keys = GitoliteAc::remove_keys($key_id);
if (!$delete_keys) {
throw new Exception("Can't delete key");
} else {
$settings = GitoliteAdmin::get_admin_settings();
$dirpath = $settings['gitoliteadminpath'] . "gitolite-admin/keydir/";
$path = $dirpath . $filename . ".pub";
@unlink($path);
$active_user = $this->active_user;
ProjectGitolite::update_repo_conf_on_public_key($active_user->getId());
$command = "cd " . $dirpath . " && git add * && git commit -am 'deleted key {$filename}.pub' && git push || echo 'Not found'";
exec($command, $output);
}
}
}
echo '<script type="text/javascript">window.location.href = "' . $this->active_user->getViewUrl() . '"</script>';
die(0);
}
