Improvements to JVersion

cmake/MakeJVersionH.cmake

@@ -15,31 +15,35 @@ set_property(
 )
 
 execute_process(
- COMMAND git log -1 --format=%H 2>/dev/null
+ COMMAND git log -1 --format=%H
  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
  RESULT_VARIABLE JVERSION_GIT_RESULT
  OUTPUT_VARIABLE JVERSION_COMMIT_HASH
+ ERROR_QUIET
  OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 
 execute_process(
- COMMAND git log -1 --format=%aD 2>/dev/null
+ COMMAND git log -1 --format=%aD
  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
  OUTPUT_VARIABLE JVERSION_COMMIT_DATE
+ ERROR_QUIET
  OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 
 execute_process(
- COMMAND git show-ref -s v${jana2_VERSION_MAJOR}.${jana2_VERSION_MINOR}.${jana2_VERSION_PATCH} 2>/dev/null
+ COMMAND git show-ref -s v${jana2_VERSION_MAJOR}.${jana2_VERSION_MINOR}.${jana2_VERSION_PATCH}
  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
  OUTPUT_VARIABLE JVERSION_RELEASE_COMMIT_HASH
+ ERROR_QUIET
  OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 
 execute_process(
- COMMAND git status --porcelain 2>/dev/null
+ COMMAND git status --porcelain
  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
  OUTPUT_VARIABLE JVERSION_MODIFIED_FILES
+ ERROR_QUIET
  OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 

src/libraries/JANA/CLI/JMain.cc

@@ -4,7 +4,6 @@
 
 #include "JMain.h"
 
-#include <JANA/JVersion.h>
 #include <JANA/CLI/JBenchmarker.h>
 #include <JANA/CLI/JSignalHandler.h>
 
@@ -45,15 +44,6 @@ void PrintUsageOptions() {
  std::cout << " --inspect-component <name> Inspect a component" << std::endl;
 }
 
-void PrintVersion() {
- /// Prints JANA version information to stdout, for use by the CLI.
-
- std::cout << "JANA2 version: " << JVersion::GetVersion() << std::endl;
- if (!JVersion::is_unknown) {
- std::cout << "Commit hash: " << JVersion::GetCommitHash() << std::endl;
- std::cout << "Commit date: " << JVersion::GetCommitDate() << std::endl;
- }
-}
 
 JApplication* CreateJApplication(UserOptions& options) {
 
@@ -85,13 +75,6 @@ JApplication* CreateJApplication(UserOptions& options) {
 
 int Execute(JApplication* app, UserOptions &options) {
 
- std::cout << std::endl;
- std::cout << " | \\ \\ | \\ ___ \\ " << std::endl;
- std::cout << " | _ \\ \\ | _ \\ ) |" << std::endl;
- std::cout << " \\ | ___ \\ |\\ | ___ \\ __/" << std::endl;
- std::cout << " \\___/ _/ _\\ _| \\_| _/ _\\ _____|" << std::endl;
- std::cout << std::endl;
- PrintVersion();
  JSignalHandler::register_handlers(app);
 
  if (options.flags[ShowConfigs]) {

src/libraries/JANA/CMakeLists.txt

@@ -23,6 +23,7 @@ set(JANA2_SOURCES
  JMultifactory.cc
  JMultifactory.h
  JService.cc
+ JVersion.cc
 
  Engine/JArrowProcessingController.cc
  Engine/JArrowProcessingController.h

src/libraries/JANA/JApplication.cc

@@ -17,6 +17,7 @@
 #include <JANA/Engine/JArrowProcessingController.h>
 #include <JANA/Utils/JApplicationInspector.h>
 
+#include <sstream>
 #include <unistd.h>
 
 JApplication *japp = nullptr;
@@ -108,6 +109,12 @@ void JApplication::Initialize() {
  // Only run this once
  if (m_initialized) return;
 
+ std::ostringstream oss;
+ oss << "Initializing..." << std::endl;
+ JVersion::PrintSplash(oss);
+ JVersion::PrintVersionDescription(oss);
+ LOG_INFO(m_logger) << oss.str() << LOG_END;
+
  // Now that all parameters, components, plugin names, etc have been set, 
  // we can expose our builtin services to the user via GetService()
  m_services_available = true;

src/libraries/JANA/JVersion.cc

@@ -0,0 +1,62 @@
+// Copyright 2024, Jefferson Science Associates, LLC.
+// Subject to the terms in the LICENSE file found in the top-level directory.
+// Author: Nathan Brei
+
+#include <JANA/JVersion.h>
+#include <sstream>
+
+
+constexpr uint64_t JVersion::GetVersionNumber() {
+ return 1000000*GetMajorNumber() + 1000*minor + patch;
+}
+
+std::string JVersion::GetVersion() {
+ std::stringstream ss;
+ PrintVersionNumbers(ss);
+ return ss.str();
+}
+
+void JVersion::PrintVersionNumbers(std::ostream& os) {
+ os << major << "." << minor << "." << patch;
+}
+
+void JVersion::PrintSplash(std::ostream& os) {
+ os << std::endl;
+ os << " | \\ \\ | \\ ___ \\ " << std::endl;
+ os << " | _ \\ \\ | _ \\ ) |" << std::endl;
+ os << " \\ | ___ \\ |\\ | ___ \\ __/" << std::endl;
+ os << " \\___/ _/ _\\ _| \\_| _/ _\\ _____|" << std::endl;
+ os << std::endl;
+}
+
+void JVersion::PrintVersionDescription(std::ostream& os) {
+
+ os << "JANA2 version: " << JVersion::GetVersion() << " ";
+ if (is_unknown) {
+ os << " (unknown git status)";
+ }
+ else if (is_release) {
+ os << " (release)";
+ }
+ else if (is_modified) {
+ os << " (uncommitted changes)";
+ }
+ else {
+ os << " (committed changes)";
+ }
+ os << std::endl;
+ if (!JVersion::is_unknown) {
+ os << "Commit hash: " << JVersion::GetCommitHash() << std::endl;
+ os << "Commit date: " << JVersion::GetCommitDate() << std::endl;
+ }
+ os << "Install prefix: " << JVersion::GetInstallDir() << std::endl;
+ if (JVersion::HasPodio() || JVersion::HasROOT() || JVersion::HasXerces()) {
+ os << "Optional deps: ";
+ if (JVersion::HasPodio()) os << "Podio ";
+ if (JVersion::HasROOT()) os << "ROOT ";
+ if (JVersion::HasXerces()) os << "Xerces ";
+ os << std::endl;
+ }
+}
+
+

src/libraries/JANA/JVersion.h.in

@@ -3,7 +3,8 @@
 // Subject to the terms in the LICENSE file found in the top-level directory.
 
 #pragma once
-#include <sstream>
+#include <cstdint>
+#include <ostream>
 
 #define JANA2_HAVE_PODIO @JANA2_HAVE_PODIO@
 #define JANA2_HAVE_ROOT @JANA2_HAVE_ROOT@
@@ -12,9 +13,9 @@
 
 struct JVersion {
 
- static const int major = @jana2_VERSION_MAJOR@;
- static const int minor = @jana2_VERSION_MINOR@;
- static const int patch = @jana2_VERSION_PATCH@;
+ static const uint64_t major = @jana2_VERSION_MAJOR@;
+ static const uint64_t minor = @jana2_VERSION_MINOR@;
+ static const uint64_t patch = @jana2_VERSION_PATCH@;
 
  inline static const std::string last_commit_hash = "@JVERSION_COMMIT_HASH@";
  inline static const std::string last_commit_date = "@JVERSION_COMMIT_DATE@";
@@ -24,36 +25,25 @@ struct JVersion {
  static const bool is_release = @JVERSION_RELEASE@;
  static const bool is_modified = @JVERSION_MODIFIED@;
 
- static unsigned int GetMajorNumber() { return major; }
- static unsigned int GetMinorNumber() { return minor; }
- static unsigned int GetPatchNumber() { return patch; }
+ static constexpr uint64_t GetMajorNumber() { return major; }
+ static constexpr uint64_t GetMinorNumber() { return minor; }
+ static constexpr uint64_t GetPatchNumber() { return patch; }
 
  static std::string GetCommitHash() { return last_commit_hash; }
  static std::string GetCommitDate() { return last_commit_date; }
  static std::string GetInstallDir() { return installdir; }
 
- static bool HasPodio() { return JANA2_HAVE_PODIO; }
- static bool HasROOT() { return JANA2_HAVE_ROOT; }
- static bool HasXerces() { return JANA2_HAVE_XERCES; }
-
- static std::string GetVersion() {
- std::stringstream ss;
- ss << major << "." << minor << "." << patch;
- if (is_unknown) {
- // ss << " (git status unknown)";
- // If .git is not present, degrade gracefully. Don't lead the user to believe that there is an error
- }
- else if (is_modified) {
- ss << " (uncommitted changes)";
- }
- else if (is_release) {
- ss << " (release)";
- }
- else {
- ss << " (development)";
- }
- return ss.str();
- }
+ static constexpr bool HasPodio() { return JANA2_HAVE_PODIO; }
+ static constexpr bool HasROOT() { return JANA2_HAVE_ROOT; }
+ static constexpr bool HasXerces() { return JANA2_HAVE_XERCES; }
+
+ static std::string GetVersion();
+ static constexpr uint64_t GetVersionNumber();
+
+ static void PrintSplash(std::ostream& os);
+ static void PrintVersionNumbers(std::ostream& os);
+ static void PrintVersionDescription(std::ostream& os);
+
 };
 
 

src/libraries/JANA/Services/JPluginLoader.cc

@@ -6,6 +6,7 @@
 #include "JPluginLoader.h"
 #include "JComponentManager.h"
 #include "JParameterManager.h"
+#include <JANA/JVersion.h>
 
 #include <dlfcn.h>
 #include <iostream>
@@ -55,6 +56,39 @@ void JPluginLoader::add_plugin(std::string plugin_name) {
  m_plugins_to_include.push_back(plugin_name);
 }
 
+void JPluginLoader::resolve_plugin_paths() {
+ // Build our list of plugin search paths.
+
+ // 1. First we look for plugins in the local directory
+ add_plugin_path(".");
+
+ // 2. Next we look for plugins in locations specified via parameters. (Colon-separated)
+ std::stringstream param_ss(m_plugin_paths_str);
+ std::string path;
+ while (getline(param_ss, path, ':')) add_plugin_path(path);
+
+ // 3. Next we look for plugins in locations specified via environment variable. (Colon-separated)
+ const char* jpp = getenv("JANA_PLUGIN_PATH");
+ if (jpp) {
+ std::stringstream envvar_ss(jpp);
+ while (getline(envvar_ss, path, ':')) add_plugin_path(path);
+ }
+
+ // 4. Next we look in the plugin directories relative to $JANA_HOME
+ if (const char* jana_home = getenv("JANA_HOME")) {
+ add_plugin_path(std::string(jana_home) + "/plugins/JANA"); // In case we did a system install and want to avoid conflicts.
+ add_plugin_path(std::string(jana_home) + "/plugins");
+ }
+
+ // 5. Finally we look in the JANA install directory.
+ // By checking here, the user no longer needs to set JANA_HOME in order to run built-in plugins 
+ // such as janadot and JTest. The install directory is supposed to be the same as JANA_HOME, 
+ // but we can't guarantee that because the user can set JANA_HOME to be anything they want.
+ // It would be nice if nothing in the JANA codebase itself relied on JANA_HOME, although we 
+ // won't be removing it anytime soon because of build_scripts.
+ add_plugin_path(JVersion::GetInstallDir() + "/plugins");
+}
+
 
 void JPluginLoader::add_plugin_path(std::string path) {
 
@@ -84,28 +118,7 @@ void JPluginLoader::attach_plugins(JComponentManager* jcm) {
  /// Loop over list of plugin names added via AddPlugin() and
  /// actually attach and initialize them. See AddPlugin method
  /// for more.
-
- // Build our list of plugin search paths.
- // 1. First we look for plugins in the local directory
- add_plugin_path(".");
-
- // 2. Next we look for plugins in locations specified via parameters. (Colon-separated)
- std::stringstream param_ss(m_plugin_paths_str);
- std::string path;
- while (getline(param_ss, path, ':')) add_plugin_path(path);
-
- // 3. Next we look for plugins in locations specified via environment variable. (Colon-separated)
- const char* jpp = getenv("JANA_PLUGIN_PATH");
- if (jpp) {
- std::stringstream envvar_ss(jpp);
- while (getline(envvar_ss, path, ':')) add_plugin_path(path);
- }
-
- // 4. Finally we look in the plugin directories relative to $JANA_HOME
- if (const char* jana_home = getenv("JANA_HOME")) {
- add_plugin_path(std::string(jana_home) + "/plugins/JANA"); // In case we did a system install and want to avoid conflicts.
- add_plugin_path(std::string(jana_home) + "/plugins");
- }
+ resolve_plugin_paths();
 
  // Add plugins specified via PLUGINS configuration parameter
  // (comma separated list).

src/libraries/JANA/Services/JPluginLoader.h

@@ -28,6 +28,7 @@ class JPluginLoader : public JService {
  void add_plugin_path(std::string path);
  void attach_plugins(JComponentManager* jcm);
  void attach_plugin(std::string plugin_name);
+ void resolve_plugin_paths();
 
 private:
  Service<JParameterManager> m_params {this};

src/programs/jana/jana.cc

@@ -3,6 +3,7 @@
 // Subject to the terms in the LICENSE file found in the top-level directory.
 
 #include <JANA/CLI/JMain.h>
+#include <JANA/JVersion.h>
 
 int main(int argc, char* argv[]) {
 
@@ -15,7 +16,7 @@ int main(int argc, char* argv[]) {
  }
  if (options.flags[jana::ShowVersion]) {
  // Show version information and exit immediately
- jana::PrintVersion();
+ JVersion::PrintVersionDescription(std::cout);
  return -1;
  }
  auto app = jana::CreateJApplication(options);