277 lines
11 KiB
Java
277 lines
11 KiB
Java
package name.nathanmcrae.numbersstation;
|
|
|
|
import com.jcraft.jsch.ChannelSftp;
|
|
import com.jcraft.jsch.JSch;
|
|
import com.jcraft.jsch.JSchException;
|
|
import com.jcraft.jsch.Session;
|
|
import com.jcraft.jsch.SftpException;
|
|
import com.leakyabstractions.result.api.Result;
|
|
import com.leakyabstractions.result.core.Results;
|
|
import com.tearsofaunicorn.wordpress.api.model.Post;
|
|
import com.tearsofaunicorn.wordpress.api.WordpressClient;
|
|
import java.io.IOException;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.text.SimpleDateFormat;
|
|
import java.time.format.DateTimeFormatter;
|
|
import java.time.LocalDateTime;
|
|
import java.util.Date;
|
|
import java.util.logging.FileHandler;
|
|
import java.util.logging.Logger;
|
|
import java.util.logging.Level;
|
|
import java.util.Optional;
|
|
import javafx.application.Application;
|
|
import javafx.application.Platform;
|
|
import javafx.fxml.FXMLLoader;
|
|
import javafx.scene.image.Image;
|
|
import javafx.scene.Parent;
|
|
import javafx.scene.Scene;
|
|
import javafx.stage.Stage;
|
|
import org.apache.commons.cli.*;
|
|
|
|
public class Main extends Application {
|
|
public record StartParameters (Optional<NotificationController.NotificationParameters> notification) {}
|
|
|
|
private static final Logger logger = Logger.getLogger(Main.class.getName());
|
|
// TODO: get git info
|
|
private static final String VERSION = "0.0.1";
|
|
private static Path statePath = null;
|
|
|
|
public static Path getStatePath() {
|
|
if (statePath == null) {
|
|
String stateHome = System.getenv("XDG_STATE_HOME");
|
|
if (stateHome == null || stateHome.isEmpty() || !Paths.get(stateHome).isAbsolute()) {
|
|
String userHome = System.getProperty("user.home");
|
|
statePath = Paths.get(userHome, ".local", "state", "numbers-station");
|
|
} else {
|
|
statePath = Paths.get(stateHome, "numbers-station");
|
|
}
|
|
}
|
|
|
|
return statePath;
|
|
}
|
|
|
|
private static StartParameters startParams = new StartParameters(Optional.empty());
|
|
|
|
@Override
|
|
public void start(Stage primaryStage) throws Exception {
|
|
primaryStage.setOnCloseRequest(e -> {
|
|
Platform.exit();
|
|
});
|
|
|
|
try {
|
|
if (startParams.notification().isPresent()){
|
|
FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("/NotificationView.fxml"));
|
|
Parent root = fxmlLoader.load();
|
|
|
|
NotificationController controller = fxmlLoader.getController();
|
|
controller.setNotification(startParams.notification().get());
|
|
|
|
primaryStage.setTitle("Numbers Station");
|
|
primaryStage.getIcons().add(new Image(getClass().getResourceAsStream("/icon.png")));
|
|
primaryStage.setScene(new Scene(root));
|
|
primaryStage.show();
|
|
} else {
|
|
FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource("/MainView.fxml"));
|
|
Parent root = fxmlLoader.load();
|
|
|
|
MainController controller = fxmlLoader.getController();
|
|
|
|
primaryStage.setOnCloseRequest(e -> {
|
|
if (!controller.handleCloseRequest()) {
|
|
e.consume();
|
|
} else {
|
|
Platform.exit();
|
|
}
|
|
});
|
|
|
|
primaryStage.setTitle("Numbers Station");
|
|
primaryStage.getIcons().add(new Image(getClass().getResourceAsStream("/icon.png")));
|
|
primaryStage.setScene(new Scene(root));
|
|
primaryStage.titleProperty().bindBidirectional(controller.windowTitle);
|
|
primaryStage.show();
|
|
logger.info("Application started");
|
|
}
|
|
} catch (IOException e) {
|
|
logger.log(Level.SEVERE, "Failed to load main view", e);
|
|
}
|
|
}
|
|
|
|
private static void setupLogger() {
|
|
try {
|
|
Path logFile = getStatePath().resolve("main.log");
|
|
|
|
if (!Files.exists(logFile.getParent())) {
|
|
Files.createDirectories(logFile.getParent());
|
|
}
|
|
|
|
FileHandler fileHandler = new FileHandler(logFile.toString(), true);
|
|
fileHandler.setFormatter(new CustomFormatter());
|
|
logger.addHandler(fileHandler);
|
|
} catch (IOException e) {
|
|
System.out.println("Failed to set up logger: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
MainParsedArguments parsedArgs = new MainParsedArguments(args);
|
|
|
|
if (parsedArgs.getParseException() != null) {
|
|
logger.log(Level.SEVERE, "Failed when parsing arguments", parsedArgs.getParseException());
|
|
parsedArgs.printHelp();
|
|
System.exit(0);
|
|
}
|
|
|
|
if (parsedArgs.getHelpFlag()) {
|
|
parsedArgs.printHelp();
|
|
System.exit(0);
|
|
}
|
|
|
|
if (parsedArgs.getVersionFlag()) {
|
|
System.out.println("Numbers Station version " + VERSION);
|
|
System.exit(0);
|
|
}
|
|
|
|
Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
|
|
logger.log(Level.SEVERE, "Unhandled exception caught", throwable);
|
|
});
|
|
|
|
Platform.setImplicitExit(false);
|
|
Thread.currentThread().setUncaughtExceptionHandler((thread, throwable) -> {
|
|
logger.log(Level.SEVERE, "Unhandled exception in JavaFX application thread", throwable);
|
|
});
|
|
|
|
setupLogger();
|
|
|
|
if (parsedArgs.getStationName() != null) {
|
|
try {
|
|
runStation(parsedArgs);
|
|
} catch (StationRunException e) {
|
|
DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
|
|
String message = "Attempted to run station '" +
|
|
parsedArgs.getStationName() +
|
|
"' at " +
|
|
LocalDateTime.now().format(dateFormatter) +
|
|
"\n\n" +
|
|
e.getMessage();
|
|
var notification = new NotificationController.NotificationParameters("Error running station '" + parsedArgs.getStationName() + "'",
|
|
message,
|
|
NotificationController.NotificationType.ERROR,
|
|
Optional.empty());
|
|
startParams = new StartParameters(Optional.of(notification));
|
|
|
|
launch(args);
|
|
System.exit(1);
|
|
}
|
|
} else {
|
|
launch(args);
|
|
}
|
|
}
|
|
|
|
public static class StationRunException extends Exception {
|
|
public StationRunException(String message) {
|
|
super(message);
|
|
}
|
|
}
|
|
|
|
public static void runStation(MainParsedArguments parsedArgs) throws StationRunException {
|
|
if (parsedArgs.getStationName() == null || parsedArgs.getStationName() == "") {
|
|
String message = "Station name must be provided and not empty";
|
|
logger.log(Level.SEVERE, message);
|
|
|
|
throw new StationRunException(message);
|
|
}
|
|
|
|
Result<MainSettings, Exception> result = MainSettings.load();
|
|
if (!result.hasSuccess()) {
|
|
String message = "Unable to load settings";
|
|
logger.log(Level.SEVERE, message);
|
|
throw new StationRunException(message);
|
|
}
|
|
MainSettings settings = result.getSuccess().get();
|
|
|
|
StationSettings loadedStation = settings.getStations().stream()
|
|
.filter(station -> station.getName().equals(parsedArgs.getStationName()))
|
|
.findFirst()
|
|
.orElse(null);
|
|
|
|
if (loadedStation == null) {
|
|
String message = "Unable to find station '" + parsedArgs.getStationName() + "'";
|
|
logger.log(Level.SEVERE, message);
|
|
|
|
throw new StationRunException(message);
|
|
}
|
|
|
|
logger.info("Loaded station " + parsedArgs.getStationName());
|
|
|
|
Path stationDirPath = loadedStation.stationPath();
|
|
|
|
try {
|
|
boolean generateMessage = false;
|
|
if (!Files.exists(stationDirPath)) {
|
|
Files.createDirectories(stationDirPath);
|
|
}
|
|
|
|
Path nextMessagePath = stationDirPath.resolve("next-message.txt");
|
|
String messageText;
|
|
if (!Files.exists(nextMessagePath)) {
|
|
messageText = loadedStation.generateMessage(settings.getMessageGenerationAttempts());
|
|
} else {
|
|
messageText = new String(Files.readAllBytes(nextMessagePath));
|
|
}
|
|
|
|
switch (loadedStation.getMessageMethod()) {
|
|
case StationSettings.MessageMethod.SFTP:
|
|
//loadedStation.uploadNextMessageToSFTP();
|
|
JSch jsch = new JSch();
|
|
try {
|
|
Session session = jsch.getSession(loadedStation.getUsername(), loadedStation.getAddress(), 22);
|
|
session.setPassword(loadedStation.getPassword());
|
|
session.setConfig("StrictHostKeyChecking", "no");
|
|
session.connect(30000); // 30 seconds timeout
|
|
|
|
if (session.isConnected()) {
|
|
ChannelSftp channel = (ChannelSftp) session.openChannel("sftp");
|
|
channel.connect();
|
|
|
|
String localFile = loadedStation.nextMessagePath().toString();
|
|
channel.put(localFile, "www/message.txt");
|
|
channel.exit();
|
|
session.disconnect();
|
|
} else {
|
|
logger.log(Level.SEVERE, "SFTP connection failed");
|
|
}
|
|
} catch (JSchException e) {
|
|
logger.log(Level.SEVERE, "SFTP connection failed", e);
|
|
}
|
|
break;
|
|
case StationSettings.MessageMethod.WORDPRESS:
|
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
|
|
String dateStr = dateFormat.format(new Date());
|
|
System.setProperty("wordpress.username", loadedStation.getUsername());
|
|
System.setProperty("wordpress.password", loadedStation.getPassword());
|
|
System.setProperty("wordpress.url", loadedStation.getAddress());
|
|
Post post = new Post(dateStr, messageText);
|
|
WordpressClient client = new WordpressClient();
|
|
String newPostId = client.newPost(post);
|
|
break;
|
|
default:
|
|
String message = "Message method " + loadedStation.getMessageMethod() + " not supported";
|
|
logger.log(Level.SEVERE, message);
|
|
throw new StationRunException(message);
|
|
}
|
|
|
|
String newMessageText = loadedStation.generateMessage(settings.getMessageGenerationAttempts());
|
|
Files.write(nextMessagePath, newMessageText.getBytes(StandardCharsets.UTF_8));
|
|
} catch (Exception e) {
|
|
String message = "Exception while posting message to station " + parsedArgs.getStationName();
|
|
logger.log(Level.SEVERE, message, e);
|
|
throw new StationRunException(message);
|
|
}
|
|
|
|
System.exit(0);
|
|
}
|
|
}
|