358 lines
12 KiB
Java
358 lines
12 KiB
Java
/*
|
|
* Copyright (c) 2017, 7u83 <7u83@mail.ru>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
package sesim;
|
|
|
|
import gui.Globals;
|
|
import java.io.File;
|
|
import java.io.FileFilter;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Modifier;
|
|
import java.net.MalformedURLException;
|
|
import java.net.URL;
|
|
import java.net.URLClassLoader;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.*;
|
|
import java.util.function.Consumer;
|
|
import java.util.jar.JarEntry;
|
|
import java.util.jar.JarInputStream;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
/**
|
|
*
|
|
* @author 7u83 <7u83@mail.ru>
|
|
*/
|
|
public class AutoTraderLoader {
|
|
|
|
private ArrayList<String> pathlist;
|
|
private ArrayList<Class<AutoTraderInterface>> traders_cache;
|
|
|
|
public AutoTraderLoader(ArrayList<String> pathlist) {
|
|
setPathList(pathlist);
|
|
}
|
|
|
|
public final void setPathList(ArrayList<String> pathlist) {
|
|
this.pathlist = pathlist;
|
|
this.traders_cache = null;
|
|
}
|
|
|
|
/**
|
|
* Check if a given class can instaciated as AutoTrader.
|
|
*
|
|
* @param cls Class to check
|
|
* @return true if it is an AutoTrader, otherwise false
|
|
*/
|
|
public boolean isAutoTrader(Class<?> cls) {
|
|
if (Modifier.isAbstract(cls.getModifiers())) {
|
|
return false;
|
|
}
|
|
|
|
do {
|
|
for (Class<?> i : cls.getInterfaces()) {
|
|
Globals.LOGGER.info(String.format("Interface: %s", i.getCanonicalName()));
|
|
|
|
String cn = AutoTraderInterface.class.getCanonicalName();
|
|
Globals.LOGGER.info(String.format("Interface1: %s", cn));
|
|
|
|
// if (i == (AutoTraderInterface.class)) {
|
|
if (cn.endsWith(i.getCanonicalName())) {
|
|
|
|
Globals.LOGGER.info("YEEEEA");
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
} while ((cls = cls.getSuperclass()) != null);
|
|
return false;
|
|
}
|
|
|
|
|
|
private ClassLoader cl;
|
|
|
|
public AutoTraderInterface MakeInstance(Class<?> cls){
|
|
ClassLoader cur = Thread.currentThread().getContextClassLoader();
|
|
Thread.currentThread().setContextClassLoader(cl);
|
|
|
|
AutoTraderInterface ai;
|
|
Globals.LOGGER.info("Going to load");
|
|
try {
|
|
ai = (AutoTraderInterface)cls.newInstance();
|
|
} catch (InstantiationException | IllegalAccessException ex) {
|
|
Globals.LOGGER.info("Ist was passiert");
|
|
Logger.getLogger(AutoTraderLoader.class.getName()).log(Level.SEVERE, null, ex);
|
|
ai=null;
|
|
}
|
|
Thread.currentThread().setContextClassLoader(cur);
|
|
|
|
return ai;
|
|
}
|
|
|
|
|
|
Class<AutoTraderInterface> loadAutoTraderClass(String filename, String classname) {
|
|
|
|
System.out.printf("Comming in width %s %s", filename, classname);
|
|
Globals.LOGGER.info(String.format("Comming in width %s %s\n", filename, classname));
|
|
|
|
if (classname == null) {
|
|
System.out.printf("Calssname is null\n");
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
String clnam = classname.substring(1, classname.length() - 6).replace('/', '.');
|
|
File f = new File(filename);
|
|
|
|
URL url = null;
|
|
try {
|
|
url = f.toURL();
|
|
} catch (MalformedURLException ex) {
|
|
Logger.getLogger(AutoTraderLoader.class.getName()).log(Level.SEVERE, null, ex);
|
|
}
|
|
|
|
Globals.LOGGER.info(String.format("URL: %s", url.toString()));
|
|
|
|
URL[] urls = new URL[]{url};
|
|
|
|
|
|
// Create a new class loader with the directory
|
|
cl = new URLClassLoader(urls);
|
|
|
|
|
|
//Thread.currentThread().setContextClassLoader(cl);
|
|
|
|
cl = Thread.currentThread().getContextClassLoader();
|
|
|
|
|
|
try {
|
|
Globals.LOGGER.info("try cl");
|
|
// Class<?> cls = cl.loadClass(clnam);
|
|
Class<?> c = cl.loadClass(clnam);
|
|
if (c == null) {
|
|
Globals.LOGGER.info("loader c was null");
|
|
}
|
|
Globals.LOGGER.info("Ccast");
|
|
Class<AutoTraderInterface> cls = (Class<AutoTraderInterface>) c; // cl.loadClass(clnam);
|
|
// return cls;
|
|
if (cls == null) {
|
|
|
|
}
|
|
|
|
System.out.printf("Check Class: %s\n", cls.getCanonicalName());
|
|
Globals.LOGGER.info(String.format("Class prope %s", cls.getCanonicalName()));
|
|
|
|
if (isAutoTrader(cls)) {
|
|
Globals.LOGGER.info("We have found an autotrader interface");
|
|
Class<AutoTraderInterface> claa;
|
|
claa = (Class<AutoTraderInterface>) cls;
|
|
|
|
if (claa == null) {
|
|
Globals.LOGGER.info("claa = null");
|
|
}
|
|
|
|
Globals.LOGGER.info("return ok");
|
|
return claa;
|
|
//return (Class<AutoTraderInterface>) cls;
|
|
//return (Class<AutoTraderInterface>) cls;
|
|
}
|
|
|
|
} catch (ClassNotFoundException ex) {
|
|
// something wnet wrong, but we ignore it
|
|
System.out.printf("Class not found\n");
|
|
Globals.LOGGER.info("Class not loadable");
|
|
}
|
|
return null;
|
|
|
|
}
|
|
|
|
/* public ArrayList<Class<AutoTraderInterface>> getTradersX() {
|
|
String[] a = System.getProperty("java.class.path").split(System.getProperty("path.separator"));
|
|
this.pathlist=new ArrayList<>(Arrays.asList(a));
|
|
return getTraders0();
|
|
}
|
|
*/
|
|
public ArrayList<Class<AutoTraderInterface>> getTraders() {
|
|
|
|
if (traders_cache != null) {
|
|
return traders_cache;
|
|
}
|
|
|
|
ArrayList<Class<AutoTraderInterface>> traders;
|
|
traders = new ArrayList<>();
|
|
|
|
for (String classpathEntry : pathlist) {
|
|
|
|
Globals.LOGGER.info(String.format("Here we ar looking now %s", classpathEntry));
|
|
|
|
Consumer<? super Path> pf = (Object t) -> {
|
|
|
|
String fn = ((Path) t).toString();
|
|
// System.out.printf("Checking out file %s\n", fn);
|
|
Globals.LOGGER.info(String.format("Checking out file %s\n", fn));
|
|
|
|
if (fn.toLowerCase().endsWith(".class")) {
|
|
String cl = fn.substring(classpathEntry.length());
|
|
System.out.printf("The CL: %s\n", cl);
|
|
|
|
Class<AutoTraderInterface> cls = loadAutoTraderClass(fn, cl);
|
|
if (cls == null) {
|
|
return;
|
|
}
|
|
traders.add(cls);
|
|
}
|
|
if (fn.toLowerCase().endsWith(".jar")) {
|
|
System.out.printf("Its a jar!\n");
|
|
Globals.LOGGER.info("Its a jar");
|
|
|
|
JarInputStream is = null;
|
|
try {
|
|
File jar = new File(fn);
|
|
is = new JarInputStream(new FileInputStream(jar));
|
|
JarEntry entry;
|
|
|
|
Globals.LOGGER.info("starting entries");
|
|
while ((entry = is.getNextJarEntry()) != null) {
|
|
Globals.LOGGER.info(String.format("Jar entry: %s", entry));
|
|
|
|
if (entry.getName().endsWith(".class")) {
|
|
|
|
System.out.printf("Entry: %s\n", entry.getName());
|
|
|
|
String fn0 = entry.getName();
|
|
Class<AutoTraderInterface> cls = loadAutoTraderClass(fn, "/" + entry.getName());
|
|
if (cls != null) {
|
|
Globals.LOGGER.info("Class is not null!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
|
|
traders.add(cls);
|
|
}
|
|
//Globals.LOGGER.info("clas was null");
|
|
|
|
}
|
|
}
|
|
} catch (IOException ex) {
|
|
Globals.LOGGER.info("ioeception");
|
|
Logger.getLogger(AutoTraderLoader.class.getName()).log(Level.SEVERE, null, ex);
|
|
} finally {
|
|
try {
|
|
is.close();
|
|
} catch (IOException ex) {
|
|
|
|
Logger.getLogger(AutoTraderLoader.class.getName()).log(Level.SEVERE, null, ex);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
try {
|
|
Files.walk(Paths.get(classpathEntry))
|
|
.filter(Files::isRegularFile)
|
|
.forEach(pf);
|
|
} catch (IOException ex) {
|
|
Logger.getLogger(AutoTraderLoader.class.getName()).log(Level.SEVERE, null, ex);
|
|
}
|
|
|
|
}
|
|
traders_cache = traders;
|
|
|
|
Globals.LOGGER.info(String.format("We hav found %d traders", traders.size()));
|
|
|
|
return traders;
|
|
|
|
}
|
|
|
|
public ArrayList<String> getDefaultStrategyNames(boolean devel) {
|
|
ArrayList<Class<AutoTraderInterface>> trclasses;
|
|
trclasses = this.getTraders();
|
|
|
|
ArrayList<String> ret = new ArrayList<>();
|
|
trclasses = getTraders();
|
|
|
|
for (int i = 0; i < trclasses.size(); i++) {
|
|
try {
|
|
|
|
//AutoTraderInterface ac = trclasses.get(i).newInstance();
|
|
AutoTraderInterface ac = this.MakeInstance(trclasses.get(i));
|
|
|
|
if (ac.getDevelStatus() && devel == false) {
|
|
continue;
|
|
}
|
|
ret.add(ac.getClass().getCanonicalName());
|
|
} catch (Exception e) {
|
|
System.out.printf("Can't load \n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
public ArrayList<String> getDefaultStrategyNames() {
|
|
return this.getDefaultStrategyNames(true);
|
|
}
|
|
|
|
public AutoTraderInterface getStrategyBase(String name) {
|
|
ArrayList<Class<AutoTraderInterface>> traders = this.getTraders();
|
|
for (int i = 0; i < traders.size(); i++) {
|
|
try {
|
|
Globals.LOGGER.info(String.format("Making lll instance of %s", traders.get(i).getCanonicalName()));
|
|
|
|
if (traders.get(i)==null){
|
|
Globals.LOGGER.info("We have null");
|
|
}
|
|
|
|
// AutoTraderInterface ac = traders.get(i).newInstance();
|
|
AutoTraderInterface ac = this.MakeInstance(traders.get(i));
|
|
|
|
System.out.printf("Looking for in %s == %s\n", ac.getClass().getCanonicalName(), name);
|
|
|
|
if (ac.getClass().getCanonicalName().equals(name)) {
|
|
return ac;
|
|
|
|
// if (ac.getDisplayName().equals(name)) {
|
|
// return ac;}
|
|
}
|
|
} catch (Exception ex) {
|
|
Globals.LOGGER.info(String.format("Instance failed %s", ex.getMessage()));
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public ArrayList getTraders(String dir) {
|
|
File f = new File(dir);
|
|
File[] ff = f.listFiles();
|
|
ArrayList a = new ArrayList();
|
|
a.addAll(Arrays.asList(ff));
|
|
return a;
|
|
}
|
|
|
|
}
|