private AbstractExtensionWrapper getCache(Class<AbstractExtension<?>> cls)
throws StartException, InstantiationException, IllegalAccessException, IOException {
String id = cls.getName().substring(27);
// File cache = Application.getResource("tmp/extensioncache/" + id +
// ".json");
// AbstractExtensionWrapper cached = JSonStorage.restoreFrom(cache,
// true, (byte[]) null, new TypeRef<AbstractExtensionWrapper>() {
AbstractExtensionWrapper cached = cache.get(id);
int v = AbstractExtension.readVersion(cls);
if (cached != null) {
cached._setClazz(cls);
if (cached.getVersion() != v
|| !cached.getLng().equals(_JDT.getLanguage())
|| cached._getSettings() == null) {
// update cache
cached = null;
}
}
if (cached == null) {
Log.L.info("Update Cache " + cache);
cached = AbstractExtensionWrapper.create(id, cls);
cache.put(id, cached);
cacheChanged = true;
} else {
cached._setClazz(cls);
}
return cached;
}
/**
* Set-up this class by creating the HashMap for the key-string-pairs.
*
* @param loc
* name of the localization file
* @see Loc#parseLocalization(RFSFile)
*/
public static void setLocale(String loc) {
try {
if (loc == null) {
loc = Loc.CFG.get(Loc.PROPERTY_LOCALE, Loc.getDefaultLocale());
}
// first check filesystem
final URL file = Loc.getResourceURL(loc);
Loc.locale = loc;
if (file != null) {
// TODO
Loc.CFG.put(Loc.PROPERTY_LOCALE, loc);
Loc.parseLocalization(file);
} else {
Log.L.info("The language " + loc + " isn't available! Parsing default (" + Loc.FALLBACK_LOCALE + ".loc) one!");
Loc.locale = Loc.getDefaultLocale();
final String[] locs = Loc.locale.split("_");
Locale.setDefault(new Locale(locs[0], locs[1]));
Loc.parseLocalization(Loc.getResourceURL(Loc.FALLBACK_LOCALE));
}
} catch (final Exception e) {
org.appwork.utils.logging.Log.exception(e);
}
}
@Override
protected String send(String serviceName, String routine, String serialise)
throws ServerInvokationException {
try {
String url =
"http://" + this.host + "/" + serviceName + "/" + URLEncoder.encode(routine, "UTF-8");
Log.L.finer(url + "?" + serialise);
String red = br.postPageRaw(url, serialise);
URLConnectionAdapter con = br.getHttpConnection();
if (con.getResponseCode() == HTTPConstants.ResponseCode.SUCCESS_OK.getCode()) {
return red;
} else if (con.getResponseCode()
== HTTPConstants.ResponseCode.SERVERERROR_INTERNAL.getCode()) {
// Exception
throw new ServerInvokationException(red, new Requestor(serviceName, routine, serialise));
} else {
throw new RemoteCallCommunicationException("Wrong ResponseCode " + con.getResponseCode());
}
} catch (final ServerInvokationException e) {
throw e;
} catch (final IOException e) {
throw new RemoteCallCommunicationException(e);
} catch (final Exception e) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
}
throw new RuntimeException(e);
}
}
/**
* Called when a new directory has to be added.
*
* <p>For each 'addDir' call server will call 'closeDir' method after all children of the added
* directory are added.
*
* <p>This implementation creates corresponding directory below root directory.
*/
public void addDir(String path, String copyFromPath, long copyFromRevision) throws SVNException {
File newDir = new File(myRootDirectory, path);
if (!newDir.exists()) {
if (!newDir.mkdirs()) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.IO_ERROR, "error: failed to add the directory ''{0}''.", newDir);
throw new SVNException(err);
}
}
Log.L.fine("dir added: " + path);
}
/**
* Returns the translated value for the translation-key. If the current
* language file doesn't contain the translated value, the default value
* will be returned.
*
* @param key
* key for the translation in the language file. the key should
* <b>always</b> have the following structure
* <i>PACKAGE_NAME_FROM_CALLER.CLASS_NAME_FROM_CALLER.key</i>
* @param def
* default value which will be returned if there is no mapping
* for the key
* @return translated value or the def parameter
* @see Loc#LF(String, String, Object...)
* @throws IllegalArgumentException
* if the key is null or is empty
*/
public static String L(String key, final String def) {
if (key == null || (key = key.trim()).length() == 0) { throw new IllegalArgumentException(); }
if (Loc.DATA == null) {
Log.L.warning("No parsed localization found! Loading now from saved localization file!");
try {
Loc.setLocale(Loc.CFG.get(Loc.PROPERTY_LOCALE, Loc.FALLBACK_LOCALE));
} catch (final Exception e) {
Log.L.severe("Error while loading the stored localization name!");
Loc.setLocale(Loc.FALLBACK_LOCALE);
}
if (Loc.DATA == null) { return def == null ? "Error in Loc! No loaded data!" : def; }
}
final String loc = Loc.DATA.get(key.toLowerCase().hashCode());
if (loc == null) {
Loc.DATA.put(key.toLowerCase().hashCode(), def);
return def;
}
return loc;
}
/**
* Creates a HashMap with the data obtained from the localization file. <br>
* <b>Warning:</b> Overwrites any previously created HashMap
*
* @param file
* {@link RFSFile} object to the localization file
* @throws IllegalArgumentException
* if the parameter is null or doesn't exist
* @see Loc#DATA
*/
public static void parseLocalization(final URL file) throws IllegalArgumentException {
if (file == null) { throw new IllegalArgumentException(); }
if (Loc.DATA != null) {
Log.L.finer("Previous HashMap will be overwritten!");
}
Loc.DATA = new HashMap<Integer, String>();
BufferedReader reader = null;
InputStreamReader isr = null;
InputStream fis = null;
try {
reader = new BufferedReader(isr = new InputStreamReader(fis = file.openStream(), "UTF8"));
String line;
String key;
String value;
int split;
while ((line = reader.readLine()) != null) {
if (line.startsWith("#")) {
continue;
}
if ((split = line.indexOf('=')) <= 0) {
continue;
}
key = line.substring(0, split).toLowerCase().trim();
value = line.substring(split + 1).trim();
value = value.replace("\\n", "\n").replace("\\r", "\r");
Loc.DATA.put(key.hashCode(), value);
}
} catch (final FileNotFoundException e) {
throw new IllegalArgumentException(e);
} catch (final Exception e) {
org.appwork.utils.logging.Log.exception(e);
} finally {
try {
reader.close();
} catch (final Throwable e) {
}
try {
isr.close();
} catch (final Throwable e) {
}
try {
fis.close();
} catch (final Throwable e) {
}
}
}
public void validate(Login login, String url) {
if (StringUtils.isEmpty(url)) {
return;
}
AuthenticationInfo.Type type = null;
if (url.startsWith("ftp")) {
type = Type.FTP;
} else if (url.startsWith("http")) {
type = Type.HTTP;
} else {
Log.L.info("Unknown Protocoll: " + url);
return;
}
String urlHost = Browser.getHost(url, true);
for (AuthenticationInfo info : list) {
if (!info.isEnabled()) {
continue;
}
String authHost = info.getHostmask();
if (info.getType().equals(type) && !StringUtils.isEmpty(authHost)) {
boolean contains = false;
if (authHost.length() > urlHost.length()) {
/* hostMask of AuthenticationInfo is longer */
contains = authHost.contains(urlHost);
} else {
/* hostMask of urlHost is longer */
contains = urlHost.contains(authHost);
}
if (contains) {
if (StringUtils.equals(info.getUsername(), login.getUsername())
&& StringUtils.equals(info.getPassword(), login.getPassword())) {
info.setLastValidated(System.currentTimeMillis());
}
}
}
}
}
public ExceptionDialog(
final int flag,
final String title,
final String message,
final Throwable exception,
final String okOption,
final String cancelOption) {
super(flag, title, null, okOption, cancelOption);
Log.L.fine(
"Dialog ["
+ okOption
+ "]["
+ cancelOption
+ "]\r\nflag: "
+ Integer.toBinaryString(flag)
+ "\r\ntitle: "
+ title
+ "\r\nmsg: \r\n"
+ message);
this.message = message;
this.exception = exception;
}
public List<Login> getSortedLoginsList(String url) {
if (StringUtils.isEmpty(url)) {
return null;
}
AuthenticationInfo.Type type = null;
if (url.startsWith("ftp")) {
type = Type.FTP;
} else if (url.startsWith("http")) {
type = Type.HTTP;
} else {
Log.L.info("Unknown Protocoll: " + url);
return null;
}
final ArrayList<AuthenticationInfo> possibleInfos = new ArrayList<AuthenticationInfo>();
String urlHost = Browser.getHost(url, true);
for (AuthenticationInfo info : list) {
if (!info.isEnabled()) {
continue;
}
final String authHost = info.getHostmask();
if (info.getType().equals(type) && !StringUtils.isEmpty(authHost)) {
boolean contains = false;
if (authHost.length() > urlHost.length()) {
/* hostMask of AuthenticationInfo is longer */
contains = authHost.contains(urlHost);
} else {
/* hostMask of urlHost is longer */
contains = urlHost.contains(authHost);
}
if (contains) {
possibleInfos.add(info);
}
}
}
try {
Collections.sort(
possibleInfos,
new Comparator<AuthenticationInfo>() {
@Override
public int compare(AuthenticationInfo o1, AuthenticationInfo o2) {
int ret = Integer.compare(o2.getHostmask().length(), o1.getHostmask().length());
if (ret == 0) {
ret = Long.compare(o2.getLastValidated(), o1.getLastValidated());
}
if (ret == 0) {
ret = Long.compare(o2.getCreated(), o1.getCreated());
}
return ret;
}
});
} catch (Throwable e) {
logger.log(e);
}
final ArrayList<Login> ret = new ArrayList<Login>();
for (AuthenticationInfo info : possibleInfos) {
ret.add(new Login(info.getUsername(), info.getPassword()));
}
return ret;
}
@SuppressWarnings("unchecked")
private void loadUnpacked() {
URL ret = getClass().getResource("/");
File root;
if (ret.getProtocol().equalsIgnoreCase("file")) {
try {
root = new File(ret.toURI());
} catch (URISyntaxException e) {
Log.exception(e);
Log.L.finer("Did not load unpacked Extensions from " + ret);
return;
}
} else {
Log.L.finer("Did not load unpacked Extensions from " + ret);
return;
}
root = new File(root, AbstractExtension.class.getPackage().getName().replace('.', '/'));
Log.L.finer("Load Extensions from: " + root.getAbsolutePath());
File[] folders =
root.listFiles(
new FileFilter() {
public boolean accept(File pathname) {
return pathname.isDirectory();
}
});
ClassLoader cl = getClass().getClassLoader();
main:
for (File f : folders) {
File[] modules =
f.listFiles(
new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.endsWith("Extension.class");
}
});
boolean loaded = false;
for (File module : modules) {
Class<?> cls;
try {
cls =
cl.loadClass(
AbstractExtension.class.getPackage().getName()
+ "."
+ module.getParentFile().getName()
+ "."
+ module.getName().substring(0, module.getName().length() - 6));
if (AbstractExtension.class.isAssignableFrom(cls)) {
loaded = true;
initModule((Class<AbstractExtension<?>>) cls);
continue main;
}
} catch (IllegalArgumentException e) {
Log.L.warning("Did not init Extension " + module + " : " + e.getMessage());
} catch (Throwable e) {
Log.exception(e);
Dialog.getInstance().showExceptionDialog("Error", e.getMessage(), e);
}
}
if (!loaded) {
Log.L.warning("Could not load any Extension Module from " + f);
}
}
}
public static void main(String[] args) {
Log.L.setLevel(Level.ALL);
new EDTRunner() {
@Override
protected void runInEDT() {
final ProgressGetter pg =
new ProgressGetter() {
private long loaded = 0;
private long total = 100;
@Override
public int getProgress() {
if (this.total == 0) {
return 0;
}
return (int) (this.loaded * 100 / this.total);
}
@Override
public String getString() {
if (this.total <= 0) {
return _AWU.T.connecting();
}
String ret =
_AWU.T.progress(
SizeFormatter.formatBytes(this.loaded),
SizeFormatter.formatBytes(this.total),
(this.loaded * 10000 / this.total) / 100.0);
return ret;
}
@Override
public void run() throws Exception {
for (int i = 0; i < 100; i++) {
Thread.sleep(1000);
loaded++;
}
}
@Override
public String getLabelString() {
return getProgress() + " %";
}
};
final ProgressDialog dialog =
new ProgressDialog(
pg,
UIOManager.BUTTONS_HIDE_CANCEL | UIOManager.BUTTONS_HIDE_OK,
_AWU.T.download_title(),
_AWU.T.download_msg(),
AWUTheme.getInstance().getIcon("download", 32)) {
/** */
protected boolean isLabelEnabled() {
// TODO Auto-generated method stub
return true;
}
};
try {
Dialog.getInstance().showDialog(dialog);
} catch (DialogCanceledException ee) {
} catch (DialogClosedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
}