From 27ae9095639bb228a1b7ff86a3ebe4264abf05be Mon Sep 17 00:00:00 2001
From: mschaefers <mschaefers@scoop-gmbh.de>
Date: Thu, 29 Nov 2012 12:33:09 -0500
Subject: [PATCH] feature: when using LdapUserService one can configure Gitblit to fetch all users from ldap that can possibly login. This allows to see newly generated LDAP users instantly in Gitblit. By now an LDAP user had to log in once to appear in GitBlit.

---
 src/com/gitblit/utils/FileUtils.java |  127 ++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 127 insertions(+), 0 deletions(-)

diff --git a/src/com/gitblit/utils/FileUtils.java b/src/com/gitblit/utils/FileUtils.java
index 29c9d0f..0b8aeb4 100644
--- a/src/com/gitblit/utils/FileUtils.java
+++ b/src/com/gitblit/utils/FileUtils.java
@@ -34,6 +34,90 @@
  * 
  */
 public class FileUtils {
+	
+	/** 1024 (number of bytes in one kilobyte) */
+	public static final int KB = 1024;
+
+	/** 1024 {@link #KB} (number of bytes in one megabyte) */
+	public static final int MB = 1024 * KB;
+
+	/** 1024 {@link #MB} (number of bytes in one gigabyte) */
+	public static final int GB = 1024 * MB;
+
+	/**
+	 * Returns an int from a string representation of a file size.
+	 * e.g. 50m = 50 megabytes
+	 * 
+	 * @param aString
+	 * @param defaultValue
+	 * @return an int value or the defaultValue if aString can not be parsed
+	 */
+	public static int convertSizeToInt(String aString, int defaultValue) {
+		return (int) convertSizeToLong(aString, defaultValue);
+	}
+	
+	/**
+	 * Returns a long from a string representation of a file size.
+	 * e.g. 50m = 50 megabytes
+	 * 
+	 * @param aString
+	 * @param defaultValue
+	 * @return a long value or the defaultValue if aString can not be parsed
+	 */
+	public static long convertSizeToLong(String aString, long defaultValue) {
+		// trim string and remove all spaces 
+		aString = aString.toLowerCase().trim();
+		StringBuilder sb = new StringBuilder();
+		for (String a : aString.split(" ")) {
+			sb.append(a);
+		}
+		aString = sb.toString();
+		
+		// identify value and unit
+		int idx = 0;
+		int len = aString.length();
+		while (Character.isDigit(aString.charAt(idx))) {
+			idx++;
+			if (idx == len) {
+				break;
+			}
+		}
+		long value = 0;
+		String unit = null;
+		try {
+			value = Long.parseLong(aString.substring(0, idx));
+			unit = aString.substring(idx);
+		} catch (Exception e) {
+			return defaultValue;
+		}
+		if (unit.equals("g") || unit.equals("gb")) {
+			return value * GB;
+		} else if (unit.equals("m") || unit.equals("mb")) {
+			return value * MB;
+		} else if (unit.equals("k") || unit.equals("kb")) {
+			return value * KB;
+		}
+		return defaultValue;
+	}
+	
+	/**
+	 * Returns the byte [] content of the specified file.
+	 * 
+	 * @param file
+	 * @return the byte content of the file
+	 */
+	public static byte [] readContent(File file) {
+		byte [] buffer = new byte[(int) file.length()];
+		try {
+			BufferedInputStream is = new BufferedInputStream(new FileInputStream(file));
+			is.read(buffer,  0,  buffer.length);
+			is.close();
+		} catch (Throwable t) {
+			System.err.println("Failed to read byte content of " + file.getAbsolutePath());
+			t.printStackTrace();
+		}
+		return buffer;
+	}
 
 	/**
 	 * Returns the string content of the specified file.
@@ -149,4 +233,47 @@
 			}
 		}
 	}
+	
+	/**
+	 * Determine the relative path between two files.  Takes into account
+	 * canonical paths, if possible.
+	 * 
+	 * @param basePath
+	 * @param path
+	 * @return a relative path from basePath to path
+	 */
+	public static String getRelativePath(File basePath, File path) {
+		File exactBase = getExactFile(basePath);
+		File exactPath = getExactFile(path);
+		if (path.getAbsolutePath().startsWith(basePath.getAbsolutePath())) {
+			// absolute base-path match
+			return StringUtils.getRelativePath(basePath.getAbsolutePath(), path.getAbsolutePath());
+		} else if (exactPath.getPath().startsWith(exactBase.getPath())) {
+			// canonical base-path match
+			return StringUtils.getRelativePath(exactBase.getPath(), exactPath.getPath());
+		} else if (exactPath.getPath().startsWith(basePath.getAbsolutePath())) {
+			// mixed path match
+			return StringUtils.getRelativePath(basePath.getAbsolutePath(), exactPath.getPath());
+		} else if (path.getAbsolutePath().startsWith(exactBase.getPath())) {
+			// mixed path match
+			return StringUtils.getRelativePath(exactBase.getPath(), path.getAbsolutePath());
+		}
+		// no relative relationship
+		return null;
+	}
+	
+	/**
+	 * Returns the exact path for a file. This path will be the canonical path
+	 * unless an exception is thrown in which case it will be the absolute path.
+	 * 
+	 * @param path
+	 * @return the exact file
+	 */
+	public static File getExactFile(File path) {
+		try {
+			return path.getCanonicalFile();
+		} catch (IOException e) {
+			return path.getAbsoluteFile();
+		}
+	}
 }

--
Gitblit v1.9.1