// 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
// 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.db;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Map;
import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.Column;
import javax.persistence.Embeddable;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
import javax.persistence.Id;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.PrimaryKeyJoinColumns;
import javax.persistence.SecondaryTable;
import javax.persistence.SecondaryTables;
import javax.persistence.Table;
import javax.persistence.Transient;
import org.apache.log4j.Logger;
public class DbUtil {
protected final static Logger s_logger = Logger.getLogger(DbUtil.class);
private static Map<String, Connection> s_connectionForGlobalLocks = new HashMap<String, Connection>();
public static Connection getConnectionForGlobalLocks(String name, boolean forLock) {
synchronized(s_connectionForGlobalLocks) {
if(forLock) {
if(s_connectionForGlobalLocks.get(name) != null) {
s_logger.error("Sanity check failed, global lock name " + name + " is already in use");
assert(false);
}
Connection connection = TransactionLegacy.getStandaloneConnection();
if(connection != null) {
try {
connection.setAutoCommit(true);
} catch (SQLException e) {
try {
connection.close();
} catch(SQLException sqlException) {
}
return null;
}
s_connectionForGlobalLocks.put(name, connection);
return connection;
}
return null;
} else {
Connection connection = s_connectionForGlobalLocks.get(name);
s_connectionForGlobalLocks.remove(name);
return connection;
}
}
}
public static void removeConnectionForGlobalLocks(String name) {
synchronized(s_connectionForGlobalLocks) {
s_connectionForGlobalLocks.remove(name);
}
}
public static String getColumnName(Field field, AttributeOverride[] overrides) {
if (overrides != null) {
for (AttributeOverride override : overrides) {
if (override.name().equals(field.getName())) {
return override.column().name();
}
}
}
assert(field.getAnnotation(Embedded.class) == null) : "Cannot get column name from embedded field: " + field.getName();
Column column = field.getAnnotation(Column.class);
return column != null ? column.name() : field.getName();
}
public static String getColumnName(Field field) {
return getColumnName(field, null);
}
public static String getReferenceColumn(PrimaryKeyJoinColumn pkjc) {
return pkjc.referencedColumnName().length() != 0
? pkjc.referencedColumnName()
: pkjc.name();
}
public static PrimaryKeyJoinColumn[] getPrimaryKeyJoinColumns(Class<?> clazz) {
PrimaryKeyJoinColumn pkjc = clazz.getAnnotation(PrimaryKeyJoinColumn.class);
if (pkjc != null) {
return new PrimaryKeyJoinColumn[] { pkjc };
}
PrimaryKeyJoinColumns pkjcs = clazz.getAnnotation(PrimaryKeyJoinColumns.class);
if (pkjcs != null) {
return pkjcs.value();
}
return null;
}
public static Field findField(Class<?> clazz, String columnName) {
for (Field field : clazz.getDeclaredFields()) {
if (field.getAnnotation(Embedded.class) != null || field.getAnnotation(EmbeddedId.class) != null) {
findField(field.getClass(), columnName);
} else {
if (columnName.equals(DbUtil.getColumnName(field))) {
return field;
}
}
}
return null;
}
public static final AttributeOverride[] getAttributeOverrides(AnnotatedElement ae) {
AttributeOverride[] overrides = null;
AttributeOverrides aos = ae.getAnnotation(AttributeOverrides.class);
if (aos != null) {
overrides = aos.value();
}
if (overrides == null || overrides.length == 0) {
AttributeOverride override = ae.getAnnotation(AttributeOverride.class);
if (override != null) {
overrides = new AttributeOverride[1];
overrides[0] = override;
} else {
overrides = new AttributeOverride[0];
}
}
return overrides;
}
public static final boolean isPersistable(Field field) {
if (field.getAnnotation(Transient.class) != null) {
return false;
}
int modifiers = field.getModifiers();
return !(Modifier.isFinal(modifiers) ||
Modifier.isStatic(modifiers) ||
Modifier.isTransient(modifiers));
}
public static final boolean isIdField(Field field) {
if (field.getAnnotation(Id.class) != null) {
return true;
}
if (field.getAnnotation(EmbeddedId.class) != null) {
assert (field.getClass().getAnnotation(Embeddable.class) != null) : "Class " + field.getClass().getName() + " must be Embeddable to be used as Embedded Id";
return true;
}
return false;
}
public static final SecondaryTable[] getSecondaryTables(AnnotatedElement clazz) {
SecondaryTable[] sts = null;
SecondaryTable stAnnotation = clazz.getAnnotation(SecondaryTable.class);
if (stAnnotation == null) {
SecondaryTables stsAnnotation = clazz.getAnnotation(SecondaryTables.class);
sts = stsAnnotation != null ? stsAnnotation.value() : new SecondaryTable[0];
} else {
sts = new SecondaryTable[] {stAnnotation};
}
return sts;
}
public static final String getTableName(Class<?> clazz) {
Table table = clazz.getAnnotation(Table.class);
return table != null ? table.name() : clazz.getSimpleName();
}
public static boolean getGlobalLock(String name, int timeoutSeconds) {
Connection conn = getConnectionForGlobalLocks(name, true);
if(conn == null) {
s_logger.error("Unable to acquire DB connection for global lock system");
return false;
}
PreparedStatement pstmt = null;
try {
pstmt = conn.prepareStatement("SELECT COALESCE(GET_LOCK(?, ?),0)");
pstmt.setString(1, name);
pstmt.setInt(2, timeoutSeconds);
ResultSet rs = pstmt.executeQuery();
if (rs != null && rs.first()) {
if(rs.getInt(1) > 0) {
return true;
} else {
if(s_logger.isDebugEnabled())
s_logger.debug("GET_LOCK() timed out on lock : " + name);
}
}
} catch (SQLException e) {
s_logger.error("GET_LOCK() throws exception ", e);
} catch (Throwable e) {
s_logger.error("GET_LOCK() throws exception ", e);
} finally {
if (pstmt != null) {
try {
pstmt.close();
} catch (Throwable e) {
s_logger.error("What the heck? ", e);
}
}
}
removeConnectionForGlobalLocks(name);
try {
conn.close();
} catch (SQLException e) {
}
return false;
}
public static Class<?> getEntityBeanType(GenericDao<?, Long> dao) {
return dao.getEntityBeanType();
}
public static boolean releaseGlobalLock(String name) {
Connection conn = getConnectionForGlobalLocks(name, false);
if(conn == null) {
s_logger.error("Unable to acquire DB connection for global lock system");
assert(false);
return false;
}
PreparedStatement pstmt = null;
try {
pstmt = conn.prepareStatement("SELECT COALESCE(RELEASE_LOCK(?), 0)");
pstmt.setString(1, name);
ResultSet rs = pstmt.executeQuery();
if(rs != null && rs.first())
return rs.getInt(1) > 0;
s_logger.error("RELEASE_LOCK() returns unexpected result : " + rs.getInt(1));
} catch (SQLException e) {
s_logger.error("RELEASE_LOCK() throws exception ", e);
} catch (Throwable e) {
s_logger.error("RELEASE_LOCK() throws exception ", e);
} finally {
try {
if (pstmt != null) {
pstmt.close();
}
conn.close();
} catch(SQLException e) {
}
}
return false;
}
public static void closeResources(final Connection connection,
final Statement statement, final ResultSet resultSet) {
closeResultSet(resultSet);
closeStatement(statement);
closeConnection(connection);
}
public static void closeResources(final Statement statement, final ResultSet resultSet) {
closeResources(null, statement, resultSet);
}
public static void closeResultSet(final ResultSet resultSet) {
try {
if (resultSet != null) {
resultSet.close();
}
} catch (Exception e) {
s_logger.warn("Ignored exception while closing result set.",e);
}
}
public static void closeStatement(final Statement statement) {
try {
if (statement != null) {
statement.close();
}
} catch (Exception e) {
s_logger.warn("Ignored exception while closing statement.",e);
}
}
public static void closeConnection(final Connection connection) {
try {
if (connection != null) {
connection.close();
}
} catch (Exception e) {
s_logger.warn("Ignored exception while close connection.",e);
}
}
}