/// <summary>
/// Initialize and start new TcpClientHandler
/// </summary>
/// <param name="client">TcpClient to Handle</param>
public MemTcpClient(TcpClient client, ProtocolType protocol)
{
_logManager = new LogManager(client.Client.RemoteEndPoint.ToString());
_logManager.Info("MemTcpClient", "\tNew client connected on protocol :" + protocol.ToString());
_client = client;
_stream = _client.GetStream();
_executionManager = new SequentialExecutionManager(_logManager);
_inputBuffer = new byte[MAX_BUFFER_SIZE];
_inputDataStream = new DataStream();
_protocol = protocol;
if (protocol == ProtocolType.Text)
{
_parser = new TextProtocolParser(_inputDataStream, this, _logManager);
_responseManager = new TextResponseManager(_stream, _logManager);
}
else
{
_parser = new BinaryProtocolParser(_inputDataStream, this, _logManager);
_responseManager = new BinaryResponseManager(_stream, _logManager);
}
_responseManager.MemTcpClient = this;
_parser.CommandConsumer = _executionManager;
_executionManager.CommandConsumer = _responseManager;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="log">ログ</param>
/// <param name="index">3D表示インデックス</param>
public frmGraph3D(LogManager log, int index)
{
InitializeComponent();
this.log = log;
this.index = index;
}
static void Main(string[] args)
{
LogManager lm = new LogManager("TestSearch", @"C:\Users\Thibault\Documents\Logs\", 3);
//LogManager lm2 = new LogManager("log");
// LogManager f = new LogManager("fu");
lm.logEvent("Programme principal", "Erreur 7");
lm.logEvent("Programme secondaire", "Erreur 0");
/*lm.logEvent("Programme principal", "Nlkd,qds");
lm.logEvent("Programme principal", "kdjzalmk");
lm.logEvent("Programme principal", "Rhaaaa");*/
//Test de la recherche
DateTime now = new DateTime(2011,11,27,16,36,45);
DateTime end = now.AddDays(3);
lm.getLogs(now, end);
//lm.getLogs(now, end, "Programme secondaire");
// lm.logEvent("Programme secondaire", "Erreur 7", "Test2");
//ThreadTest tt = new ThreadTest(lm);
/* try
{
StreamReader sr = System.IO.File.OpenText("test");
}
catch (Exception err)
{
lm.logException("Programme principal", err);
}*/
}
public ZLogViewer()
{
InitializeComponent();
this.mLogManager = LogManager.GetInstance();
this.openFileDialog.Multiselect = true;
this.ListViewLog.Dock = DockStyle.Fill;
this.textBoxLog.Dock = DockStyle.Fill;
this.fileToolStripMenuItem.Click += this.GetAllLogPaths;
this.mergeToolStripMenuItem.Click += this.GetAllLogPathsMerge;
this.btnFilter.Click += this.Filter;
this.btnNext.Click += this.SearchNext;
this.btnPrevious.Click += this.SearchPrev;
this.ListViewLog.ColumnClick += this.ColumnFilter;
this.ListViewLog.MultiSelect = false;
this.ListViewLog.SelectedIndexChanged += this.ShowLog;
this.ListViewLog.ItemSelectionChanged += this.listview_itemselectionchanged;
this.ListViewLog.Validated += this.listview_validated;
this.DragDrop += DragAndDropFile;
this.ListViewLog.DragDrop += DragAndDropFile;
this.ListViewLog.DragEnter += listViewFolder_DragEnter;
this.textBoxLog.MouseClick += this.aa;
this.toolStripProgressBar.Dock = DockStyle.Bottom;
this.HelpRequested += this.HelpPopup;
this.checkBoxAutoReresh.CheckedChanged += AutoRefresh;
this.decryptToolStripMenuItem.Click += DecryptText;
LogManager.readCompleteCallBack += Refresh;
LogManager.SetFormControl(this);
this.ListViewLog.HideSelection = true;
//ZLog.AddLogEventHander(this.SetTextAsLog);
}
internal Log(LogManager manager, string name)
{
this._manager = new WeakReference(manager);
this._name = name;
this._level = LogLevel.None;
manager.Add(new Log.Shadow(this));
}
public InterfaceManager(TextBox tBox)
{
PANGU_Manager.killPANGU();
navigationMapManager = new NavigationMapManager();
logManager = new LogManager(tBox);
logManager.clearSimulationLog();
}
/// <summary>
/// Internal constructor. This class cannot be instantiated externally.
/// </summary>
public LogManager()
{
if ( instance == null )
{
instance = this;
}
}
public void DefaultToStandardListenersIfSwitchNameUnknown()
{
var logManager = new LogManager();
var logger = (Logger)logManager.CreateLogger("LogManager.UnknownSource");
Assert.Equal(Trace.Listeners.Count, logger.TraceSource.Listeners.Count);
}
public void OverrideListenersIfSourceConfigured()
{
var logManager = new LogManager();
var logger = (Logger)logManager.CreateLogger("LogManager.Test");
Assert.Equal(0, logger.TraceSource.Listeners.Count);
}
public void OverrideDefaultLevelIfSwitchConfigured()
{
var logManager = new LogManager();
var logger = logManager.CreateLogger("LogManager.Test");
Assert.True(logger.IsDebugEnabled);
}
/// <summary>
/// Initialize a new OpenVPN service.
/// </summary>
/// <param name="binfile">path to openvpn</param>
/// <param name="configfile">path to openvpn config</param>
/// <param name="dir">directory where config lies</param>
/// <param name="logs">provider to write logs to</param>
/// <param name="host">The host to connect to (e.g. 127.0.0.1)</param>
/// <param name="port">The port to connect to</param>
/// <param name="logfile">file to write OpenVPN log to</param>
/// <param name="smartCardSupport">enable SmartCard support</param>
public UserSpaceService(string binfile, string configfile,
string dir, LogManager logs, string host, int port,
string logfile, bool smartCardSupport)
{
m_logs = logs;
m_psi.FileName = binfile;
m_psi.WorkingDirectory = dir;
m_psi.WindowStyle = ProcessWindowStyle.Hidden;
m_psi.UseShellExecute = true;
/*WindowsPrincipal principal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
principal.IsInRole(WindowsBuiltInRole.Administrator)*/
if (Environment.OSVersion.Version.Major >= 6)
m_psi.Verb = "runas";
m_psi.CreateNoWindow = true;
m_psi.Arguments =
(logfile != null ? "--log \"" + logfile + "\"" : "") +
" --config \"" + configfile + "\"" +
" --management " + host + " " + port.ToString(CultureInfo.InvariantCulture) +
" --management-query-passwords" +
" --management-hold" +
" --management-signal" +
" --management-forget-disconnect" +
" --auth-retry interact";
if (smartCardSupport)
m_psi.Arguments += " --pkcs11-id-management";
}
/// <summary>
/// Constructor
/// </summary>
public frmMain()
{
InitializeComponent();
//ボード情報取得イベント
CommunicationMonitor.GetInstance().GotBoardInfoEvent += new EventHandler(CommunicationMonitor_GotBoardInfoEvent);
//メッセージ要求
CommunicationMonitor.GetInstance().ShowMessageRequestEvent += new CommunicationMonitor.ShowMessageRequestHandler(CommunicationMonitor_ShowMessageRequestEvent);
//監視モニタコメント表示要求
CommunicationMonitor.GetInstance().ShowCommunicationCommentEvent += new CommunicationMonitor.ShowCommunicationCommentHandler(CommunicationMonitor_ShowCommunicationCommentEvent);
// ログ設定
var logConfigPath = ConfigurationManager.AppSettings["LogConfigPathUi"];
if (string.IsNullOrEmpty(System.IO.Path.GetDirectoryName(logConfigPath)))
{
// ファイル名だけの場合はRM-3000.exeと同じパスとしてフルパス化する
var assemblyPath = System.Reflection.Assembly.GetExecutingAssembly().CodeBase;
var localPath = (new System.Uri(assemblyPath)).LocalPath;
logConfigPath = System.IO.Path.GetDirectoryName(localPath) + @"\" + logConfigPath;
}
this.log = LogManager.Instance;
this.log.SetupLog(logConfigPath);
AppResource.SetControlsText(this);
ContentsLoad();
}
/// <summary>
/// Initialize log
/// </summary>
/// <param name="_logPath"></param>
public static void Initialize(string _logPath, LogLevel logLevel = LogLevel.Information)
{
singleton = new LogManager();
singleton.LogPath = _logPath;
singleton.currentLogLevel = logLevel;
singleton.Start();
}
protected void Page_Load(object sender, EventArgs e)
{
string UserName =Request["UserName"] ?? string.Empty;
string UserPwd = Request["UserPwd"] ?? string.Empty;
string LogData =Request["LogData"] ?? string.Empty;
try
{
UserManager um = new UserManager();
if (um.CheckUser(UserName, UserPwd))
{
if (!string.IsNullOrEmpty(LogData))
{
List<LogEvent> logList = JsonConvert.DeserializeObject<List<LogEvent>>(LogData);
if (logList != null)
{
LogManager lm = new LogManager();
bool result = lm.AddLog(logList);
}
}
}
}
catch (Exception ex)
{
LogExt.SetError(ex, "");
}
}
public static void log(string information, LogManager.Level level)
{
/// Without this line under, if using Debug.WriteLine in multiple classes the settings will be unable to be read. They will be returned as null and the application will fall to its knees.
/// Looking at AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, it seems that the config path isn't set, trying to set it here too solves the issue. For now...
AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", MainConsole.fullConfig);
string logMessage = null;
switch (level) {
// INFO
case Level.INFO:
logMessage = "[INFO] " + information;
break;
// ERROR
case Level.ERROR:
logMessage = "[ERROR] " + information;
break;
// SETTING
case Level.SETTING:
logMessage = "[SETTING] " + information;
break;
default:
break;
}
Debug.WriteLine(logMessage);
}
public LogManager()
{
instance = this;
logPath = GetLogPath();
logStream = new FileStream(logPath, FileMode.Create, FileAccess.Write, FileShare.Read);
writer = new StreamWriter(logStream);
}
public void TestGetLoggerByType()
{
var manager = new LogManager(new LoggingConfiguration());
var logger = manager.GetLogger<LogManagerBaseTests>();
Assert.NotNull(logger);
}
public void TestGetLogger()
{
var manager = new LogManager(new LoggingConfiguration());
var logger = manager.GetLogger("Foobar");
Assert.NotNull(logger);
}
public static void Main(string[] args)
{
LogManager customLogManager = new LogManager(LogManager.ErrorType.OFF, LogManager.ErrorType.FATAL, "customlogfile.log", true);
// all delegate where execute in thread
LogManager.defaultInstance.objectExceptCatched += objLog;
LogManager.defaultInstance.writeToConsole = LogManager.ErrorType.TRACE;
DemoClass demoClass = new DemoClass(){ jobs = "Demo for PonyLogManager" };
demoClass.sw.Start();
LogManager.defaultInstance.trace("Start demo");
try{
int a = 0, b = 0;
a /= b;
} catch (Exception e) {
e.ERROR();
// you can also
LogManager.defaultInstance.debug(e);
// or
e.DEBUG(customLogManager);
customLogManager.debug(e);
}
demoClass.sw.Stop();
LogManager.defaultInstance.debug(demoClass);
LogManager.defaultInstance.trace("End demo");
Console.Read();
}
public void Write(string category, string source, LogType logType, string logMsg, string detail)
{
Guid id = Guid.NewGuid();
LogEntity log = new LogEntity();
log.Id = id;
log.Category = category;
log.Source = source;
log.Type = (short)logType;
log.Message = logMsg;
LogDetailEntity logDetail = new LogDetailEntity();
logDetail.Id = id;
logDetail.LogDetail = detail;
try
{
using (ILHDBTran tran = BeginTran())
{
LogManager manager = new LogManager(tran);
manager.AddLog(log);
manager.AddLogDetail(logDetail);
tran.Commit();
}
}
catch (Exception ex)
{
FileLogWriter writer = new FileLogWriter();
writer.Write(LogCategory.LogWrite, "Write log to database", ex);
writer.Write(category, source, logType, logMsg, detail);
}
}
public void TreatPeriodAsNamespaceMarker()
{
var logManager = new LogManager();
var logger = (Logger)logManager.CreateLogger("LogManager.Test.Namespace");
Assert.True(logger.IsDebugEnabled);
Assert.Equal(0, logger.TraceSource.Listeners.Count);
}
public void changeDayIntervalTest()
{
string fileName = string.Empty; // TODO: initialisez à une valeur appropriée
LogManager target = new LogManager(fileName); // TODO: initialisez à une valeur appropriée
int dayInterval = 0; // TODO: initialisez à une valeur appropriée
target.changeDayInterval(dayInterval);
Assert.Inconclusive("Une méthode qui ne retourne pas une valeur ne peut pas être vérifiée.");
}
public static void Init(LogConfig config)
{
_instance = new LogManager(config);
string initMessage = $@">>> LogManager initialized successfully. UTC time: {DateTime.UtcNow.ToString("R")}";
_instance.GetLogger("XLog.LogManager").Info(initMessage);
}
public void DefaultToWarningIfSwitchNameUnknown()
{
var logManager = new LogManager();
var logger = logManager.CreateLogger("LogManager.UnknownSource");
Assert.True(logger.IsWarnEnabled);
Assert.False(logger.IsInfoEnabled);
}
public static LogManager GetInstance()
{
if (_instance == null)
{
_instance = new LogManager();
}
return _instance;
}
public static LogManager getInstance()
{
if (m_instance == null)
{
m_instance = new LogManager();
}
return m_instance;
}
/// <summary>
/// Returns a <c>LogManager</c> object.
/// </summary>
/// <returns><c>LogManager</c> instance</returns>
public static LogManager GetLogManager()
{
if (instance == null) {
instance = new LogManager();
}
return instance;
}
/// <summary>
/// Initializes a new OVPNCommunicator object.
/// </summary>
/// <param name="host">Host to connect to (127.0.0.1)</param>
/// <param name="port">Port to connect to</param>
/// <param name="logs">Log manager</param>
public Communicator(string host, int port,
LogManager logs)
{
m_host = host;
m_port = port;
m_logs = logs;
m_tcpC = new TcpClient();
}
private int wizard_step; //ウイザードのステップ番号
//サブウインドウの初期化
internal frmSubWindow(EnvData en, LogManager lg, OpenWindowType c_window) {
InitializeComponent();
this.env = en;
this.log = lg;
this.folder = env.Project.Folder;
Init(c_window);
}
public static void RecordLog(string title,
LogEventType eventType,
LogPriority priority,
object extraObject,
System.Exception e)
{
LogManager lm = new LogManager();
lm.Record(title, eventType, priority, extraObject, e);
}
public override ILogger Create(String name)
{
var log = LogManager.GetLogger(name);
return(new Log4netLogger(log.Logger, this));
}
public StopWindowsService(string id, StopWindowsServiceConfig config)
: base(id, config)
{
logger = LogManager.GetLogger(GetType());
}
/// <summary>
/// Initializes a new instance of the <see cref="EnvironmentLogExtension"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
public EnvironmentLogExtension(string logger)
{
this.log = LogManager.GetLogger(logger);
}
public HangmanGame(IMessageChannel channel, string type)
{
_log = LogManager.GetCurrentClassLogger();
this.GameChannel = channel;
this.TermType = type.ToTitleCase();
}
public static void AddMap(ServerMap map)
{
//File.WriteAllText(GTANInstallDir + "\\logs\\map.json", JsonConvert.SerializeObject(map));
Ped PlayerChar = Game.Player.Character;
try
{
NetEntityHandler.ServerWorld = map.World;
if (map.World.LoadedIpl != null)
{
foreach (var ipl in map.World.LoadedIpl)
{
Function.Call(Hash.REQUEST_IPL, ipl);
}
}
if (map.World.RemovedIpl != null)
{
foreach (var ipl in map.World.RemovedIpl)
{
Function.Call(Hash.REMOVE_IPL, ipl);
}
}
if (map.Objects != null)
{
foreach (var pair in map.Objects)
{
if (NetEntityHandler.ClientMap.ContainsKey(pair.Key))
{
continue;
}
NetEntityHandler.CreateObject(pair.Key, pair.Value);
//GTA.UI.Screen.ShowSubtitle("Creating object...", 500000);
}
}
if (map.Vehicles != null)
{
foreach (var pair in map.Vehicles)
{
if (NetEntityHandler.ClientMap.ContainsKey(pair.Key))
{
continue;
}
NetEntityHandler.CreateVehicle(pair.Key, pair.Value);
//GTA.UI.Screen.ShowSubtitle("Creating vehicle...", 500000);
}
}
if (map.Blips != null)
{
foreach (var blip in map.Blips)
{
if (NetEntityHandler.ClientMap.ContainsKey(blip.Key))
{
continue;
}
NetEntityHandler.CreateBlip(blip.Key, blip.Value);
}
}
if (map.Markers != null)
{
foreach (var marker in map.Markers)
{
if (NetEntityHandler.ClientMap.ContainsKey(marker.Key))
{
continue;
}
NetEntityHandler.CreateMarker(marker.Key, marker.Value);
}
}
if (map.Pickups != null)
{
foreach (var pickup in map.Pickups)
{
if (NetEntityHandler.ClientMap.ContainsKey(pickup.Key))
{
continue;
}
NetEntityHandler.CreatePickup(pickup.Key, pickup.Value);
}
}
if (map.TextLabels != null)
{
//map.TextLabels.GroupBy(x => x.Key).Select(y => y.First()); //Remove duplicates before procceeding
foreach (var label in map.TextLabels)
{
if (NetEntityHandler.ClientMap.ContainsKey(label.Key))
{
continue;
}
NetEntityHandler.CreateTextLabel(label.Key, label.Value);
}
}
if (map.Peds != null)
{
foreach (var ped in map.Peds)
{
if (NetEntityHandler.ClientMap.ContainsKey(ped.Key))
{
continue;
}
NetEntityHandler.CreatePed(ped.Key, ped.Value);
}
}
if (map.Particles != null)
{
foreach (var ped in map.Particles)
{
if (NetEntityHandler.ClientMap.ContainsKey(ped.Key))
{
continue;
}
NetEntityHandler.CreateParticle(ped.Key, ped.Value);
}
}
if (map.Players != null)
{
LogManager.DebugLog("STARTING PLAYER MAP");
foreach (var pair in map.Players)
{
if (NetEntityHandler.NetToEntity(pair.Key)?.Handle == PlayerChar.Handle)
{
// It's us!
var remPl = NetEntityHandler.NetToStreamedItem(pair.Key) as RemotePlayer;
remPl.Name = pair.Value.Name;
}
else
{
var ourSyncPed = NetEntityHandler.GetPlayer(pair.Key);
NetEntityHandler.UpdatePlayer(pair.Key, pair.Value);
if (ourSyncPed.Character != null)
{
ourSyncPed.Character.RelationshipGroup = (pair.Value.Team == LocalTeam &&
pair.Value.Team != -1)
? Main.FriendRelGroup
: Main.RelGroup;
for (int i = 0; i < 15; i++) //NEEDS A CHECK
{
Function.Call(Hash.SET_PED_COMPONENT_VARIATION, ourSyncPed.Character, i,
pair.Value.Props.Get((byte)i),
pair.Value.Textures.Get((byte)i), 2);
}
lock (NetEntityHandler.HandleMap)
NetEntityHandler.HandleMap.Set(pair.Key, ourSyncPed.Character.Handle);
ourSyncPed.Character.Opacity = pair.Value.Alpha;
/*
* if (ourSyncPed.Character.AttachedBlip != null)
* {
* ourSyncPed.Character.AttachedBlip.Sprite = (BlipSprite)pair.Value.BlipSprite;
* ourSyncPed.Character.AttachedBlip.Color = (BlipColor)pair.Value.BlipColor;
* ourSyncPed.Character.AttachedBlip.Alpha = pair.Value.BlipAlpha;
* }
*/
NetEntityHandler.ReattachAllEntities(ourSyncPed, false);
}
}
}
}
}
catch (Exception ex)
{
GTA.UI.Notification.Show("FATAL ERROR WHEN PARSING MAP");
GTA.UI.Notification.Show(ex.Message);
Client.Disconnect("Map Parse Error");
LogManager.LogException(ex, "MAP PARSE");
return;
}
World.CurrentTimeOfDay = new TimeSpan(map.World.Hours, map.World.Minutes, 00);
Time = new TimeSpan(map.World.Hours, map.World.Minutes, 00);
if (map.World.Weather >= 0 && map.World.Weather < Enums._weather.Length)
{
Weather = Enums._weather[map.World.Weather];
Function.Call(Hash.SET_WEATHER_TYPE_NOW_PERSIST, Enums._weather[map.World.Weather]);
}
Function.Call(Hash.PAUSE_CLOCK, true);
}
public AppWebDriver Sleep(int sec)
{
LogManager.GetCurrentClassLogger().Debug($"Sleep for : {sec} Secs");
Thread.Sleep(sec * 1000);
return this;
}
public void Configure(IConfigureThisEndpoint specifier)
{
// setup your logging infrastructure then call
LogManager.Use <Log4NetFactory>();
}
static LogHelper()
{
LogHelper.Logger = LogManager.GetLogger("service");
}
public LoggerCloudWatch()
{
_logger = LogManager.GetCurrentClassLogger();
}
/// <summary>
/// Returns a logger for the object's type
/// </summary>
/// <param name="getTypeFromInstance"></param>
/// <returns></returns>
public static ILog LoggerFor(object getTypeFromInstance)
{
Mandate.ParameterNotNull(getTypeFromInstance, "getTypeFromInstance");
return(LogManager.GetLogger(getTypeFromInstance.GetType()));
}
private static void AddLogging()
{
log4net.Repository.ILoggerRepository logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
}
///<summary>
/// Returns a logger for the type specified
///</summary>
///<typeparam name="T"></typeparam>
///<returns></returns>
public static ILog LoggerFor <T>()
{
return(LogManager.GetLogger(typeof(T)));
}
/// <summary>
/// 初始化 Log4Net
/// </summary>
/// <returns></returns>
public static void CreateRepository(string FilePath)
{
_ILoggerRepository = LogManager.CreateRepository(AppConfig.Log4NETRepositoryName);
XmlConfigurator.Configure(_ILoggerRepository, new FileInfo(FilePath));
}
public StationService()
{
log = LogManager.GetLogger(this.GetType());
}
public AppWebDriver SetElementByCss(string css)
{
LogManager.GetCurrentClassLogger().Debug($"SetElementByCss : {css}");
Element = Wait.Until(ExpectedConditions.ElementIsVisible(By.CssSelector(css)));
return this;
}
static FileLogger()
{
Log = LogManager.GetLogger(typeof(FileLogger));
}
public AppWebDriver SetElementById(string id)
{
LogManager.GetCurrentClassLogger().Debug($"SetElementById : {id}");
Element = Wait.Until(ExpectedConditions.ElementIsVisible(By.Id(id)));
return this;
}
public IInternalLogger LoggerFor(Type type)
{
return new NLogLogger(LogManager.GetLogger(type.FullName));
}
private static void Main(string[] args)
{
ExceptionlessClient.Default.Startup("ujUuuNlhz7ZQKoDxBohBMKmPxErDgbFmNdYvPRHM");
SetupNLog();
_fluentCommandLineParser = new FluentCommandLineParser <ApplicationArguments>
{
IsCaseSensitive = false
};
_fluentCommandLineParser.Setup(arg => arg.LogDirectory)
.As('d')
.WithDescription(
"The directory that contains IIS logs. If not specified, defaults to same directory as executable")
.SetDefault(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
_fluentCommandLineParser.Setup(arg => arg.FieldName)
.As('f')
.WithDescription(
"The field name to find to do the geolocation on. Default is 'c-ip'")
.SetDefault("c-ip");
_logger = LogManager.GetCurrentClassLogger();
var header =
$"iisgeolocate version {Assembly.GetExecutingAssembly().GetName().Version}" +
"\r\n\r\nAuthor: Eric Zimmerman ([email protected])" +
"\r\nhttps://github.com/EricZimmerman/iisGeolocate";
_fluentCommandLineParser.SetupHelp("?", "help", "h")
.WithHeader(header)
.Callback(text => _logger.Info(text + "\r\n" + ""));
var result = _fluentCommandLineParser.Parse(args);
if (result.HelpCalled)
{
return;
}
if (result.HasErrors)
{
_logger.Error("");
_logger.Error(result.ErrorText);
_fluentCommandLineParser.HelpOption.ShowHelp(_fluentCommandLineParser.Options);
return;
}
var outDirName = "out";
var outDir = Path.Combine(_fluentCommandLineParser.Object.LogDirectory, outDirName);
if (Directory.Exists(outDir) == false)
{
Directory.CreateDirectory(outDir);
}
var uniqueIps = new Dictionary <string, UniqueIp>();
var logFiles = Directory.GetFiles(_fluentCommandLineParser.Object.LogDirectory, "*.log");
if (logFiles.Length > 0)
{
_logger.Info($"Found {logFiles.Length} log files");
}
else
{
_logger.Fatal("No files ending in .log found. Exiting...");
return;
}
var dataSlot = -1;
if (File.Exists("GeoLite2-City.mmdb") == false && File.Exists("GeoIP2-City.mmdb") == false)
{
_logger.Fatal("'GeoLite2-City.mmdb' or 'GeoIP2-City.mmdb' missing! Cannot continue. Exiting");
return;
}
var dbName = "GeoLite2-City.mmdb";
if (File.Exists("GeoIP2-City.mmdb"))
{
_logger.Info("Found 'GeoIP2-City.mmdb', so using that vs lite...");
dbName = "GeoIP2-City.mmdb";
}
_logger.Warn(
"NOTE: multicast, private, or reserved addresses will be SKIPPED (including IPv6 that starts with 'fe80'");
using (var reader = new DatabaseReader(dbName))
{
foreach (var file in logFiles)
{
_logger.Warn($"Opening '{file}'");
var baseFilename = Path.GetFileName(file);
var outFilename = Path.Combine(outDir, baseFilename);
using (var outstream = new StreamWriter(File.Open(outFilename, FileMode.OpenOrCreate,
FileAccess.Write, FileShare.Read)))
{
if (uniqueIps.Count > 0)
{
_logger.Info($"Unique IPs found so far: {uniqueIps.Count:N0}");
//return;
}
using (var instream = File.OpenText(file))
{
var csv = new CsvReader(instream);
csv.Configuration.Delimiter = " ";
csv.Configuration.HasHeaderRecord = false;
csv.Configuration.BadDataFound = null;
csv.Read();
string[] fields = null;
dynamic currentRecord;
var rawLine = csv.Context.RawRecord.Trim();
while (rawLine.StartsWith("#"))
{
if (rawLine.StartsWith("#Fields"))
{
fields = rawLine.Split(' ').Skip(1).ToArray();
rawLine += " GeoCity GeoCountry";
}
outstream.WriteLine(rawLine);
csv.Read();
rawLine = csv.Context.RawRecord.Trim();
}
if (fields == null)
{
_logger.Warn("Unable to find 'Fields' info in file. Skipping...");
continue;
}
var pos = 0;
_logger.Info(
$"Looking for/verifying '{_fluentCommandLineParser.Object.FieldName}' field position...");
foreach (var field in fields)
{
if (field.Equals(_fluentCommandLineParser.Object.FieldName,
StringComparison.OrdinalIgnoreCase))
{
dataSlot = pos;
_logger.Info(
$"Found '{_fluentCommandLineParser.Object.FieldName}' field position in column '{dataSlot}'!");
break;
}
pos += 1;
}
//we are at the actual data now
while (csv.Read())
{
rawLine = csv.Context.RawRecord.Trim();
if (rawLine.StartsWith("#"))
{
continue;
}
currentRecord = csv.GetRecord <dynamic>();
var rec = (IDictionary <string, object>)currentRecord;
var key = $"Field{dataSlot + 1}"; //fields start at 1
var ipAddress = ((string)rec[key]).Replace("\"", "");
if (ipAddress.StartsWith("fe80"))
{
continue;
}
//do ip work
var geoCity = "NA";
var geoCountry = "NA";
try
{
var segs2 = ipAddress.Split('.');
if (segs2.Length > 1)
{
var first = int.Parse(segs2[0]);
var second = int.Parse(segs2[1]);
if (first >= 224 || first == 10 || first == 192 && second == 168 ||
first == 172 && second >= 16 && second <= 31)
{
continue;
}
}
var city = reader.City(ipAddress);
geoCity = city.City?.Name?.Replace(' ', '_');
geoCountry = city.Country.Name.Replace(' ', '_');
if (uniqueIps.ContainsKey(ipAddress) == false)
{
var ui = new UniqueIp {
City = city.City?.Name
};
ui.Country = city.Country.Name;
ui.IpAddress = ipAddress;
uniqueIps.Add(ipAddress, ui);
}
}
catch (AddressNotFoundException an)
{
}
catch (Exception ex)
{
_logger.Info($"Error: {ex.Message} for line: {rawLine}");
geoCity = $"City error: {ex.Message}";
geoCountry = "Country error: (See city error)";
}
rawLine += $" {geoCity} {geoCountry}";
outstream.WriteLine(rawLine);
}
}
outstream.Flush();
}
}
}
_logger.Info("");
if (uniqueIps.Count <= 0)
{
_logger.Info("No unique, geolocated IPs found!\r\n");
return;
}
_logger.Info("Saving unique IPs to '!UniqueIPs.csv'");
using (var uniqOut = new StreamWriter(File.OpenWrite(Path.Combine(outDir, "!UniqueIPs.csv"))))
{
var csw = new CsvWriter(uniqOut);
csw.WriteHeader <UniqueIp>();
csw.NextRecord();
csw.WriteRecords(uniqueIps.Values);
uniqOut.Flush();
}
_logger.Info("");
}
public IInternalLogger LoggerFor(string keyName)
{
return new NLogLogger(LogManager.GetLogger(keyName));
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
repository = LogManager.CreateRepository("rollingAppender");
XmlConfigurator.Configure(repository, new FileInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "log4net.config")));
}
void IListener.Call(params object[] args)
{
if (_onTransportOpenListener._parameters.Failed[0])
{
return;
}
var log = LogManager.GetLogger(Global.CallerName());
var msg = (Packet)args[0];
if (Packet.PONG == msg.Type && "probe" == (string)msg.Data)
{
//log.Info(
// string.Format("probe transport '{0}' pong",
// _onTransportOpenListener.Parameters.Transport[0].Name));
_onTransportOpenListener._parameters.Socket._upgrading = true;
_onTransportOpenListener._parameters.Socket.Emit(EventUpgrading,
_onTransportOpenListener._parameters.Transport[0]);
PriorWebsocketSuccess = WebSocket.NAME ==
_onTransportOpenListener._parameters.Transport[0].Name;
//log.Info(
// string.Format("pausing current transport '{0}'",
// _onTransportOpenListener.Parameters.Socket.Transport.Name));
((Polling)_onTransportOpenListener._parameters.Socket.Transport).Pause(
() =>
{
if (_onTransportOpenListener._parameters.Failed[0])
{
// reset upgrading flag and resume polling
((Polling)_onTransportOpenListener._parameters.Socket.Transport).Resume();
_onTransportOpenListener._parameters.Socket._upgrading = false;
_onTransportOpenListener._parameters.Socket.Flush();
return;
}
if (ReadyStateEnum.Closed == _onTransportOpenListener._parameters.Socket._readyState ||
ReadyStateEnum.Closing == _onTransportOpenListener._parameters.Socket._readyState)
{
return;
}
log.Info("changing transport and sending upgrade packet");
_onTransportOpenListener._parameters.Cleanup[0]();
_onTransportOpenListener._parameters.Socket.SetTransport(
_onTransportOpenListener._parameters.Transport[0]);
var packetList =
ImmutableList <Packet> .Empty.Add(new Packet(Packet.UPGRADE));
try
{
_onTransportOpenListener._parameters.Transport[0].Send(packetList);
_onTransportOpenListener._parameters.Socket._upgrading = false;
_onTransportOpenListener._parameters.Socket.Flush();
_onTransportOpenListener._parameters.Socket.Emit(EventUpgrade,
_onTransportOpenListener._parameters.Transport[0]);
_onTransportOpenListener._parameters.Transport =
_onTransportOpenListener._parameters.Transport.RemoveAt(0);
}
catch (Exception e)
{
log.Error("", e);
}
});
}
else
{
log.Info(string.Format("probe transport '{0}' failed",
_onTransportOpenListener._parameters.Transport[0].Name));
var err = new EngineIOException("probe error");
_onTransportOpenListener._parameters.Socket.Emit(EventUpgradeError, err);
}
}
public Startup(IConfiguration configuration)
{
LogManager.LoadConfiguration(string.Concat(Directory.GetCurrentDirectory(), "/nlog.config"));
Configuration = configuration;
}
public static Log GetLogger(Type type)
{
return(new Log(LogManager.GetLogger(type)));
}
public static void MyClassInitialize(TestContext testContext)
{
ILogger logger = LogManager.GetLogger(typeof(CatsBPTest).FullName);
}
public static Log GetLogger(string str)
{
return(new Log(LogManager.GetLogger(str)));
}
public TeamspeakController() : base()
{
logger = LogManager.GetLogger("TeamspeakController");
GameMode.OnWorldReady += World_OnWorldStartup;
GameMode.OnWorldShutdown += World_OnWorldShutdown;
}
public AppWebDriver SetElementByLinkText(string text)
{
LogManager.GetCurrentClassLogger().Debug($"SetElementByLinkText : {text}");
Element = Wait.Until(ExpectedConditions.ElementIsVisible(By.LinkText(text)));
return this;
}
private static Dictionary <String, Decimal> GetExchangeRates()
{
if (ObsoleteData())
{
lock (_syncRoot)
{
if (ObsoleteData())
{
try
{
_exchangeRates = new Dictionary <string, decimal>();
var tmppath = GetExchangesTempPath();
TryToReadPublisherDate(tmppath);
var updateEnable = ConfigurationManagerExtension.AppSettings["crm.update.currency.info.enable"] != "false";
var ratesUpdatedFlag = false;
foreach (var ci in _currencies.Values.Where(c => c.IsConvertable))
{
var filepath = Path.Combine(tmppath, ci.Abbreviation + ".html");
if (updateEnable && 0 < (DateTime.UtcNow.Date - _publisherDate.Date).TotalDays || !File.Exists(filepath))
{
var filepath_temp = Path.Combine(tmppath, ci.Abbreviation + "_temp.html");
DownloadCurrencyPage(ci.Abbreviation, filepath_temp);
if (File.Exists(filepath_temp))
{
if (TryGetRatesFromFile(filepath_temp, ci))
{
ratesUpdatedFlag = true;
File.Copy(filepath_temp, filepath, true);
}
File.Delete(filepath_temp);
continue;
}
}
if (File.Exists(filepath) && TryGetRatesFromFile(filepath, ci))
{
ratesUpdatedFlag = true;
}
}
if (ratesUpdatedFlag)
{
_publisherDate = DateTime.UtcNow;
WritePublisherDate(tmppath);
}
}
catch (Exception error)
{
LogManager.GetLogger("ASC.CRM").Error(error);
_publisherDate = DateTime.UtcNow;
}
}
}
}
return(_exchangeRates);
}
public AppWebDriver SetElementByXPath(string path)
{
LogManager.GetCurrentClassLogger().Debug($"SetElementByXPath : {path}");
Element = Wait.Until(ExpectedConditions.ElementIsVisible(By.XPath(path)));
return this;
}
