//**************************************************************************

//** main

//**************************************************************************

/** Command line interface used to start the server.

public static void main(String[] arguments) throws Exception {

HashMap<String, String> args = parseArgs(arguments);

Jar jar = new Jar(Server.class);

//Process command line args

if (args.containsKey("-version")){

String version = jar.getVersion();

if (version==null) version = "Unknown";

System.out.println(version);

}

else if (args.containsKey("-deploy")){

Deploy.main(arguments);

}

else if (args.containsKey("-start")){

javaxt.utils.Value start = getValue(args, "-start");

Config config = getConfig(args, jar);

try {

//Get servlet

HttpServlet servlet;

if (start.equals("website") || start.equals("cms")){

servlet = new WebSite(config, args);

}

else if (start.equals("webservice") || start.equals("webservices")){

servlet = new WebServices(config, args);

}

else{

servlet = new WebServer(config, args);

}

//Start server

int port = config.get("webserver").get("port").toInteger();

int numThreads = config.get("webserver").get("numThreads").toInteger();

javaxt.http.Server server = new javaxt.http.Server(port, numThreads, servlet);

server.start();

}

catch (Exception e) {

System.out.println("Server could not start because of an " +

e.getClass() + ": " + e.getMessage());

e.printStackTrace();

}

}

else{

System.out.println("Unsupported command");

}

}

//**************************************************************************

//** WebSite

//**************************************************************************

/** Returns an HTTP servlet used serve content using the Express Content

private static class WebSite extends javaxt.express.cms.WebSite {

private WebSite(Config config, HashMap<String, String> args){

super(getDirectory(config));

}

private static javaxt.io.Directory getDirectory(Config config){

javaxt.io.Directory web = null;

try{

web = (javaxt.io.Directory)

config.get("webserver").get("webDir").toObject();

}

catch(Exception e){}

if (web==null) throw new IllegalArgumentException(

"Invalid directory. Use the -dir argument to specify a path to a CMS folder.");

return web;

}

/* Override the native getContent method to generate custom HTML for wiki

public Content getContent(HttpServletRequest request, javaxt.io.File file){

//Get path from url

String path = request.getURL().getPath().toLowerCase();

//Remove leading and trailing "/" characters

if (path.startsWith("/")) path = path.substring(1);

if (path.endsWith("/")) path = path.substring(0, path.length()-1);

//Return content

if (path.equals("wiki")){

String html = file.getText();

Date date = file.getDate();

if (file.getName(false).equals("index")){

Content content = getIndex(file);

javaxt.utils.Date d = new javaxt.utils.Date(content.getDate());

if (d.isAfter(new javaxt.utils.Date(date))){

date = d.getDate();

}

html = html.replace("<%=index%>", content.getHTML());

}

return new Content(html, date);

}

else{

return super.getContent(request, file);

}

}

}

//**************************************************************************

//** WebServer

//**************************************************************************

/** Returns an HTTP servlet used serve static files using the FileManager.

private static class WebServer extends HttpServlet {

private FileManager fileManager;

public WebServer(Config config, HashMap<String, String> args){

//Get directory

javaxt.io.Directory web = null;

try{

web = (javaxt.io.Directory)

config.get("webserver").get("webDir").toObject();

}

catch(Exception e){}

if (web==null) throw new IllegalArgumentException(

"Invalid directory. Use the -dir argument to specify a path to a web folder.");

//If we're still here, instantiate the file manager

fileManager = new FileManager(web);

}

public void processRequest(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

fileManager.sendFile(request, response);

}

}

//**************************************************************************

//** WebServices

//**************************************************************************

/** Returns an HTTP servlet used execute CRUD operations (create, read,

private static class WebServices extends HttpServlet {

private WebService ws;

private Database database;

public WebServices(Config config, HashMap<String, String> args) throws Exception {

//Parse inputs

String input = getValue(args, "-model", "-models").toString();

javaxt.io.File inputFile;

try {

inputFile = new javaxt.io.File(input);

if (!inputFile.exists()) throw new Exception();

}

catch(Exception e){

throw new IllegalArgumentException("Models are required");

}

database = config.getDatabase();

if (database==null) throw new IllegalArgumentException("Invalid or missing database");

//Get models

javaxt.orm.Model[] models = new javaxt.orm.Parser(inputFile.getText()).getModels();

//Initialize schema (create tables, indexes, etc)

String schema = new javaxt.orm.Schema(models).getSQLScript();

if (database.getDriver().equals("H2")){

//Set H2 to PostgreSQL mode

Properties properties = database.getProperties();

if (properties==null){

properties = new java.util.Properties();

database.setProperties(properties);

}

properties.setProperty("MODE", "PostgreSQL");

properties.setProperty("DATABASE_TO_LOWER", "TRUE");

properties.setProperty("DEFAULT_NULL_ORDERING", "HIGH");

//Update list of non-reserved keywords (e.g. "KEY", "VALUE", "YEAR")

HashSet<String> nonKeyWords = new HashSet<>();

Set<String> resevedKeyWords = new HashSet<>(

Arrays.asList(database.getReservedKeywords())

);

for (javaxt.orm.Model model : models){

String str = model.getTableName().toUpperCase();

if (resevedKeyWords.contains(str)) nonKeyWords.add(str);

for (javaxt.orm.Field field : model.getFields()){

str = field.getColumnName().toUpperCase();

if (resevedKeyWords.contains(str)) nonKeyWords.add(str);

}

}

if (!nonKeyWords.isEmpty()){

properties.setProperty("NON_KEYWORDS", String.join(",", nonKeyWords));

}

}

DbUtils.initSchema(database, schema, null);

//Enable metadata caching

database.enableMetadataCache(true);

//Inititalize connection pool

database.initConnectionPool();

//Compile models into classes

Class[] classes = new javaxt.orm.Compiler(models).getClasses();

//Instantiate web services

ws = new Demo();

//Initialize classes and register them with the web service

for (Class c : classes){

Model.init(c, database.getConnectionPool());

ws.addModel(c);

}

}

/** Used to process HTTP requests */

public void processRequest(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

//Add CORS support

response.addHeader("Access-Control-Allow-Origin", "*");

response.addHeader("Access-Control-Allow-Headers","*");

response.addHeader("Access-Control-Allow-Methods", "*");

//Generate response

ServiceRequest req = new ServiceRequest(request);

ServiceResponse rsp = ws.getServiceResponse(req, database);

rsp.send(response);

}

private class Demo extends WebService {}

}

//**************************************************************************

//** getConfig

//**************************************************************************

private static Config getConfig(HashMap<String, String> args, Jar jar){

javaxt.io.File jarFile = new javaxt.io.File(jar.getFile());

//Get config file

javaxt.io.File configFile = (args.containsKey("-config")) ?

getFile(args.get("-config"), jarFile) :

new javaxt.io.File(jar.getFile().getParentFile(), "config.json");

//Initialize config

Config config = new Config();

if (configFile.exists()){

try{

config.init(configFile.getJSONObject());

}

catch(Exception e){}

}

//Get web config

JSONObject webConfig = config.get("webserver").toJSONObject();

if (webConfig==null){

webConfig = new JSONObject();

config.set("webserver", webConfig);

}

//Set directory for the web server

try{

String dir = getValue(args, "-d", "-dir", "-directory", "-web", "-share").toString();

if (dir.endsWith("\"")) dir = dir.substring(0, dir.length()-1);

java.io.File f = new java.io.File(dir);

if (f.isFile()) f = f.getParentFile();

javaxt.io.Directory web = new javaxt.io.Directory(f);

webConfig.set("webDir", web);

}

catch(Exception e){}

//Set port for the web server

Integer port = getValue(args, "-p", "-port").toInteger();

if (port==null && !webConfig.has("port")) webConfig.set("port", 8080);

else webConfig.set("port", port);

//Set number of threads for the web server

Integer numThreads = getValue(args, "-t", "-threads").toInteger();

if (numThreads==null && !webConfig.has("numThreads")) webConfig.set("numThreads", 250);

else webConfig.set("numThreads", numThreads);

//Get database config

Database database = config.getDatabase();

if (database==null){

String db = getValue(args, "-database", "-data").toString();

if (db!=null){

try{

//Check if the database arg represents a path to a directory

String path = db;

javaxt.io.Directory dir = new javaxt.io.Directory(path);

if (dir.exists()){

try{

java.io.File f = new java.io.File(path);

javaxt.io.Directory d = new javaxt.io.Directory(f.getCanonicalFile());

if (!dir.toString().equals(d.toString())){

dir = d;

}

}

catch(Exception e){

}

}

else{

path = (configFile.exists()) ? configFile.MapPath(path)

: jarFile.MapPath(path);

dir = new javaxt.io.Directory(new java.io.File(path));

}

//If the directory doesn't exist, throw an error. Do not try

//to create a new directory because the path may be invalid.

if (!dir.exists()) throw new Exception();

//Create a new database using H2

database = new Database();

database.setDriver("H2");

database.setHost(dir.toString().replace("\\", "/") + "database");

}

catch(Exception e){

//Try parsing connection string

if (args.containsKey("-database")){

try{

database = new Database(db);

}

catch(Exception ex){}

}

}

//Update database config

if (database!=null){

int maxConnections = Math.min(25, webConfig.get("numThreads").toInteger());

database.setConnectionPoolSize(maxConnections);

config.setDatabase(database);

}

}

}

return config;

}

//**************************************************************************

//** getFile

//**************************************************************************

/** Returns a File for a given path

public static javaxt.io.File getFile(String path, javaxt.io.File jarFile){

javaxt.io.File file = new javaxt.io.File(path);

if (!file.exists()){

file = new javaxt.io.File(jarFile.MapPath(path));

}

return file;

}

}