TEST_F(LogLevelFactoryTest, TestInfoNameCreateAnInfoLevel)
{
std::unique_ptr<erty::LogLevel> logLevel(logLevelFactory.create("info"));
ASSERT_EQ(logLevel->priority(), 10);
}
int main(int argc, char** argv)
{
#ifdef OS_Darwin
struct rlimit rlp;
if (getrlimit(RLIMIT_NOFILE, &rlp) == 0) {
if (rlp.rlim_cur < 1000) {
rlp.rlim_cur = 1000;
setrlimit(RLIMIT_NOFILE, &rlp);
}
}
#endif
{
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_getstacksize(&attr, &defaultStackSize);
pthread_attr_destroy(&attr);
if (defaultStackSize < 1024 * 1024 * 4) { // 4 megs should be enough for everyone right?
defaultStackSize = 1024 * 1024 * 4;
}
}
Rct::findExecutablePath(*argv);
struct option opts[] = {
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 2 },
{ "include-path", required_argument, 0, 'I' },
{ "isystem", required_argument, 0, 's' },
{ "define", required_argument, 0, 'D' },
{ "log-file", required_argument, 0, 'L' },
{ "setenv", required_argument, 0, 'e' },
{ "no-Wall", no_argument, 0, 'W' },
{ "Weverything", no_argument, 0, 'u' },
{ "cache-AST", required_argument, 0, 'A' },
{ "verbose", no_argument, 0, 'v' },
{ "job-count", required_argument, 0, 'j' },
{ "header-error-job-count", required_argument, 0, 'H' },
{ "test", required_argument, 0, 't' },
{ "test-timeout", required_argument, 0, 'z' },
{ "clean-slate", no_argument, 0, 'C' },
{ "disable-sighandler", no_argument, 0, 'x' },
{ "silent", no_argument, 0, 'S' },
{ "exclude-filter", required_argument, 0, 'X' },
{ "socket-file", required_argument, 0, 'n' },
{ "config", required_argument, 0, 'c' },
{ "no-rc", no_argument, 0, 'N' },
{ "data-dir", required_argument, 0, 'd' },
{ "ignore-printf-fixits", no_argument, 0, 'F' },
{ "no-unlimited-errors", no_argument, 0, 'f' },
{ "block-argument", required_argument, 0, 'G' },
{ "no-spell-checking", no_argument, 0, 'l' },
{ "large-by-value-copy", required_argument, 0, 'r' },
{ "disallow-multiple-sources", no_argument, 0, 'm' },
{ "no-startup-project", no_argument, 0, 'o' },
{ "no-no-unknown-warnings-option", no_argument, 0, 'Y' },
{ "ignore-compiler", required_argument, 0, 'b' },
{ "watch-system-paths", no_argument, 0, 'w' },
{ "rp-visit-file-timeout", required_argument, 0, 'Z' },
{ "rp-indexer-message-timeout", required_argument, 0, 'T' },
{ "rp-connect-timeout", required_argument, 0, 'O' },
{ "rp-connect-attempts", required_argument, 0, 3 },
{ "rp-nice-value", required_argument, 0, 'a' },
{ "thread-stack-size", required_argument, 0, 'k' },
{ "suspend-rp-on-crash", no_argument, 0, 'q' },
{ "rp-log-to-syslog", no_argument, 0, 7 },
{ "start-suspended", no_argument, 0, 'Q' },
{ "separate-debug-and-release", no_argument, 0, 'E' },
{ "max-crash-count", required_argument, 0, 'K' },
{ "completion-cache-size", required_argument, 0, 'i' },
{ "completion-no-filter", no_argument, 0, 8 },
{ "extra-compilers", required_argument, 0, 'U' },
{ "allow-Wpedantic", no_argument, 0, 'P' },
{ "enable-compiler-manager", no_argument, 0, 'R' },
{ "enable-NDEBUG", no_argument, 0, 'g' },
{ "progress", no_argument, 0, 'p' },
{ "max-file-map-cache-size", required_argument, 0, 'y' },
#ifdef OS_FreeBSD
{ "filemanager-watch", no_argument, 0, 'M' },
#else
{ "no-filemanager-watch", no_argument, 0, 'M' },
#endif
{ "no-filemanager", no_argument, 0, 15 },
{ "no-file-lock", no_argument, 0, 13 },
{ "pch-enabled", no_argument, 0, 14 },
{ "no-filesystem-watcher", no_argument, 0, 'B' },
{ "arg-transform", required_argument, 0, 'V' },
{ "no-comments", no_argument, 0, 1 },
#ifdef RTAGS_HAS_LAUNCHD
{ "launchd", no_argument, 0, 4 },
#endif
{ "inactivity-timeout", required_argument, 0, 5 },
{ "daemon", no_argument, 0, 6 },
{ "log-file-log-level", required_argument, 0, 9 },
{ "watch-sources-only", no_argument, 0, 10 },
{ "debug-locations", no_argument, 0, 11 },
{ "validate-file-maps", no_argument, 0, 16 },
{ "tcp-port", required_argument, 0, 12 },
{ "rp-path", required_argument, 0, 17 },
{ "log-timestamp", no_argument, 0, 18 },
{ 0, 0, 0, 0 }
};
const String shortOptions = Rct::shortOptions(opts);
if (getenv("RTAGS_DUMP_UNUSED")) {
String unused;
for (int i=0; i<26; ++i) {
if (!shortOptions.contains('a' + i))
unused.append('a' + i);
if (!shortOptions.contains('A' + i))
unused.append('A' + i);
}
printf("Unused: %s\n", unused.constData());
for (int i=0; opts[i].name; ++i) {
if (opts[i].name) {
if (!opts[i].val) {
printf("No shortoption for %s\n", opts[i].name);
} else if (opts[i].name[0] != opts[i].val) {
printf("Not ideal option for %s|%c\n", opts[i].name, opts[i].val);
}
}
}
return 0;
}
bool daemon = false;
List<String> argCopy;
List<char*> argList;
{
bool norc = false;
Path rcfile = Path::home() + ".rdmrc";
opterr = 0;
StackBuffer<128, char*> originalArgv(argc);
memcpy(originalArgv, argv, sizeof(char*) * argc);
/* getopt will molest argv by moving pointers around when it sees
* fit. Their idea of an optional argument is different from ours so we
* have to take a copy of argv before they get their sticky fingers all
* over it.
*
* We think this should be okay for an optional argument:
* -s something
*
* They only populate optarg if you do:
* -ssomething.
*
* We don't want to copy argv into argList before processing rc files
* since command line args should take precedence over things in rc
* files.
*
*/
while (true) {
const int c = getopt_long(argc, argv, shortOptions.constData(), opts, 0);
if (c == -1)
break;
switch (c) {
case 'N':
norc = true;
break;
case 'c':
rcfile = optarg;
break;
default:
break;
}
}
opterr = 1;
argList.append(argv[0]);
if (!norc) {
String rc = Path("/etc/rdmrc").readAll();
if (!rc.isEmpty()) {
for (const String& s : rc.split('\n')) {
if (!s.isEmpty() && !s.startsWith('#'))
argCopy += s.split(' ');
}
}
if (!rcfile.isEmpty()) {
rc = rcfile.readAll();
if (!rc.isEmpty()) {
for (const String& s : rc.split('\n')) {
if (!s.isEmpty() && !s.startsWith('#'))
argCopy += s.split(' ');
}
}
}
const int s = argCopy.size();
for (int i=0; i<s; ++i) {
String &arg = argCopy.at(i);
if (!arg.isEmpty())
argList.append(arg.data());
}
}
for (int i=1; i<argc; ++i)
argList.append(originalArgv[i]);
optind = 1;
}
Server::Options serverOpts;
serverOpts.threadStackSize = defaultStackSize;
serverOpts.socketFile = String::format<128>("%s.rdm", Path::home().constData());
serverOpts.jobCount = std::max(2, ThreadPool::idealThreadCount());
serverOpts.headerErrorJobCount = -1;
serverOpts.rpVisitFileTimeout = DEFAULT_RP_VISITFILE_TIMEOUT;
serverOpts.rpIndexDataMessageTimeout = DEFAULT_RP_INDEXER_MESSAGE_TIMEOUT;
serverOpts.rpConnectTimeout = DEFAULT_RP_CONNECT_TIMEOUT;
serverOpts.rpConnectAttempts = DEFAULT_RP_CONNECT_ATTEMPTS;
serverOpts.maxFileMapScopeCacheSize = DEFAULT_RDM_MAX_FILE_MAP_CACHE_SIZE;
serverOpts.rpNiceValue = INT_MIN;
serverOpts.options = Server::Wall|Server::SpellChecking;
serverOpts.maxCrashCount = DEFAULT_MAX_CRASH_COUNT;
serverOpts.completionCacheSize = DEFAULT_COMPLETION_CACHE_SIZE;
serverOpts.rp = defaultRP();
#ifdef OS_FreeBSD
serverOpts.options |= Server::NoFileManagerWatch;
#endif
// #ifndef NDEBUG
// serverOpts.options |= Server::SuspendRPOnCrash;
// #endif
serverOpts.dataDir = String::format<128>("%s.rtags", Path::home().constData());
const char *logFile = 0;
Flags<LogFlag> logFlags = DontRotate|LogStderr;
LogLevel logLevel(LogLevel::Error);
LogLevel logFileLogLevel(LogLevel::Error);
bool sigHandler = true;
assert(Path::home().endsWith('/'));
int argCount = argList.size();
char **args = argList.data();
bool defaultDataDir = true;
int inactivityTimeout = 0;
while (true) {
const int c = getopt_long(argCount, args, shortOptions.constData(), opts, 0);
if (c == -1)
break;
switch (c) {
case 'N':
case 'c':
// ignored
break;
case 'S':
logLevel = LogLevel::None;
break;
case 'X':
serverOpts.excludeFilters += String(optarg).split(';');
break;
case 'G':
serverOpts.blockedArguments << optarg;
break;
case 1:
serverOpts.options |= Server::NoComments;
break;
case 10:
serverOpts.options |= Server::WatchSourcesOnly;
break;
case 11:
if (!strcmp(optarg, "clear") || !strcmp(optarg, "none")) {
serverOpts.debugLocations.clear();
} else {
serverOpts.debugLocations << optarg;
}
break;
case 12:
serverOpts.tcpPort = atoi(optarg);
if (!serverOpts.tcpPort) {
fprintf(stderr, "Invalid port %s for --tcp-port\n", optarg);
return 1;
}
break;
case 13:
serverOpts.options |= Server::NoFileLock;
break;
case 14:
serverOpts.options |= Server::PCHEnabled;
break;
case 15:
serverOpts.options |= Server::NoFileManager;
break;
case 16:
serverOpts.options |= Server::ValidateFileMaps;
break;
case 17:
serverOpts.rp = optarg;
if (serverOpts.rp.isFile())
serverOpts.rp.resolve();
break;
case 18:
logFlags |= LogTimeStamp;
break;
case 2:
fprintf(stdout, "%s\n", RTags::versionString().constData());
return 0;
case 6:
daemon = true;
logLevel = LogLevel::None;
break;
case 9:
if (!strcasecmp(optarg, "verbose-debug")) {
logFileLogLevel = LogLevel::VerboseDebug;
} else if (!strcasecmp(optarg, "debug")) {
logFileLogLevel = LogLevel::Debug;
} else if (!strcasecmp(optarg, "warning")) {
logFileLogLevel = LogLevel::Warning;
} else if (!strcasecmp(optarg, "error")) {
logFileLogLevel = LogLevel::Error;
} else {
fprintf(stderr, "Unknown log level: %s options are error, warning, debug or verbose-debug\n",
optarg);
return 1;
}
break;
case 'U':
serverOpts.extraCompilers.append(std::regex(optarg));
break;
case 'E':
serverOpts.options |= Server::SeparateDebugAndRelease;
break;
case 'g':
serverOpts.options |= Server::EnableNDEBUG;
break;
case 'Q':
serverOpts.options |= Server::StartSuspended;
break;
case 'Z':
serverOpts.rpVisitFileTimeout = atoi(optarg);
if (serverOpts.rpVisitFileTimeout < 0) {
fprintf(stderr, "Invalid argument to -Z %s\n", optarg);
return 1;
}
if (!serverOpts.rpVisitFileTimeout)
serverOpts.rpVisitFileTimeout = -1;
break;
case 'y':
serverOpts.maxFileMapScopeCacheSize = atoi(optarg);
if (serverOpts.maxFileMapScopeCacheSize <= 0) {
fprintf(stderr, "Invalid argument to -y %s\n", optarg);
return 1;
}
break;
case 'O':
serverOpts.rpConnectTimeout = atoi(optarg);
if (serverOpts.rpConnectTimeout < 0) {
fprintf(stderr, "Invalid argument to -O %s\n", optarg);
return 1;
}
break;
case 3:
serverOpts.rpConnectAttempts = atoi(optarg);
if (serverOpts.rpConnectAttempts <= 0) {
fprintf(stderr, "Invalid argument to --rp-connect-attempts %s\n", optarg);
return 1;
}
break;
case 'k':
serverOpts.threadStackSize = atoi(optarg);
if (serverOpts.threadStackSize < 0) {
fprintf(stderr, "Invalid argument to -k %s\n", optarg);
return 1;
}
break;
case 'b':
serverOpts.ignoredCompilers.insert(Path::resolved(optarg));
break;
case 't': {
Path test(optarg);
if (!test.resolve() || !test.isFile()) {
fprintf(stderr, "%s doesn't seem to be a file\n", optarg);
return 1;
}
serverOpts.tests += test;
break; }
case 'z':
serverOpts.testTimeout = atoi(optarg);
if (serverOpts.testTimeout <= 0) {
fprintf(stderr, "Invalid argument to -z %s\n", optarg);
return 1;
}
break;
case 'n':
serverOpts.socketFile = optarg;
break;
case 'd':
defaultDataDir = false;
serverOpts.dataDir = String::format<128>("%s", Path::resolved(optarg).constData());
break;
case 'h':
usage(stdout);
return 0;
case 'Y':
serverOpts.options |= Server::NoNoUnknownWarningsOption;
break;
case 'p':
serverOpts.options |= Server::Progress;
break;
case 'R':
serverOpts.options |= Server::EnableCompilerManager;
break;
case 'm':
serverOpts.options |= Server::DisallowMultipleSources;
break;
case 'o':
serverOpts.options |= Server::NoStartupCurrentProject;
break;
case 'w':
serverOpts.options |= Server::WatchSystemPaths;
break;
case 'q':
serverOpts.options |= Server::SuspendRPOnCrash;
break;
case 'M':
#ifdef OS_FreeBSD
serverOpts.options &= ~Server::NoFileManagerWatch;
#else
serverOpts.options |= Server::NoFileManagerWatch;
#endif
break;
case 'B':
serverOpts.options |= Server::NoFileSystemWatch;
break;
case 'V':
serverOpts.argTransform = Process::findCommand(optarg);
if (strlen(optarg) && serverOpts.argTransform.isEmpty()) {
fprintf(stderr, "Invalid argument to -V. Can't resolve %s", optarg);
return 1;
}
break;
case 'F':
serverOpts.options |= Server::IgnorePrintfFixits;
break;
case 'f':
serverOpts.options |= Server::NoUnlimitedErrors;
break;
case 'l':
serverOpts.options &= ~Server::SpellChecking;
break;
case 'W':
serverOpts.options &= ~Server::Wall;
break;
case 'u':
serverOpts.options |= Server::Weverything;
break;
case 'P':
serverOpts.options |= Server::AllowPedantic;
break;
case 'C':
serverOpts.options |= Server::ClearProjects;
break;
case 'e':
putenv(optarg);
break;
case 'x':
sigHandler = false;
break;
case 'K':
serverOpts.maxCrashCount = atoi(optarg);
if (serverOpts.maxCrashCount <= 0) {
fprintf(stderr, "Invalid argument to -K %s\n", optarg);
return 1;
}
break;
case 'i':
serverOpts.completionCacheSize = atoi(optarg);
if (serverOpts.completionCacheSize <= 0) {
fprintf(stderr, "Invalid argument to -i %s\n", optarg);
return 1;
}
break;
case 'T':
serverOpts.rpIndexDataMessageTimeout = atoi(optarg);
if (serverOpts.rpIndexDataMessageTimeout <= 0) {
fprintf(stderr, "Can't parse argument to -T %s.\n", optarg);
return 1;
}
break;
case 'a': {
bool ok;
serverOpts.rpNiceValue = String(optarg).toLong(&ok);
if (!ok) {
fprintf(stderr, "Can't parse argument to -a %s.\n", optarg);
return 1;
}
break; }
case 'j': {
bool ok;
serverOpts.jobCount = String(optarg).toULong(&ok);
if (!ok) {
fprintf(stderr, "Can't parse argument to -j %s. -j must be a positive integer.\n", optarg);
return 1;
}
break; }
case 'H': {
bool ok;
serverOpts.headerErrorJobCount = String(optarg).toULong(&ok);
if (!ok) {
fprintf(stderr, "Can't parse argument to -H %s. -H must be a positive integer.\n", optarg);
return 1;
}
break; }
case 'r': {
int large = atoi(optarg);
if (large <= 0) {
fprintf(stderr, "Can't parse argument to -r %s\n", optarg);
return 1;
}
serverOpts.defaultArguments.append("-Wlarge-by-value-copy=" + String(optarg)); // ### not quite working
break; }
case 'D': {
const char *eq = strchr(optarg, '=');
Source::Define def;
if (!eq) {
def.define = optarg;
} else {
def.define = String(optarg, eq - optarg);
def.value = eq + 1;
}
serverOpts.defines.append(def);
break; }
case 'I':
serverOpts.includePaths.append(Source::Include(Source::Include::Type_Include, Path::resolved(optarg)));
break;
case 's':
serverOpts.includePaths.append(Source::Include(Source::Include::Type_System, Path::resolved(optarg)));
break;
case 'L':
logFile = optarg;
logLevel = LogLevel::None;
break;
case 'v':
if (logLevel != LogLevel::None)
++logLevel;
break;
#ifdef RTAGS_HAS_LAUNCHD
case 4:
serverOpts.options |= Server::Launchd;
break;
#endif
case 5:
inactivityTimeout = atoi(optarg); // seconds.
if (inactivityTimeout <= 0) {
fprintf(stderr, "Invalid argument to --inactivity-timeout %s\n", optarg);
return 1;
}
break;
case 7:
serverOpts.options |= Server::RPLogToSyslog;
break;
case 8:
serverOpts.options |= Server::CompletionsNoFilter;
break;
case '?': {
fprintf(stderr, "Run rdm --help for help\n");
return 1; }
}
}
if (optind < argCount) {
fprintf(stderr, "rdm: unexpected option -- '%s'\n", args[optind]);
return 1;
}
if (daemon) {
switch (fork()) {
case -1:
fprintf(stderr, "Failed to fork (%d) %s\n", errno, strerror(errno));
return 1;
case 0:
setsid();
switch (fork()) {
case -1:
fprintf(stderr, "Failed to fork (%d) %s\n", errno, strerror(errno));
return 1;
case 0:
break;
default:
return 0;
}
break;
default:
return 0;
}
}
if (serverOpts.excludeFilters.isEmpty())
serverOpts.excludeFilters = String(EXCLUDEFILTER_DEFAULT).split(';');
if (!serverOpts.headerErrorJobCount) {
serverOpts.headerErrorJobCount = std::max<size_t>(1, serverOpts.jobCount / 2);
} else {
serverOpts.headerErrorJobCount = std::min(serverOpts.headerErrorJobCount, serverOpts.jobCount);
}
if (sigHandler) {
signal(SIGSEGV, sigSegvHandler);
signal(SIGILL, sigSegvHandler);
signal(SIGABRT, sigSegvHandler);
}
// Shell-expand logFile
Path logPath(logFile); logPath.resolve();
if (!initLogging(argv[0], logFlags, logLevel, logPath.constData(), logFileLogLevel)) {
fprintf(stderr, "Can't initialize logging with %d %s %s\n",
logLevel.toInt(), logFile ? logFile : "", logFlags.toString().constData());
return 1;
}
#ifdef RTAGS_HAS_LAUNCHD
if (serverOpts.options & Server::Launchd) {
// Clamp inactivity timeout. launchd starts to worry if the
// process runs for less than 10 seconds.
static const int MIN_INACTIVITY_TIMEOUT = 15; // includes
// fudge factor.
if (inactivityTimeout < MIN_INACTIVITY_TIMEOUT) {
inactivityTimeout = MIN_INACTIVITY_TIMEOUT;
fprintf(stderr, "launchd mode - clamped inactivity timeout to %d to avoid launchd warnings.\n", inactivityTimeout);
}
}
#endif
EventLoop::SharedPtr loop(new EventLoop);
loop->init(EventLoop::MainEventLoop|EventLoop::EnableSigIntHandler|EventLoop::EnableSigTermHandler);
std::shared_ptr<Server> server(new Server);
if (!serverOpts.tests.isEmpty()) {
char buf[1024];
Path path;
while (true) {
strcpy(buf, "/tmp/rtags-test-XXXXXX");
if (!mkdtemp(buf)) {
fprintf(stderr, "Failed to mkdtemp (%d)\n", errno);
return 1;
}
path = buf;
path.resolve();
break;
}
serverOpts.dataDir = path;
strcpy(buf, "/tmp/rtags-sock-XXXXXX");
const int fd = mkstemp(buf);
if (fd == -1) {
fprintf(stderr, "Failed to mkstemp (%d)\n", errno);
return 1;
}
close(fd);
serverOpts.socketFile = buf;
serverOpts.socketFile.resolve();
}
if (defaultDataDir) {
Path migration = String::format<128>("%s.rtags-file", Path::home().constData());
if (migration.isDir()) {
Rct::removeDirectory(serverOpts.dataDir);
rename(migration.constData(), serverOpts.dataDir.constData());
error() << "Migrated datadir from ~/.rtags-file ~/.rtags";
}
}
serverOpts.dataDir = serverOpts.dataDir.ensureTrailingSlash();
if (!server->init(serverOpts)) {
cleanupLogging();
return 1;
}
if (!serverOpts.tests.isEmpty()) {
return server->runTests() ? 0 : 1;
}
loop->setInactivityTimeout(inactivityTimeout * 1000);
loop->exec();
const int ret = server->exitCode();
server.reset();
cleanupLogging();
return ret;
}
TEST_F(LogLevelFactoryTest, TestUppercaseName)
{
std::unique_ptr<erty::LogLevel> logLevel(logLevelFactory.create("DEBUG"));
ASSERT_EQ(logLevel->priority(), 0);
}
int main(int argc, char *argv[])
{
QApplication::setApplicationName(LONG_NAME);
QApplication::setApplicationVersion(VERSION);
QApplication::setOrganizationName(ORG);
QApplication::setDesktopSettingsAware(true);
QApplication app(argc, argv);
// Create seed for the QT random number generator
QTime time = QTime::currentTime();
qsrand((uint)time.msec());
// setup the command line parser
QCommandLineParser parser;
parser.setApplicationDescription(QApplication::translate("main.cpp", "GStreamer based media player.") );
QCommandLineOption streamBuffering(QStringList() << "b" << "stream-buffering", QCoreApplication::translate("main.cpp", "Enable buffering of the demuxed or parsed data in the stream (default is no stream buffering).") );
parser.addOption(streamBuffering);
QCommandLineOption connectionSpeed(QStringList() << "c" << "connection-speed", QCoreApplication::translate("main.cpp", "Specify a network connection speed in kbps (default is 0 meaning unknown)."), QCoreApplication::translate("main.cpp", "connection-speed"), "0" );
parser.addOption(connectionSpeed);
QCommandLineOption downloadBuffering(QStringList() << "d" << "download-buffering", QCoreApplication::translate("main.cpp", "Enable progressive download buffering of selected formats (default is no download buffering).") );
parser.addOption(downloadBuffering);
QCommandLineOption openFullScreen(QStringList() << "f" << "fullscreen", QCoreApplication::translate("main.cpp", "Start the player in full screen mode (default is start in window).") );
parser.addOption(openFullScreen);
QCommandLineOption openGUI(QStringList() << "g" << "gui", QCoreApplication::translate("main.cpp", "Open the player in GUI mode (default is no GUI).") );
parser.addOption(openGUI);
parser.addHelpOption();
QCommandLineOption useIconTheme(QStringList() << "i" << "icon-theme",
QCoreApplication::translate("main.cpp", "Use an icon theme from your system."),
QCoreApplication::translate("main.cpp", "Icon Theme Name"),
QString() );
parser.addOption(useIconTheme);
QCommandLineOption logLevel(QStringList() << "l" << "loglevel", QCoreApplication::translate("main.cpp", "Set the log level from 0 to 4 (default is 1)."), QCoreApplication::translate("main.cpp", "loglevel"), "1" );
parser.addOption(logLevel);
QCommandLineOption openShadeMode(QStringList() << "s" << "shademode", QCoreApplication::translate("main.cpp", "Start the player in shade mode (default is start in normal mode).") );
parser.addOption(openShadeMode);
QCommandLineOption noHardwareDecoding(QStringList() << "w" << "no-hardware-decoding", QCoreApplication::translate("main.cpp", "Disable hardware decoding, (default is enabled).") );
parser.addOption(noHardwareDecoding);
parser.addVersionOption();
QCommandLineOption cdDevice(QStringList() << "C" << "CD", QCoreApplication::translate("main.cpp", "Specify the optical drive that will play the audio CD (default is /dev/sr0)."), QCoreApplication::translate("main.cpp", "CD"), "/dev/sr0");
parser.addOption(cdDevice);
QCommandLineOption dvdDevice(QStringList() << "D" << "DVD", QCoreApplication::translate("main.cpp", "Specify the optical drive that will play the DVD (default is /dev/sr0)."), QCoreApplication::translate("main.cpp", "DVD"), "/dev/sr0");
parser.addOption(dvdDevice);
QCommandLineOption enableSubtitles(QStringList() << "S" << "subtitles", QCoreApplication::translate("main.cpp", "Enable display of subtitles if a subtitle stream is found (default is no subtitles).") );
parser.addOption(enableSubtitles);
QCommandLineOption enableVisualizer(QStringList() << "V" << "visualizer", QCoreApplication::translate("main.cpp", "Enable a visualizer when playing audio tracks (default is no visualizer).") );
parser.addOption(enableVisualizer);
QCommandLineOption promoteElement(QStringList() << "promote", QCoreApplication::translate("main.cpp", "List of GStreamer elements (comma separated) to be promoted."), QCoreApplication::translate("main.cpp", "element list"), "" );
parser.addOption(promoteElement);
QCommandLineOption blacklistElement(QStringList() << "blacklist", QCoreApplication::translate("main.cpp", "List (comma separated) of GStreamer elements to be blacklisted."), QCoreApplication::translate("main.cpp", "element list"), "" );
parser.addOption(blacklistElement);
parser.addPositionalArgument("filename", QCoreApplication::translate("main.cpp", "Media file to play."));
// Setup translations
QTranslator qtTranslator;
qtTranslator.load("qt_" + QLocale::system().name(),
QLibraryInfo::location(QLibraryInfo::TranslationsPath));
app.installTranslator(&qtTranslator);
QTranslator mbmpTranslator;
if (mbmpTranslator.load("mbmp_" + QLocale::system().name(), ":/translations/translations" ) ) {
app.installTranslator(&mbmpTranslator);
}
// else use en_US as it contains Connman strings properized and some singular/plural strings
else if (mbmpTranslator.load("mbmp_en_US", ":/translations/translations" ) ) {
app.installTranslator(&mbmpTranslator);
}
// Make sure all the command lines can be parsed
// using parse() instead of process() as process stops on an error if an option needs a value
// and it is not specified, even if we provide a default. We're supposed to catch errors if we
// use parse(), but parse.errorText() returns an empty string on this. Bag the error checking
// for now.
parser.parse(QCoreApplication::arguments() );
QStringList sl = parser.unknownOptionNames();
if (sl.size() > 0 ) parser.showHelp(1);
if (parser.isSet("help") ) parser.showHelp(1);
if (parser.isSet("version") ) parser.showVersion();
// signal handler
signal(SIGINT, signalhandler);
PlayerControl pctl(parser);
pctl.show();
return app.exec();
}
QString AppConfig::logLevelText() const
{
return logLevelNames[logLevel()];
}
int deployerParseCmdLine(int argc,
char** argv,
std::string& siteFile,
std::vector<std::string>& scriptFiles,
std::string& name,
bool& requireNameService,
po::variables_map& vm,
po::options_description* otherOptions)
{
std::string logLevel("info"); // set to valid default
po::options_description options;
po::options_description allowed("Allowed options");
po::positional_options_description pos;
allowed.add_options()
("help,h",
"Show program usage")
("version",
"Show program version")
("start,s",
po::value< std::vector<std::string> >(&scriptFiles),
"Deployment XML or script file (eg 'config-file.xml' or 'script.ops')")
("site-file",
po::value<std::string>(&siteFile),
"Site deployment XML file (eg 'Deployer-site.cpf' or 'Deployer-site.xml')")
("log-level,l",
po::value<std::string>(&logLevel),
"Level at which to log from RTT (case-insensitive) Never,Fatal,Critical,Error,Warning,Info,Debug,Realtime")
("no-consolelog",
"Turn off RTT logging to the console (will still log to 'orocos.log')")
("require-name-service",
"Require CORBA name service")
("DeployerName",
po::value<std::string>(&name),
"Name of deployer component (the --DeployerName flag is optional)")
;
pos.add("DeployerName", 1);
// collate options
options.add(allowed);
if (NULL != otherOptions)
{
options.add(*otherOptions);
}
try
{
po::store(po::command_line_parser(argc, argv).
options(options).positional(pos).run(),
vm);
po::notify(vm);
// deal with options
if (vm.count("help"))
{
std::cout << options << std::endl;
return 1;
}
// version info
if (vm.count("version"))
{
std::cout<< " OROCOS Toolchain version '" ORO_xstr(RTT_VERSION) "'";
#ifdef __GNUC__
std::cout << " ( GCC " ORO_xstr(__GNUC__) "." ORO_xstr(__GNUC_MINOR__) "." ORO_xstr(__GNUC_PATCHLEVEL__) " )";
#endif
#ifdef OROPKG_OS_LXRT
std::cout<<" -- LXRT/RTAI.";
#endif
#ifdef OROPKG_OS_GNULINUX
std::cout<<" -- GNU/Linux.";
#endif
#ifdef OROPKG_OS_XENOMAI
std::cout<<" -- Xenomai.";
#endif
std::cout << endl;
return 1;
}
// turn off all console logging
if (vm.count("no-consolelog"))
{
RTT::Logger::Instance()->mayLogStdOut(false);
log(Warning) << "Console logging disabled" << endlog();
}
if (vm.count("require-name-service"))
{
requireNameService = true;
log(Info) << "CORBA name service required." << endlog();
}
// verify that is a valid logging level
boost::algorithm::to_lower(logLevel); // always lower case
if (vm.count("log-level"))
{
if (0 != logMap.count(logLevel))
{
RTT::Logger::Instance()->setLogLevel(logMap[logLevel]);
}
else
{
std::cout << "Did not understand log level: "
<< logLevel << std::endl
<< options << std::endl;
return -1;
}
}
if (vm.count("DeployerName")) {
if (name.find_last_of(".xml") != string::npos ||
name.find_last_of(".cpf") != string::npos ||
name.find_last_of(".osd") != string::npos ||
name.find_last_of(".ops") != string::npos )
log(Warning) <<"The given Deployer name "<<name <<" resembles a filename. Did you forget to use '-s' ?"<<endlog();
}
}
catch (std::logic_error e)
{
std::cerr << "Exception:" << e.what() << std::endl << options << std::endl;
return -1;
}
return 0;
}
void JobScheduler::startJobs()
{
static Path rp;
if (rp.isEmpty()) {
rp = Rct::executablePath().parentDir() + "rp";
if (!rp.isFile()) {
rp = Rct::executablePath();
rp.resolve();
rp = rp.parentDir() + "rp";
if (!rp.isFile()) // should be in $PATH
rp = "rp";
}
}
const auto &options = Server::instance()->options();
std::shared_ptr<Node> node = mPendingJobs.first();
auto cont = [&node, this]() {
auto tmp = node->next;
mPendingJobs.remove(node);
node = tmp;
};
while (mActiveByProcess.size() < options.jobCount && node) {
assert(node);
assert(node->job);
assert(!(node->job->flags & (IndexerJob::Running|IndexerJob::Complete|IndexerJob::Crashed|IndexerJob::Aborted)));
std::shared_ptr<Project> project = Server::instance()->project(node->job->project);
if (!project) {
cont();
debug() << node->job->sourceFile << "doesn't have a project, discarding";
continue;
}
uint32_t headerError = 0;
if (!mHeaderErrors.isEmpty()) {
headerError = hasHeaderError(node->job->source.fileId, project);
if (headerError) {
// error() << "We got a headerError" << Location::path(headerError) << "for" << node->job->source.sourceFile()
// << mHeaderErrorMaxJobs << mHeaderErrorJobIds;
if (options.headerErrorJobCount <= mHeaderErrorJobIds.size()) {
warning() << "Holding off on" << node->job->sourceFile << "it's got a header error from" << Location::path(headerError);
node = node->next;
continue;
}
}
}
const uint64_t jobId = node->job->id;
Process *process = new Process;
debug() << "Starting process for" << jobId << node->job->source.key() << node->job.get();
List<String> arguments;
for (int i=logLevel().toInt(); i>0; --i)
arguments << "-v";
process->readyReadStdOut().connect([this](Process *proc) {
std::shared_ptr<Node> node = mActiveByProcess[proc];
assert(node);
node->stdOut.append(proc->readAllStdOut());
std::regex rx("@CRASH@([^@]*)@CRASH@");
std::smatch match;
while (std::regex_search(node->stdOut.ref(), match, rx)) {
error() << match[1].str();
node->stdOut.remove(match.position(), match.length());
}
});
if (!process->start(rp, arguments)) {
error() << "Couldn't start rp" << rp << process->errorString();
delete process;
node->job->flags |= IndexerJob::Crashed;
debug() << "job crashed (didn't start)" << jobId << node->job->source.key() << node->job.get();
std::shared_ptr<IndexDataMessage> msg(new IndexDataMessage(node->job));
msg->setFlag(IndexDataMessage::ParseFailure);
jobFinished(node->job, msg);
rp.clear(); // in case rp was missing for a moment and we fell back to searching $PATH
cont();
continue;
}
if (headerError) {
node->job->priority = IndexerJob::HeaderError;
warning() << "Letting" << node->job->sourceFile << "go even with a headerheader error from" << Location::path(headerError);
mHeaderErrorJobIds.insert(jobId);
}
process->finished().connect([this, jobId](Process *proc) {
EventLoop::deleteLater(proc);
auto node = mActiveByProcess.take(proc);
assert(!node || node->process == proc);
const String stdErr = proc->readAllStdErr();
if ((node && !node->stdOut.isEmpty()) || !stdErr.isEmpty()) {
error() << (node ? ("Output from " + node->job->sourceFile + ":") : String("Orphaned process:"))
<< '\n' << stdErr << (node ? node->stdOut : String());
}
if (node) {
assert(node->process == proc);
node->process = 0;
assert(!(node->job->flags & IndexerJob::Aborted));
if (!(node->job->flags & IndexerJob::Complete) && proc->returnCode() != 0) {
auto nodeById = mActiveById.take(jobId);
assert(nodeById);
assert(nodeById == node);
// job failed, probably no IndexDataMessage coming
node->job->flags |= IndexerJob::Crashed;
debug() << "job crashed" << jobId << node->job->source.key() << node->job.get();
std::shared_ptr<IndexDataMessage> msg(new IndexDataMessage(node->job));
msg->setFlag(IndexDataMessage::ParseFailure);
jobFinished(node->job, msg);
}
}
mHeaderErrorJobIds.remove(jobId);
startJobs();
});
node->process = process;
assert(!(node->job->flags & ~IndexerJob::Type_Mask));
node->job->flags |= IndexerJob::Running;
process->write(node->job->encode());
mActiveByProcess[process] = node;
// error() << "STARTING JOB" << node->job->source.sourceFile();
mInactiveById.remove(jobId);
mActiveById[jobId] = node;
cont();
}
}
virtual bool testLog(int level) const
{
return level == logLevel();
}