/* 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!");
}
}
/**
* ** 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());
}
public static void main(String argv[]) {
DBConfig.cmdLineInit(argv, true); // main
String accountID = RTConfig.getString(ARG_ACCOUNT, "");
String deviceID = RTConfig.getString(ARG_DEVICE, "");
int statusCode = RTConfig.getInt(ARG_CODE, 0);
boolean anyCode = true; // RTConfig.hasProperty(ARG_ECODE);
/* account-id specified? */
if (StringTools.isBlank(accountID)) {
Print.logError("Account-ID not specified.");
usage();
}
/* get account */
Account account = null;
try {
account = Account.getAccount(accountID); // may throw DBException
if (account == null) {
Print.logError("Account-ID does not exist: " + accountID);
usage();
}
} catch (DBException dbe) {
Print.logException("Error loading Account: " + accountID, dbe);
// dbe.printException();
System.exit(99);
}
/* device-id specified? */
if (StringTools.isBlank(deviceID) || deviceID.startsWith("/")) {
deviceID = ALL_DEVICES;
}
/* check device existance */
if (!deviceID.equals(ALL_DEVICES)) {
try {
Device device = Device.getDevice(account, deviceID); // may throw DBException
if (device == null) {
Print.logError("Device-ID does not exist: " + accountID + " / " + deviceID);
usage();
}
} catch (DBException dbe) {
Print.logException("Error loading Device: " + accountID + " / " + deviceID, dbe);
System.exit(99);
}
}
/* status-code specified? */
if ((statusCode > 0)
&& !anyCode
&& !StatusCodes.IsValid(statusCode, account.getPrivateLabel())) {
Print.logError("Invalid Status Code specified.");
usage();
}
/* statusCode specified? */
if (statusCode <= 0) {
Print.logError("StatusCode not specified.");
usage();
}
/* statusCode exists? */
boolean statusCodeExists = false;
try {
statusCodeExists = StatusCode.exists(accountID, deviceID, statusCode);
} catch (DBException dbe) {
Print.logError(
"Error determining if StatusCode exists: "
+ accountID
+ "/"
+ deviceID
+ "/"
+ statusCode);
System.exit(99);
}
/* option count */
int opts = 0;
/* delete */
if (RTConfig.getBoolean(ARG_DELETE, false)) {
opts++;
if (!statusCodeExists) {
Print.logWarn(
"StatusCode does not exist: " + accountID + "/" + deviceID + "/" + statusCode);
Print.logWarn("Continuing with delete process ...");
}
try {
StatusCode.Key scKey = new StatusCode.Key(accountID, deviceID, statusCode);
scKey.delete(true); // also delete dependencies (if any)
Print.logInfo("StatusCode deleted: " + accountID + "/" + deviceID + "/" + statusCode);
statusCodeExists = false;
} catch (DBException dbe) {
Print.logError(
"Error deleting StatusCode: " + accountID + "/" + deviceID + "/" + statusCode);
dbe.printException();
System.exit(99);
}
System.exit(0);
}
/* create */
if (RTConfig.getBoolean(ARG_CREATE, false)) {
opts++;
if (statusCodeExists) {
Print.logWarn(
"StatusCode already exists: " + accountID + "/" + deviceID + "/" + statusCode);
} else {
try {
StatusCode.createNewStatusCode(account, deviceID, statusCode);
Print.logInfo("Created StatusCode: " + accountID + "/" + deviceID + "/" + statusCode);
statusCodeExists = true;
} catch (DBException dbe) {
Print.logError(
"Error creating StatusCode: " + accountID + "/" + deviceID + "/" + statusCode);
dbe.printException();
System.exit(99);
}
}
}
/* edit */
if (RTConfig.getBoolean(ARG_EDIT, false)) {
opts++;
if (!statusCodeExists) {
Print.logError(
"StatusCode does not exist: " + accountID + "/" + deviceID + "/" + statusCode);
} else {
try {
StatusCode sc =
StatusCode.getStatusCode(account, deviceID, statusCode); // may throw DBException
DBEdit editor = new DBEdit(sc);
editor.edit(); // may throw IOException
} catch (IOException ioe) {
if (ioe instanceof EOFException) {
Print.logError("End of input");
} else {
Print.logError("IO Error");
}
} catch (DBException dbe) {
Print.logError(
"Error editing StatusCode: " + accountID + "/" + deviceID + "/" + statusCode);
dbe.printException();
}
}
System.exit(0);
}
/* list */
if (RTConfig.hasProperty(ARG_LIST)) {
opts++;
String listType = RTConfig.getString(ARG_LIST, null);
// TODO: complete ...
}
/* no options specified */
if (opts == 0) {
Print.logWarn("Missing options ...");
usage();
}
}
public static void main(String args[]) {
DBConfig.cmdLineInit(args, true); // main
String acctID = RTConfig.getString(ARG_ACCOUNT, "");
String roleID = RTConfig.getString(ARG_ROLE, "");
String aclID = RTConfig.getString(ARG_ACL, "");
/* account-id specified? */
if ((acctID == null) || acctID.equals("")) {
Print.logError("Account-ID not specified.");
usage();
}
/* get account */
Account acct = null;
try {
acct = Account.getAccount(acctID); // may return DBException
if (acct == null) {
Print.logError("Account-ID does not exist: " + acctID);
usage();
}
} catch (DBException dbe) {
Print.logException("Error loading Account: " + acctID, dbe);
// dbe.printException();
System.exit(99);
}
/* role-id specified? */
if ((roleID == null) || roleID.equals("")) {
Print.logError("Role-ID not specified.");
usage();
}
/* get role */
Role role = null;
try {
role = Role.getRole(acct, roleID); // may return DBException
if (role == null) {
Print.logError("Role-ID does not exist: " + acctID + "/" + roleID);
usage();
}
} catch (DBException dbe) {
Print.logException("Error loading Role: " + acctID + "/" + roleID, dbe);
// dbe.printException();
System.exit(99);
}
/* RoleAcl exists? */
boolean aclExists = false;
if ((aclID != null) && !aclID.equals("")) {
try {
aclExists = RoleAcl.exists(acctID, roleID, aclID);
} catch (DBException dbe) {
Print.logError(
"Error determining if RoleAcl exists: " + acctID + "/" + roleID + "/" + aclID);
System.exit(99);
}
}
/* option count */
int opts = 0;
/* list */
if (RTConfig.getBoolean(ARG_LIST, false)) {
opts++;
try {
String aclList[] = role.getAclsForRole();
for (int i = 0; i < aclList.length; i++) {
AccessLevel level = RoleAcl.getAccessLevel(role, aclList[i], AccessLevel.NONE);
Print.sysPrintln(" " + aclList[i] + " ==> " + level);
}
} catch (DBException dbe) {
Print.logError("Error getting Acl list: " + dbe);
System.exit(99);
}
System.exit(0);
}
/* delete */
if (RTConfig.getBoolean(ARG_DELETE, false) && !acctID.equals("") && !roleID.equals("")) {
opts++;
if (!aclExists) {
Print.logWarn("RoleAcl does not exist: " + acctID + "/" + roleID + "/" + aclID);
Print.logWarn("Continuing with delete process ...");
}
try {
RoleAcl.Key aclKey = new RoleAcl.Key(acctID, roleID, aclID);
aclKey.delete(true); // also delete dependencies
Print.logInfo("RoleAcl deleted: " + acctID + "/" + roleID + "/" + aclID);
} catch (DBException dbe) {
Print.logError("Error deleting RoleAcl: " + acctID + "/" + roleID + "/" + aclID);
dbe.printException();
System.exit(99);
}
System.exit(0);
}
/* create */
if (RTConfig.getBoolean(ARG_CREATE, false)) {
opts++;
if (aclExists) {
Print.logWarn("RoleAcl already exists: " + acctID + "/" + roleID + "/" + aclID);
} else {
try {
RoleAcl.createNewRoleAcl(role, aclID);
Print.logInfo("Created RoleAcl: " + acctID + "/" + roleID + "/" + aclID);
aclExists = true;
} catch (DBException dbe) {
Print.logError("Error creating RoleAcl: " + acctID + "/" + roleID + "/" + aclID);
dbe.printException();
System.exit(99);
}
}
}
/* set */
if (RTConfig.hasProperty(ARG_SET)) {
opts++;
AccessLevel aclLevel = EnumTools.getValueOf(AccessLevel.class, RTConfig.getInt(ARG_SET, -1));
try {
RoleAcl.setAccessLevel(role, aclID, aclLevel);
Print.logInfo(
"Set RoleAcl '" + acctID + "/" + roleID + "/" + aclID + "' to level " + aclLevel);
} catch (DBException dbe) {
Print.logError("Error setting RoleAcl: " + acctID + "/" + roleID + "/" + aclID);
dbe.printException();
System.exit(99);
}
System.exit(0);
}
/* edit */
if (RTConfig.getBoolean(ARG_EDIT, false)) {
opts++;
if (!aclExists) {
Print.logError("RoleAcl does not exist: " + acctID + "/" + roleID + "/" + aclID);
} else {
try {
RoleAcl roleAcl = RoleAcl.getRoleAcl(role, aclID, false); // may throw DBException
DBEdit editor = new DBEdit(roleAcl);
editor.edit(); // may throw IOException
} catch (IOException ioe) {
if (ioe instanceof EOFException) {
Print.logError("End of input");
} else {
Print.logError("IO Error");
}
} catch (DBException dbe) {
Print.logError("Error editing RoleAcl: " + acctID + "/" + roleID + "/" + aclID);
dbe.printException();
}
}
System.exit(0);
}
/* no options specified */
if (opts == 0) {
Print.logWarn("Missing options ...");
usage();
}
}