Source for file svnadmin.class.php

Documentation is available at svnadmin.class.php

  1. <?php
  2. /**
  3. * Diese Klasse dient dazu die Repositories zu verwalten
  4. * wird später mehr Funktionalität gewünscht, kann diese in dieser
  5. * Klasse hinzugefügt werden. Damit nur authorisierte Benutzer
  6. * Repositories wieder löschen können, werden alle reps und deren
  7. * Ersteller in einer eigenen INI Datei verwaltet. Dabei werden alle Benutzer
  8. * die zu einem Repository hinzugefügt werden können in einer separaten htpasswd
  9. * Datei verwaltet. Die Zugriffsrechte für die Repositorys werden doppelt gespeichert
  10. * einmal in der Datei <code>$_config_file_name</code> und in der Konfigurationsdatei
  11. * die von Subversion direkt benutzt wird. So ist es möglich in der Konfigurationsdatei
  12. * die im lokalem Programm benutzt wird weitere Informationen hinzuzufügen.
  13. *
  14. * @copyright 2005 Hasso-Plattner-Institut für Softwaresystemtechnik
  15. * @author Martin Grund
  16. * @link http://www.grundprinzip.de
  17. * @version 1.0
  18. */
  19. class SVNAdmin {
  20.  
  21. var $_repository_list = array();
  22. var $_config_file_name = "rep_list.ini";
  23. var $_svn_config_file = "c:/xampp5/svn/usr_config.cfg";
  24. var $_svn_password_file = "c:/xampp5/svn/usr_list";
  25. var $_svn_parent_path = "c:/xampp5/svn";
  26. var $current_user = null;
  27. var $pass = null;
  28. var $error_list = array();
  29. var $user_list = array();
  30. /**
  31. * Konstruktor der Klasse. Hier wird der aktuelle Benutzer
  32. * initialisiert und geladen. Weiterhin wird die Konfiguration
  33. * geladen, damit diese Benutzt werden kann
  34. *
  35. * @param String $username Der aktuelle Benutzername
  36. * @param String $pass Das Passwort
  37. * @access public
  38. */
  39. function SVNAdmin($username, $pass) {
  40. $this->current_user = $username;
  41. $this->pass = $pass;
  42. //Laden der Konfiguration
  43. if (!$this->_loadRepositoryFile())
  44. {
  45. $this->error_list[] = "Konnte Objekt nicht korrekt erzeugen";
  46. foreach ($this->error_list as $error) {
  47. echo $error;
  48. }
  49. die();
  50. }
  51. //Ab hier fertig für Aufträge
  52. }
  53. /**
  54. * Diese Methode erstellt ein neues Repository im Kontext
  55. * des aktuellen Benutzers. Dazu wird mittels
  56. * <code>svn create</code> ein neues Repository angelegt und dann der Benutzer
  57. * hinzugefügt.
  58. *
  59. * @param String $rep_name Der Name des Repositories
  60. * @return Boolean
  61. * @access public
  62. */
  63. function createRepository($rep_name)
  64. {
  65. //Zurücksetzen der Fehlermeldungen
  66. $this->error_list = array();
  67. //Als erstes überprüfen, ob Rep schon ex.
  68. if (!$this->_checkIfRepositoryExists($rep_name))
  69. {
  70. //Wechseln in SVN Parent Path
  71. //merken des eigenen pfades
  72. $old_path = getcwd();
  73. chdir($this->_svn_parent_path);
  74. //Ausführen von svnadmin create
  75. $line = system("svnadmin create $rep_name", $return);
  76. //und wieder verzeichnis wechseln
  77. chdir($old_path);
  78. //Nun Rep zu Datei hinzu und die Konfig schreiben
  79. $rep = $this->_repository_list[$rep_name];
  80. $rep['owner'] = $this->current_user;
  81. $this->_repository_list[$rep_name] = $rep;
  82. //Speichern der Konfig
  83. $this->_writeRepositoryFile();
  84. //Den aktuellen Benutzer mit vollen Rechten hinzu
  85. //plus das owner feld
  86. $this->addUserToRepository($this->current_user, $rep_name, "rw");
  87. return true;
  88. } else
  89. return false;
  90. }
  91. /**
  92. * Diese Methode löscht ein Repository aus dem Stammverzeichnis
  93. * dise geschieht durch aufrufen von <code>rm -Rf</code>
  94. *
  95. * @param String $rep_name Der Name des Repositorys
  96. * @return Boolean
  97. * @access public
  98. */
  99. function deleteRepository($rep_name)
  100. {
  101. if ($this->_checkIfUserIsRepOwner($rep_name))
  102. {
  103. unset($this->_repository_list[$rep_name]);
  104. $this->_writeRepositoryFile();
  105. //Wechseln in SVN Parent Path
  106. //merken des eigenen pfades
  107. $old_path = getcwd();
  108. chdir($this->_svn_parent_path);
  109. //Ausführen von svnadmin create
  110. $line = system("rm -Rf $rep_name", $return);
  111. //und wieder verzeichnis wechseln
  112. chdir($old_path);
  113. return true;
  114. }
  115. return false;
  116. }
  117. /**
  118. * Diese Methode fügt einen Bentzer zu dem Repository hinzu
  119. *
  120. * @param String $user der neue Benutzer
  121. * @param String $rep_name Der Name des Repositorys
  122. * @param String $rights Die Rechte des Benutzers
  123. * @return Boolean
  124. * @access public
  125. */
  126. function addUserToRepository($user, $rep_name, $rights)
  127. {
  128. if ($this->_checkIfRepositoryExists($rep_name) &&
  129. $this->_checkIfUserIsRepOwner($rep_name) &&
  130. !$this->_checkIfUserExistsInRep($rep_name, $user) &&
  131. $this->_checkIfUserExists($user))
  132. {
  133. $rep = $this->_repository_list[$rep_name];
  134. $rep[$user] = $rights;
  135. $this->_repository_list[$rep_name] = $rep;
  136. $this->_writeRepositoryFile();
  137. return true;
  138. }
  139. return false;
  140. }
  141. /**
  142. * Diese Methode entfernt einen Benutzer aus dem Repository.
  143. *
  144. * @param String $user Der zu entfernende Benutzer
  145. * @param String $rep_name Der Name des Repositorys
  146. * @return Boolean
  147. * @access public
  148. */
  149. function removeUserFromRepository($user, $rep_name)
  150. {
  151. if ($this->_checkIfRepositoryExists($rep_name) &&
  152. $this->_checkIfUserIsRepOwner($rep_name) &&
  153. $this->_checkIfUserExistsInRep($rep_name, $user))
  154. {
  155. unset($this->_repository_list[$rep_name][$user]);
  156. $this->_writeRepositoryFile();
  157. return true;
  158. }
  159. return false;
  160. }
  161. /**
  162. * Diese Funktion löscht einen Benutzer aus der globalen
  163. * Benutzerliste
  164. *
  165. * @param String $user Der Benutzer
  166. */
  167. function deleteUser($user)
  168. {
  169. }
  170. /**
  171. * Diese Methode verändert die Zugriffsrechte eines Benutzers
  172. * in einem Repository.
  173. *
  174. * @param String $user Der zu verändernde Benutzer
  175. * @param String $rep_name Der Name des Repositorys
  176. * @param String $rights Die neuen Benutzerrechte
  177. * @return boolean
  178. * @access public
  179. */
  180. function changeUserRights($user, $rep_name, $rights)
  181. {
  182. if ($this->_checkIfRepositoryExists($rep_name) &&
  183. $this->_checkIfUserIsRepOwner($rep_name) &&
  184. $this->_checkIfUserExistsInRep($rep_name, $user))
  185. {
  186. $this->_repository_list[$rep_name][$user] = $rights;
  187. $this->_writeRepositoryFile();
  188. return true;
  189. }
  190. return false;
  191. }
  192. /**
  193. * Diese Funktion liefert die Benutzer eines ausgewählten
  194. * Repositorys zurück
  195. *
  196. * @param String $rep_name Der Name des Repositorys
  197. * @return Array
  198. * @access public
  199. */
  200. function getRepositoryUsers($rep_name)
  201. {
  202. if ($this->_checkIfRepositoryExists($rep_name) && $this->_checkIfUserIsRepOwner($rep_name))
  203. {
  204. return $this->_getUserByRepository($rep_name);
  205. }
  206. return false;
  207. }
  208. /**
  209. * Liest alle Repositories des aktuellen Benutzers aus
  210. * und liefert diese in einem Array zurück.
  211. *
  212. * @package String $user Der Benutzer
  213. * @return Array
  214. * @access public
  215. */
  216. function getUserRepositories($user)
  217. {
  218. $out = array();
  219. foreach ($this->_repository_list as $key => $rep) {
  220. if ($rep['owner'] == $user)
  221. {
  222. $out[$key] = $rep;
  223. }
  224. }
  225. return $out;
  226. }
  227. /**
  228. * Liefert die Liste aller global registrierten Benutzer zurück.
  229. *
  230. * @return Array
  231. * @access public
  232. */
  233. function getAllRegisteredUsers()
  234. {
  235. return array_keys($this->user_list);
  236. }
  237. function getRegisteredUserByName($username)
  238. {
  239. }
  240. ///////////////////////////////////////////////////////////////
  241. // Hilfsfunktionen
  242. ///////////////////////////////////////////////////////////////
  243. function _getUserByRepository($rep_name)
  244. {
  245. $rep = $this->_repository_list[$rep_name];
  246. unset($rep['owner']);
  247. return $rep;
  248. }
  249. function _loadRepositoryFile()
  250. {
  251. //Erstellen der INI Klasse und öffnen der Datei
  252. $this->_repository_list = IniController::parse_ini_file($this->_config_file_name);
  253. //Laden der Benutzer und Passwörter
  254. $this->_parsePasswordFile();
  255. if (empty($this->_repository_list))
  256. $this->_repository_list = array();
  257. if (!is_array($this->_repository_list))
  258. {
  259. $this->error_list[] = "Fehler beim laden der INI Datei";
  260. return false;
  261. }
  262. return true;
  263. }
  264. function _writeRepositoryFile()
  265. {
  266. $res = IniController::save_ini_file($this->_config_file_name, $this->_repository_list);
  267. $res_svn = IniController::save_ini_file($this->_svn_config_file, $this->_repository_list, true, true);
  268. if ($res && $res_svn)
  269. {
  270. return true;
  271. }
  272. $this->error_list[] = $ini_class->writeError;
  273. $this->_loadRepositoryFile();
  274. $this->_parsePasswordFile();
  275. return false;
  276. }
  277. function _checkIfRepositoryExists($rep_name)
  278. {
  279. //Das Repository muss als Schlüssel in der
  280. //globalen Kofig stehen
  281. if (array_key_exists($rep_name, $this->_repository_list))
  282. {
  283. return true;
  284. }
  285. $this->error_list[] ='Das gewählte Repository existiert nicht';
  286. return false;
  287. }
  288. function _checkIfUserIsRepOwner($rep_name)
  289. {
  290. $rep = $this->_repository_list[$rep_name];
  291. if ($rep['owner'] == $this->current_user)
  292. return true;
  293. else {
  294. $this->error_list[] = "Der angemeldete Benutzer ist nicht Besitzer des Repositorys";
  295. return false;
  296. }
  297. }
  298. function _checkIfUserExistsInRep($rep_name, $user)
  299. {
  300. $rep = $this->_repository_list[$rep_name];
  301. if (array_key_exists($user, $rep))
  302. return true;
  303. else
  304. return false;
  305. }
  306. function _checkIfUserExists($user)
  307. {
  308. $users = array_keys($this->user_list);
  309. if (in_array($user, $users))
  310. return true;
  311. else {
  312. $this->error_list[] = "Der gewünschte Benutzer exisitiert nicht.";
  313. return false;
  314. }
  315. }
  316. function _parsePasswordFile()
  317. {
  318. $cts = file_get_contents($this->_svn_password_file);
  319. if ($cts)
  320. {
  321. $user_list_raw = explode("\n", $cts);
  322. foreach ($user_list_raw as $val) {
  323. $tmp = explode(":", $val);
  324. if ($tmp[0] != "")
  325. $this->user_list[$tmp[0]] = $tmp[1];
  326. }
  327. return true;
  328. }
  329. return false;
  330. }
  331. function _writePasswordFile()
  332. {
  333. $cts = "";
  334. foreach ($this->user_list as $key => $val) {
  335. $cts.=$key.":".$val."\n";
  336. }
  337. $fid = fopen($this->_svn_password_file, "w+");
  338. if ($fid)
  339. {
  340. fwrite($fid, $cts);
  341. fclose($fid);
  342. }
  343. $this->error_list[] = "Konnte Passwort Datei nicht schreiben.";
  344. return false;
  345. }
  346. }
  347.  
  348.  
  349. ?>

Documentation generated on Sun, 22 May 2005 23:51:09 +0200 by phpDocumentor 1.3.0RC3