lib.SVNAdmin
[ class tree: lib.SVNAdmin ] [ index: lib.SVNAdmin ] [ all elements ]

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. var $use_fs_locks = true;
  31. var $lock_handle;
  32. /**
  33. * Konstruktor der Klasse. Hier wird der aktuelle Benutzer
  34. * initialisiert und geladen. Weiterhin wird die Konfiguration
  35. * geladen, damit diese Benutzt werden kann
  36. *
  37. * @param String $username Der aktuelle Benutzername
  38. * @param String $pass Das Passwort
  39. * @access public
  40. */
  41. function SVNAdmin($username, $pass) {
  42. $this->current_user = $username;
  43. $this->pass = $pass;
  44. if ($this->_aquireExclusiveLock())
  45. {
  46. //Laden der Konfiguration
  47. if (!$this->_loadRepositoryFile())
  48. {
  49. $this->error_list[] = "Konnte Objekt nicht korrekt erzeugen";
  50. foreach ($this->error_list as $error) {
  51. echo $error;
  52. }
  53. die();
  54. }
  55. $this->_releaseExclusiveLock();
  56. } else {
  57. die("Dateisystemfehler");
  58. }
  59. //Ab hier fertig für Aufträge
  60. }
  61. /**
  62. * Diese Methode erstellt ein neues Repository im Kontext
  63. * des aktuellen Benutzers. Dazu wird mittels
  64. * <code>svn create</code> ein neues Repository angelegt und dann der Benutzer
  65. * hinzugefügt.
  66. *
  67. * @param String $rep_name Der Name des Repositories
  68. * @return Boolean
  69. * @access public
  70. */
  71. function createRepository($rep_name)
  72. {
  73. if ($this->_aquireExclusiveLock())
  74. {
  75. //Laden der Repository Konfiguration
  76. $this->_loadRepositoryFile();
  77. //Zurücksetzen der Fehlermeldungen
  78. $this->error_list = array();
  79. //Als erstes überprüfen, ob Rep schon ex.
  80. if (!$this->_checkIfRepositoryExists($rep_name))
  81. {
  82. //Wechseln in SVN Parent Path
  83. //merken des eigenen pfades
  84. $old_path = getcwd();
  85. chdir($this->_svn_parent_path);
  86. //Ausführen von svnadmin create
  87. $line = system("svnadmin create $rep_name", $return);
  88. //und wieder verzeichnis wechseln
  89. chdir($old_path);
  90. //Nun Rep zu Datei hinzu und die Konfig schreiben
  91. $rep = $this->_repository_list[$rep_name];
  92. $rep['owner'] = $this->current_user;
  93. $this->_repository_list[$rep_name] = $rep;
  94. //Speichern der Konfig
  95. $this->_writeRepositoryFile();
  96. //Den aktuellen Benutzer mit vollen Rechten hinzu
  97. //plus das owner feld
  98. $this->_releaseExclusiveLock();
  99. $this->addUserToRepository($this->current_user, $rep_name, "rw");
  100. return true;
  101. } else
  102. {
  103. $this->_releaseExclusiveLock();
  104. return false;
  105. }
  106. }
  107. $this->error_list[] = "Dateisystemfehler";
  108. return false;
  109. }
  110. /**
  111. * Diese Methode löscht ein Repository aus dem Stammverzeichnis
  112. * dise geschieht durch aufrufen von <code>rm -Rf</code>
  113. *
  114. * @param String $rep_name Der Name des Repositorys
  115. * @return Boolean
  116. * @access public
  117. */
  118. function deleteRepository($rep_name)
  119. {
  120. if ($this->_aquireExclusiveLock())
  121. {
  122. //Laden der Repository Konfiguration
  123. $this->_loadRepositoryFile();
  124. if ($this->_checkIfUserIsRepOwner($rep_name))
  125. {
  126. unset($this->_repository_list[$rep_name]);
  127. $this->_writeRepositoryFile();
  128. //Wechseln in SVN Parent Path
  129. //merken des eigenen pfades
  130. $old_path = getcwd();
  131. chdir($this->_svn_parent_path);
  132. //Ausführen von svnadmin create
  133. $line = system("rm -Rf $rep_name", $return);
  134. //und wieder verzeichnis wechseln
  135. chdir($old_path);
  136. $this->_releaseExclusiveLock();
  137. return true;
  138. }
  139. $this->_releaseExclusiveLock();
  140. return false;
  141. }
  142. $this->error_list[] = "Dateisystemfehler";
  143. return false;
  144. }
  145. /**
  146. * Diese Methode fügt einen Bentzer zu dem Repository hinzu
  147. *
  148. * @param String $user der neue Benutzer
  149. * @param String $rep_name Der Name des Repositorys
  150. * @param String $rights Die Rechte des Benutzers
  151. * @return Boolean
  152. * @access public
  153. */
  154. function addUserToRepository($user, $rep_name, $rights)
  155. {
  156. if ($this->_aquireExclusiveLock())
  157. {
  158. //Laden der Repository Konfiguration
  159. $this->_loadRepositoryFile();
  160. if ($this->_checkIfRepositoryExists($rep_name) &&
  161. $this->_checkIfUserIsRepOwner($rep_name) &&
  162. !$this->_checkIfUserExistsInRep($rep_name, $user) &&
  163. $this->_checkIfUserExists($user))
  164. {
  165. $rep = $this->_repository_list[$rep_name];
  166. $rep[$user] = $rights;
  167. $this->_repository_list[$rep_name] = $rep;
  168. $this->_writeRepositoryFile();
  169. $this->_releaseExclusiveLock();
  170. return true;
  171. }
  172. $this->_releaseExclusiveLock();
  173. return false;
  174. }
  175. $this->error_list[] = "Dateisystemfehler";
  176. return false;
  177. }
  178. /**
  179. * Diese Methode entfernt einen Benutzer aus dem Repository.
  180. *
  181. * @param String $user Der zu entfernende Benutzer
  182. * @param String $rep_name Der Name des Repositorys
  183. * @return Boolean
  184. * @access public
  185. */
  186. function removeUserFromRepository($user, $rep_name)
  187. {
  188. if ($this->_aquireExclusiveLock())
  189. {
  190. //Laden der Repository Konfiguration
  191. $this->_loadRepositoryFile();
  192. if ($this->_checkIfRepositoryExists($rep_name) &&
  193. $this->_checkIfUserIsRepOwner($rep_name) &&
  194. $this->_checkIfUserExistsInRep($rep_name, $user))
  195. {
  196. unset($this->_repository_list[$rep_name][$user]);
  197. $this->_writeRepositoryFile();
  198. $this->_releaseExclusiveLock();
  199. return true;
  200. }
  201. $this->_releaseExclusiveLock();
  202. return false;
  203. }
  204. $this->error_list[] = "Dateisystemfehler";
  205. return false;
  206. }
  207. /**
  208. * Diese Funktion löscht einen Benutzer aus der globalen
  209. * Benutzerliste
  210. *
  211. * @param String $user Der Benutzer
  212. */
  213. function deleteUser($user)
  214. {
  215. }
  216. /**
  217. * Diese Methode verändert die Zugriffsrechte eines Benutzers
  218. * in einem Repository.
  219. *
  220. * @param String $user Der zu verändernde Benutzer
  221. * @param String $rep_name Der Name des Repositorys
  222. * @param String $rights Die neuen Benutzerrechte
  223. * @return boolean
  224. * @access public
  225. */
  226. function changeUserRights($user, $rep_name, $rights)
  227. {
  228. if ($this->_aquireExclusiveLock())
  229. {
  230. //Laden der Repository Konfiguration
  231. $this->_loadRepositoryFile();
  232. if ($this->_checkIfRepositoryExists($rep_name) &&
  233. $this->_checkIfUserIsRepOwner($rep_name) &&
  234. $this->_checkIfUserExistsInRep($rep_name, $user))
  235. {
  236. $this->_repository_list[$rep_name][$user] = $rights;
  237. $this->_writeRepositoryFile();
  238. $this->_releaseExclusiveLock();
  239. return true;
  240. }
  241. $this->_releaseExclusiveLock();
  242. return false;
  243. }
  244. $this->error_list[] = "Dateisystemfehler";
  245. return false;
  246. }
  247. /**
  248. * Diese Funktion liefert die Benutzer eines ausgewählten
  249. * Repositorys zurück
  250. *
  251. * @param String $rep_name Der Name des Repositorys
  252. * @return Array
  253. * @access public
  254. */
  255. function getRepositoryUsers($rep_name)
  256. {
  257. if ($this->_aquireExclusiveLock())
  258. {
  259. //Laden der Repository Konfiguration
  260. $this->_loadRepositoryFile();
  261. if ($this->_checkIfRepositoryExists($rep_name) && $this->_checkIfUserIsRepOwner($rep_name))
  262. {
  263. $this->_releaseExclusiveLock();
  264. return $this->_getUserByRepository($rep_name);
  265. }
  266. $this->_releaseExclusiveLock();
  267. return false;
  268. }
  269. $this->error_list[] = "Dateisystemfehler";
  270. return false;
  271. }
  272. /**
  273. * Liest alle Repositories des aktuellen Benutzers aus
  274. * und liefert diese in einem Array zurück.
  275. *
  276. * @package String $user Der Benutzer
  277. * @return Array
  278. * @access public
  279. */
  280. function getUserRepositories($user)
  281. {
  282. if ($this->_aquireExclusiveLock())
  283. {
  284. //Laden der Repository Konfiguration
  285. $this->_loadRepositoryFile();
  286. $out = array();
  287. foreach ($this->_repository_list as $key => $rep) {
  288. if ($rep['owner'] == $user)
  289. {
  290. $out[$key] = $rep;
  291. }
  292. }
  293. $this->_releaseExclusiveLock();
  294. return $out;
  295. }
  296. $this->error_list[] = "Dateisystemfehler";
  297. return false;
  298. }
  299. /**
  300. * Liefert die Liste aller global registrierten Benutzer zurück.
  301. *
  302. * @return Array
  303. * @access public
  304. */
  305. function getAllRegisteredUsers()
  306. {
  307. if ($this->_aquireExclusiveLock())
  308. {
  309. //Laden der Repository Konfiguration
  310. $this->_loadRepositoryFile();
  311. $this->_releaseExclusiveLock();
  312. return array_keys($this->user_list);
  313. }
  314. $this->error_list[] = "Dateisystemfehler";
  315. return false;
  316. }
  317. function getRegisteredUserByName($username)
  318. {
  319. }
  320. /**
  321. * Diese Methode erzeugt ein HTAccess Password mittels
  322. * der Funktion htpasswd. Diese wird benutzt, da unter Windows Probleme mit
  323. * dem manuellen Crypt auftreten können.
  324. */
  325. function addGlobalUser($username, $password)
  326. {
  327. if ($this->_aquireExclusiveLock())
  328. {
  329. if (is_string($username) && $password )
  330. {
  331. if (!$this->_checkIfUserExists($username))
  332. {
  333. //Laden von htpasswd
  334. $line = exec("htpasswd -bn $username $password", $out);
  335. $linearr = explode(":", $out[0]);
  336. $this->_loadRepositoryFile();
  337. $res = $this->user_list[$username] = $linearr[1];
  338. $res2 = $this->_writeRepositoryFile();
  339. $res3 = $this->_writePasswordFile();
  340. $this->_releaseExclusiveLock();
  341. return $res && $res2 && $res3;
  342. } else {
  343. $this->_releaseExclusiveLock();
  344. $this->error_list[] = "Der gewählte Benutzer existiert schon";
  345. return false;
  346. }
  347. } else {
  348. $this->_releaseExclusiveLock();
  349. $this->error_list[] = "Benutzername oder Passwort nicht vollständig eingegeben.";
  350. return false;
  351. }
  352. }
  353. $this->error_list[] = "Dateisystemfehler";
  354. return false;
  355. }
  356. ///////////////////////////////////////////////////////////////
  357. // Hilfsfunktionen
  358. ///////////////////////////////////////////////////////////////
  359. /**
  360. * Liefert alle Benutzer des Repositorys zurück. Spezielle Felder
  361. * in der INI Datei werden dabei ignoriert
  362. *
  363. * @param String $rep_name Der Name des Repositorys
  364. * @return Array
  365. * @access privcate
  366. */
  367. function _getUserByRepository($rep_name)
  368. {
  369. $rep = $this->_repository_list[$rep_name];
  370. unset($rep['owner']);
  371. return $rep;
  372. }
  373. /**
  374. * Diese Methode läd die Repository Konfiguration aus der
  375. * angegebenen Datei. Die liste wird dabei global in die Klasse
  376. * geschrien
  377. * @access private
  378. */
  379. function _loadRepositoryFile()
  380. {
  381. //Erstellen der INI Klasse und öffnen der Datei
  382. $this->_repository_list = IniController::parse_ini_file($this->_config_file_name);
  383. //Laden der Benutzer und Passwörter
  384. $this->_parsePasswordFile();
  385. if (empty($this->_repository_list))
  386. $this->_repository_list = array();
  387. if (!is_array($this->_repository_list))
  388. {
  389. $this->error_list[] = "Fehler beim laden der INI Datei";
  390. return false;
  391. }
  392. return true;
  393. }
  394. /**
  395. * Diese Methode schreibt die nötigen Änderungen wieder in die entsprechenden INI
  396. * Dateien. Dabei wird nicht nur die lokale Konfiguration geschrieben sondern auch
  397. * die Konfiguration für Subversion selbst.
  398. *
  399. * @return boolean
  400. * @access private
  401. */
  402. function _writeRepositoryFile()
  403. {
  404. $res = IniController::save_ini_file($this->_config_file_name, $this->_repository_list);
  405. $res_svn = IniController::save_ini_file($this->_svn_config_file, $this->_repository_list, true, true);
  406. if ($res && $res_svn)
  407. {
  408. return true;
  409. }
  410. $this->error_list[] = $ini_class->writeError;
  411. $this->_loadRepositoryFile();
  412. $this->_parsePasswordFile();
  413. return false;
  414. }
  415. /**
  416. * Diese Methode überprüft, ob das angegebene Repository existiert. Dazu
  417. * wird die lokale Liste der Repositorys überprüft.
  418. *
  419. * @param String $rep_name Der Name des Repositorys
  420. * @return boolean
  421. * @access private
  422. */
  423. function _checkIfRepositoryExists($rep_name)
  424. {
  425. //Das Repository muss als Schlüssel in der
  426. //globalen Kofig stehen
  427. if (array_key_exists($rep_name, $this->_repository_list))
  428. {
  429. return true;
  430. }
  431. $this->error_list[] ='Das gewählte Repository existiert nicht';
  432. return false;
  433. }
  434. /**
  435. * Diese Methode überprüft, ob der aktuelle Benutzer der Besitzter
  436. * des Repositorys ist
  437. *
  438. * @param String $rep_name Der Name des Repositorys
  439. * @return boolean
  440. * @access private
  441. */
  442. function _checkIfUserIsRepOwner($rep_name)
  443. {
  444. $rep = $this->_repository_list[$rep_name];
  445. if ($rep['owner'] == $this->current_user)
  446. return true;
  447. else {
  448. $this->error_list[] = "Der angemeldete Benutzer ist nicht Besitzer des Repositorys";
  449. return false;
  450. }
  451. }
  452. /**
  453. * Diese Methode überprüft, ob ein Benutzer in dem Repository existiert
  454. *
  455. * @param String $rep_name Der Name des Repositorys
  456. * @param String $user Der Benutzer
  457. * @return boolean
  458. * @access private
  459. */
  460. function _checkIfUserExistsInRep($rep_name, $user)
  461. {
  462. $rep = $this->_repository_list[$rep_name];
  463. if (array_key_exists($user, $rep))
  464. return true;
  465. else
  466. return false;
  467. }
  468. /**
  469. * Die Methode überprüft, ob ein Benutzer überhaupt existiert
  470. *
  471. * @param String $user Der Benutzer
  472. * @return boolean
  473. * @access private
  474. */
  475. function _checkIfUserExists($user)
  476. {
  477. $users = array_keys($this->user_list);
  478. if (in_array($user, $users))
  479. return true;
  480. else {
  481. $this->error_list[] = "Der gewünschte Benutzer exisitiert nicht.";
  482. return false;
  483. }
  484. }
  485. /**
  486. * Diese Methode parst ene <code>htpasswd</code> Datei
  487. * um daraus die Benuternamen und die gehashten Passwörter
  488. * zu extrahieren
  489. *
  490. * @access private
  491. * @return boolean
  492. *
  493. */
  494. function _parsePasswordFile()
  495. {
  496. $cts = file_get_contents($this->_svn_password_file);
  497. if ($cts)
  498. {
  499. $user_list_raw = explode("\n", $cts);
  500. foreach ($user_list_raw as $val) {
  501. $tmp = explode(":", $val);
  502. if ($tmp[0] != "")
  503. $this->user_list[$tmp[0]] = $tmp[1];
  504. }
  505. return true;
  506. }
  507. return false;
  508. }
  509. /**
  510. * Diese Methode schreibt ene <code>htpasswd</code> Datei
  511. *
  512. * @access private
  513. * @return boolean
  514. *
  515. */
  516. function _writePasswordFile()
  517. {
  518. $cts = "";
  519. foreach ($this->user_list as $key => $val) {
  520. $cts.=$key.":".$val."\n";
  521. }
  522. $fid = fopen($this->_svn_password_file, "w+");
  523. if ($fid)
  524. {
  525. fwrite($fid, $cts);
  526. fclose($fid);
  527. return true;
  528. }
  529. $this->error_list[] = "Konnte Passwort Datei nicht schreiben.";
  530. return false;
  531. }
  532. /**
  533. * Diese Funktion legt eine globale Schreibsperre auf die Konfigurationsdateien.
  534. * Diese Funktion funktioniert solange, wie nur auf die public Methoden zugegriffen
  535. * wird. Dies ist der Tribut an die Performance.
  536. *
  537. * @access private
  538. * @return boolean
  539. */
  540. function _aquireExclusiveLock()
  541. {
  542. if ($this->use_fs_locks)
  543. {
  544. $fid = fopen("file.lck", "w+");
  545. if ($fid)
  546. {
  547. $res = flock($fid, LOCK_EX);
  548. if ($res)
  549. {
  550. $this->lock_handle = $fid;
  551. return true;
  552. } else
  553. return false;
  554. }
  555. return false;
  556. }
  557. return true;
  558. }
  559. /**
  560. * Diese Funktion hebt die Schreibsperre auf die Konfigurationsdateien
  561. * wieder auf.
  562. *
  563. * @access private
  564. * @return boolean
  565. */
  566. function _releaseExclusiveLock()
  567. {
  568. if ($this->use_fs_locks)
  569. {
  570. $res = flock($this->lock_handle, LOCK_UN);
  571. fclose($this->lock_handle);
  572. unlink("file.lck");
  573. if ($res)
  574. {
  575. $this->lock_handle = null;
  576. return true;
  577. }
  578. else
  579. return false;
  580. }
  581. return true;
  582. }
  583. }
  584.  
  585.  
  586. ?>

Documentation generated on Mon, 23 May 2005 22:13:23 +0200 by phpDocumentor 1.3.0RC3