http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/HttpUtils.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/HttpUtils.java b/utils/src/main/java/com/cloud/utils/HttpUtils.java new file mode 100644 index 0000000..d2e844a --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/HttpUtils.java @@ -0,0 +1,114 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import org.apache.log4j.Logger; + +import javax.servlet.http.Cookie; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import java.io.IOException; +import java.util.Map; + +public class HttpUtils { + + public static final Logger s_logger = Logger.getLogger(HttpUtils.class); + + public static final String UTF_8 = "UTF-8"; + public static final String RESPONSE_TYPE_JSON = "json"; + public static final String RESPONSE_TYPE_XML = "xml"; + public static final String JSON_CONTENT_TYPE = "application/json; charset=UTF-8"; + public static final String XML_CONTENT_TYPE = "text/xml; charset=UTF-8"; + + public static void addSecurityHeaders(final HttpServletResponse resp) { + if (resp.containsHeader("X-Content-Type-Options")) { + resp.setHeader("X-Content-Type-Options", "nosniff"); + } + else { + resp.addHeader("X-Content-Type-Options", "nosniff"); + } + if (resp.containsHeader("X-XSS-Protection")) { + resp.setHeader("X-XSS-Protection", "1;mode=block"); + } + else { + resp.addHeader("X-XSS-Protection", "1;mode=block"); + } + } + + public static void writeHttpResponse(final HttpServletResponse resp, final String response, + final Integer responseCode, final String responseType, final String jsonContentType) { + try { + if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) { + if (jsonContentType != null && !jsonContentType.isEmpty()) { + resp.setContentType(jsonContentType); + } else { + resp.setContentType(JSON_CONTENT_TYPE); + } + } else if (RESPONSE_TYPE_XML.equalsIgnoreCase(responseType)){ + resp.setContentType(XML_CONTENT_TYPE); + } + if (responseCode != null) { + resp.setStatus(responseCode); + } + addSecurityHeaders(resp); + resp.getWriter().print(response); + } catch (final IOException ioex) { + if (s_logger.isTraceEnabled()) { + s_logger.trace("Exception writing http response: " + ioex); + } + } catch (final Exception ex) { + if (!(ex instanceof IllegalStateException)) { + s_logger.error("Unknown exception writing http response", ex); + } + } + } + + public static String findCookie(final Cookie[] cookies, final String key) { + if (cookies == null || key == null || key.isEmpty()) { + return null; + } + for (Cookie cookie: cookies) { + if (cookie != null && cookie.getName().equals(key)) { + return cookie.getValue(); + } + } + return null; + } + + public static boolean validateSessionKey(final HttpSession session, final Map<String, Object[]> params, final Cookie[] cookies, final String sessionKeyString) { + if (session == null || sessionKeyString == null) { + return false; + } + final String sessionKey = (String) session.getAttribute(sessionKeyString); + final String sessionKeyFromCookie = HttpUtils.findCookie(cookies, sessionKeyString); + String[] sessionKeyFromParams = null; + if (params != null) { + sessionKeyFromParams = (String[]) params.get(sessionKeyString); + } + if ((sessionKey == null) + || (sessionKeyFromParams == null && sessionKeyFromCookie == null) + || (sessionKeyFromParams != null && !sessionKey.equals(sessionKeyFromParams[0])) + || (sessionKeyFromCookie != null && !sessionKey.equals(sessionKeyFromCookie))) { + return false; + } + return true; + } + +}
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/IteratorUtil.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/IteratorUtil.java b/utils/src/main/java/com/cloud/utils/IteratorUtil.java new file mode 100644 index 0000000..8ab88f5 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/IteratorUtil.java @@ -0,0 +1,72 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Enumeration; +import java.util.Iterator; +import java.util.List; + +public class IteratorUtil { + public static <T> Iterable<T> enumerationAsIterable(final Enumeration<T> e) { + return new Iterable<T>() { + @Override + public Iterator<T> iterator() { + return new Iterator<T>() { + @Override + public boolean hasNext() { + return e.hasMoreElements(); + } + + @Override + public T next() { + return e.nextElement(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + }; + } + + public static <T> Enumeration<T> iteratorAsEnumeration(final Iterator<T> it) { + return new Enumeration<T>() { + @Override + public boolean hasMoreElements() { + return it.hasNext(); + } + + @Override + public T nextElement() { + return it.next(); + } + }; + } + + public static <T extends Comparable<? super T>> List<T> asSortedList(Collection<T> c) { + List<T> list = new ArrayList<T>(c); + java.util.Collections.sort(list); + return list; + } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/Journal.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/Journal.java b/utils/src/main/java/com/cloud/utils/Journal.java new file mode 100644 index 0000000..e88dba3 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/Journal.java @@ -0,0 +1,104 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.util.ArrayList; + +import org.apache.log4j.Level; +import org.apache.log4j.Logger; + +/** + * Journal is used to kept what has happened during a process so someone can track + * what happens during a process. + * + */ +public class Journal { + String _name; + ArrayList<Pair<String, Object[]>> _entries; + + public Journal(String name) { + _name = name; + _entries = new ArrayList<Pair<String, Object[]>>(); + } + + final private void log(String msg, Object... params) { + Pair<String, Object[]> entry = new Pair<String, Object[]>(msg, params); + assert msg != null : "Message can not be null or else it's useless!"; + _entries.add(entry); + } + + public void record(String msg, Object... params) { + log(msg, params); + } + + public void record(Logger logger, Level p, String msg, Object... params) { + if (logger.isEnabledFor(p)) { + StringBuilder buf = new StringBuilder(); + toString(buf, msg, params); + String entry = buf.toString(); + log(entry); + logger.log(p, entry); + } else { + log(msg, params); + } + } + + protected void toString(StringBuilder buf, String msg, Object[] params) { + buf.append(msg); + if (params != null) { + buf.append(" - "); + int i = 0; + for (Object obj : params) { + buf.append('P').append(i).append('='); + buf.append(obj != null ? obj.toString() : "null"); + buf.append(", "); + } + buf.delete(buf.length() - 2, buf.length()); + } + } + + public String toString(String separator) { + StringBuilder buf = new StringBuilder(_name).append(": "); + for (Pair<String, Object[]> entry : _entries) { + toString(buf, entry.first(), entry.second()); + buf.append(separator); + } + return buf.toString(); + } + + @Override + public String toString() { + return toString("; "); + } + + public static class LogJournal extends Journal { + Logger _logger; + + public LogJournal(String name, Logger logger) { + super(name); + _logger = logger; + } + + @Override + public void record(String msg, Object... params) { + record(_logger, Level.DEBUG, msg, params); + } + } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/LogUtils.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/LogUtils.java b/utils/src/main/java/com/cloud/utils/LogUtils.java new file mode 100644 index 0000000..d86766c --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/LogUtils.java @@ -0,0 +1,45 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.io.File; + +import org.apache.log4j.Logger; +import org.apache.log4j.xml.DOMConfigurator; + +public class LogUtils { + public static final Logger s_logger = Logger.getLogger(LogUtils.class); + + public static void initLog4j(String log4jConfigFileName) { + assert (log4jConfigFileName != null); + File file = PropertiesUtil.findConfigFile(log4jConfigFileName); + if (file != null) { + s_logger.info("log4j configuration found at " + file.getAbsolutePath()); + DOMConfigurator.configureAndWatch(file.getAbsolutePath()); + } else { + String nameWithoutExtension = log4jConfigFileName.substring(0, log4jConfigFileName.lastIndexOf('.')); + file = PropertiesUtil.findConfigFile(nameWithoutExtension + ".properties"); + if (file != null) { + s_logger.info("log4j configuration found at " + file.getAbsolutePath()); + DOMConfigurator.configureAndWatch(file.getAbsolutePath()); + } + } + } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/MethodCapturer.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/MethodCapturer.java b/utils/src/main/java/com/cloud/utils/MethodCapturer.java new file mode 100644 index 0000000..655a45d --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/MethodCapturer.java @@ -0,0 +1,113 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.lang.reflect.Method; +import java.util.WeakHashMap; + +import net.sf.cglib.proxy.Callback; +import net.sf.cglib.proxy.CallbackFilter; +import net.sf.cglib.proxy.Enhancer; +import net.sf.cglib.proxy.MethodInterceptor; +import net.sf.cglib.proxy.MethodProxy; + +/* + * This helper class provides a way to retrieve Method in a strong-type way. It takes advantage of power of + * Intelligent IDE(Eclipse) in code-editing + * + * DummyImpl dummy = new DummyImpl(); + * MethodCapturer<DummyImpl> capturer = MethodCapturer.capture(dummy); + * Method method = capturer.get(capturer.instance().foo2()); + * + */ +public class MethodCapturer<T> { + + private final static int CACHE_SIZE = 1024; + + private T _instance; + private Method _method; + + private static WeakHashMap<Object, Object> s_cache = new WeakHashMap<Object, Object>(); + + private MethodCapturer() { + } + + @SuppressWarnings("unchecked") + public static <T> MethodCapturer<T> capture(T obj) { + synchronized (s_cache) { + MethodCapturer<T> capturer = (MethodCapturer<T>)s_cache.get(obj); + if (capturer != null) { + return capturer; + } + + final MethodCapturer<T> capturerNew = new MethodCapturer<T>(); + + Enhancer en = new Enhancer(); + en.setSuperclass(obj.getClass()); + en.setCallbacks(new Callback[] {new MethodInterceptor() { + @Override + public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable { + capturerNew.setMethod(arg1); + return null; + } + }, new MethodInterceptor() { + @Override + public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable { + return null; + } + }}); + en.setCallbackFilter(new CallbackFilter() { + @Override + public int accept(Method method) { + if (method.getParameterTypes().length == 0 && method.getName().equals("finalize")) { + return 1; + } + return 0; + } + }); + + capturerNew.setInstance((T)en.create()); + + // We expect MethodCapturer is only used for singleton objects here, so we only maintain a limited cache + // here + if (s_cache.size() < CACHE_SIZE) { + s_cache.put(obj, capturerNew); + } + + return capturerNew; + } + } + + public T instance() { + return _instance; + } + + private void setInstance(T instance) { + _instance = instance; + } + + public Method get(Object... useless) { + return _method; + } + + private void setMethod(Method method) { + _method = method; + } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/NumbersUtil.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/NumbersUtil.java b/utils/src/main/java/com/cloud/utils/NumbersUtil.java new file mode 100644 index 0000000..8b93a40 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/NumbersUtil.java @@ -0,0 +1,139 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.nio.ByteBuffer; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Formatter; +import java.util.Locale; + +import org.apache.commons.lang.math.NumberUtils; + +import com.cloud.utils.exception.CloudRuntimeException; + +public class NumbersUtil { + public static long parseLong(String s, long defaultValue) { + return NumberUtils.toLong(s, defaultValue); + } + + public static int parseInt(String s, int defaultValue) { + return NumberUtils.toInt(s, defaultValue); + } + + public static float parseFloat(String s, float defaultValue) { + return NumberUtils.toFloat(s, defaultValue); + } + + /** + * Converts bytes to long on input. + */ + public static long bytesToLong(byte b[]) { + return bytesToLong(b, 0); + } + + public static long bytesToLong(byte b[], int pos) { + return ByteBuffer.wrap(b, pos, 8).getLong(); + } + + /** + * Converts a byte array to a hex readable string. + **/ + public static String bytesToString(byte[] data, int start, int end) { + StringBuilder buf = new StringBuilder(); + if (end > data.length) { + end = data.length; + } + for (int i = start; i < end; i++) { + buf.append(" "); + buf.append(Integer.toHexString(data[i] & 0xff)); + } + return buf.toString(); + } + + protected static final long KB = 1024; + protected static final long MB = 1024 * KB; + protected static final long GB = 1024 * MB; + protected static final long TB = 1024 * GB; + + public static String toReadableSize(long bytes) { + if (bytes < KB && bytes >= 0) { + return Long.toString(bytes) + " bytes"; + } + StringBuilder builder = new StringBuilder(); + Formatter format = new Formatter(builder, Locale.getDefault()); + if (bytes < MB) { + format.format("%.2f KB", (float)bytes / (float)KB); + } else if (bytes < GB) { + format.format("%.2f MB", (float)bytes / (float)MB); + } else if (bytes < TB) { + format.format("%.2f GB", (float)bytes / (float)GB); + } else { + format.format("%.4f TB", (float)bytes / (float)TB); + } + format.close(); + return builder.toString(); + } + + /** + * Converts a string of the format 'yy-MM-dd'T'HH:mm:ss.SSS" into ms. + * + * @param str containing the interval. + * @param defaultValue value to return if str doesn't parse. If -1, throws VmopsRuntimeException + * @return interval in ms + */ + public static long parseInterval(String str, long defaultValue) { + try { + if (str == null) { + throw new ParseException("String is wrong", 0); + } + + SimpleDateFormat sdf = null; + if (str.contains("D")) { + sdf = new SimpleDateFormat("dd'D'HH'h'mm'M'ss'S'SSS'ms'"); + } else if (str.contains("h")) { + sdf = new SimpleDateFormat("HH'h'mm'M'ss'S'SSS'ms'"); + } else if (str.contains("M")) { + sdf = new SimpleDateFormat("mm'M'ss'S'SSS'ms'"); + } else if (str.contains("S")) { + sdf = new SimpleDateFormat("ss'S'SSS'ms'"); + } else if (str.contains("ms")) { + sdf = new SimpleDateFormat("SSS'ms'"); + } + if (sdf == null) { + throw new ParseException("String is wrong", 0); + } + + Date date = sdf.parse(str); + return date.getTime(); + } catch (ParseException e) { + if (defaultValue != -1) { + return defaultValue; + } else { + throw new CloudRuntimeException("Unable to parse: " + str, e); + } + } + } + + public static int hash(long value) { + return (int)(value ^ (value >>> 32)); + } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/Pair.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/Pair.java b/utils/src/main/java/com/cloud/utils/Pair.java new file mode 100644 index 0000000..73d3562 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/Pair.java @@ -0,0 +1,87 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.io.Serializable; + +public class Pair<T, U> implements Serializable { + private static final long serialVersionUID = 2L; + T t; + U u; + + protected Pair() { + + } + + public Pair(T t, U u) { + this.t = t; + this.u = u; + } + + public T first() { + return t; + } + + public U second() { + return u; + } + + public U second(U value) { + u = value; + return u; + } + + public T first(T value) { + t = value; + return t; + } + + public void set(T t, U u) { + this.t = t; + this.u = u; + } + + @Override + // Note: This means any two pairs with null for both values will match each + // other but what can I do? This is due to stupid type erasure. + public + int hashCode() { + return (t != null ? t.hashCode() : 0) | (u != null ? u.hashCode() : 0); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof Pair)) { + return false; + } + Pair<?, ?> that = (Pair<?, ?>)obj; + return (t != null ? t.equals(that.t) : that.t == null) && (u != null ? u.equals(that.u) : that.u == null); + } + + @Override + public String toString() { + StringBuilder b = new StringBuilder("P["); + b.append((t != null) ? t.toString() : "null"); + b.append(":"); + b.append((u != null) ? u.toString() : "null"); + b.append("]"); + return b.toString(); + } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/PasswordGenerator.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/PasswordGenerator.java b/utils/src/main/java/com/cloud/utils/PasswordGenerator.java new file mode 100644 index 0000000..0d79143 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/PasswordGenerator.java @@ -0,0 +1,90 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.security.SecureRandom; +import java.util.Random; + +/** + * Generate random passwords + * + */ +public class PasswordGenerator { + //Leave out visually confusing l,L,1,o,O,0 + static private char[] lowerCase = new char[] {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}; + static private char[] upperCase = new char[] {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; + static private char[] numeric = new char[] {'2', '3', '4', '5', '6', '7', '8', '9'}; + + static private char[] alphaNumeric = new char[] {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', + 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '2', '3', '4', '5', '6', '7', '8', '9'}; + + static private int minLength = 3; + + public static String generateRandomPassword(int num) { + Random r = new SecureRandom(); + StringBuilder password = new StringBuilder(); + + //Guard for num < minLength + if (num < minLength) { + //Add alphanumeric chars at random + for (int i = 0; i < minLength; i++) { + password.append(generateAlphaNumeric(r)); + } + } else { + // Generate random 3-character string with a lowercase character, + // uppercase character, and a digit + password.append(generateLowercaseChar(r)).append(generateUppercaseChar(r)).append(generateDigit(r)); + + // Generate a random n-character string with only lowercase + // characters + for (int i = 0; i < num - 3; i++) { + password.append(generateLowercaseChar(r)); + } + } + + return password.toString(); + } + + private static char generateLowercaseChar(Random r) { + return lowerCase[r.nextInt(lowerCase.length)]; + } + + private static char generateDigit(Random r) { + return numeric[r.nextInt(numeric.length)]; + } + + private static char generateUppercaseChar(Random r) { + return upperCase[r.nextInt(upperCase.length)]; + } + + private static char generateAlphaNumeric(Random r) { + return alphaNumeric[r.nextInt(alphaNumeric.length)]; + } + + public static String generatePresharedKey(int numChars) { + Random r = new SecureRandom(); + StringBuilder psk = new StringBuilder(); + for (int i = 0; i < numChars; i++) { + psk.append(generateAlphaNumeric(r)); + } + return psk.toString(); + + } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/Predicate.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/Predicate.java b/utils/src/main/java/com/cloud/utils/Predicate.java new file mode 100644 index 0000000..6079d16 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/Predicate.java @@ -0,0 +1,24 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +public interface Predicate { + boolean checkCondition(); +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/ProcessUtil.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/ProcessUtil.java b/utils/src/main/java/com/cloud/utils/ProcessUtil.java new file mode 100644 index 0000000..53137c4 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/ProcessUtil.java @@ -0,0 +1,112 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.io.File; +import java.io.IOException; +import java.util.Properties; + +import javax.naming.ConfigurationException; + +import org.apache.commons.io.FileUtils; +import org.apache.log4j.Logger; + +import com.cloud.utils.exception.CloudRuntimeException; +import com.cloud.utils.script.OutputInterpreter; +import com.cloud.utils.script.Script; + +public class ProcessUtil { + private static final Logger s_logger = Logger.getLogger(ProcessUtil.class.getName()); + + // paths cannot be hardcoded + public static void pidCheck(String pidDir, String run) throws ConfigurationException { + + String dir = pidDir == null ? "/var/run" : pidDir; + + try { + final File propsFile = PropertiesUtil.findConfigFile("environment.properties"); + if (propsFile == null) { + s_logger.debug("environment.properties could not be opened"); + } else { + final Properties props = PropertiesUtil.loadFromFile(propsFile); + dir = props.getProperty("paths.pid"); + if (dir == null) { + dir = pidDir == null ? "/var/run" : pidDir; + } + } + } catch (IOException e) { + s_logger.debug("environment.properties could not be opened"); + } + + final File pidFile = new File(dir + File.separator + run); + try { + if (!pidFile.createNewFile()) { + if (!pidFile.exists()) { + throw new ConfigurationException("Unable to write to " + pidFile.getAbsolutePath() + ". Are you sure you're running as root?"); + } + + final String pidLine = FileUtils.readFileToString(pidFile).trim(); + if (pidLine.isEmpty()) { + throw new ConfigurationException("Java process is being started twice. If this is not true, remove " + pidFile.getAbsolutePath()); + } + try { + final long pid = Long.parseLong(pidLine); + final Script script = new Script("bash", 120000, s_logger); + script.add("-c", "ps -p " + pid); + final String result = script.execute(); + if (result == null) { + throw new ConfigurationException("Java process is being started twice. If this is not true, remove " + pidFile.getAbsolutePath()); + } + if (!pidFile.delete()) { + throw new ConfigurationException("Java process is being started twice. If this is not true, remove " + pidFile.getAbsolutePath()); + } + if (!pidFile.createNewFile()) { + throw new ConfigurationException("Java process is being started twice. If this is not true, remove " + pidFile.getAbsolutePath()); + } + } catch (final NumberFormatException e) { + throw new ConfigurationException("Java process is being started twice. If this is not true, remove " + pidFile.getAbsolutePath()); + } + } + pidFile.deleteOnExit(); + + final Script script = new Script("bash", 120000, s_logger); + script.add("-c", "echo $PPID"); + final OutputInterpreter.OneLineParser parser = new OutputInterpreter.OneLineParser(); + script.execute(parser); + + final String pid = parser.getLine(); + + FileUtils.writeStringToFile(pidFile, pid + "\n"); + } catch (final IOException e) { + throw new CloudRuntimeException("Unable to create the " + pidFile.getAbsolutePath() + ". Are you running as root?", e); + } + } + + public static String dumpStack() { + StringBuilder sb = new StringBuilder(); + StackTraceElement[] elems = Thread.currentThread().getStackTrace(); + if (elems != null && elems.length > 0) { + for (StackTraceElement elem : elems) { + sb.append("\tat ").append(elem.getMethodName()).append("(").append(elem.getFileName()).append(":").append(elem.getLineNumber()).append(")\n"); + } + } + return sb.toString(); + } +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/Profiler.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/Profiler.java b/utils/src/main/java/com/cloud/utils/Profiler.java new file mode 100644 index 0000000..f8e44bd --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/Profiler.java @@ -0,0 +1,91 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +public class Profiler { + + private static final long MILLIS_FACTOR = 1000l; + private static final double EXPONENT = 2d; + + + private Long startTickNanoSeconds; + private Long stopTickNanoSeconds; + + public long start() { + startTickNanoSeconds = System.nanoTime(); + return startTickNanoSeconds; + } + + public long stop() { + stopTickNanoSeconds = System.nanoTime(); + return stopTickNanoSeconds; + } + + /** + * 1 millisecond = 1e+6 nanoseconds + * 1 second = 1000 milliseconds = 1e+9 nanoseconds + * + * @return the duration in nanoseconds. + */ + public long getDuration() { + if (startTickNanoSeconds != null && stopTickNanoSeconds != null) { + final long timeInNanoSeconds = stopTickNanoSeconds - startTickNanoSeconds; + return timeInNanoSeconds; + } + + return -1; + } + + /** + * 1 millisecond = 1e+6 nanoseconds + * 1 second = 1000 millisecond = 1e+9 nanoseconds + * + * @return the duration in milliseconds. + */ + public long getDurationInMillis() { + if (startTickNanoSeconds != null && stopTickNanoSeconds != null) { + final long timeInMillis = (stopTickNanoSeconds - startTickNanoSeconds) / (long)Math.pow(MILLIS_FACTOR, EXPONENT); + return timeInMillis; + } + + return -1; + } + + public boolean isStarted() { + return startTickNanoSeconds != null; + } + + public boolean isStopped() { + return stopTickNanoSeconds != null; + } + + @Override + public String toString() { + if (startTickNanoSeconds == null) { + return "Not Started"; + } + + if (stopTickNanoSeconds == null) { + return "Started but not stopped"; + } + + return "Done. Duration: " + getDurationInMillis() + "ms"; + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/PropertiesUtil.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/PropertiesUtil.java b/utils/src/main/java/com/cloud/utils/PropertiesUtil.java new file mode 100644 index 0000000..4cb89f7 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/PropertiesUtil.java @@ -0,0 +1,196 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.util.HashMap; +import java.util.Map; +import java.util.Properties; +import java.util.Set; + +import org.apache.log4j.Logger; + +public class PropertiesUtil { + private static final Logger s_logger = Logger.getLogger(PropertiesUtil.class); + + /** + * Searches the class path and local paths to find the config file. + * @param path path to find. if it starts with / then it's absolute path. + * @return File or null if not found at all. + */ + + public static File findConfigFile(String path) { + ClassLoader cl = PropertiesUtil.class.getClassLoader(); + URL url = cl.getResource(path); + + if (url != null && "file".equals(url.getProtocol())) { + return new File(url.getFile()); + } + + url = ClassLoader.getSystemResource(path); + if (url != null && "file".equals(url.getProtocol())) { + return new File(url.getFile()); + } + + File file = new File(path); + if (file.exists()) { + return file; + } + + String newPath = "conf" + (path.startsWith(File.separator) ? "" : "/") + path; + url = ClassLoader.getSystemResource(newPath); + if (url != null && "file".equals(url.getProtocol())) { + return new File(url.getFile()); + } + + url = cl.getResource(newPath); + if (url != null && "file".equals(url.getProtocol())) { + return new File(url.getFile()); + } + + newPath = "conf" + (path.startsWith(File.separator) ? "" : File.separator) + path; + file = new File(newPath); + if (file.exists()) { + return file; + } + + newPath = System.getProperty("catalina.home"); + if (newPath == null) { + newPath = System.getenv("CATALINA_HOME"); + } + + if (newPath == null) { + newPath = System.getenv("CATALINA_BASE"); + } + + if (newPath == null) { + return null; + } + + file = new File(newPath + File.separator + "conf" + File.separator + path); + if (file.exists()) { + return file; + } + + return null; + } + + public static Map<String, Object> toMap(Properties props) { + Set<String> names = props.stringPropertyNames(); + HashMap<String, Object> map = new HashMap<String, Object>(names.size()); + for (String name : names) { + map.put(name, props.getProperty(name)); + } + + return map; + } + + /* + * Returns an InputStream for the given resource + * This is needed to read the files within a jar in classpath. + */ + public static InputStream openStreamFromURL(String path) { + ClassLoader cl = PropertiesUtil.class.getClassLoader(); + URL url = cl.getResource(path); + if (url != null) { + try { + InputStream stream = url.openStream(); + return stream; + } catch (IOException ioex) { + return null; + } + } + return null; + } + + public static void loadFromJar(Properties properties, String configFile) throws IOException { + InputStream stream = PropertiesUtil.openStreamFromURL(configFile); + if (stream != null) { + properties.load(stream); + } else { + s_logger.error("Unable to find properties file: " + configFile); + } + } + + // Returns key=value pairs by parsing a commands.properties/config file + // with syntax; key=cmd;value (with this syntax cmd is stripped) and key=value + public static Map<String, String> processConfigFile(String[] configFiles) { + Map<String, String> configMap = new HashMap<String, String>(); + Properties preProcessedCommands = new Properties(); + for (String configFile : configFiles) { + File commandsFile = findConfigFile(configFile); + if (commandsFile != null) { + try { + loadFromFile(preProcessedCommands, commandsFile); + } catch (IOException ioe) { + s_logger.error("IO Exception loading properties file", ioe); + } + } + else { + // in case of a file within a jar in classpath, try to open stream using url + try { + loadFromJar(preProcessedCommands, configFile); + } catch (IOException e) { + s_logger.error("IO Exception loading properties file from jar", e); + } + } + } + + for (Object key : preProcessedCommands.keySet()) { + String preProcessedCommand = preProcessedCommands.getProperty((String)key); + int splitIndex = preProcessedCommand.lastIndexOf(";"); + String value = preProcessedCommand.substring(splitIndex + 1); + configMap.put((String)key, value); + } + + return configMap; + } + + /** + * Load a Properties object with contents from a File. + * @param properties the properties object to be loaded + * @param file the file to load from + * @throws IOException + */ + public static void loadFromFile(final Properties properties, final File file) + throws IOException { + try (final InputStream stream = new FileInputStream(file)) { + properties.load(stream); + } + } + + /** + * Load the file and return the contents as a Properties object. + * @param file the file to load + * @return A Properties object populated + * @throws IOException + */ + public static Properties loadFromFile(final File file) + throws IOException { + final Properties properties = new Properties(); + loadFromFile(properties, file); + return properties; + } + +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/ReflectUtil.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/ReflectUtil.java b/utils/src/main/java/com/cloud/utils/ReflectUtil.java new file mode 100644 index 0000000..c8ae954 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/ReflectUtil.java @@ -0,0 +1,213 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import static java.beans.Introspector.getBeanInfo; +import static java.util.Collections.emptyList; +import static java.util.Collections.unmodifiableList; + +import java.beans.BeanInfo; +import java.beans.IntrospectionException; +import java.beans.PropertyDescriptor; +import java.lang.annotation.Annotation; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.apache.log4j.Logger; +import org.reflections.Reflections; +import org.reflections.util.ConfigurationBuilder; +import org.reflections.util.ClasspathHelper; +import org.reflections.scanners.SubTypesScanner; +import org.reflections.scanners.TypeAnnotationsScanner; + +import com.google.common.collect.ImmutableSet; + +import com.cloud.utils.exception.CloudRuntimeException; + +public class ReflectUtil { + + private static final Logger s_logger = Logger.getLogger(ReflectUtil.class); + private static final Logger logger = Logger.getLogger(Reflections.class); + + public static Pair<Class<?>, Field> getAnyField(Class<?> clazz, String fieldName) { + try { + return new Pair<Class<?>, Field>(clazz, clazz.getDeclaredField(fieldName)); + } catch (SecurityException e) { + throw new CloudRuntimeException("How the heck?", e); + } catch (NoSuchFieldException e) { + // Do I really want this? No I don't but what can I do? It only throws the NoSuchFieldException. + Class<?> parent = clazz.getSuperclass(); + if (parent != null) { + return getAnyField(parent, fieldName); + } + return null; + } + } + + // Gets all classes with some annotation from a package + public static Set<Class<?>> getClassesWithAnnotation(Class<? extends Annotation> annotation, String[] packageNames) { + Reflections reflections; + Set<Class<?>> classes = new HashSet<Class<?>>(); + ConfigurationBuilder builder=new ConfigurationBuilder(); + for (String packageName : packageNames) { + builder.addUrls(ClasspathHelper.forPackage(packageName)); + } + builder.setScanners(new SubTypesScanner(),new TypeAnnotationsScanner()); + reflections = new Reflections(builder); + classes.addAll(reflections.getTypesAnnotatedWith(annotation)); + return classes; + } + + // Checks against posted search classes if cmd is async + public static boolean isCmdClassAsync(Class<?> cmdClass, Class<?>[] searchClasses) { + boolean isAsync = false; + Class<?> superClass = cmdClass; + + while (superClass != null && superClass != Object.class) { + String superName = superClass.getName(); + for (Class<?> baseClass : searchClasses) { + if (superName.equals(baseClass.getName())) { + isAsync = true; + break; + } + } + if (isAsync) + break; + superClass = superClass.getSuperclass(); + } + return isAsync; + } + + // Returns all fields until a base class for a cmd class + public static List<Field> getAllFieldsForClass(Class<?> cmdClass, Class<?> baseClass) { + List<Field> fields = new ArrayList<Field>(); + Collections.addAll(fields, cmdClass.getDeclaredFields()); + Class<?> superClass = cmdClass.getSuperclass(); + while (baseClass.isAssignableFrom(superClass) && baseClass != superClass) { + Field[] superClassFields = superClass.getDeclaredFields(); + if (superClassFields != null) + Collections.addAll(fields, superClassFields); + superClass = superClass.getSuperclass(); + } + return fields; + } + + /** + * Returns all unique fields except excludeClasses for a cmd class + * @param cmdClass the class in which fields should be collected + * @param excludeClasses the classes whose fields must be ignored + * @return list of fields + */ + public static Set<Field> getAllFieldsForClass(Class<?> cmdClass, Class<?>[] excludeClasses) { + Set<Field> fields = new HashSet<Field>(); + Collections.addAll(fields, cmdClass.getDeclaredFields()); + Class<?> superClass = cmdClass.getSuperclass(); + + while (superClass != null && superClass != Object.class) { + String superName = superClass.getName(); + boolean isNameEqualToSuperName = false; + for (Class<?> baseClass : excludeClasses) { + if (superName.equals(baseClass.getName())) { + isNameEqualToSuperName = true; + } + } + + if (!isNameEqualToSuperName) { + Field[] superClassFields = superClass.getDeclaredFields(); + if (superClassFields != null) { + Collections.addAll(fields, superClassFields); + } + } + superClass = superClass.getSuperclass(); + } + return fields; + } + + public static List<String> flattenProperties(final Object target, final Class<?> clazz) { + return flattenPropeties(target, clazz, "class"); + } + + public static List<String> flattenPropeties(final Object target, final Class<?> clazz, final String... excludedProperties) { + return flattenProperties(target, clazz, ImmutableSet.copyOf(excludedProperties)); + } + + private static List<String> flattenProperties(final Object target, final Class<?> clazz, final ImmutableSet<String> excludedProperties) { + + assert clazz != null; + + if (target == null) { + return emptyList(); + } + + assert clazz.isAssignableFrom(target.getClass()); + + try { + + final BeanInfo beanInfo = getBeanInfo(clazz); + final PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors(); + + final List<String> serializedProperties = new ArrayList<String>(); + for (final PropertyDescriptor descriptor : descriptors) { + + if (excludedProperties.contains(descriptor.getName())) { + continue; + } + + serializedProperties.add(descriptor.getName()); + final Object value = descriptor.getReadMethod().invoke(target); + serializedProperties.add(value != null ? value.toString() : "null"); + + } + + return unmodifiableList(serializedProperties); + + } catch (IntrospectionException e) { + s_logger.warn("Ignored IntrospectionException when serializing class " + target.getClass().getCanonicalName(), e); + } catch (IllegalArgumentException e) { + s_logger.warn("Ignored IllegalArgumentException when serializing class " + target.getClass().getCanonicalName(), e); + } catch (IllegalAccessException e) { + s_logger.warn("Ignored IllegalAccessException when serializing class " + target.getClass().getCanonicalName(), e); + } catch (InvocationTargetException e) { + s_logger.warn("Ignored InvocationTargetException when serializing class " + target.getClass().getCanonicalName(), e); + } + + return emptyList(); + + } + + public static String getEntityName(Class clz){ + if(clz == null) + return null; + + String entityName = clz.getName(); + int index = entityName.lastIndexOf("."); + if (index != -1) { + return entityName.substring(index + 1); + }else{ + return entityName; + } + } + +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/ReflectionUse.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/ReflectionUse.java b/utils/src/main/java/com/cloud/utils/ReflectionUse.java new file mode 100644 index 0000000..a5a78e2 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/ReflectionUse.java @@ -0,0 +1,31 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +@Target({METHOD}) +@Retention(RUNTIME) +public @interface ReflectionUse { +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/S3Utils.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/S3Utils.java b/utils/src/main/java/com/cloud/utils/S3Utils.java new file mode 100644 index 0000000..6efe76b --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/S3Utils.java @@ -0,0 +1,603 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +import static com.amazonaws.Protocol.HTTP; +import static com.amazonaws.Protocol.HTTPS; +import static com.cloud.utils.StringUtils.join; +import static java.io.File.createTempFile; +import static java.lang.String.format; +import static java.lang.System.currentTimeMillis; +import static java.util.Collections.emptyList; +import static java.util.Collections.singletonList; +import static java.util.Collections.unmodifiableList; +import static org.apache.commons.lang.ArrayUtils.isEmpty; +import static org.apache.commons.lang.StringUtils.isBlank; +import static org.apache.commons.lang.StringUtils.isNotBlank; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FilenameFilter; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.UUID; + +import org.apache.commons.lang.ArrayUtils; +import org.apache.log4j.Logger; + +import com.amazonaws.AmazonClientException; +import com.amazonaws.ClientConfiguration; +import com.amazonaws.HttpMethod; +import com.amazonaws.auth.AWSCredentials; +import com.amazonaws.auth.BasicAWSCredentials; +import com.amazonaws.services.s3.AmazonS3; +import com.amazonaws.services.s3.AmazonS3Client; +import com.amazonaws.services.s3.model.Bucket; +import com.amazonaws.services.s3.model.CannedAccessControlList; +import com.amazonaws.services.s3.model.GetObjectRequest; +import com.amazonaws.services.s3.model.ListObjectsRequest; +import com.amazonaws.services.s3.model.ObjectListing; +import com.amazonaws.services.s3.model.ObjectMetadata; +import com.amazonaws.services.s3.model.PutObjectRequest; +import com.amazonaws.services.s3.model.S3Object; +import com.amazonaws.services.s3.model.S3ObjectSummary; +import com.amazonaws.services.s3.transfer.TransferManager; +import com.amazonaws.services.s3.transfer.Upload; +import com.cloud.utils.exception.CloudRuntimeException; + +public final class S3Utils { + + private static final Logger LOGGER = Logger.getLogger(S3Utils.class); + + public static final String SEPARATOR = "/"; + + private static final int MIN_BUCKET_NAME_LENGTH = 3; + private static final int MAX_BUCKET_NAME_LENGTH = 63; + + private S3Utils() { + super(); + } + + public static AmazonS3 acquireClient(final ClientOptions clientOptions) { + + final AWSCredentials credentials = new BasicAWSCredentials(clientOptions.getAccessKey(), clientOptions.getSecretKey()); + + final ClientConfiguration configuration = new ClientConfiguration(); + + if (clientOptions.isHttps() != null) { + configuration.setProtocol(clientOptions.isHttps() == true ? HTTPS : HTTP); + } + + if (clientOptions.getConnectionTimeout() != null) { + configuration.setConnectionTimeout(clientOptions.getConnectionTimeout()); + } + + if (clientOptions.getMaxErrorRetry() != null) { + configuration.setMaxErrorRetry(clientOptions.getMaxErrorRetry()); + } + + if (clientOptions.getSocketTimeout() != null) { + configuration.setSocketTimeout(clientOptions.getSocketTimeout()); + } + + if (clientOptions.getUseTCPKeepAlive() != null) { + //configuration.setUseTcpKeepAlive(clientOptions.getUseTCPKeepAlive()); + LOGGER.debug("useTCPKeepAlive not supported by old AWS SDK"); + } + + if (clientOptions.getConnectionTtl() != null) { + //configuration.setConnectionTTL(clientOptions.getConnectionTtl()); + LOGGER.debug("connectionTtl not supported by old AWS SDK"); + } + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Creating S3 client with configuration: [protocol: %1$s, connectionTimeOut: " + "%2$s, maxErrorRetry: %3$s, socketTimeout: %4$s, useTCPKeepAlive: %5$s, connectionTtl: %6$s]", + configuration.getProtocol(), configuration.getConnectionTimeout(), configuration.getMaxErrorRetry(), configuration.getSocketTimeout(), + -1, -1)); + } + + final AmazonS3Client client = new AmazonS3Client(credentials, configuration); + + if (isNotBlank(clientOptions.getEndPoint())) { + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Setting the end point for S3 client %1$s to %2$s.", client, clientOptions.getEndPoint())); + } + client.setEndpoint(clientOptions.getEndPoint()); + } + + return client; + + } + + public static void putFile(final ClientOptions clientOptions, final File sourceFile, final String bucketName, final String key) { + + assert clientOptions != null; + assert sourceFile != null; + assert !isBlank(bucketName); + assert !isBlank(key); + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Sending file %1$s as S3 object %2$s in " + "bucket %3$s", sourceFile.getName(), key, bucketName)); + } + + acquireClient(clientOptions).putObject(bucketName, key, sourceFile); + + } + + public static void putObject(final ClientOptions clientOptions, final InputStream sourceStream, final String bucketName, final String key) { + + assert clientOptions != null; + assert sourceStream != null; + assert !isBlank(bucketName); + assert !isBlank(key); + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Sending stream as S3 object %1$s in " + "bucket %2$s", key, bucketName)); + } + + acquireClient(clientOptions).putObject(bucketName, key, sourceStream, null); + + } + + public static void putObject(final ClientOptions clientOptions, final PutObjectRequest req) { + + assert clientOptions != null; + assert req != null; + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Sending stream as S3 object using PutObjectRequest")); + } + + acquireClient(clientOptions).putObject(req); + + } + + // multi-part upload file + public static void mputFile(final ClientOptions clientOptions, final File sourceFile, final String bucketName, final String key) throws InterruptedException { + + assert clientOptions != null; + assert sourceFile != null; + assert !isBlank(bucketName); + assert !isBlank(key); + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Multipart sending file %1$s as S3 object %2$s in " + "bucket %3$s", sourceFile.getName(), key, bucketName)); + } + TransferManager tm = new TransferManager(S3Utils.acquireClient(clientOptions)); + Upload upload = tm.upload(bucketName, key, sourceFile); + upload.waitForCompletion(); + } + + // multi-part upload object + public static void mputObject(final ClientOptions clientOptions, final InputStream sourceStream, final String bucketName, final String key) + throws InterruptedException { + + assert clientOptions != null; + assert sourceStream != null; + assert !isBlank(bucketName); + assert !isBlank(key); + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Multipart sending stream as S3 object %1$s in " + "bucket %2$s", key, bucketName)); + } + TransferManager tm = new TransferManager(S3Utils.acquireClient(clientOptions)); + Upload upload = tm.upload(bucketName, key, sourceStream, null); + upload.waitForCompletion(); + } + + // multi-part upload object + public static void mputObject(final ClientOptions clientOptions, final PutObjectRequest req) throws InterruptedException { + + assert clientOptions != null; + assert req != null; + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Multipart sending object to S3 using PutObjectRequest"); + } + TransferManager tm = new TransferManager(S3Utils.acquireClient(clientOptions)); + Upload upload = tm.upload(req); + upload.waitForCompletion(); + + } + + public static void setObjectAcl(final ClientOptions clientOptions, final String bucketName, final String key, final CannedAccessControlList acl) { + + assert clientOptions != null; + assert acl != null; + + acquireClient(clientOptions).setObjectAcl(bucketName, key, acl); + + } + + public static URL generatePresignedUrl(final ClientOptions clientOptions, final String bucketName, final String key, final Date expiration) { + + assert clientOptions != null; + assert !isBlank(bucketName); + assert !isBlank(key); + + return acquireClient(clientOptions).generatePresignedUrl(bucketName, key, expiration, HttpMethod.GET); + + } + + // Note that whenever S3Object is returned, client code needs to close the internal stream to avoid resource leak. + public static S3Object getObject(final ClientOptions clientOptions, final String bucketName, final String key) { + + assert clientOptions != null; + assert !isBlank(bucketName); + assert !isBlank(key); + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Get S3 object %1$s in " + "bucket %2$s", key, bucketName)); + } + + return acquireClient(clientOptions).getObject(bucketName, key); + + } + + @SuppressWarnings("unchecked") + public static File getFile(final ClientOptions clientOptions, final String bucketName, final String key, final File targetDirectory, + final FileNamingStrategy namingStrategy) { + + assert clientOptions != null; + assert isNotBlank(bucketName); + assert isNotBlank(key); + assert targetDirectory != null && targetDirectory.isDirectory(); + assert namingStrategy != null; + + final AmazonS3 connection = acquireClient(clientOptions); + + File tempFile = null; + try { + + tempFile = createTempFile(join("-", targetDirectory.getName(), currentTimeMillis(), "part"), "tmp", targetDirectory); + tempFile.deleteOnExit(); + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Downloading object %1$s from bucket %2$s to temp file %3$s", key, bucketName, tempFile.getName())); + } + + try { + connection.getObject(new GetObjectRequest(bucketName, key), tempFile); + } catch (AmazonClientException ex) { + // hack to handle different ETAG format generated from RiakCS for multi-part uploaded object + String msg = ex.getMessage(); + if (!msg.contains("verify integrity")) { + throw ex; + } + } + + final File targetFile = new File(targetDirectory, namingStrategy.determineFileName(key)); + tempFile.renameTo(targetFile); + + return targetFile; + + } catch (FileNotFoundException e) { + + throw new CloudRuntimeException(format("Failed open file %1$s in order to get object %2$s from bucket %3$s.", targetDirectory.getAbsoluteFile(), bucketName, + key), e); + + } catch (IOException e) { + + throw new CloudRuntimeException(format("Unable to allocate temporary file in directory %1$s to download %2$s:%3$s from S3", + targetDirectory.getAbsolutePath(), bucketName, key), e); + + } finally { + + if (tempFile != null) { + tempFile.delete(); + } + + } + + } + + public static List<File> getDirectory(final ClientOptions clientOptions, final String bucketName, final String sourcePath, final File targetDirectory, + final FileNamingStrategy namingStrategy) { + + assert clientOptions != null; + assert isNotBlank(bucketName); + assert isNotBlank(sourcePath); + assert targetDirectory != null; + + final AmazonS3 connection = acquireClient(clientOptions); + + // List the objects in the source directory on S3 + final List<S3ObjectSummary> objectSummaries = listDirectory(bucketName, sourcePath, connection); + final List<File> files = new ArrayList<File>(); + + for (final S3ObjectSummary objectSummary : objectSummaries) { + + files.add(getFile(clientOptions, bucketName, objectSummary.getKey(), targetDirectory, namingStrategy)); + + } + + return unmodifiableList(files); + + } + + public static List<S3ObjectSummary> getDirectory(final ClientOptions clientOptions, final String bucketName, final String sourcePath) { + assert clientOptions != null; + assert isNotBlank(bucketName); + assert isNotBlank(sourcePath); + + final AmazonS3 connection = acquireClient(clientOptions); + + // List the objects in the source directory on S3 + return listDirectory(bucketName, sourcePath, connection); + } + + private static List<S3ObjectSummary> listDirectory(final String bucketName, final String directory, final AmazonS3 client) { + + List<S3ObjectSummary> objects = new ArrayList<S3ObjectSummary>(); + ListObjectsRequest listObjectsRequest = new ListObjectsRequest().withBucketName(bucketName).withPrefix(directory + SEPARATOR); + + ObjectListing ol = client.listObjects(listObjectsRequest); + if(ol.isTruncated()) { + do { + objects.addAll(ol.getObjectSummaries()); + listObjectsRequest.setMarker(ol.getNextMarker()); + ol = client.listObjects(listObjectsRequest); + } while (ol.isTruncated()); + } + else { + objects.addAll(ol.getObjectSummaries()); + } + + if (objects.isEmpty()) { + return emptyList(); + } + + return unmodifiableList(objects); + } + + public static void putDirectory(final ClientOptions clientOptions, final String bucketName, final File directory, final FilenameFilter fileNameFilter, + final ObjectNamingStrategy namingStrategy) { + + assert clientOptions != null; + assert isNotBlank(bucketName); + assert directory != null && directory.isDirectory(); + assert fileNameFilter != null; + assert namingStrategy != null; + + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Putting directory %1$s in S3 bucket %2$s.", directory.getAbsolutePath(), bucketName)); + } + + // Determine the list of files to be sent using the passed filter ... + final File[] files = directory.listFiles(fileNameFilter); + + if (LOGGER.isTraceEnabled()) { + LOGGER.trace(format("Putting files (%1$s) in S3 bucket %2$s.", ArrayUtils.toString(files, "no files found"), bucketName)); + } + + // Skip spinning up an S3 connection when no files will be sent ... + if (isEmpty(files)) { + return; + } + + final AmazonS3 client = acquireClient(clientOptions); + + // Send the files to S3 using the passed ObjectNaming strategy to + // determine the key ... + for (final File file : files) { + final String key = namingStrategy.determineKey(file); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug(format("Putting file %1$s into bucket %2$s with key %3$s.", file.getAbsolutePath(), bucketName, key)); + } + client.putObject(bucketName, key, file); + } + + } + + public static void deleteObject(final ClientOptions clientOptions, final String bucketName, final String key) { + + assert clientOptions != null; + assert isNotBlank(bucketName); + assert isNotBlank(key); + + final AmazonS3 client = acquireClient(clientOptions); + + client.deleteObject(bucketName, key); + + } + + public static void deleteDirectory(final ClientOptions clientOptions, final String bucketName, final String directoryName) { + + assert clientOptions != null; + assert isNotBlank(bucketName); + assert isNotBlank(directoryName); + + final AmazonS3 client = acquireClient(clientOptions); + + final List<S3ObjectSummary> objects = listDirectory(bucketName, directoryName, client); + + for (final S3ObjectSummary object : objects) { + + client.deleteObject(bucketName, object.getKey()); + + } + + client.deleteObject(bucketName, directoryName); + + } + + public static boolean canConnect(final ClientOptions clientOptions) { + + try { + + acquireClient(clientOptions); + return true; + + } catch (AmazonClientException e) { + + LOGGER.warn("Ignored Exception while checking connection options", e); + return false; + + } + + } + + public static boolean doesBucketExist(final ClientOptions clientOptions, final String bucketName) { + + assert clientOptions != null; + assert !isBlank(bucketName); + + try { + + final List<Bucket> buckets = acquireClient(clientOptions).listBuckets(); + + for (Bucket bucket : buckets) { + if (bucket.getName().equals(bucketName)) { + return true; + } + } + + return false; + + } catch (AmazonClientException e) { + + LOGGER.warn("Ignored Exception while checking bucket existence", e); + return false; + + } + + } + + public static boolean canReadWriteBucket(final ClientOptions clientOptions, final String bucketName) { + + assert clientOptions != null; + assert isNotBlank(bucketName); + + try { + + final AmazonS3 client = acquireClient(clientOptions); + + final String fileContent = "testing put and delete"; + final InputStream inputStream = new ByteArrayInputStream(fileContent.getBytes()); + final String key = UUID.randomUUID().toString() + ".txt"; + + final ObjectMetadata metadata = new ObjectMetadata(); + metadata.setContentLength(fileContent.length()); + + client.putObject(bucketName, key, inputStream, metadata); + client.deleteObject(bucketName, key); + + return true; + + } catch (AmazonClientException e) { + + return false; + + } + + } + + public static List<String> checkClientOptions(ClientOptions clientOptions) { + + assert clientOptions != null; + + List<String> errorMessages = new ArrayList<String>(); + + errorMessages.addAll(checkRequiredField("access key", clientOptions.getAccessKey())); + errorMessages.addAll(checkRequiredField("secret key", clientOptions.getSecretKey())); + + errorMessages.addAll(checkOptionalField("connection timeout", clientOptions.getConnectionTimeout())); + errorMessages.addAll(checkOptionalField("socket timeout", clientOptions.getSocketTimeout())); + errorMessages.addAll(checkOptionalField("max error retries", clientOptions.getMaxErrorRetry())); + errorMessages.addAll(checkOptionalField("connection ttl", clientOptions.getConnectionTtl())); + + return unmodifiableList(errorMessages); + + } + + public static List<String> checkBucketName(final String bucketLabel, final String bucket) { + + assert isNotBlank(bucketLabel); + assert isNotBlank(bucket); + + final List<String> errorMessages = new ArrayList<String>(); + + if (bucket.length() < MIN_BUCKET_NAME_LENGTH) { + errorMessages.add(format("The length of %1$s " + "for the %2$s must have a length of at least %3$s " + "characters", bucket, bucketLabel, + MIN_BUCKET_NAME_LENGTH)); + } + + if (bucket.length() > MAX_BUCKET_NAME_LENGTH) { + errorMessages.add(format("The length of %1$s " + "for the %2$s must not have a length of at greater" + " than %3$s characters", bucket, bucketLabel, + MAX_BUCKET_NAME_LENGTH)); + } + + return unmodifiableList(errorMessages); + + } + + private static List<String> checkOptionalField(final String fieldName, final Integer fieldValue) { + if (fieldValue != null && fieldValue < 0) { + return singletonList(format("The value of %1$s must " + "be greater than zero.", fieldName)); + } + return emptyList(); + } + + private static List<String> checkRequiredField(String fieldName, String fieldValue) { + if (isBlank(fieldValue)) { + return singletonList(format("A %1$s must be specified.", fieldName)); + } + return emptyList(); + } + + public interface ClientOptions { + + String getAccessKey(); + + String getSecretKey(); + + String getEndPoint(); + + Boolean isHttps(); + + Integer getConnectionTimeout(); + + Integer getMaxErrorRetry(); + + Integer getSocketTimeout(); + + Boolean getUseTCPKeepAlive(); + + Integer getConnectionTtl(); + } + + public interface ObjectNamingStrategy { + + String determineKey(File file); + + } + + public interface FileNamingStrategy { + + String determineFileName(String key); + + } + +} http://git-wip-us.apache.org/repos/asf/cloudstack/blob/83fd8f60/utils/src/main/java/com/cloud/utils/SerialVersionUID.java ---------------------------------------------------------------------- diff --git a/utils/src/main/java/com/cloud/utils/SerialVersionUID.java b/utils/src/main/java/com/cloud/utils/SerialVersionUID.java new file mode 100644 index 0000000..e4ea217 --- /dev/null +++ b/utils/src/main/java/com/cloud/utils/SerialVersionUID.java @@ -0,0 +1,69 @@ +// +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// + +package com.cloud.utils; + +/** + * purposes. This is purely on an honor system though. You should always + **/ +public interface SerialVersionUID { + public static final long Base = 0x564D4F70 << 32; // 100 brownie points if you guess what this is and tell me. + + public static final long UUID = Base | 0x1; + public static final long CloudRuntimeException = Base | 0x2; + public static final long CloudStartupServlet = Base | 0x3; + public static final long CloudServiceImpl = Base | 0x4; + public static final long AccountLimitException = Base | 0x5; + public static final long InsufficientVirtualNetworkCapacityException = Base | 0x7; + public static final long NetworkUnavailableException = Base | 0x8; + public static final long Ip = Base | 0x9; + public static final long UnsupportedVersionException = Base | 0xb; + public static final long DataCenterIpAddressPK = Base | 0xc; + public static final long UnableToExecuteException = Base | 0xd; + public static final long ExecutionException = Base | 0xe; + public static final long VnetKey = Base | 0xf; + public static final long InsufficientServerCapacityException = Base | 0x10; + public static final long InsufficientAddressCapacityException = Base | 0x11; + public static final long ManagementServerException = Base | 0x12; + public static final long HAStateException = Base | 0x13; + public static final long InsufficientStorageCapacityException = Base | 0x14; + public static final long InsufficientCapacityException = Base | 0x15; + public static final long ConcurrentOperationException = Base | 0x16; + public static final long AgentUnavailableException = Base | 0x17; + public static final long OperationTimedoutException = Base | 0x18; + public static final long StorageUnavailableException = Base | 0x19; + public static final long InfficientVirtualNetworkCapacityException = Base | 0x1a; + public static final long DiscoveryException = Base | 0x1b; + public static final long ConflictingNetworkSettingException = Base | 0x1c; + public static final long CloudAuthenticationException = Base | 0x1d; + public static final long AsyncCommandQueued = Base | 0x1e; + public static final long ResourceUnavailableException = Base | 0x1f; + public static final long ConnectionException = Base | 0x20; + public static final long PermissionDeniedException = Base | 0x21; + public static final long sshException = Base | 0x22; + public static final long HttpCallException = Base | 0x23; + public static final long VirtualMachineMigrationException = Base | 0x24; + public static final long DiscoveredWithErrorException = Base | 0x25; + public static final long NoTransitionException = Base | 0x26; + public static final long CloudExecutionException = Base | 0x27; + public static final long CallFailedException = Base | 0x28; + public static final long UnableDeleteHostException = Base | 0x29; + public static final long AffinityConflictException = Base | 0x2a; + public static final long JobCancellationException = Base | 0x2b; +}
