public interface HotReloadListener {

void preHotReload();

}

private static App INST;

public enum F {

;

public static $.Predicate<String> JAVA_SOURCE = S.F.endsWith(".java");

public static $.Predicate<String> JAR_FILE = S.F.endsWith(".jar");

public static $.Predicate<String> CONF_FILE = S.F.endsWith(".conf").or(S.F.endsWith(".properties").or(S.F.endsWith(".yaml").or(S.F.endsWith(".yml").or(S.F.endsWith(".xml")))));

public static $.Predicate<String> ROUTES_FILE = $.F.eq(RouteTableRouterBuilder.ROUTES_FILE);

}

private volatile String profile;

private String name;

private String shortId;

private File appBase;

private File appHome;

private Router router;

private CliDispatcher cliDispatcher;

private CaptchaManager captchaManager;

private Map<NamedPort, Router> moreRouters;

private AppConfig<?> config;

private AppClassLoader classLoader;

private ProjectLayout layout;

private AppBuilder builder;

private EventBus eventBus;

private AppCodeScannerManager scannerManager;

private ClassMetaInfoRepo classMetaInfoRepo;

private DbServiceManager dbServiceManager;

private JobManager jobManager;

private ApiManager apiManager;

private ManagedCollectionService managedCollectionService;

private CliServer cliServer;

private MailerConfigManager mailerConfigManager;

private StringValueResolverManager resolverManager;

private SingletonRegistry singletonRegistry;

private BinderManager binderManager;

private AppInterceptorManager interceptorManager;

private DependencyInjector<?> dependencyInjector;

private HttpClientService httpClientService;

private UploadFileStorageService uploadFileStorageService;

private AppServiceRegistry appServiceRegistry;

private MasterEntityMetaInfoRepo entityMetaInfoRepo;

private Map<String, Daemon> daemonRegistry;

private WebSocketConnectionManager webSocketConnectionManager;

private MetricMetaInfoRepo metricMetaInfoRepo;

private AppCrypto crypto;

private IdGenerator idGenerator;

private SessionManager sessionManager;

private CacheService cache;

// used in dev mode only

private CompilationException compilationException;

private AsmException asmException;

private SysEventId currentState;

private Set<SysEventId> eventEmitted;

private Thread mainThread;

private Set<String> scanList;

private List<File> baseDirs;

private volatile File tmpDir;

private boolean restarting;

private Result blockIssue;

private Throwable blockIssueCause;

private RequestHandler blockIssueHandler = new FastRequestHandler() {

@Override

public void handle(ActionContext context) {

E.illegalArgumentIf(null == blockIssue);

blockIssue.apply(context.req(), context.prepareRespForResultEvaluation());

}

@Override

public String toString() {

return "fatal error: block issue found";

}

};

private final Version version;

private List<HotReloadListener> hotReloadListeners = new ArrayList<>();

private App() {

this.version = Version.get();

this.appBase = new File(".");

this.layout = ProjectLayout.PredefinedLayout.MAVEN;

this.appHome = RuntimeDirs.home(this);

this.config = new AppConfig<>().app(this);

INST = this;

this.sessionManager = new SessionManager(this.config);

this.dependencyInjector = new GenieInjector(this);

this.singletonRegistry = new SingletonRegistry(this);

this.singletonRegistry.register(SessionManager.class, this.sessionManager);

this.singletonRegistry.register(CookieSessionMapper.class, new CookieSessionMapper(this.config));

}

protected App(File appBase, Version version, ProjectLayout layout) {

this("MyApp", version, appBase, layout);

}

protected App(String name, Version version, File appBase, ProjectLayout layout) {

this.name(name);

this.version = version;

this.appBase = appBase;

this.layout = layout;

this.appHome = RuntimeDirs.home(this);

INST = this;

}

public static App instance() {

return INST;

}

App name(String name) {

this.name = name;

this.shortId = generateId(name);

return this;

}

/**

public String name() {

return name;

}

/**

public Version version() {

return version;

}

/**

public String shortId() {

return shortId;

}

private static String generateId(String name) {

String id;

if (S.blank(name) || "MyApp".equals(name)) {

return "act";

}

String[] sa = name.split("[\\s]+");

int len = sa.length;

switch (len) {

case 1:

String s = sa[0];

id = s.length() > 2 ? s.substring(0, 3) : s;

break;

case 2:

String s1 = sa[0], s2 = sa[1];

s1 = s1.length() > 1 ? s1.substring(0, 2) : s1;

s2 = s2.length() > 1 ? s2.substring(0, 2) : s2;

id = S.concat(s1, "-", s2);

break;

default:

id = S.concat(

sa[0].substring(0, 1),

sa[1].substring(0, 1),

sa[2].substring(0, 1),

"-"

);

}

return id;

}

public String profile() {

if (null == profile) {

synchronized (this) {

if (null == profile) {

String s = SysProps.get(AppConfigKey.PROFILE.key());

if (null == s) {

s = Act.mode().name().toLowerCase();

}

profile = s;

}

}

}

return profile;

}

public Act.Mode mode() {

return Act.mode();

}

public boolean isDev() {

return mode().isDev();

}

public boolean isProd() {

return mode().isProd();

}

public AppConfig<?> config() {

return config;

}

public List<File> baseDirs() {

if (null == baseDirs) {

baseDirs = new ArrayList<>();

if (null != appBase && appBase.isDirectory()) {

baseDirs.add(appBase);

}

for (File baseDir : config.moduleBases()) {

if (null != baseDir && baseDir.isDirectory()) {

baseDirs.add(baseDir);

}

}

}

return baseDirs;

}

public List<File> sourceDirs() {

return layoutDirs(ProjectLayout.F.SRC.curry(layout()));

}

public List<File> resourceDirs() {

return layoutDirs(ProjectLayout.F.RSRC.curry(layout()));

}

public List<File> libDirs() {

return layoutDirs(ProjectLayout.F.LIB.curry(layout()));

}

public List<File> testSourceDirs() {

return layoutDirs(ProjectLayout.F.TST_SRC.curry(layout()));

}

public List<File> testResourceDirs() {

return layoutDirs(ProjectLayout.F.TST_RSRC.curry(layout()));

}

public List<File> testLibDirs() {

return layoutDirs(ProjectLayout.F.TST_LIB.curry(layout()));

}

public List<File> allSourceDirs(boolean requireTestProfile) {

List<File> dirs = new ArrayList<>();

dirs.addAll(sourceDirs());

if (!requireTestProfile || "test".equals(Act.profile())) {

dirs.addAll(testSourceDirs());

}

return dirs;

}

public List<File> allResourceDirs(boolean requireTestProfile) {

List<File> dirs = new ArrayList<>();

dirs.addAll(resourceDirs());

if (!requireTestProfile || "test".equals(Act.profile())) {

dirs.addAll(testResourceDirs());

}

return dirs;

}

public List<File> allLibDirs(boolean requireTestProfile) {

List<File> dirs = new ArrayList<>();

dirs.addAll(libDirs());

if (!requireTestProfile || "test".equals(Act.profile())) {

dirs.addAll(testLibDirs());

}

return dirs;

}

private List<File> layoutDirs($.Function<File, File> transformer) {

return C.list(baseDirs()).map(transformer);

}

public CliDispatcher cliDispatcher() {

return cliDispatcher;

}

public CaptchaManager captchaManager() {

return captchaManager;

}

public Router router() {

return router;

}

public Router router(String name) {

if (S.blank(name)) {

return router();

}

for (Map.Entry<NamedPort, Router> entry : moreRouters.entrySet()) {

if (S.eq(entry.getKey().name(), name)) {

return entry.getValue();

}

}

return null;

}

public Router router(NamedPort port) {

if (null == port) {

return router();

}

return moreRouters.get(port);

}

public AppCrypto crypto() {

return crypto;

}

/**

public File base() {

return appBase;

}

/**

public File home() {

return appHome;

}

public AppClassLoader classLoader() {

return classLoader;

}

public ProjectLayout layout() {

return layout;

}

public void registerHotReloadListener(HotReloadListener listener) {

if (Act.isDev()) {

hotReloadListeners.add(listener);

}

}

public boolean checkUpdates(boolean async) {

if (!Act.isDev()) {

return false;

}

synchronized (this) {

try {

detectChanges();

return false;

} catch (RequestRefreshClassLoader refreshRequest) {

refresh(async);

return true;

} catch (RequestServerRestart requestServerRestart) {

refresh(async);

return true;

}

}

}

public synchronized void detectChanges() {

if (null == classLoader) {

throw new RequestServerRestart();

}

classLoader.detectChanges();

if (null != compilationException) {

throw ActErrorResult.of(compilationException);

} else if (null != asmException) {

throw ActErrorResult.of(asmException);

}

}

public void restart() {

build();

refresh();

}

public synchronized void setBlockIssue(Throwable e) {

logger.fatal(e, "Block issue encountered");

if (null != blockIssue || null != blockIssueCause) {

// do not overwrite previous block issue

return;

}

if (e instanceof ActErrorResult) {

blockIssue = (ActErrorResult) e;

} else {

if (null != classLoader()) {

blockIssue = ActErrorResult.of(e);

blockIssueCause = null;

} else {

blockIssueCause = e;

}

}

throw BlockIssueSignal.INSTANCE;

}

/**

public void asyncRefresh() {

new Thread() {

@Override

public void run() {

refresh();

}

}.start();

}

public boolean isStarted() {

return currentState == POST_START || currentState == ACT_START;

}

public boolean isMainThread() {

return Thread.currentThread() == mainThread;

}

public void shutdown() {

Act.shutdown(this);

}

public void shutdown(int exitCode) {

Act.shutdown(this, exitCode);

}

@Override

protected void releaseResources() {

// shall not interrupt main thread

// see https://stackoverflow.com/questions/44665552/undertow-xnio-i-o-thread-consistently-eat-cpu

// mainThread.interrupt();

if (null == daemonRegistry) {

return;

}

logger.info("App shutting down ....");

for (HotReloadListener listener : hotReloadListeners) {

listener.preHotReload();

}

if (null != classLoader && config().i18nEnabled()) {

// clear resource bundle cache for Act I18n

ResourceBundle.clearCache(classLoader);

// clear resource bundle cache for Rythm I18n

ResourceBundle.clearCache(I18N.class.getClassLoader());

}

for (Daemon d : daemonRegistry.values()) {

stopDaemon(d);

}

shutdownCliServer();

shutdownEventBus();

shutdownJobManager();

clearServiceResourceManager();

classLoader = null;

}

public synchronized void refresh(boolean async) {

if (async) {

asyncRefresh();

} else {

refresh();

}

}

public synchronized boolean isRestarting() {

return restarting;

}

public RequestHandler blockIssueHandler() {

if (null != blockIssue && Act.isDev()) {

return blockIssueHandler;

}

return null;

}

public synchronized void refresh() {

currentState = null;

final long ms = $.ms();

logger.info("App starting ....");

profile = null;

blockIssue = null;

blockIssueCause = null;

Act.viewManager().clearAppDefinedVars();

initScanlist();

initServiceResourceManager();

reload();

managedCollectionService = new ManagedCollectionService(this);

I18n.classInit(this);

ParamValueLoaderService.classInit(this);

JodaTransformers.classInit(this);

FastJsonPropertyPreFilter.classInit(this);

ActErrorResult.classInit(this);

ActProviders.classInit(this);

ProvidedValueLoader.classInit(this);

GenieFactoryFinder.classInit(this);

mainThread = Thread.currentThread();

restarting = mainThread.getName().contains("job");

eventEmitted = C.newSet();

initSingletonRegistry();

initEventBus();

emit(EVENT_BUS_INITIALIZED);

try {

loadConfig();

emit(CONFIG_LOADED);

initDataPropertyRepository();

initCrypto();

initIdGenerator();

initJobManager();

initDaemonRegistry();

initInterceptorManager();

initResolverManager();

initBinderManager();

initUploadFileStorageService();

initRouters();

emit(ROUTER_INITIALIZED);

loadRoutes();

emit(ROUTER_LOADED);

initApiManager();

initHttpClientService();

initCaptchaPluginManager();

initCliDispatcher();

initCliServer();

initMetricMetaInfoRepo();

initEntityMetaInfoRepo();

initClassMetaInfoRepo();

initWebSocketConnectionManager();

initDbServiceManager();

Act.viewManager().reset();

loadGlobalPlugin();

emit(APP_ACT_PLUGIN_LOADED);

initScannerManager();

loadActScanners();

loadBuiltInScanners();

emit(PRE_LOAD_CLASSES);

initClassLoader();

emit(SysEventId.CLASS_LOADER_INITIALIZED);

initCache();

preloadClasses();

try {

scanAppCodes();

compilationException = null;

asmException = null;

} catch (CompilationException e) {

compilationException = e;

throw ActErrorResult.of(e);

} catch (AsmException e) {

asmException = e;

throw ActErrorResult.of(e);

}

} catch (BlockIssueSignal e) {

return;

}

try {

//classLoader().loadClasses();

emit(APP_CODE_SCANNED);

emit(CLASS_LOADED);

Act.viewManager().reload(this);

} catch (BlockIssueSignal e) {

// ignore and keep going with dependency injector initialization

}

try {

loadDependencyInjector();

emit(DEPENDENCY_INJECTOR_LOADED);

} catch (BlockIssueSignal e) {

return;

}

if (null == blockIssue && null == blockIssueCause) {

try {

initJsonDTOClassManager();

initParamValueLoaderManager();

initMailerConfigManager();

// setting context class loader here might lead to memory leaks

// and cause weird problems as class loader been set to thread

// could be switched to handling other app in ACT or still hold

// old app class loader instance after the app been refreshed

// - Thread.currentThread().setContextClassLoader(classLoader());

initHttpConfig();

initViewManager();

// let's any emit the dependency injector loaded event

// in case some other service depend on this event.

// If any DI plugin e.g. guice has emitted this event

// already, it doesn't matter we emit the event again

// because once app event is consumed the event listeners

// are cleared

emit(DEPENDENCY_INJECTOR_PROVISIONED);

emit(SINGLETON_PROVISIONED);

registerMetricProvider();

config().preloadConfigurations();

initSessionManager();

Runnable runnable = new Runnable() {

@Override

public void run() {

if (null != blockIssueCause) {

setBlockIssue(blockIssueCause);

}

emit(PRE_START);

emit(STATELESS_PROVISIONED);

emit(START);

daemonKeeper();

logger.info("App[%s] loaded in %sms", name(), $.ms() - ms);

emit(POST_START);

}

};

if (!dbServiceManager().hasDbService() || eventEmitted(DB_SVC_LOADED)) {

runnable.run();

} else {

jobManager().on(DB_SVC_LOADED, runnable, true);

}

} catch (BlockIssueSignal e) {

// ignore

}

}

}

/**

public boolean hasBlockIssue() {

return null != blockIssue;

}

public AppBuilder builder() {

return builder;

}

public <T extends ClassMetaInfoBase<T>> ClassMetaInfoManager<T> classMetaInfoManager(Class<T> metaInfoType) {

return classMetaInfoRepo.manager(metaInfoType);

}

public void register(ClassMetaInfoManager<?> classMetaInfoManager) {

classMetaInfoRepo.register(classMetaInfoManager);

}

/**

public boolean isSingleton(Class<?> cls) {

return null != singletonRegistry.get(cls) || hasSingletonAnnotation(cls);

}

private void registerMetricProvider() {

GenieInjector gi = this.injector();

MetricProvider mp = new MetricProvider();

gi.registerNamedProvider(Metric.class, mp);

gi.registerProvider(Metric.class, mp);

}

private boolean hasSingletonAnnotation(Class<?> cls) {

boolean found = false;

GenieInjector injector = Act.app().injector();

Annotation[] aa = cls.getAnnotations();

for (Annotation a: aa) {

Class<? extends Annotation> type = a.annotationType();

if (injector.isInheritedScopeStopper(type)) {

return false;

}

if (InheritedStateless.class == type || Stateless.class == type || Singleton.class == type) {

found = true;

}

}

return found;

}

void build() {

builder = AppBuilder.build(this);

}

void hook() {

Act.hook(this);

}

public File tmpDir() {

if (null == tmpDir) {

synchronized (this) {

if (Act.isDev()) {

tmpDir = new File(this.layout().target(appBase), "tmp");

} else {

try {

tmpDir = java.nio.file.Files.createTempDirectory(name()).toFile();

} catch (IOException e) {

throw E.ioException(e);

}

}

}

}

return tmpDir;

}

public File file(String path) {

return new File(base(), path);

}

public File resource(String path) {

return new File(this.layout().resource(appBase), path);

}

public void registerDaemon(Daemon daemon) {

daemonRegistry.put(daemon.id(), daemon);

}

public void unregisterDaemon(Daemon daemon) {

daemonRegistry.remove(daemon.id());

}

List<Daemon> registeredDaemons() {

return C.list(daemonRegistry.values());

}

Daemon registeredDaemon(String id) {

return daemonRegistry.get(id);

}

public <T> void registerSingleton(Class<? extends T> cls, T instance) {

if (null != singletonRegistry) {

singletonRegistry.register(cls, instance);

}

}

public void registerSingletonClass(Class<?> aClass) {

singletonRegistry.register(aClass);

}

public void registerSingleton(Object instance) {

singletonRegistry.register(instance.getClass(), instance);

}

public AppInterceptorManager interceptorManager() {

return interceptorManager;

}

public SessionManager sessionManager() {

return sessionManager;

}

public AppCodeScannerManager scannerManager() {

return scannerManager;

}

public DbServiceManager dbServiceManager() {

return dbServiceManager;

}

public StringValueResolverManager resolverManager() {

return resolverManager;

}

public BinderManager binderManager() {

return binderManager;

}

public CacheService cache() {

return cache;

}

public CacheService cache(String name) {

return config().cacheService(name);

}

public MailerConfigManager mailerConfigManager() {

return mailerConfigManager;

}

public EventBus eventBus() {

return eventBus;

}

public HttpClientService httpClientService() {

return httpClientService;

}

public MasterEntityMetaInfoRepo entityMetaInfoRepo() {

return entityMetaInfoRepo;

}

public JobManager jobManager() {

return jobManager;

}

public MetricMetaInfoRepo metricMetaInfoRepo() {

return metricMetaInfoRepo;

}

public <DI extends DependencyInjector> App injector(DI dependencyInjector) {

E.NPE(dependencyInjector);

E.illegalStateIf(null != this.dependencyInjector, "Dependency injection factory already set");

this.dependencyInjector = dependencyInjector;

return this;

}

public <DI extends DependencyInjector> DI injector() {

return (DI) dependencyInjector;

}

public UploadFileStorageService uploadFileStorageService() {

return uploadFileStorageService;

}

public String sign(String message) {

return crypto().sign(message);

}

public String encrypt(String message) {

return crypto().encrypt(message);

}

public String decrypt(String message) {

return crypto().decrypt(message);

}

public <T> T singleton(Class<T> clz) {

return singletonRegistry.get(clz);

}

/**

public <T> T getInstance(String className) {

Class<T> c = $.classForName(className, classLoader());

return getInstance(c);

}

/**

public <T> T getInstance(Class<T> clz) {

if (null == dependencyInjector) {

return $.newInstance(clz);

}

return dependencyInjector.get(clz);

}

/**

public URL getResource(String name) {

return classLoader().getResource(name);