/**
* ** A String reperesentation of this URI (with arguments) ** @return A String representation of
* this URI
*/
public String toString() {
StringBuffer sb = new StringBuffer(this.getURI());
if (!ListTools.isEmpty(this.getKeyValList())) {
sb.append("?");
this.getArgString(sb);
}
return sb.toString();
}
/**
* ** A String reperesentation of this URI (with arguments) ** @param includeBlankValues True to
* include keys for blank values. ** @return A String representation of this URI
*/
public String toString(boolean includeBlankValues) {
StringBuffer sb = new StringBuffer(this.getURI());
if (!ListTools.isEmpty(this.getKeyValList())) {
sb.append("?");
this.getArgString(sb, includeBlankValues);
}
return sb.toString();
}
/* private constructor */
private TrackServer(int tcpPorts[], int udpPorts[], int commandPort) throws Throwable {
int listeners = 0;
// Start TCP listeners
if (!ListTools.isEmpty(tcpPorts)) {
for (int i = 0; i < tcpPorts.length; i++) {
int port = tcpPorts[i];
if (ServerSocketThread.isValidPort(port)) {
try {
this._startTCP(port);
listeners++;
} catch (java.net.BindException be) {
Print.logError("TCP: Error binding to port: %d", port);
}
} else {
throw new Exception("TCP: Invalid port number: " + port);
}
}
}
// Start UDP listeners
if (!ListTools.isEmpty(udpPorts)) {
for (int i = 0; i < udpPorts.length; i++) {
int port = udpPorts[i];
if (ServerSocketThread.isValidPort(port)) {
try {
ServerSocketThread sst = this._startUDP(port);
if (this.udpSocket == null) {
this.udpSocket = sst.getDatagramSocket();
}
listeners++;
} catch (java.net.BindException be) {
Print.logError("UDP: Error binding to port: %d", port);
}
} else {
throw new Exception("UDP: Invalid port number: " + port);
}
}
}
/* do we have any active listeners? */
if (listeners <= 0) {
Print.logWarn("No active device communication listeners!");
}
}
public static String GetPropertyString_OBDII(long dtcFault[]) {
if (ListTools.isEmpty(dtcFault)) {
return GetPropertyString_OBDII("");
} else {
java.util.List<String> dtc = new Vector<String>();
for (int i = 0; i < dtcFault.length; i++) {
if (dtcFault[i] != 0L) {
dtc.add(GetFaultString(dtcFault[i]));
}
}
return GetPropertyString_OBDII(dtc);
}
}
/**
* ** Returns a new URIArg with this URIArg's arguments encoded into a ** single RTProperties
* added with a specified key [CHECK] ** @param rtpKey The key to add the encoded args at
* ** @param exclKeys keys to exclude from encoding ** @return A new URIArg with non excluded
* arguments encoded
*/
public URIArg rtpEncode(String rtpKey, String... exclKeys) {
URIArg rtpUrl = new URIArg(this.getURI());
RTProperties rtp = new RTProperties();
for (KeyVal kv : this.getKeyValList()) {
String kn = kv.getKey();
if (ListTools.contains(exclKeys, kn)) {
rtpUrl.addArg(kv);
} else {
rtp.setString(kn, kv.getValue());
}
}
rtpUrl.addArg(rtpKey, rtp);
return rtpUrl;
}
/**
* ** Sets the specified argument key to the specified String value. ** @param key The key of the
* agrument ** @param value The value to set ** @param obfuscate True if the value should be
* obfuscated ** @return True if the argument existed, else false
*/
public boolean setArgValue(String key[], String value, boolean obfuscate) {
if (ListTools.size(key) >= 1) {
boolean hadArg = this.hasArg(key);
// remove all but the first key
for (int i = 1; i < key.length; i++) {
this.removeArg(key[i]);
}
// set the first key
this.setArgValue(key[0], value, obfuscate);
return hadArg;
} else {
return false;
}
}
/**
* ** Returns true if this key fully defines all key fields ** @return True if this key fully
* defines all key fields
*/
public boolean isFullKey() {
DBField kfld[] = this.getKeyFields();
if (ListTools.isEmpty(kfld)) {
return false;
} else {
DBFieldValues fldVals = this.getFieldValues(); // hasPartialKey
for (int i = 0; i < kfld.length; i++) {
String fldName = kfld[i].getName();
if (!fldVals.hasFieldValue(fldName)) {
return false;
}
}
return true;
}
}
/**
* ** Return the 'WHERE' clause for this key [CHECK] ** @param altIndexName The alternate index
* name. If null or blank, uses ** primary keys instead ** @param whereKeyType The where key type.
* One of the constants from DBWhere ** @return The 'WHERE' clause for this key
*/
protected String _getWhereClause(
String altIndexName, int whereKeyType) // boolean fullKeyRequired)
throws DBException {
/* key fields */
boolean usePrimaryKey = StringTools.isBlank(altIndexName);
DBField keyFlds[] = usePrimaryKey ? this.getKeyFields() : this.getAltKeyFields(altIndexName);
if (ListTools.isEmpty(keyFlds)) {
throw new DBException("No keys found!");
}
/* WHERE */
DBWhere dwh = new DBWhere(this.getFactory());
DBFieldValues fldVals = this.getFieldValues();
int keyCnt = 0;
boolean hasPartialKey = false;
for (int i = 0; i < keyFlds.length; i++) {
String fldName = keyFlds[i].getName();
if (fldVals.hasFieldValue(fldName)) {
if (!hasPartialKey || (whereKeyType == DBWhere.KEY_PARTIAL_ALL)) {
String fev = dwh.EQ(fldName, fldVals.getFieldValueAsString(fldName));
if (keyCnt > 0) {
dwh.append(dwh.AND_(fev));
} else {
dwh.append(fev);
}
keyCnt++;
} else {
// whereKeyType == DBWhere.KEY_PARTIAL_FIRST, and we found a subsequent key
String m =
"Additional partial key in 'WHERE' clause! ["
+ this.getTableName()
+ "."
+ fldName
+ "]";
// throw new DBException(m); // TODO:
Print.logWarn("******************************************************************");
Print.logWarn(m);
// Print.logWarn(StringTools.join(keyFlds,","));
// Print.logStackTrace(m);
Print.logWarn("******************************************************************");
}
} else if ((i == 0) && (whereKeyType != DBWhere.KEY_PARTIAL_ALL_EMPTY)) { //
// missing first key
if (keyFlds[i].isAutoIncrement()) {
// first key is an "auto_increment" and it is not present
// assume that we are expecting the DB server to create this value for us, thus the key
// dow not exist
// However, there is nothing we can do about this here.
String m =
"First key field for 'WHERE' clause is 'auto_increment' and field is not present ["
+ this.getTableName()
+ "."
+ fldName
+ "]";
throw new DBException(m);
} else {
String m =
"Missing first key field for 'WHERE' clause! ["
+ this.getTableName()
+ "."
+ fldName
+ "]";
throw new DBException(m);
}
} else if (whereKeyType == DBWhere.KEY_FULL) {
// missing a key when all keys are required
String m = "Missing key for 'WHERE' clause! [" + this.getTableName() + "." + fldName + "]";
throw new DBException(m);
} else {
// only a portion of the key has been specified.
// This is a common occurance deleting an Account/Device with sub-dependencies
// Print.logWarn("Key field not specified: " + this.getTableName() + "." + fldName);
hasPartialKey = true;
}
}
return (keyCnt > 1) ? dwh.WHERE(dwh.toString()) : dwh.WHERE_(dwh.toString());
}
/**
* ** Returns true if the specified key attribute exists in the table ** @param altIndexName The
* alternate index name, or null to use the primary index ** @param whereKeyType The partial key
* match type ** @return True if the specified key attribute exists in the table, false otherwise
*/
protected boolean _exists(String altIndexName, int whereKeyType)
throws SQLException, DBException {
/* key fields */
boolean usePrimaryKey = StringTools.isBlank(altIndexName);
DBField kfld[] = usePrimaryKey ? this.getKeyFields() : this.getAltKeyFields(altIndexName);
if (ListTools.isEmpty(kfld)) {
throw new DBException("No keys found!");
}
/* check last key for "auto_increment" */
if (whereKeyType == DBWhere.KEY_FULL) {
DBField lastField = kfld[kfld.length - 1];
if (lastField.isAutoIncrement()
&& !this.getFieldValues().hasFieldValue(lastField.getName())) {
// full key requested and last key is auto_increment, which is missing
return false;
}
}
// DBSelect: SELECT <Keys> FROM <TableName> <KeyWhere>
String firstKey = kfld[0].getName();
DBSelect<gDBR> dsel = new DBSelect<gDBR>(this.getFactory());
dsel.setSelectedFields(firstKey);
dsel.setWhere(this._getWhereClause(altIndexName, whereKeyType));
/* get keyed record */
DBConnection dbc = null;
Statement stmt = null;
ResultSet rs = null;
boolean exists = false;
try {
dbc = DBConnection.getDefaultConnection();
stmt = dbc.execute(dsel.toString()); // may throw DBException
rs = stmt.getResultSet();
exists = rs.next();
} catch (SQLException sqe) {
if (sqe.getErrorCode() == DBFactory.SQLERR_TABLE_NOTLOCKED) {
// MySQL: This case has been seen on rare occasions. Not sure what causes it.
Print.logError("SQL Lock Error: " + sqe);
Print.logError("Hackery! Forcing lock on table: " + this.getTableName());
if (DBProvider.lockTableForRead(this.getTableName(), true)) { // may throw DBException
stmt = dbc.execute(dsel.toString()); // may throw SQLException, DBException
rs = stmt.getResultSet(); // SQLException
exists = rs.next(); // SQLException
DBProvider.unlockTables(); // DBException
}
} else {
throw sqe;
}
} finally {
if (rs != null) {
try {
rs.close();
} catch (Throwable t) {
}
}
if (stmt != null) {
try {
stmt.close();
} catch (Throwable t) {
}
}
DBConnection.release(dbc);
}
return exists;
}
/**
* ** Returns true if any tagged field names have been defined ** @return True if any tagged field
* names have been defined
*/
public boolean hasTaggedFields() {
return !ListTools.isEmpty(this.taggedFields);
}
public static String GetPropertyString_OBDII(java.util.List<String> dtc) {
String dtcStr = !ListTools.isEmpty(dtc) ? StringTools.join(dtc, ",") : "";
return GetPropertyString_OBDII(dtcStr);
}
public static String GetPropertyString_OBDII(String dtc[]) {
String dtcStr = !ListTools.isEmpty(dtc) ? StringTools.join(dtc, ",") : "";
return GetPropertyString_OBDII(dtcStr);
}