protected String getLogBuffer(
VariableSpace space, String logChannelId, LogStatus status, String limit) {
StringBuffer buffer = KettleLogStore.getAppender().getBuffer(logChannelId, true);
if (Const.isEmpty(limit)) {
String defaultLimit = space.getVariable(Const.KETTLE_LOG_SIZE_LIMIT, null);
if (!Const.isEmpty(defaultLimit)) {
limit = defaultLimit;
}
}
// See if we need to limit the amount of rows
//
int nrLines = Const.isEmpty(limit) ? -1 : Const.toInt(space.environmentSubstitute(limit), -1);
if (nrLines > 0) {
int start = buffer.length() - 1;
for (int i = 0; i < nrLines && start > 0; i++) {
start = buffer.lastIndexOf(Const.CR, start - 1);
}
if (start > 0) {
buffer.delete(0, start + Const.CR.length());
}
}
return buffer.append(Const.CR + status.getStatus().toUpperCase() + Const.CR).toString();
}
// Listen to the Variable... button
public static final String getVariableName(Shell shell, VariableSpace space) {
String keys[] = space.listVariables();
Arrays.sort(keys);
int size = keys.length;
String key[] = new String[size];
String val[] = new String[size];
String str[] = new String[size];
for (int i = 0; i < keys.length; i++) {
key[i] = keys[i];
val[i] = space.getVariable(key[i]);
str[i] = key[i] + " [" + val[i] + "]";
}
EnterSelectionDialog esd =
new EnterSelectionDialog(
shell,
str,
Messages.getString("System.Dialog.SelectEnvironmentVar.Title"),
Messages.getString("System.Dialog.SelectEnvironmentVar.Message"));
esd.clearModal();
if (esd.open() != null) {
int nr = esd.getSelectionNr();
String var = key[nr];
return var;
} else {
return null;
}
}
public void setVariables(VariableSpace space) {
this.variables = new HashMap<String, String>();
for (String name : space.listVariables()) {
String value = space.getVariable(name);
this.variables.put(name, value);
}
}
/** @return the connectionName */
public String getActualConnectionName() {
String name = space.environmentSubstitute(connectionName);
if (Const.isEmpty(name)) {
name = space.getVariable(getConnectionNameVariable());
}
if (Const.isEmpty(name)) return null;
else return name;
}
/** @return the tableName */
public String getActualTableName() {
if (!Const.isEmpty(tableName)) return space.environmentSubstitute(tableName);
String name = space.getVariable(getTableNameVariable());
if (Const.isEmpty(name)) {
return null;
} else {
return name;
}
}
/** @return the schemaName */
public String getActualSchemaName() {
if (!Const.isEmpty(schemaName)) {
return space.environmentSubstitute(schemaName);
}
String name = space.getVariable(getSchemaNameVariable());
if (Const.isEmpty(name)) {
return null;
} else {
return name;
}
}
public void getUsedVariables(JobMeta jobMeta) {
Properties sp = new Properties();
VariableSpace space = Variables.getADefaultVariableSpace();
String[] keys = space.listVariables();
for (int i = 0; i < keys.length; i++) {
sp.put(keys[i], space.getVariable(keys[i]));
}
List<String> vars = jobMeta.getUsedVariables();
if (vars != null && vars.size() > 0) {
HashMap<String, String> newVariables = new HashMap<String, String>();
for (int i = 0; i < vars.size(); i++) {
String varname = vars.get(i);
if (!varname.startsWith(Const.INTERNAL_VARIABLE_PREFIX)) {
newVariables.put(varname, Const.NVL(variables.get(varname), sp.getProperty(varname, "")));
}
}
// variables.clear();
variables.putAll(newVariables);
}
}
/**
* This factory returns a FileSystemConfigBuilder. Custom FileSystemConfigBuilders can be created
* by implementing the {@link IKettleFileSystemConfigBuilder} or overriding the {@link
* KettleGenericFileSystemConfigBuilder}
*
* @see FileSystemConfigBuilder
* @param varSpace A Kettle variable space for resolving VFS config parameters
* @param scheme The VFS scheme (FILE, HTTP, SFTP, etc...)
* @return A FileSystemConfigBuilder that can translate Kettle variables into VFS config
* parameters
* @throws IOException
*/
public static IKettleFileSystemConfigBuilder getConfigBuilder(
VariableSpace varSpace, String scheme) throws IOException {
IKettleFileSystemConfigBuilder result = null;
// Attempt to load the Config Builder from a variable: vfs.config.parser = class
String parserClass =
varSpace.getVariable("vfs." + scheme + ".config.parser"); // $NON-NLS-1$ //$NON-NLS-2$
if (parserClass != null) {
try {
Class<?> configBuilderClass =
KettleFileSystemConfigBuilderFactory.class.getClassLoader().loadClass(parserClass);
Method mGetInstance = configBuilderClass.getMethod("getInstance"); // $NON-NLS-1$
if ((mGetInstance != null)
&& (IKettleFileSystemConfigBuilder.class.isAssignableFrom(
mGetInstance.getReturnType()))) {
result = (IKettleFileSystemConfigBuilder) mGetInstance.invoke(null);
} else {
result = (IKettleFileSystemConfigBuilder) configBuilderClass.newInstance();
}
} catch (Exception e) {
// Failed to load custom parser. Throw exception.
throw new IOException(
BaseMessages.getString(PKG, "CustomVfsSettingsParser.Log.FailedToLoad")); // $NON-NLS-1$
}
} else {
// No custom parser requested, load default
if (scheme.equalsIgnoreCase("sftp")) { // $NON-NLS-1$
result = KettleSftpFileSystemConfigBuilder.getInstance();
} else {
result = KettleGenericFileSystemConfigBuilder.getInstance();
}
}
return result;
}
public String getVariable(String variableName) {
return variables.getVariable(variableName);
}
public String getVariable(String variableName, String defaultValue) {
return variables.getVariable(variableName, defaultValue);
}
