public void Test_Append_NewFile()
{
Console.WriteLine ("");
Console.WriteLine ("Preparing test");
Console.WriteLine ("");
var dataDirectory = Path.GetFullPath (".data");
var folderName = "TestFolder";
var fileName = "TestFile.txt";
var deviceKey = "deviceKey";
var text = "Hello world!";
var appender = new FileAppender (dataDirectory, folderName, deviceKey);
Console.WriteLine ("");
Console.WriteLine ("Executing test");
Console.WriteLine ("");
appender.Append (fileName, text);
Console.WriteLine ("");
Console.WriteLine ("Analysing test");
Console.WriteLine ("");
var filePath = Path.Combine (dataDirectory, folderName + "/" + fileName);
var fileContents = File.ReadAllLines (filePath);
Assert.AreEqual (1, fileContents.Length);
}
static void Main()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
var fileAppender = new FileAppender(simpleLayout);
fileAppender.LogFile = "log.txt";
var errorLog = new Log(new Level("Error"), "Error parsing JSON.");
var infoLog = new Log(new Level("Info"), string.Format("User {0} successfully registered.", "Pesho"));
var warnLog = new Log(new Level("Warning"), "Warning - missing files.");
var logger = new Models.Logger(new List<IAppender> { consoleAppender, fileAppender });
logger.AppendLog(errorLog);
logger.AppendLog(infoLog);
logger.AppendLog(warnLog);
//xml Logger
var xmlLayout = new XmlLayout();
var consoleXmlAppender = new ConsoleAppender(xmlLayout);
var xmlLogger = new Models.Logger(new List<IAppender>{consoleXmlAppender});
var fatalLog = new Log(new Level("Fatal"), "mscorlib.dll does not respond");
var criticalLog = new Log(new Level("Critical"), "No connection string found in App.config");
xmlLogger.AppendLog(fatalLog);
xmlLogger.AppendLog(criticalLog);
}
public static void Main()
{
ILayout simpleLayout = new SimpleLayout();
IAppender consoleAppender = new ConsoleAppender(simpleLayout);
var fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "../../log.txt";
var logger = new Logger(consoleAppender, fileAppender);
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Dobri"));
logger.Warn("Warning - missing files.");
var xmlLayout = new XmlLayout();
consoleAppender = new ConsoleAppender(xmlLayout);
logger = new Logger(consoleAppender);
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
consoleAppender = new ConsoleAppender(simpleLayout);
consoleAppender.ReportLevel = ReportLevel.Error;
logger = new Logger(consoleAppender);
logger.Info("Everything seems fine");
logger.Warn("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
}
static void Main(string[] args)
{
IFormater formetter = new SimpleFormatter();
IAppender appender = new FileAppender("file.txt",formetter);
Logger logger = new Logger(appender);
logger.Critical("Out of Memmory");
logger.Info("Unused local Variable");
}
public PostFolderManager(string dataDirectory, string contentDirectory, string folderName, string securityKey)
{
DataDirectory = dataDirectory;
ContentDirectory = contentDirectory;
FolderId = folderName;
SecurityKey = securityKey;
Overwriter = new FileOverwriter (contentDirectory, folderName, securityKey);
Appender = new FileAppender (contentDirectory, folderName, securityKey);
Keys = new KeyManager (dataDirectory);
Authentication = new Authenticator (Keys);
}
public static void Main()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
var fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "log.txt";
var logger = new Logger(consoleAppender, fileAppender);
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
logger.Warn("Warning - missing files.");
}
static void Main()
{
//Init dependencies
ILayout layout = new XmlLayout();
IAppender fileAppender = new FileAppender(layout, "file.txt");
IAppender consoleAppender = new ConsoleAppender(layout);
Logger logger = new Logger(consoleAppender);
//shows every report level above ReportLevel.Warn
consoleAppender.ReportLevel = ReportLevel.Fatal;
logger.Critical("Critical Sample Report");
logger.Fatal("Fatal Sample Report");
logger.Info("Info Sample Report");
}
public static void Main()
{
ILayout simpleLayout = new SimpleLayout();
IDataAppender consoleAppender =
new ConsoleAppender(simpleLayout);
ILogger logger = new Logger(consoleAppender);
logger.Error("Error parsing JSON.");
logger.Info($"User {"Pesho"} successfully registered.");
var fileAppender = new FileAppender(simpleLayout, "log.txt");
logger = new Logger(fileAppender);
logger.Error("Error parsing JSON.");
logger.Info($"User {"Pesho"} successfully registered.");
logger.Warn("Warning - missing files.");
}
static void Main(string[] args)
{
ILayout simpleLayout = new SimpleLayout();
IAppender consoleAppender = new ConsoleAppender(simpleLayout);
ILogger logger = new Logger(consoleAppender);
logger.Error("Error parsing JSON");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
Console.WriteLine(new string('-', 20));
//We create a second Appender and add it to the existing ILogger object
IFileAppender fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "log.txt";
logger.AddAppender(fileAppender);
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
Console.WriteLine(new string('-', 20));
//We set the new XML Layout on each Appender that the Logger object uses
foreach (IAppender appender in logger.Appenders)
{
appender.Layout = new XmlLayout();
}
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
Console.WriteLine(new string('-', 20));
//We set the Report Level Minimum at Error
foreach (IAppender appender in logger.Appenders)
{
appender.ReportLevelMinimum = Enums.ReportLevel.Error;
}
logger.Info("Everything seems fine");
logger.Warning("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
Console.WriteLine(new string('-', 20));
}
static void Main(string[] args)
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
consoleAppender.Threshold = ReportLevel.Error;
var fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "log.txt";
var logger = new Logger.Loggers.Logger(consoleAppender, fileAppender);
logger.Info("Everything seems fine");
logger.Warn("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
}
public void Test_Append_ExistingFile()
{
Console.WriteLine ("");
Console.WriteLine ("Preparing test");
Console.WriteLine ("");
var dataDirectory = Path.GetFullPath (".data");
Directory.CreateDirectory (dataDirectory);
var folderName = "TestFolder";
var folderPath = Path.Combine (dataDirectory, folderName);
Directory.CreateDirectory (folderPath);
var fileName = "TestFile.txt";
var deviceKey = "deviceKey";
var filePath = Path.Combine (dataDirectory, folderName + "/" + fileName);
File.WriteAllText (filePath, "Line #1" + Environment.NewLine);
var text = "Line #2";
var appender = new FileAppender (dataDirectory, folderName, deviceKey);
Console.WriteLine ("");
Console.WriteLine ("Executing test");
Console.WriteLine ("");
appender.AppendLine (fileName, text);
Console.WriteLine ("");
Console.WriteLine ("Analysing test");
Console.WriteLine ("");
var fileContents = File.ReadAllLines (filePath);
Assert.AreEqual (2, fileContents.Length);
Assert.AreEqual (text, fileContents [1]);
}
private static void Main(string[] args)
{
ILayout simpleLayout = new SimpleLayout();
//this is a client created layout implemented in the current project
ILayout xmLayout = new XmLlayout();
IAppender consoleAppender = new ConsoleAppender(simpleLayout);
consoleAppender.ReportLevel = EntryLevel.Critical;
IFileAppender fileAppender = new FileAppender(xmLayout);
fileAppender.ReportLevel = EntryLevel.Info;
fileAppender.File = "..\\..\\log.xml";
ILogger logger = new Logger(consoleAppender, fileAppender);
// NOTE: I have redesigned the logger class so that we can easily
// add additional levels of warnings (Debug for instance) without the need to edit the Logger class
// Also I added a functionality to turn logging 'on' and 'off' without the need to comment or delete
// existing logger.Log lines. Default value is 'on'.
logger.IsLogging = false;
logger.Log(EntryLevel.Info, "This is just an info message.");
logger.Log(EntryLevel.Warning, "This is a warning.");
logger.Log(EntryLevel.Error, "Error parsing JSON.");
logger.Log(EntryLevel.Critical, "Situation is critical!");
logger.Log(EntryLevel.Fatal, "Just Give Up");
logger.IsLogging = true;
logger.Log(EntryLevel.Info, "This is just an info message.");
logger.Log(EntryLevel.Warning, "This is a warning.");
logger.Log(EntryLevel.Error, "Error parsing JSON.");
logger.Log(EntryLevel.Critical, "Situation is critical!");
logger.Log(EntryLevel.Fatal, "Just Give Up");
}
public static void Main()
{
try
{
var simpleLayout = new SimpleLayout();
var xmlLayout = new XmlLayout();
IAppender consoleAppender = new ConsoleAppender(simpleLayout);
IAppender fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "../../log.txt";
IAppender fileAppenderXml = new FileAppender(xmlLayout);
fileAppenderXml.File = "../../log.xml";
ILogger logger = new Logger(consoleAppender, fileAppender, fileAppenderXml);
// add in logs
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
logger.Warn("Warn - missing files.");
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
logger.Info("Everything seems fine");
logger.Warn("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine();
}
// /R -> Reload avalaible Stations
private static void Main(string[] args)
{
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
hierarchy.Root.RemoveAllAppenders(); /*Remove any other appenders*/
FileAppender fileAppender = new FileAppender();
fileAppender.AppendToFile = true;
fileAppender.LockingModel = new FileAppender.MinimalLock();
fileAppender.File = "log.txt";
fileAppender.AppendToFile = false;
PatternLayout pl = new PatternLayout();
pl.ConversionPattern = "%d [%2%t] %-5p [%-10c] %m%n%n";
pl.ActivateOptions();
fileAppender.Layout = pl;
fileAppender.ActivateOptions();
log4net.Config.BasicConfigurator.Configure(fileAppender);
ILog _log = LogManager.GetLogger(typeof(Program));
Facade facade = new Facade();
Settings settings = Settings.GetInstance();
_log.Info("Starting - getting available Stations");
List <Station> availableStations;
if (args.Contains("/R") || !File.Exists(settings.StationListPath) || DateTime.Now - new FileInfo(settings.StationListPath).LastWriteTime > new TimeSpan(settings.StationListUpdateIntervalDays, 0, 0, 0))
{
availableStations = facade.GetStations();
File.WriteAllText(settings.StationListPath, JsonConvert.SerializeObject(availableStations, Formatting.Indented), Encoding.UTF8);
}
else
{
availableStations = JsonConvert.DeserializeObject <List <Station> >(File.ReadAllText(settings.StationListPath, Encoding.UTF8));
}
_log.Info("got available Stations");
if (args.Contains("/addAll"))
{
settings.SenderDefinitions = availableStations.Select(s => s.DisplayName).ToList();
Settings.SaveSettings();
return;
}
List <int> idList = availableStations.Where(a => settings.SenderDefinitions.Contains(a.DisplayName)).Select(a => a.UID).ToList();
if (idList.Count == 0)
{
Console.WriteLine("KEINE SENDER DEFINIERT");
_log.Warn("KEINE SENDER DEFINIERT");
return;
}
TmpOutput tmpOutPut;
if (File.Exists(settings.TmpOutputPath))
{
tmpOutPut = JsonConvert.DeserializeObject <TmpOutput>(File.ReadAllText(settings.TmpOutputPath, Encoding.UTF8));
List <ProgramInfo> toRemove = new List <ProgramInfo>();
tmpOutPut.Programs.ForEach(p => { if (p.End.Date < DateTime.Now.Date)
{
toRemove.Add(p);
}
});
toRemove.ForEach(p => tmpOutPut.Programs.Remove(p));
File.WriteAllText(settings.TmpOutputPath, JsonConvert.SerializeObject(tmpOutPut, Formatting.Indented), Encoding.UTF8);
}
else
{
tmpOutPut = new TmpOutput {
Programs = new List <ProgramInfo>(), Stations = new List <Station>()
}
};
tmpOutPut.Stations = availableStations.Where(a => idList.Contains(a.UID)).ToList();
DateTime mostRecent = DateTime.MinValue;
tmpOutPut.Programs.ForEach(p => mostRecent = mostRecent < p.End ? p.End : mostRecent);
for (int i = 0; i < settings.DaysToLoad; i++)
{
DateTime current = DateTime.Now.Date.AddDays(i);
if (mostRecent.Date > current)
{
continue;
}
_log.Info("Getting ProgramInfos for " + current.ToShortDateString());
var programdatas = facade.GetChannelDatas(idList, current);
foreach (var pd in programdatas)
{
if (tmpOutPut.Programs.FirstOrDefault(w => w.EventId == pd.EventId) == null)
{
tmpOutPut.Programs.Add(pd);
}
}
File.WriteAllText(settings.TmpOutputPath, JsonConvert.SerializeObject(tmpOutPut, Formatting.Indented), Encoding.UTF8);
}
int count = tmpOutPut.Programs.Count(w => string.IsNullOrWhiteSpace(w.Description));
int x = 1;
WriteXml(tmpOutPut, settings, _log);
if (settings.GetDescriptions)
{
_log.Info("Getting Descriptions with " + settings.RequestsPerMinute + " requests per minute");
foreach (var item in tmpOutPut.Programs.Where(w => string.IsNullOrWhiteSpace(w.Description)))
{
try
{
Console.WriteLine("(" + x + "/" + count + ") Getting ProgramInfo for " + item.Name);
_log.Info("(" + x + "/" + count + ") Getting ProgramInfo for " + item.Name);
var details = facade.GetDescription(item.EventId);
item.Description = details.Description ?? "";
item.Category = details.Genre ?? "";
Thread.Sleep(60000 / settings.RequestsPerMinute);
}
catch (Exception e)
{
_log.Error(e);
Thread.Sleep(60000);
}
if (x % 10 == 0)
{
File.WriteAllText(settings.TmpOutputPath, JsonConvert.SerializeObject(tmpOutPut, Formatting.Indented), Encoding.UTF8);
}
x++;
}
File.WriteAllText(settings.TmpOutputPath, JsonConvert.SerializeObject(tmpOutPut, Formatting.Indented), Encoding.UTF8);
_log.Info("Got all data");
Console.WriteLine("DONE Checking");
WriteXml(tmpOutPut, settings, _log);
}
return;
//TODO Add Icon to XMLTV
//TODO MORE LOGGING
//TODO COnfigure Logging
//TODO MAIL ME IF NOT WORKING
//TODO tmpoutput berreinigen
}
// deletePDFs based on ERP name
public Boolean deletePDF(string fileName, string folder, ref string logMessage, ref string errMessage)
{
try
{
// set log file location
XmlConfigurator.Configure();
log4net.Repository.Hierarchy.Hierarchy h =
(log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository();
foreach (IAppender a in h.Root.Appenders)
{
if (a is FileAppender)
{
FileAppender fa = (FileAppender)a;
// Programmatically set this to the desired location here
string logFileLocation = folder + "PDFPrint.log";
// Uncomment the lines below if you want to retain the base file name
// and change the folder name...
//FileInfo fileInfo = new FileInfo(fa.File);
//logFileLocation = string.Format(@"C:\MySpecialFolder\{0}", fileInfo.Name);
fa.File = logFileLocation;
fa.ActivateOptions();
break;
}
}
List <string> filesToDelete = new List <string>();
string baseFileName = System.IO.Path.GetFileNameWithoutExtension(fileName);
// get all the files relating to this ipt or iam
filesToDelete = Directory.GetFiles(folder, baseFileName + "~*.pdf", SearchOption.AllDirectories).ToList();
if (System.IO.File.Exists(folder + baseFileName + ".pdf"))
{
filesToDelete.Add(Directory.GetFiles(folder, baseFileName + ".pdf", SearchOption.AllDirectories)[0]); // should only have one exact match
}
if (filesToDelete.Count > 0)
{
//logMessage += @" " + "\r\n" + @" " + "Count of files: " + filesToDelete.Count() + @" " + "\r\n" + @" ";
log.Info(@" " + "\r\n" + @" " + "Count of files: " + filesToDelete.Count() + @" " + "\r\n" + @" ");
foreach (string f in filesToDelete)
{
//logMessage += "File to delete: " + f + @" " + "\r\n" + @" ";
log.Info("File to delete: " + f + @" " + "\r\n" + @" ");
if (System.IO.File.Exists(f))
{
System.IO.File.Delete(f);
//logMessage += "Deleted File " + f + @" " + "\r\n" + @" ";
log.Info("Deleted File " + f + @" " + "\r\n" + @" ");
}
}
}
else
{
//logMessage += @" " + "\r\n" + @" " + "No File Found to Delete for " + fileName + @" " + "\r\n" + @" ";
log.Info(@" " + "\r\n" + @" " + "No File Found to Delete for " + fileName + @" " + "\r\n" + @" ");
}
return(true);
}
catch (Exception)
{
errMessage += "Cannot Delete File " + fileName + @" " + "\r\n" + @" ";
return(false);
}
}
static void CreateAppenderFromConfig(string appenderName)
{
if (string.IsNullOrEmpty(appenderName))
{
return;
}
string options = ConfigMgr.GetDefaultValue(appenderName, "");
var tokens = new StringArray(options, ',');
string name = appenderName.Substring(9);
if (tokens.Length < 2)
{
Console.WriteLine("Log.CreateAppenderFromConfig: Wrong configuration for appender {0}. Config line: {1}", name, options);
return;
}
AppenderFlags flags = AppenderFlags.None;
AppenderType type = (AppenderType)uint.Parse(tokens[0]);
LogLevel level = (LogLevel)uint.Parse(tokens[1]);
if (level > LogLevel.Fatal)
{
Console.WriteLine("Log.CreateAppenderFromConfig: Wrong Log Level {0} for appender {1}\n", level, name);
return;
}
if (tokens.Length > 2)
{
flags = (AppenderFlags)uint.Parse(tokens[2]);
}
byte id = NextAppenderId();
switch (type)
{
case AppenderType.Console:
{
var appender = new ConsoleAppender(id, name, level, flags);
appenders[id] = appender;
break;
}
case AppenderType.File:
{
string filename;
if (tokens.Length < 4)
{
if (name != "Server")
{
Console.WriteLine("Log.CreateAppenderFromConfig: Missing file name for appender {0}", name);
return;
}
filename = Process.GetCurrentProcess().ProcessName + ".log";
}
else
{
filename = tokens[3];
}
appenders[id] = new FileAppender(id, name, level, filename, m_logsDir, flags);
break;
}
case AppenderType.DB:
{
appenders[id] = new DBAppender(id, name, level);
break;
}
default:
Console.WriteLine("Log.CreateAppenderFromConfig: Unknown type {0} for appender {1}", type, name);
break;
}
}
public void Init()
{
Logs.AddAppender(FileAppender.GetAppender("debug.log"));
Logs.SetMessageLevel <FileAppender>(LogMessageType.MSG_DEBUG);
}
// Handle all the automagical stuff
//
public ServicesServerBase(string prompt, string[] args)
{
// Save raw arguments
//
m_Arguments = args;
// Read command line
//
ArgvConfigSource argvConfig = new ArgvConfigSource(args);
argvConfig.AddSwitch("Startup", "console", "c");
argvConfig.AddSwitch("Startup", "logfile", "l");
argvConfig.AddSwitch("Startup", "inifile", "i");
argvConfig.AddSwitch("Startup", "prompt", "p");
argvConfig.AddSwitch("Startup", "logconfig", "g");
// Automagically create the ini file name
//
string fileName = Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location);
string iniFile = fileName + ".ini";
string logConfig = null;
IConfig startupConfig = argvConfig.Configs["Startup"];
if (startupConfig != null)
{
// Check if a file name was given on the command line
//
iniFile = startupConfig.GetString("inifile", iniFile);
//
// Check if a prompt was given on the command line
prompt = startupConfig.GetString("prompt", prompt);
//
// Check for a Log4Net config file on the command line
logConfig = startupConfig.GetString("logconfig", logConfig);
}
// Find out of the file name is a URI and remote load it
// if it's possible. Load it as a local file otherwise.
//
Uri configUri;
try
{
if (Uri.TryCreate(iniFile, UriKind.Absolute, out configUri) &&
configUri.Scheme == Uri.UriSchemeHttp)
{
XmlReader r = XmlReader.Create(iniFile);
m_Config = new XmlConfigSource(r);
}
else
{
m_Config = new IniConfigSource(iniFile);
}
}
catch (Exception)
{
System.Console.WriteLine("Error reading from config source {0}",
iniFile);
Thread.CurrentThread.Abort();
}
// Merge the configuration from the command line into the
// loaded file
//
m_Config.Merge(argvConfig);
// Refresh the startupConfig post merge
//
if (m_Config.Configs["Startup"] != null)
{
startupConfig = m_Config.Configs["Startup"];
}
prompt = startupConfig.GetString("Prompt", prompt);
// Allow derived classes to load config before the console is
// opened.
//
ReadConfig();
// Create main console
//
string consoleType = "local";
if (startupConfig != null)
{
consoleType = startupConfig.GetString("console", consoleType);
}
if (consoleType == "basic")
{
MainConsole.Instance = new CommandConsole(prompt);
}
else if (consoleType == "rest")
{
MainConsole.Instance = new RemoteConsole(prompt);
((RemoteConsole)MainConsole.Instance).ReadConfig(Config);
}
else
{
MainConsole.Instance = new LocalConsole(prompt);
}
// Configure the appenders for log4net
//
OpenSimAppender consoleAppender = null;
FileAppender fileAppender = null;
if (logConfig != null)
{
FileInfo cfg = new FileInfo(logConfig);
XmlConfigurator.Configure(cfg);
}
else
{
XmlConfigurator.Configure();
}
ILoggerRepository repository = LogManager.GetRepository();
IAppender[] appenders = repository.GetAppenders();
foreach (IAppender appender in appenders)
{
if (appender.Name == "Console")
{
consoleAppender = (OpenSimAppender)appender;
}
if (appender.Name == "LogFileAppender")
{
fileAppender = (FileAppender)appender;
}
}
if (consoleAppender == null)
{
System.Console.WriteLine("No console appender found. Server can't start");
Thread.CurrentThread.Abort();
}
else
{
consoleAppender.Console = MainConsole.Instance;
if (null == consoleAppender.Threshold)
{
consoleAppender.Threshold = Level.All;
}
}
// Set log file
//
if (fileAppender != null)
{
if (startupConfig != null)
{
string cfgFileName = startupConfig.GetString("logfile", null);
if (cfgFileName != null)
{
fileAppender.File = cfgFileName;
fileAppender.ActivateOptions();
}
}
}
if (startupConfig.GetString("PIDFile", String.Empty) != String.Empty)
{
CreatePIDFile(startupConfig.GetString("PIDFile"));
}
// Register the quit command
//
MainConsole.Instance.Commands.AddCommand("base", false, "quit",
"quit",
"Quit the application", HandleQuit);
MainConsole.Instance.Commands.AddCommand("base", false, "shutdown",
"shutdown",
"Quit the application", HandleQuit);
// Register a command to read other commands from a file
MainConsole.Instance.Commands.AddCommand("base", false, "command-script",
"command-script <script>",
"Run a command script from file", HandleScript);
// Allow derived classes to perform initialization that
// needs to be done after the console has opened
//
Initialise();
}
internal void Open(IFileInfo fileInfo)
{
_appendStream = FileAppender.CreateAppendStream(fileInfo);
ShouldEnsurePreamble = true;
}
public void Start()
{
var numberOfAppenders = int.Parse(Console.ReadLine());
var appenders = new IAppender[numberOfAppenders];
string[] inputParams = null;
for (int i = 0; i < numberOfAppenders; i++)
{
inputParams = Console.ReadLine().Split();
ILayout layoutType = null;
IAppender appenderType = null;
if (inputParams[1] == "SimpleLayout")
{
layoutType = new SimpleLayout();
}
else if (inputParams[1] == "XmlLayout")
{
layoutType = new XmlLayout();
}
if (inputParams[0] == "ConsoleAppender")
{
appenderType = new ConsoleAppender(layoutType);
}
else if (inputParams[0] == "FileAppender")
{
appenderType = new FileAppender(layoutType);
}
if (inputParams.Length == 3)
{
var reportLevel = Enum.Parse <ReportLevel>(inputParams[2], true);
appenderType.ReportLevel = reportLevel;
}
appenders[i] = appenderType;
}
while (true)
{
inputParams = Console.ReadLine().Split('|').ToArray();
if (inputParams[0] == "END")
{
break;
}
var reportLevel = Enum.Parse <ReportLevel>(inputParams[0], true);
var time = inputParams[1];
var message = inputParams[2];
foreach (var appender in appenders)
{
if (appender.ReportLevel <= reportLevel)
{
appender.Append(time, reportLevel, message);
}
}
}
foreach (var item in appenders)
{
Console.WriteLine(item.ToString());
}
}
public void Act(int countOfAppenders)
{
IAppender[] appenders = new IAppender[countOfAppenders];
for (int i = 0; i < countOfAppenders; i++)
{
var input = Console.ReadLine().Split();
ILayout layout = null;
switch (input[1])
{
case nameof(SimpleLayout):
layout = new SimpleLayout();
break;
case nameof(XmlLayout):
layout = new XmlLayout();
break;
default:
throw new ArgumentException();
}
IAppender appender = null;
switch (input[0])
{
case nameof(ConsoleAppender):
appender = new ConsoleAppender(layout);
break;
case nameof(FileAppender):
appender = new FileAppender(layout);
((FileAppender)appender).File = new LogFile();
break;
}
if (input.Length == 3)
{
ReportLevel level = (ReportLevel)Enum.Parse(typeof(ReportLevel), input[2]);
appender.ReportLevel = level;
}
appenders[i] = appender;
}
var logger = new Logger(appenders);
string command;
while ((command = Console.ReadLine()) != "END")
{
var input = command.Split('|');
string time = input[1];
string message = input[2];
ReportLevel level = (ReportLevel)Enum.Parse(typeof(ReportLevel), input[0]);
switch (level)
{
case ReportLevel.CRITICAL:
logger.Critical(time, message);
break;
case ReportLevel.ERROR:
logger.Error(time, message);
break;
case ReportLevel.FATAL:
logger.Fatal(time, message);
break;
case ReportLevel.INFO:
logger.Info(time, message);
break;
case ReportLevel.WARNING:
logger.Warn(time, message);
break;
}
}
Console.WriteLine(logger);
}
/// <summary>
/// This method is used to set up the log4net configuration files that will log the application.
/// </summary>
/// <param name="fileName">The name of the informatoin file.</param>
private static void Setup(string fileName)
{
string logFilePath = "../../../Logs/";
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
PatternLayout patternLayoutTC = new PatternLayout();
patternLayoutTC.ConversionPattern = "%date [%level] - %message%newline";
patternLayoutTC.ActivateOptions();
RollingFileAppender testCaseRoller = new RollingFileAppender();
testCaseRoller.AppendToFile = false;
testCaseRoller.File = string.Format("{0}logfile-{1}-{2}.log", logFilePath, fileName, DateTime.Now.ToString("HHmm-MMdd-yyyy"));
testCaseRoller.Layout = patternLayoutTC;
testCaseRoller.DatePattern = "HH-MMdd-yyyy";
testCaseRoller.MaxSizeRollBackups = -1;
testCaseRoller.MaximumFileSize = "1MB";
testCaseRoller.RollingStyle = RollingFileAppender.RollingMode.Composite;
var filterTC = new log4net.Filter.LevelRangeFilter
{
LevelMin = Level.Debug,
LevelMax = Level.Warn
};
testCaseRoller.AddFilter(filterTC);
testCaseRoller.ActivateOptions();
hierarchy.Root.AddAppender(testCaseRoller);
PatternLayout ErrorPatternLayout = new PatternLayout();
ErrorPatternLayout.ConversionPattern = "%date [%level] %logger - message: %message%newline%newline";
ErrorPatternLayout.ActivateOptions();
FileAppender ErrorFiles = new FileAppender();
ErrorFiles.File = string.Format("{0}ErrorLogFile.log", logFilePath);
ErrorFiles.AppendToFile = true;
ErrorFiles.LockingModel = new FileAppender.MinimalLock();
ErrorFiles.Layout = ErrorPatternLayout;
var filter = new log4net.Filter.LevelRangeFilter
{
LevelMin = Level.Error,
LevelMax = Level.Fatal
};
ErrorFiles.AddFilter(filter);
ErrorFiles.ActivateOptions();
hierarchy.Root.AddAppender(ErrorFiles);
MemoryAppender memory = new MemoryAppender();
memory.ActivateOptions();
hierarchy.Root.AddAppender(memory);
hierarchy.Root.Level = Level.All;
hierarchy.Configured = true;
}
private void SetUpConsole(IConfigSource config, IRegistryCore registry)
{
List <ICommandConsole> Plugins = AuroraModuleLoader.PickupModules <ICommandConsole>();
foreach (ICommandConsole plugin in Plugins)
{
plugin.Initialize(config, registry.RequestModuleInterface <ISimulationBase>());
}
List <INotificationService> NotificationPlugins = AuroraModuleLoader.PickupModules <INotificationService>();
foreach (INotificationService plugin in NotificationPlugins)
{
plugin.Init(config, registry);
}
ILoggerRepository repository = LogManager.GetRepository();
IAppender[] appenders = repository.GetAppenders();
foreach (IAppender appender in appenders)
{
if (appender.Name == "Console")
{
m_consoleAppender = (OpenSimAppender)appender;
break;
}
}
if (null != m_consoleAppender)
{
m_consoleAppender.Console = MainConsole.Instance;
// If there is no threshold set then the threshold is effectively everything.
if (null == m_consoleAppender.Threshold)
{
m_consoleAppender.Threshold = Level.All;
}
repository.Threshold = m_consoleAppender.Threshold;
foreach (ILogger log in repository.GetCurrentLoggers())
{
log.Level = m_consoleAppender.Threshold;
}
}
IAppender logFileAppender = null;
foreach (IAppender appender in appenders)
{
if (appender.Name == "LogFileAppender")
{
logFileAppender = appender;
}
}
if (logFileAppender != null)
{
if (logFileAppender is FileAppender)
{
FileAppender appender = (FileAppender)logFileAppender;
IConfig startupConfig = config.Configs["Startup"];
string fileName = startupConfig.GetString("LogFile", String.Empty);
if (fileName != String.Empty)
{
appender.File = fileName;
appender.ActivateOptions();
}
}
}
if (MainConsole.Instance == null)
{
m_log.Info("[Console]: No Console located");
return;
}
MainConsole.Instance.MaxLogLevel = m_consoleAppender.Threshold;
if (m_consoleAppender != null)
{
MainConsole.Instance.Fatal(String.Format("[Console]: Console log level is {0}", m_consoleAppender.Threshold));
}
MainConsole.Instance.Commands.AddCommand("set log level", "set log level [level]", "Set the console logging level", HandleLogLevel);
MainConsole.Instance.Commands.AddCommand("get log level", "get log level", "Returns the current console logging level", HandleGetLogLevel);
}
public static ILogger Create(string logFile, bool outputConsole)
{
var logger = new FileAppender(logFile, outputConsole);
return(new Logger(logger));
}
void Start()
{
this.logger = FileAppender.Create("logfile.txt", true);
}
// Handle all the automagical stuff
public ServicesServerBase(string prompt, string[] args)
{
// Save raw arguments
m_Arguments = args;
// Read command line
ArgvConfigSource argvConfig = new ArgvConfigSource(args);
argvConfig.AddSwitch("Startup", "console", "c");
argvConfig.AddSwitch("Startup", "logfile", "l");
argvConfig.AddSwitch("Startup", "inifile", "i");
// Automagically create the ini file name
string fullName = Assembly.GetEntryAssembly().FullName;
AssemblyName assemblyName = new AssemblyName(fullName);
string iniFile = assemblyName.Name + ".ini";
// Check if a file name was given on the command line
IConfig startupConfig = argvConfig.Configs["Startup"];
if (startupConfig != null)
{
iniFile = startupConfig.GetString("inifile", iniFile);
}
// Find out of the file name is a URI and remote load it
// if it's possible. Load it as a local file otherwise.
Uri configUri;
try
{
if (Uri.TryCreate(iniFile, UriKind.Absolute, out configUri) && configUri.Scheme == Uri.UriSchemeHttp)
{
XmlReader r = XmlReader.Create(iniFile);
m_Config = new XmlConfigSource(r);
}
else
{
m_Config = new IniConfigSource(iniFile);
}
}
catch (Exception)
{
System.Console.WriteLine("Error reading from config source {0}", iniFile);
Thread.CurrentThread.Abort();
}
// Merge the configuration from the command line into the
// loaded file
m_Config.Merge(argvConfig);
// Refresh the startupConfig post merge
startupConfig = argvConfig.Configs["Startup"];
// Allow derived classes to load config before the console is
// opened.
ReadConfig();
// Create main console
string consoleType = "local";
if (startupConfig != null)
{
consoleType = startupConfig.GetString("console", consoleType);
}
if (consoleType == "basic")
{
MainConsole.Instance = new CommandConsole(prompt);
}
else
{
MainConsole.Instance = new LocalConsole(prompt);
}
// Configure the appenders for log4net
OpenSimAppender consoleAppender = null;
FileAppender fileAppender = null;
XmlConfigurator.Configure();
ILoggerRepository repository = LogManager.GetRepository();
IAppender[] appenders = repository.GetAppenders();
foreach (IAppender appender in appenders)
{
if (appender.Name == "Console")
{
consoleAppender = (OpenSimAppender)appender;
}
if (appender.Name == "LogFileAppender")
{
fileAppender = (FileAppender)appender;
}
}
if (consoleAppender == null)
{
System.Console.WriteLine("No console appender found. Server can't start");
Thread.CurrentThread.Abort();
}
else
{
consoleAppender.Console = MainConsole.Instance;
if (null == consoleAppender.Threshold)
{
consoleAppender.Threshold = Level.All;
}
}
// Set log file
if (fileAppender != null)
{
if (startupConfig != null)
{
fileAppender.File = startupConfig.GetString("logfile", assemblyName.Name + ".log");
}
}
// Register the quit command
MainConsole.Instance.Commands.AddCommand("base", false, "quit",
"quit",
"Quit the application", HandleQuit);
// Allow derived classes to perform initialization that
// needs to be done after the console has opened
Initialise();
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
/***
* Implements error logging.
* Configure all appenders.
* Get logging level out of App.config.
*/
Logger logger = Logger.Instance;
// Create file appender for logging
FileAppender filelogger = new FileAppender();
filelogger.Configure();
// Add all logger appenders to static list
Logger.Appenders.Add(filelogger);
// Get logging level out of config file
AppSettingsReader config = new AppSettingsReader(); // Settings.Default.
Logger.Loggerlevel = (int)config.GetValue("LoggerLevel", typeof(int));
// Program startup logging
logger.Log(Logger.Level.Info, "-----------------------------------------------------------");
logger.Log(Logger.Level.Info, "Program is started.");
logger.Log(Logger.Level.Info, "Logging level: " + Logger.Loggerlevel);
/***
* Checks data base existance and creates if needed.
*/
ConfigFileManager cfm = new ConfigFileManager();
bool exists = false;
try
{
// Check if mock database shall be used. Result is stored in var ConfigFileManager.mockDB
cfm.UsingMockDatabase();
// Save info in logfile
if (ConfigFileManager.MockDB == true)
{
logger.Log(Logger.Level.Info, "Using mock database.");
}
else
{
logger.Log(Logger.Level.Info, "Using SQLite database.");
}
exists = cfm.CheckDataBaseExistance();
}
// probably syntax error in config file - see logfile
catch (System.Configuration.ConfigurationErrorsException)
{
Application.Exit();
}
// Open window, which one depends on whether the database has been found or not
if (!exists)
{
Application.Run(new DBNotFoundForm());
}
else // database found. Start with home screen.
{
Application.Run(new HomeForm());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FileAppenderFApi"/> class.
/// </summary>
/// <param name="fileFI">FileAppender</param>
public FileAppenderFApi(FileAppender fileFI)
{
this.file = fileFI;
}
static async Task Main(string[] args)
{
IWorker worker = null;
try
{
new ArgsManager <ArgsHandler>().Start(args);
var appender = new FileAppender
{
Layout = new SimpleLayout(),
File = Assembly.GetExecutingAssembly().Location + ".log",
Encoding = Encoding.UTF8,
AppendToFile = true,
LockingModel = new FileAppender.MinimalLock()
};
appender.ActivateOptions();
var logRepo = LogManager.GetRepository(Assembly.GetEntryAssembly());
BasicConfigurator.Configure(logRepo, appender);
var primaryDirectory = Args.Value(ArgsHandler.PrimaryDirectory);
var name = Args.Value(ArgsHandler.Name);
var ip = Args.Value(ArgsHandler.IpAddress);
var port = Args.Value(ArgsHandler.Port).To <int>();
if (string.IsNullOrWhiteSpace(name))
{
name = $"{ip}:{port}";
}
var repoType = Args.Value(ArgsHandler.Repo);
IDirectoryPreparerAsync directoryPreparer = null;
IRepo repo = null;
if (repoType == "Local")
{
directoryPreparer = new LocalDirectoryPreparerAsync();
repo = new LocalRepo();
}
if (repoType == "S3")
{
var region = RegionEndpoint.GetBySystemName(ConfigurationManager.AppSettings["AWSRegion"]);
var client = new AmazonS3Client(Args.Value("AccessKey"), Args.Value("SecretKey"), region);
var bucket = Args.Value(ArgsHandler.Bucket);
repo = new S3Repo(client, bucket);
directoryPreparer = new S3DirectoryPreparerAsync(client, bucket);
}
var isPrepared = await directoryPreparer.PrepareAync(primaryDirectory, Folders.SubDirs);
if (!isPrepared)
{
throw new Exception(Messages.FolderStructureNotPrepared);
}
worker = new Worker(name, ip, port, new ReplyServer(), primaryDirectory,
directoryPreparer,
new ElectionRequester(new RequestClient()),
repo.Reader,
repo.Writer,
repo.UnitOfWorkReader,
repo.UnitOfWorkWriter);
await worker.StartAsync();
var task = (worker as Worker)?.ListenerTask;
if (task != null)
{
await Task.WhenAll(task);
}
}
catch (Exception e)
{
(worker as Worker)._Logger.Debug(e.ToString());
}
}
/// <summary>
/// Loads native dependencies.
/// </summary>
private static void Initialize()
{
if (_isInitialized)
{
return;
}
#region Prepare logger
var hierarchy = (Hierarchy)LogManager.GetRepository();
var logFile = new FileAppender
{
AppendToFile = true,
File = string.Format("XInput1_3_{0}.log.xml", Environment.UserName),
Layout = new XmlLayoutSchemaLog4j(true)
};
logFile.ActivateOptions();
hierarchy.Root.AddAppender(logFile);
hierarchy.Root.Level = Level.Debug;
hierarchy.Configured = true;
#endregion
Log.InfoFormat("Library loaded by process {0} [{1}]",
Process.GetCurrentProcess().ProcessName,
Process.GetCurrentProcess().MainWindowTitle);
Log.Info("Initializing library");
var iniOpts = new IniOptions
{
CommentStarter = IniCommentStarter.Semicolon
};
var ini = new IniFile(iniOpts);
var fullPath = Path.Combine(WorkingDirectory, CfgFile);
Log.DebugFormat("INI-File path: {0}", fullPath);
if (!File.Exists(fullPath))
{
Log.FatalFormat("Configuration file {0} not found", fullPath);
return;
}
try
{
// parse data from INI
ini.Load(fullPath);
var basePath = ini.Sections["ScpControl"].Keys["BinPath"].Value;
Log.DebugFormat("ScpToolkit bin path: {0}", basePath);
var binName = ini.Sections["ScpControl"].Keys["BinName"].Value;
Log.DebugFormat("ScpControl bin path: {0}", binName);
// load all assembly dependencies
AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
{
var asmName = new AssemblyName(args.Name).Name;
Log.DebugFormat("Loading assembly: {0}", asmName);
return(Assembly.LoadFrom(Path.Combine(basePath, string.Format("{0}.dll", asmName))));
};
var scpControl = Assembly.LoadFrom(Path.Combine(basePath, binName));
var scpProxyType = scpControl.GetType("ScpControl.ScpProxy");
_scpProxy = Activator.CreateInstance(scpProxyType);
_scpProxy.Start();
}
catch (Exception ex)
{
Log.FatalFormat("Error during library initialization: {0}", ex);
return;
}
// if no custom path specified by user, use DLL in system32 dir
var xinput13Path = ini.Sections["xinput1_3"].Keys.Contains("OriginalFilePath")
? ini.Sections["xinput1_3"].Keys["OriginalFilePath"].Value
: Path.Combine(Environment.SystemDirectory, "xinput1_3.dll");
Log.DebugFormat("Original XInput 1.3 DLL path: {0}", xinput13Path);
_dll = Kernel32Natives.LoadLibrary(xinput13Path);
if (_dll != IntPtr.Zero)
{
_isInitialized = true;
}
Log.Info("Library initialized");
}
public static void Run(string[] argsArray, IServiceConfig?config = null)
{
bool inConsoleMode = argsArray.Length > 0;
config ??= LoadConfigAndInitLoggers(inConsoleMode);
if (!inConsoleMode)
{
Log.Debug("Starting WinSW in service mode");
using var service = new WrapperService(config);
try
{
ServiceBase.Run(service);
}
catch
{
// handled in OnStart
}
return;
}
Log.Debug("Starting WinSW in console mode");
if (argsArray.Length == 0)
{
PrintHelp();
return;
}
var args = new List <string>(Array.AsReadOnly(argsArray));
if (args[0] == "/redirect")
{
var f = new FileStream(args[1], FileMode.Create);
var w = new StreamWriter(f)
{
AutoFlush = true
};
Console.SetOut(w);
Console.SetError(w);
var handle = f.SafeFileHandle;
_ = Kernel32.SetStdHandle(-11, handle); // set stdout
_ = Kernel32.SetStdHandle(-12, handle); // set stder
args = args.GetRange(2, args.Count - 2);
}
bool elevated;
if (args[0] == "/elevated")
{
elevated = true;
_ = ConsoleApis.FreeConsole();
_ = ConsoleApis.AttachConsole(ConsoleApis.ATTACH_PARENT_PROCESS);
#if VNEXT
string stdinName = args[1];
if (stdinName != NoPipe)
{
var stdin = new NamedPipeClientStream(".", stdinName, PipeDirection.In, PipeOptions.Asynchronous);
stdin.Connect();
Console.SetIn(new StreamReader(stdin));
}
string stdoutName = args[2];
if (stdoutName != NoPipe)
{
var stdout = new NamedPipeClientStream(".", stdoutName, PipeDirection.Out, PipeOptions.Asynchronous);
stdout.Connect();
Console.SetOut(new StreamWriter(stdout)
{
AutoFlush = true
});
}
string stderrName = args[3];
if (stderrName != NoPipe)
{
var stderr = new NamedPipeClientStream(".", stderrName, PipeDirection.Out, PipeOptions.Asynchronous);
stderr.Connect();
Console.SetError(new StreamWriter(stderr)
{
AutoFlush = true
});
}
args = args.GetRange(4, args.Count - 4);
#else
args = args.GetRange(1, args.Count - 1);
#endif
}
else if (Environment.OSVersion.Version.Major == 5)
{
// Windows XP
elevated = true;
}
else
{
elevated = IsProcessElevated();
}
switch (args[0].ToLower())
{
case "install":
Install();
return;
case "uninstall":
Uninstall();
return;
case "start":
Start();
return;
case "stop":
Stop(true);
return;
case "stopwait":
Stop(false);
return;
case "restart":
Restart();
return;
case "restart!":
RestartSelf();
return;
case "status":
Status();
return;
case "test":
Test();
return;
case "testwait":
TestWait();
return;
case "help":
case "--help":
case "-h":
case "-?":
case "/?":
PrintHelp();
return;
case "version":
PrintVersion();
return;
default:
Console.WriteLine("Unknown command: " + args[0]);
PrintAvailableCommands();
throw new Exception("Unknown command: " + args[0]);
}
void Install()
{
if (!elevated)
{
Elevate();
return;
}
Log.Info($"Installing service '{Format(config)}'...");
using var scm = ServiceManager.Open(ServiceManagerAccess.CreateService);
if (scm.ServiceExists(config.Name))
{
Log.Error($"A service with ID '{config.Name}' already exists.");
Throw.Command.Win32Exception(Errors.ERROR_SERVICE_EXISTS, "Failed to install the service.");
}
string?username = null;
string?password = null;
bool allowServiceLogonRight = false;
if (args.Count > 1 && args[1] == "/p")
{
Credentials.PromptForCredentialsConsole(ref username, ref password);
Console.Write("Set Account rights to allow log on as a service (y/n)?: ");
var keypressed = Console.ReadKey();
Console.WriteLine();
if (keypressed.Key == ConsoleKey.Y)
{
allowServiceLogonRight = true;
}
}
else
{
if (config.ServiceAccount.HasServiceAccount())
{
username = config.ServiceAccount.FullUser;
password = config.ServiceAccount.Password;
allowServiceLogonRight = config.ServiceAccount.AllowServiceLogonRight;
}
}
if (allowServiceLogonRight)
{
Security.AddServiceLogonRight(config.ServiceAccount.Domain !, config.ServiceAccount.User !);
}
using var sc = scm.CreateService(
config.Name,
config.DisplayName,
config.Interactive,
config.StartMode,
$"\"{config.ExecutablePath}\"",
config.ServiceDependencies,
username,
password);
string description = config.Description;
if (description.Length != 0)
{
sc.SetDescription(description);
}
var actions = config.FailureActions;
if (actions.Length > 0)
{
sc.SetFailureActions(config.ResetFailureAfter, actions);
}
bool isDelayedAutoStart = config.StartMode == ServiceStartMode.Automatic && config.DelayedAutoStart;
if (isDelayedAutoStart)
{
sc.SetDelayedAutoStart(true);
}
string?securityDescriptor = config.SecurityDescriptor;
if (securityDescriptor != null)
{
// throws ArgumentException
sc.SetSecurityDescriptor(new RawSecurityDescriptor(securityDescriptor));
}
string eventLogSource = config.Name;
if (!EventLog.SourceExists(eventLogSource))
{
EventLog.CreateEventSource(eventLogSource, "Application");
}
Log.Info($"Service '{Format(config)}' was installed successfully.");
}
void Uninstall()
{
if (!elevated)
{
Elevate();
return;
}
Log.Info($"Uninstalling service '{Format(config)}'...");
using var scm = ServiceManager.Open(ServiceManagerAccess.Connect);
try
{
using var sc = scm.OpenService(config.Name);
if (sc.Status != ServiceControllerStatus.Stopped)
{
// We could fail the opeartion here, but it would be an incompatible change.
// So it is just a warning
Log.Warn($"Service '{Format(config)}' is started. It may be impossible to uninstall it.");
}
sc.Delete();
Log.Info($"Service '{Format(config)}' was uninstalled successfully.");
}
catch (CommandException e) when(e.InnerException is Win32Exception inner)
{
switch (inner.NativeErrorCode)
{
case Errors.ERROR_SERVICE_DOES_NOT_EXIST:
Log.Warn($"Service '{Format(config)}' does not exist.");
break; // there's no such service, so consider it already uninstalled
case Errors.ERROR_SERVICE_MARKED_FOR_DELETE:
Log.Error(e.Message);
// TODO: change the default behavior to Error?
break; // it's already uninstalled, so consider it a success
default:
Throw.Command.Exception("Failed to uninstall the service.", inner);
break;
}
}
}
void Start()
{
if (!elevated)
{
Elevate();
return;
}
using var svc = new ServiceController(config.Name);
try
{
Log.Info($"Starting service '{Format(svc)}'...");
svc.Start();
Log.Info($"Service '{Format(svc)}' started successfully.");
}
catch (InvalidOperationException e)
when(e.InnerException is Win32Exception inner && inner.NativeErrorCode == Errors.ERROR_SERVICE_DOES_NOT_EXIST)
{
Throw.Command.Exception(inner);
}
catch (InvalidOperationException e)
when(e.InnerException is Win32Exception inner && inner.NativeErrorCode == Errors.ERROR_SERVICE_ALREADY_RUNNING)
{
Log.Info($"Service '{Format(svc)}' has already started.");
}
}
void Stop(bool noWait)
{
if (!elevated)
{
Elevate();
return;
}
using var svc = new ServiceController(config.Name);
try
{
Log.Info($"Stopping service '{Format(svc)}'...");
svc.Stop();
if (!noWait)
{
try
{
WaitForStatus(svc, ServiceControllerStatus.Stopped, ServiceControllerStatus.StopPending);
}
catch (TimeoutException)
{
Throw.Command.Exception("Failed to stop the service.");
}
}
Log.Info($"Service '{Format(svc)}' stopped successfully.");
}
catch (InvalidOperationException e)
when(e.InnerException is Win32Exception inner && inner.NativeErrorCode == Errors.ERROR_SERVICE_DOES_NOT_EXIST)
{
Throw.Command.Exception(inner);
}
catch (InvalidOperationException e)
when(e.InnerException is Win32Exception inner && inner.NativeErrorCode == Errors.ERROR_SERVICE_NOT_ACTIVE)
{
Log.Info($"Service '{Format(svc)}' has already stopped.");
}
}
void Restart()
{
if (!elevated)
{
Elevate();
return;
}
using var svc = new ServiceController(config.Name);
List <ServiceController>?startedDependentServices = null;
try
{
if (HasAnyStartedDependentService(svc))
{
startedDependentServices = new();
foreach (var service in svc.DependentServices)
{
if (service.Status != ServiceControllerStatus.Stopped)
{
startedDependentServices.Add(service);
}
}
}
Log.Info($"Stopping service '{Format(svc)}'...");
svc.Stop();
try
{
WaitForStatus(svc, ServiceControllerStatus.Stopped, ServiceControllerStatus.StopPending);
}
catch (TimeoutException)
{
Throw.Command.Exception("Failed to stop the service.");
}
}
catch (InvalidOperationException e)
when(e.InnerException is Win32Exception inner && inner.NativeErrorCode == Errors.ERROR_SERVICE_DOES_NOT_EXIST)
{
Throw.Command.Exception(inner);
}
catch (InvalidOperationException e)
when(e.InnerException is Win32Exception inner && inner.NativeErrorCode == Errors.ERROR_SERVICE_NOT_ACTIVE)
{
}
Log.Info($"Starting service '{Format(svc)}'...");
svc.Start();
try
{
WaitForStatus(svc, ServiceControllerStatus.Running, ServiceControllerStatus.StartPending);
}
catch (TimeoutException)
{
Throw.Command.Exception("Failed to start the service.");
}
if (startedDependentServices != null)
{
foreach (var service in startedDependentServices)
{
if (service.Status == ServiceControllerStatus.Stopped)
{
Log.Info($"Starting service '{Format(service)}'...");
service.Start();
}
}
}
Log.Info($"Service '{Format(svc)}' restarted successfully.");
}
void RestartSelf()
{
if (!elevated)
{
Throw.Command.Win32Exception(Errors.ERROR_ACCESS_DENIED);
}
Log.Info("Restarting the service with id '" + config.Name + "'");
// run restart from another process group. see README.md for why this is useful.
if (!ProcessApis.CreateProcess(
null,
config.ExecutablePath + " restart",
IntPtr.Zero,
IntPtr.Zero,
false,
ProcessApis.CREATE_NEW_PROCESS_GROUP,
IntPtr.Zero,
null,
default,
out var processInfo))
{
Throw.Command.Win32Exception("Failed to invoke restart.");
}
_ = HandleApis.CloseHandle(processInfo.ProcessHandle);
_ = HandleApis.CloseHandle(processInfo.ThreadHandle);
}
void Status()
{
using var svc = new ServiceController(config.Name);
try
{
Console.WriteLine(svc.Status != ServiceControllerStatus.Stopped ? "Started" : "Stopped");
}
catch (InvalidOperationException e)
when(e.InnerException is Win32Exception inner && inner.NativeErrorCode == Errors.ERROR_SERVICE_DOES_NOT_EXIST)
{
Console.WriteLine("NonExistent");
}
}
void Test()
{
if (!elevated)
{
Elevate();
return;
}
var wsvc = new WrapperService(config);
wsvc.RaiseOnStart(args.ToArray());
Thread.Sleep(1000);
wsvc.RaiseOnStop();
}
void TestWait()
{
if (!elevated)
{
Elevate();
return;
}
var wsvc = new WrapperService(config);
wsvc.RaiseOnStart(args.ToArray());
Console.WriteLine("Press any key to stop the service...");
_ = Console.Read();
wsvc.RaiseOnStop();
}
// [DoesNotReturn]
void Elevate()
{
#if VNEXT
string?stdinName = Console.IsInputRedirected ? Guid.NewGuid().ToString() : null;
string?stdoutName = Console.IsOutputRedirected ? Guid.NewGuid().ToString() : null;
string?stderrName = Console.IsErrorRedirected ? Guid.NewGuid().ToString() : null;
#endif
string exe = Environment.GetCommandLineArgs()[0];
string commandLine = Environment.CommandLine;
string arguments = "/elevated" +
#if VNEXT
" " + (stdinName ?? NoPipe) +
" " + (stdoutName ?? NoPipe) +
" " + (stderrName ?? NoPipe) +
#endif
commandLine.Remove(commandLine.IndexOf(exe), exe.Length).TrimStart('"');
var startInfo = new ProcessStartInfo
{
UseShellExecute = true,
Verb = "runas",
FileName = ExecutablePath,
Arguments = arguments,
WindowStyle = ProcessWindowStyle.Hidden,
};
try
{
using var elevated = Process.Start(startInfo) !;
#if VNEXT
if (stdinName != null)
{
var stdin = new NamedPipeServerStream(stdinName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
stdin.WaitForConnectionAsync().ContinueWith(_ => Console.OpenStandardInput().CopyToAsync(stdin));
}
if (stdoutName != null)
{
var stdout = new NamedPipeServerStream(stdoutName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
stdout.WaitForConnectionAsync().ContinueWith(_ => stdout.CopyToAsync(Console.OpenStandardOutput()));
}
if (stderrName != null)
{
var stderr = new NamedPipeServerStream(stderrName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
stderr.WaitForConnectionAsync().ContinueWith(_ => stderr.CopyToAsync(Console.OpenStandardError()));
}
#endif
elevated.WaitForExit();
Environment.Exit(elevated.ExitCode);
}
catch (Win32Exception e) when(e.NativeErrorCode == Errors.ERROR_CANCELLED)
{
Log.Fatal(e.Message);
Environment.Exit(e.ErrorCode);
}
}
}
private static IServiceConfig LoadConfigAndInitLoggers(bool inConsoleMode)
{
// TODO: Make logging levels configurable
var fileLogLevel = Level.Debug;
// TODO: Debug should not be printed to console by default. Otherwise commands like 'status' will be pollutted
// This is a workaround till there is a better command line parsing, which will allow determining
var consoleLogLevel = Level.Info;
var eventLogLevel = Level.Warn;
var layout = new PatternLayout {
ConversionPattern = "%d %-5p - %m%n"
};
layout.ActivateOptions();
var repository = LogManager.GetRepository(Assembly.GetExecutingAssembly());
if (inConsoleMode)
{
var consoleAppender = new ConsoleAppender
{
Name = "Wrapper console log",
Threshold = consoleLogLevel,
Layout = layout,
};
consoleAppender.ActivateOptions();
BasicConfigurator.Configure(repository, consoleAppender);
}
else
{
var eventLogAppender = new ServiceEventLogAppender(WrapperService.eventLogProvider)
{
Name = "Wrapper event log",
Threshold = eventLogLevel,
};
eventLogAppender.ActivateOptions();
BasicConfigurator.Configure(repository, eventLogAppender);
}
string executablePath = ExecutablePath;
string directory = Path.GetDirectoryName(executablePath) !;
string baseName = Path.GetFileNameWithoutExtension(executablePath);
IServiceConfig config =
File.Exists(Path.Combine(directory, baseName + ".xml")) ? new XmlServiceConfig(baseName, directory) :
File.Exists(Path.Combine(directory, baseName + ".yml")) ? new YamlServiceConfig(baseName, directory) :
throw new FileNotFoundException($"Unable to locate {baseName}.[xml|yml] file within executable directory");
// .wrapper.log
string wrapperLogPath = Path.Combine(config.LogDirectory, config.BaseName + ".wrapper.log");
var fileAppender = new FileAppender
{
AppendToFile = true,
File = wrapperLogPath,
ImmediateFlush = true,
Name = "Wrapper file log",
Threshold = fileLogLevel,
LockingModel = new FileAppender.MinimalLock(),
Layout = layout,
};
fileAppender.ActivateOptions();
BasicConfigurator.Configure(repository, fileAppender);
return(config);
}
internal static unsafe bool IsProcessElevated()
static void Main(string[] args)
{
var soundtracksListPath = @".\soundtracks.list";
if (args.Length > 0)
{
soundtracksListPath = args[0];
}
// Set up a logger
var logFile = new FileAppender();
logFile.Threshold = Level.Error;
logFile.Layout = new PatternLayout(@"%-6timestamp [%thread] %-5level %30.30logger %ndc: %message%newline");
logFile.File = Path.Combine(Path.GetTempPath(), @"parser.log");
logFile.AppendToFile = false;
logFile.ImmediateFlush = true;
logFile.ActivateOptions();
BasicConfigurator.Configure(logFile);
Console.WriteLine("Opening file for read...");
Stream soundtracksStream = File.OpenRead(soundtracksListPath);
var reader = new StreamReader(soundtracksStream);
Console.WriteLine("...done");
Console.WriteLine("Counting productions in the file...");
string line = reader.ReadLine();
IList <string> rawProductions = new List <string>();
IList <string> rawSongs = new List <string>();
while (line != null)
{
if (line.StartsWith("#"))
{
rawProductions.Add(line);
}
if (line.StartsWith("-"))
{
line = line.Replace(" (uncredited)", string.Empty).TrimStart('-').Trim();
rawSongs.Add(line);
}
line = reader.ReadLine();
}
Console.WriteLine("...done");
Console.WriteLine("Counted {0} productions and {1} songs.", rawProductions.Count, rawSongs.Count);
soundtracksStream.Seek(0, SeekOrigin.Begin);
Console.WriteLine("Parsing productions in the file...");
var parser = new SoundtrackFileParser(LogManager.GetLogger(typeof(SoundtrackFileParser)));
IEnumerable <SoundtrackRecord> records = parser.Parse(soundtracksStream);
Console.WriteLine("...done");
var parsedSongsCount = (from r in records
select r.Songs.Count).Sum();
Console.WriteLine("Parsed {0} productions of {1} total and {2} songs of {3} total.",
records.Count(), rawProductions.Count, parsedSongsCount, rawSongs.Count);
Console.ReadLine();
}
static string \u206F([In] FileAppender obj0)
{
return(obj0.get_File());
}
public Logger(IAppender appender, FileAppender fileAppender) :
this(appender)
{
this.fileAppender = fileAppender;
}
static void Main(string[] args)
{
List <IAppender> testAppender = new List <IAppender>();
ILayout layout = null;
ILogFile logFile = new LogFile();
var repeat = int.Parse(Console.ReadLine());
for (int i = 0; i < repeat; i++)
{
IAppender appender = null;
var inputCommand = Console.ReadLine().Split(' ');
if (inputCommand[1] == "SimpleLayout")
{
layout = new SimpleLayout();
}
if (inputCommand[1] == "XmlLayout")
{
layout = new XmlLayout();
}
if (inputCommand[0] == "ConsoleAppender")
{
appender = new ConsoleAppender(layout);
}
else if (inputCommand[0] == "FileAppender")
{
appender = new FileAppender(layout, logFile);
}
if (inputCommand.Length == 3)
{
foreach (ReportLevel current in Enum.GetValues(typeof(ReportLevel)))
{
if (current.ToString().ToLower() == inputCommand[2].ToLower())
{
appender.ReportLevel = current;
}
}
}
testAppender.Add(appender);
}
ILogger logger = new Logger(testAppender.ToArray());
while (true)
{
var inputCommand = Console.ReadLine().Split('|');
if (inputCommand[0] == "END")
{
break;
}
switch (inputCommand[0])
{
case "INFO":
logger.Info(inputCommand[1], inputCommand[2]);
break;
case "WARNING":
logger.Warning(inputCommand[1], inputCommand[2]);
break;
case "ERROR":
logger.Error(inputCommand[1], inputCommand[2]);
break;
case "CRITICAL":
logger.Critical(inputCommand[1], inputCommand[2]);
break;
case "FATAL":
logger.Fatal(inputCommand[1], inputCommand[2]);
break;
default:
break;
}
}
}
internal static void ReconfigureLogger()
{
string logFile = Path.Combine(AppSettings.AppSettingsPath, "ErrorLog.xml");
if (Log.Logger.Repository.Configured)
{
Log.Logger.Repository.Shutdown();
Log.Logger.Repository.ResetConfiguration();
}
if (_clearLog)
{
try
{
File.Delete(logFile);
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
}
_clearLog = false;
}
PatternLayout layout = new PatternLayout();
LevelRangeFilter filter = new LevelRangeFilter();
if (AppSettings.UseDebug)
{
layout.ConversionPattern = "%date{HH:mm:ss} [%thread] %-5level %logger.%method(%line) - %message%newline";
filter.LevelMin = Level.All;
}
else
{
layout.ConversionPattern = "%date{HH:mm:ss} %-5level %logger - %message%newline";
filter.LevelMin = Level.Warn;
}
filter.AcceptOnMatch = true;
layout.ActivateOptions();
XmlLayoutSchemaLog4j xmlLayout = new XmlLayoutSchemaLog4j(true);
RollingFileAppender fileAppender = new RollingFileAppender
{
PreserveLogFileNameExtension = true,
StaticLogFileName = false,
DatePattern = "yyyyMMdd",
RollingStyle = RollingFileAppender.RollingMode.Date,
ImmediateFlush = true,
File = logFile,
Encoding = new UTF8Encoding(true),
Layout = xmlLayout
};
fileAppender.AddFilter(filter);
fileAppender.ActivateOptions();
FileAppender file = new FileAppender
{
Layout = layout,
AppendToFile = true,
Encoding = new UTF8Encoding(),
File = logFile,
ImmediateFlush = true
};
file.AddFilter(filter);
file.ActivateOptions();
BasicConfigurator.Configure(fileAppender);
if (AppSettings.UseDebug)
{
Log.Info("Debug information enabled");
}
}
private static void InitLoggers(ServiceDescriptor d, bool enableCLILogging)
{
// TODO: Make logging levels configurable
Level logLevel = Level.Debug;
// TODO: Debug should not be printed to console by default. Otherwise commands like 'status' will be pollutted
// This is a workaround till there is a better command line parsing, which will allow determining
Level consoleLogLevel = Level.Info;
Level eventLogLevel = Level.Warn;
// Legacy format from winsw-1.x: (DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " - " + message);
PatternLayout pl = new PatternLayout {
ConversionPattern = "%d %-5p - %m%n"
};
pl.ActivateOptions();
List <IAppender> appenders = new List <IAppender>();
// wrapper.log
string wrapperLogPath = Path.Combine(d.LogDirectory, d.BaseName + ".wrapper.log");
var wrapperLog = new FileAppender
{
AppendToFile = true,
File = wrapperLogPath,
ImmediateFlush = true,
Name = "Wrapper file log",
Threshold = logLevel,
LockingModel = new FileAppender.MinimalLock(),
Layout = pl
};
wrapperLog.ActivateOptions();
appenders.Add(wrapperLog);
// Also display logs in CLI if required
if (enableCLILogging)
{
var consoleAppender = new ConsoleAppender
{
Name = "Wrapper console log",
Threshold = consoleLogLevel,
Layout = pl,
};
consoleAppender.ActivateOptions();
appenders.Add(consoleAppender);
}
// System log
var systemEventLogger = new ServiceEventLogAppender
{
Name = "System event log",
Threshold = eventLogLevel,
provider = eventLogProvider
};
systemEventLogger.ActivateOptions();
appenders.Add(systemEventLogger);
BasicConfigurator.Configure(
#if NETCOREAPP
LogManager.GetRepository(Assembly.GetExecutingAssembly()),
#endif
appenders.ToArray());
}
// this is an attempt to get rid of the extra command line step for printing pdfs.
// it also uses the display names inside the idw for the pdf names rather than getting it from a Vault property.
public Boolean printToPDF(string idw, string outputFolder, string pdfPrinterName, string psToPdfProgName, string ghostScriptWorkingFolder, ref string errMessage, ref string logMessage)
{
{
try
{
// set log file location
XmlConfigurator.Configure();
log4net.Repository.Hierarchy.Hierarchy h =
(log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository();
foreach (IAppender a in h.Root.Appenders)
{
if (a is FileAppender)
{
FileAppender fa = (FileAppender)a;
// Programmatically set this to the desired location here
string logFileLocation = outputFolder + "PDFPrint.log";
// Uncomment the lines below if you want to retain the base file name
// and change the folder name...
//FileInfo fileInfo = new FileInfo(fa.File);
//logFileLocation = string.Format(@"C:\MySpecialFolder\{0}", fileInfo.Name);
fa.File = logFileLocation;
fa.ActivateOptions();
break;
}
}
InventorApprentice.ApprenticeServerComponent oApprentice = new ApprenticeServerComponent();
InventorApprentice.ApprenticeServerDrawingDocument drgDoc;
oApprentice.Open(idw);
drgDoc = (InventorApprentice.ApprenticeServerDrawingDocument)oApprentice.Document;
int pageCount = 1;
List <string> assemblyFileNameList = new List <string>();
idwFile idwFileToPrint = new idwFile();
idwFileToPrint.sheetNames = new List <string>();
idwFileToPrint.idwName = idw;
idwFileToPrint.pageCount = drgDoc.Sheets.Count;
foreach (Sheet sh in drgDoc.Sheets)
{
if (sh.DrawingViews.Count > 0)
{
string modelName;
modelName = sh.DrawingViews[1].ReferencedDocumentDescriptor.DisplayName;
// this doesn't work right on files with special characters.
//modelName = Path.GetFileNameWithoutExtension(modelName);
if (modelName.EndsWith(".ipt") || modelName.EndsWith(".iam"))
{
int index = modelName.LastIndexOf('.');
modelName = index == -1 ? modelName: modelName.Substring(0, index);
}
idwFileToPrint.sheetNames.Add(modelName);
pageCount++;
}
}
log.Info("Sheet Names All Read When Printing " + idwFileToPrint.idwName);
string printer = pdfPrinterName;
string pdfConverter = psToPdfProgName;
string workingDir = ghostScriptWorkingFolder;
string psFileName = "";
string pdfFileName = "";
try
{
InventorApprentice.ApprenticeDrawingPrintManager pMgr;
drgDoc = (InventorApprentice.ApprenticeServerDrawingDocument)oApprentice.Document;
pMgr = (InventorApprentice.ApprenticeDrawingPrintManager)drgDoc.PrintManager;
pMgr.Printer = printer;
int actualSheetIndex = 1;
int modifiedSheetIndex = 1;
foreach (Sheet sh in drgDoc.Sheets)
{
string modelName;
//string modelExtension;
if (sh.DrawingViews.Count > 0) // added to make sure sheet has at least one drawing view
{
modelName = sh.DrawingViews[1].ReferencedDocumentDescriptor.DisplayName;
// this doesn't work right on files with special characters.
//modelName = Path.GetFileNameWithoutExtension(modelName);
if (modelName.EndsWith(".ipt") || modelName.EndsWith(".iam"))
{
int index = modelName.LastIndexOf('.');
modelName = index == -1 ? modelName : modelName.Substring(0, index);
}
string newName = "";
switch (sh.Orientation)
{
case PageOrientationTypeEnum.kLandscapePageOrientation:
pMgr.Orientation = PrintOrientationEnum.kLandscapeOrientation;
break;
case PageOrientationTypeEnum.kDefaultPageOrientation:
pMgr.Orientation = PrintOrientationEnum.kDefaultOrientation;
break;
case PageOrientationTypeEnum.kPortraitPageOrientation:
pMgr.Orientation = PrintOrientationEnum.kPortraitOrientation;
break;
}
pMgr.SetSheetRange(actualSheetIndex, actualSheetIndex);
pMgr.PrintRange = PrintRangeEnum.kPrintSheetRange;
pMgr.ScaleMode = InventorApprentice.PrintScaleModeEnum.kPrintBestFitScale;
//if (more than one matching pdf name)
if (idwFileToPrint.sheetNames.Where(x => x.Equals(idwFileToPrint.sheetNames[modifiedSheetIndex - 1])).Count() > 1)
{
newName = outputFolder + idwFileToPrint.sheetNames[modifiedSheetIndex - 1] + ".pdf";
if (System.IO.File.Exists(outputFolder + idwFileToPrint.sheetNames[modifiedSheetIndex - 1] + ".pdf"))
{
assemblyFileNameList.Add(newName);
newName = outputFolder + idwFileToPrint.sheetNames[modifiedSheetIndex - 1] + "~" + 1 + ".pdf";
if (System.IO.File.Exists(newName))
{
System.IO.File.Delete(newName);
}
System.IO.File.Move(outputFolder + idwFileToPrint.sheetNames[modifiedSheetIndex - 1] + ".pdf", newName);
assemblyFileNameList.Add(newName);
}
}
psFileName = outputFolder + idwFileToPrint.sheetNames[modifiedSheetIndex - 1] + ".ps";
pdfFileName = outputFolder + idwFileToPrint.sheetNames[modifiedSheetIndex - 1] + ".pdf";
// for some reason if a ps filename contains a comma it doesn't want to print.
// we'll replace it with a tilde.
if (psFileName.Contains(","))
{
psFileName = psFileName.Replace(',', '~');
log.Warn("One or more characters replaced with '~' in " + pdfFileName);
//logMessage += "One or more characters replaced with '~' in " + pdfFileName + "\r\n";
}
if (psFileName.Contains("°"))
{
psFileName = psFileName.Replace('°', '~');
log.Warn("One or more characters replaced with '°' in " + pdfFileName);
//logMessage += "One or more characters replaced with '°' in " + pdfFileName + "\r\n";
}
pMgr.PrintToFile(psFileName);
if (System.IO.File.Exists(psFileName))
{
log.Info("PS file generated for " + psFileName);
}
else
{
log.Warn("PS file for " + psFileName + "could not be generated.");
continue; // skip trying to create a pdf if we couldn't generate a ps
}
// notice:
// gs doesn't seem to be able to handle the degree symbol
// all filenames with a degree symbol will lose it when run through this script
Process oProc = new Process();
// need the full path to the program if we want to set UseShellExecute to false
ProcessStartInfo startInfo = new ProcessStartInfo(pdfConverter);
startInfo.WorkingDirectory = workingDir;
startInfo.Arguments = @"""" + psFileName + @"""" + " " + @"""" + pdfFileName + @"""";
startInfo.CreateNoWindow = true;
oProc.StartInfo = startInfo;
oProc.StartInfo.UseShellExecute = false;
oProc.Start();
oProc.WaitForExit();
if (assemblyFileNameList != null)
{
if (assemblyFileNameList.Count > 1) // combine multiple assembly drawings into one pdf file
{
// Open the input files
PdfDocument inputDocument1 = new PdfDocument();
PdfDocument inputDocument2 = new PdfDocument();
if (System.IO.File.Exists(assemblyFileNameList[0]))
{
inputDocument1 = PdfReader.Open(assemblyFileNameList[0], PdfDocumentOpenMode.Import);
}
if (System.IO.File.Exists(assemblyFileNameList[1]))
{
inputDocument2 = PdfReader.Open(assemblyFileNameList[1], PdfDocumentOpenMode.Import);
}
// Create the output document
PdfDocument outputDocument = new PdfDocument();
// Show consecutive pages facing. Requires Acrobat 5 or higher.
outputDocument.PageLayout = inputDocument1.PageLayout;
int count = Math.Max(inputDocument1.PageCount, inputDocument2.PageCount);
for (int idx = 0; idx < count; idx++)
{
PdfPage page1 = new PdfPage();
PdfPage page2 = new PdfPage();
if (inputDocument1.PageCount > idx)
{
page1 = inputDocument1.Pages[idx];
page1 = outputDocument.AddPage(page1);
}
if (inputDocument2.PageCount > idx)
{
page2 = inputDocument2.Pages[idx];
page2 = outputDocument.AddPage(page2);
}
}
if (System.IO.File.Exists(assemblyFileNameList[0]))
{
System.IO.File.Delete(assemblyFileNameList[0]);
}
// Save the document...
while (!(System.IO.File.Exists(assemblyFileNameList[0])))
{
string filename = assemblyFileNameList[0];
outputDocument.Save(filename);
}
// delete the temp file and clear the list
if (System.IO.File.Exists(assemblyFileNameList[1]))
{
System.IO.File.Delete(assemblyFileNameList[1]);
}
assemblyFileNameList.Clear();
}
}
System.IO.File.Delete(psFileName);
actualSheetIndex++;
modifiedSheetIndex++;
}
else
{
actualSheetIndex++; // still need to increment sheet index, even if no drawing view was found
// on current sheet...
}
// double check to make sure file got generated and saved properly.
if (!System.IO.File.Exists(pdfFileName))
{
log.Warn("No PDF Generated for " + pdfFileName);
//logMessage += "No PDF Generated for " + pdfFileName + "\r\n";
}
else
{
log.Info("PDF Generated for " + pdfFileName);
}
}
}
catch (Exception ex)
{
//errMessage += "PDF Generation Error in printToPDF\r\n";
//errMessage += ex.Message + "\r\n";
log.Error("PDF Generation Error in printToPDF");
log.Error(ex.Message);
return(false);
}
}
catch (Exception ex)
{
//errMessage += "IDW File Read Error in printToPDF\r\n";
//errMessage += ex.Message + "\r\n";
log.Error("IDW File Read Error in printToPDF");
log.Error(ex.Message);
return(false);
}
return(true);
}
}
public void RegisterCommonAppenders(IConfig startupConfig)
{
ILoggerRepository repository = LogManager.GetRepository();
IAppender[] appenders = repository.GetAppenders();
foreach (IAppender appender in appenders)
{
if (appender.Name == "Console")
{
m_consoleAppender = (OpenSimAppender)appender;
}
else if (appender.Name == "LogFileAppender")
{
m_logFileAppender = (FileAppender)appender;
}
else if (appender.Name == "StatsLogFileAppender")
{
m_statsLogFileAppender = (FileAppender)appender;
}
}
if (null == m_consoleAppender)
{
Notice("No appender named Console found (see the log4net config file for this executable)!");
}
else
{
// FIXME: This should be done through an interface rather than casting.
m_consoleAppender.Console = (ConsoleBase)m_console;
// If there is no threshold set then the threshold is effectively everything.
if (null == m_consoleAppender.Threshold)
{
m_consoleAppender.Threshold = Level.All;
}
Notice(String.Format("Console log level is {0}", m_consoleAppender.Threshold));
}
if (m_logFileAppender != null && startupConfig != null)
{
string cfgFileName = startupConfig.GetString("LogFile", null);
if (cfgFileName != null)
{
m_logFileAppender.File = cfgFileName;
m_logFileAppender.ActivateOptions();
}
m_log.InfoFormat("[SERVER BASE]: Logging started to file {0}", m_logFileAppender.File);
}
if (m_statsLogFileAppender != null && startupConfig != null)
{
string cfgStatsFileName = startupConfig.GetString("StatsLogFile", null);
if (cfgStatsFileName != null)
{
m_statsLogFileAppender.File = cfgStatsFileName;
m_statsLogFileAppender.ActivateOptions();
}
m_log.InfoFormat("[SERVER BASE]: Stats Logging started to file {0}", m_statsLogFileAppender.File);
}
}
protected void ConfigureAppenders(string fileName)
{
//Get the logger repository hierarchy.
if (!(LogManager.GetRepository(Assembly.GetCallingAssembly()) is Hierarchy repository))
{
throw new Exception("log4net repository was not configured");
}
if (!(repository.GetLogger(_loggerName) is Logger logger))
{
throw new Exception($"Logger '{_loggerName}' not found");
}
#region Configure signalRAppender
if (logger.Appenders.OfType <SignalrAppender>().All(a => a.GroupName != _logGroupName))
{
//var hub = GlobalHost.ConnectionManager.GetHubContext<SignalrAppenderHub>();
var hubContext = _iocResolver.Resolve <IHubContext <SignalrAppenderHub> >();
var signalrAppender = new SignalrAppender(hubContext, _logGroupName)
{
Name = _loggerName + "SignalrAppenderAuto",
Threshold = Level.All,
};
var signalrLayout = new PatternLayout()
{
ConversionPattern = "%d - %m%n%n"
};
signalrLayout.ActivateOptions();
signalrAppender.Layout = signalrLayout;
signalrAppender.ActivateOptions();
logger.AddAppender(signalrAppender);
}
#endregion
#region Configure file appender
if (!string.IsNullOrWhiteSpace(fileName))
{
var fileAppender = new FileAppender
{
Name = _loggerName + "FileAppenderAuto",
File = fileName,
AppendToFile = false,
Threshold = Level.All,
LockingModel = new FileAppender.MinimalLock()
};
//new log4net.Util.PatternString("D:\Temp\Logs\%property{LogName}.log")
var fileLayout = new PatternLayout()
{
ConversionPattern = "%d - %m%n%n"
};
fileLayout.ActivateOptions();
fileAppender.Layout = fileLayout;
fileAppender.ActivateOptions();
logger.AddAppender(fileAppender);
}
#endregion
// Mark repository as configured and notify that is has changed.
repository.Configured = true;
repository.RaiseConfigurationChanged(EventArgs.Empty);
_logger = LogManager.GetLogger(Assembly.GetCallingAssembly(), _loggerName);
}
public PlayerActionPredictionProvider(InfoCollection information, Dictionary <InfoProviderType, InfoProviderBase> allInformationProviders, AIRandomControl aiRandomControl)
: base(information, InfoProviderType.PlayerActionPrediction, allInformationProviders, aiRandomControl)
{
requiredInfoTypes = new List <InfoType>()
{
InfoType.CP_AKQToBoardRatio_Real, //Same for all
InfoType.CP_AOnBoard_Bool, //Same for all
InfoType.CP_FlushPossible_Bool, //Same for all
InfoType.CP_KOnBoard_Bool, //Same for all
InfoType.CP_StraightPossible_Bool, //Same for all
InfoType.GP_GameStage_Byte, //Same for all
InfoType.GP_NumActivePlayers_Byte, //Provided
InfoType.GP_NumPlayersDealtIn_Byte, //Same for all
InfoType.GP_NumTableSeats_Byte, //Same for all
InfoType.GP_NumUnactedPlayers_Byte, //Provided
InfoType.BP_BetsToCall_Byte, //Provided
InfoType.BP_LastRoundBetsToCall_Byte, // ********* From CACHE
InfoType.BP_MinimumPlayAmount_Decimal, //Provided
InfoType.BP_PlayerLastAction_Short, // ********* From CACHE
InfoType.BP_PlayerMoneyInPot_Decimal, // ********* From CACHE
InfoType.BP_TotalNumCalls_Byte, //Provided
InfoType.BP_TotalNumRaises_Byte, //Provided
InfoType.BP_TotalPotAmount_Decimal, //Provided
InfoType.BP_LastAdditionalRaiseAmount,
InfoType.GP_DealerDistance_Byte, // ********* From CACHE
InfoType.AP_AvgScaledOppPreFlopPlayFreq_Double //We don't actually need this we just want to make sure the agression provider has been added
};
providedInfoTypes = new List <InfoPiece>()
{
new InfoPiece(InfoType.PAP_RaiseToStealAmount_Amount, 0),
new InfoPiece(InfoType.PAP_RaiseToStealSuccess_Prob, 0),
new InfoPiece(InfoType.PAP_RaiseToCallAmount_Amount, 0),
new InfoPiece(InfoType.PAP_RaiseToBotCall_Prob, 1),
new InfoPiece(InfoType.PAP_FoldToBotCall_Prob, 0),
new InfoPiece(InfoType.PAP_RaiseToBotCheck_Prob, 1),
};
AddProviderInformationTypes();
//Create the player action prediction network manager if it's has not already been created.
if (networkManager == null)
{
networkManager = new playerActionPredictionNetworkManager();
}
#if logging
//If we are logging configure the logger
ILoggerRepository repository = LogManager.GetRepository(Assembly.GetCallingAssembly());
IBasicRepositoryConfigurator configurableRepository = repository as IBasicRepositoryConfigurator;
PatternLayout layout = new PatternLayout();
layout.ConversionPattern = "%level% [%thread%] - %message%newline";
layout.ActivateOptions();
FileAppender appender = new FileAppender();
appender.Layout = layout;
appender.File = "aiDecisions_PAP.csv";
appender.AppendToFile = true;
appender.ActivateOptions();
configurableRepository.Configure(appender);
#endif
}
// Handle all the automagical stuff
//
public ServicesServerBase(string prompt, string[] args) : base()
{
// Save raw arguments
//
m_Arguments = args;
// Read command line
//
ArgvConfigSource argvConfig = new ArgvConfigSource(args);
argvConfig.AddSwitch("Startup", "console", "c");
argvConfig.AddSwitch("Startup", "logfile", "l");
argvConfig.AddSwitch("Startup", "inifile", "i");
argvConfig.AddSwitch("Startup", "prompt", "p");
argvConfig.AddSwitch("Startup", "logconfig", "g");
// Automagically create the ini file name
//
string fileName = Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location);
string iniFile = fileName + ".ini";
string logConfig = null;
IConfig startupConfig = argvConfig.Configs["Startup"];
if (startupConfig != null)
{
// Check if a file name was given on the command line
//
iniFile = startupConfig.GetString("inifile", iniFile);
//
// Check if a prompt was given on the command line
prompt = startupConfig.GetString("prompt", prompt);
//
// Check for a Log4Net config file on the command line
logConfig = startupConfig.GetString("logconfig", logConfig);
}
// Find out of the file name is a URI and remote load it
// if it's possible. Load it as a local file otherwise.
//
Uri configUri;
try
{
if (Uri.TryCreate(iniFile, UriKind.Absolute, out configUri) &&
configUri.Scheme == Uri.UriSchemeHttp)
{
XmlReader r = XmlReader.Create(iniFile);
Config = new XmlConfigSource(r);
}
else
{
Config = new IniConfigSource(iniFile);
}
}
catch (Exception e)
{
System.Console.WriteLine("Error reading from config source. {0}", e.Message);
Environment.Exit(1);
}
// Merge the configuration from the command line into the
// loaded file
//
Config.Merge(argvConfig);
// Refresh the startupConfig post merge
//
if (Config.Configs["Startup"] != null)
{
startupConfig = Config.Configs["Startup"];
}
ConfigDirectory = startupConfig.GetString("ConfigDirectory", ".");
prompt = startupConfig.GetString("Prompt", prompt);
// Allow derived classes to load config before the console is
// opened.
//
ReadConfig();
// Create main console
//
string consoleType = "local";
if (startupConfig != null)
{
consoleType = startupConfig.GetString("console", consoleType);
}
if (consoleType == "basic")
{
MainConsole.Instance = new CommandConsole(prompt);
}
else if (consoleType == "rest")
{
MainConsole.Instance = new RemoteConsole(prompt);
((RemoteConsole)MainConsole.Instance).ReadConfig(Config);
}
else
{
MainConsole.Instance = new LocalConsole(prompt);
}
m_console = MainConsole.Instance;
// Configure the appenders for log4net
//
OpenSimAppender consoleAppender = null;
FileAppender fileAppender = null;
if (logConfig != null)
{
FileInfo cfg = new FileInfo(logConfig);
XmlConfigurator.Configure(cfg);
}
else
{
XmlConfigurator.Configure();
}
RegisterCommonAppenders(startupConfig);
if (startupConfig.GetString("PIDFile", String.Empty) != String.Empty)
{
CreatePIDFile(startupConfig.GetString("PIDFile"));
}
RegisterCommonCommands();
// Register the quit command
//
MainConsole.Instance.Commands.AddCommand("General", false, "quit",
"quit",
"Quit the application", HandleQuit);
MainConsole.Instance.Commands.AddCommand("General", false, "shutdown",
"shutdown",
"Quit the application", HandleQuit);
// Allow derived classes to perform initialization that
// needs to be done after the console has opened
//
Initialise();
}
