public LocalScriptStore(LoggerConfigurator logConfig, FileSystem fileSystem, IRobotPluginLocator pluginLocator)
{
_fileSystem = fileSystem;
_pluginLocator = pluginLocator;
_scriptUpdated = new Subject <IScript>();
_log = logConfig.GetLogger();
}
private void StartScriptCs()
{
var name = "WPFScript.csx";
var console = new WPFConsoleRelay();
var configurator = new LoggerConfigurator(LogLevel.Info);
configurator.Configure(console);
var logger = configurator.GetLogger();
var init = new InitializationServices(logger);
init.GetAppDomainAssemblyResolver().Initialize();
var builder = new ScriptServicesBuilder(console, logger, null, null, init)
.Cache()
.Debug(false)
.LogLevel(LogLevel.Info)
.ScriptName(name)
.Repl();
var modules = new string[0];
var extension = Path.GetExtension(name);
//OVERRIDES
builder.ScriptHostFactory <WPFScriptHostFactory>();
builder.ScriptEngine <RoslynScriptEngine>();
builder.LoadModules(extension, modules);
//BUILD SERVICE
_service = builder.Build();
_service.Executor.Initialize(Enumerable.Empty <string>(), _service.ScriptPackResolver.GetPacks(), new string[0]);
var types = new Type[] {
typeof(IConsole),
typeof(ScriptContext),
typeof(Newtonsoft.Json.Converters.BinaryConverter)
};
_service.Executor.AddReferenceAndImportNamespaces(types);
EventAggr.Instance.GetEvent <WriteLineEvent>().Subscribe((text) =>
{
string[] lines = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
foreach (var line in lines.Where(l => !string.IsNullOrEmpty(l)))
{
_area.Document.Text += line;
NewLine();
_area.Document.Text += ">";
}
});
EventAggr.Instance.GetEvent <WriteEvent>().Subscribe((text) =>
{
_area.Document.Text += text;
}
);
}
public async Task WhenRobotIsReset_ScriptCleanupIsInvoked()
{
var loggerConfigurator = new LoggerConfigurator(LogLevel.All);
var builder = new RobotBuilder(loggerConfigurator)
.UseAdapter <StubAdapter>()
.UseBrain <StubBrain>()
.DisablePluginDiscovery()
.DisableScriptDiscovery();
var scriptRunner = new ScriptRunner(loggerConfigurator.GetLogger());
var robot = builder
.Build(c => c.Register <IScriptRunner>(scriptRunner));
scriptRunner.Initialize(robot);
robot.LoadScript <StubEchoScript>();
bool isCleanedUp = false;
using (scriptRunner.StartScriptProcessingSession(new ScriptSource("TestScript", string.Empty)))
{
robot.RegisterCleanup(() => isCleanedUp = true);
}
await robot.Reset();
Assert.True(isCleanedUp);
}
public static void Register()
{
var server = HttpContext.Current.Server;
var config = server.MapPath(ConfigurationManager.AppSettings["log4net.config"]);
LoggerConfigurator.Configure(config);
}
public static LoggerConfigurator CreateLogConfig(Options options)
{
var logConfig = new LoggerConfigurator(options.Verbose ? LogLevel.Debug : LogLevel.Info);
if (Environment.UserInteractive)
{
logConfig.ConfigureForConsole();
}
else
{
logConfig.AddTraceListener();
}
var logger = logConfig.GetLogger();
if (!string.IsNullOrWhiteSpace(options.LogFile))
{
if (Directory.Exists(Path.GetDirectoryName(options.LogFile)))
{
logConfig.ConfigureForFile(options.LogFile);
}
else
{
logger.Warn(string.Format("Failed to load log file. Path for {0} does not exist.", options.LogFile));
}
}
return(logConfig);
}
private IScriptExecutor GetExecutor(List <string> references, string rootPath)
{
var console = new ScriptConsole();
var loggerConfig = new LoggerConfigurator(ScriptCs.Contracts.LogLevel.Error);
loggerConfig.Configure(console);
var logger = loggerConfig.GetLogger();
var builder = new ScriptServicesBuilder(console, logger).
InMemory(true).
ScriptName("");
var services = builder.Build();
var executor = services.Executor;
var paths = services.AssemblyResolver.GetAssemblyPaths(rootPath, null).Where(p => !p.Contains("Contracts"));
var packs = services.ScriptPackResolver.GetPacks();
executor.Initialize(paths, packs);
executor.AddReferences(references.ToArray());
var reference = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"\ScriptCs.Contracts.dll";
executor.AddReferences(reference);
executor.ImportNamespaces("ScriptCs.Contracts");
return(executor);
}
/// <summary>
/// Initialize the logger
/// </summary>
private static void InitializeLogger()
{
LoggerConfigurator.ConfigureLogger();
Log.Information(
$"{Application.ProductName} {AssemblyUtils.GetReleaseState()} ({Application.ProductVersion})");
Log.Information($"OS: {Environment.OSVersion}");
Log.Information($"Framework: {Environment.Version}");
}
public async Task TestReportAsync()
{
LoggerConfigurator loggerConfigurator = new LoggerConfigurator();
LoggerFunctions loggerFunctions = new LoggerFunctions(loggerConfigurator);
LogController logController = new LogController(loggerFunctions);
List <LogMessage> logMessages = new List <LogMessage>();
Random = new Random();
Level level = Level.Null;
for (int i = 0; i < 100; i++)
{
if (i % 4 == 1)
{
level = Level.Warning;
}
else if (i % 4 == 2)
{
level = Level.Error;
}
else if (i % 4 == 3)
{
level = Level.Critical;
}
else
{
level = Level.Information;
}
logMessages.Add(new LogMessage
{
Computer = RandomString(5),
User = RandomString(6),
Logged = DateTime.Now,
LogName = RandomString(7),
Application = "App",
Sourse = RandomString(8),
EventID = i,
Keywords = "qwe",
Level = level,
Message = "qweqweqweqe",
TaskCategory = "None"
});
}
/*Parallel.For(0, 99, async (i) =>
* {
* await logController.ReportAsync(logMessages[i]);
* });*/
/*Parallel.For(0, 99, (i) =>
* {
* logController.Report(logMessages[i]);
* });*/
for (int i = 0; i < 100; i++)
{
logController.ReportAsync(logMessages[i]);
}
}
public async Task WhenMultipleAdaptersAreConfigured_ResponsesAreOnlySentToTheOriginatingAdapter()
{
var logConfig = new LoggerConfigurator(LogLevel.Trace);
logConfig.ConfigureForConsole();
var robot = new RobotBuilder(logConfig)
.DisablePluginDiscovery()
.DisableScriptDiscovery()
.UseAdapter <StubAdapter>()
.UseAdapter <StubAdapter2>()
.UseBrain <StubBrain>()
.Build();
robot.AutoLoadScripts = false;
var adapter1 = robot.Adapters.Values.OfType <StubAdapter>().First();
var adapter2 = robot.Adapters.Values.OfType <StubAdapter2>().First();
robot.LoadScript <StubEchoScript>();
var expectedMessages = new[]
{
Tuple.Create("test1", "Hello Test 1"),
Tuple.Create("test2", "Hello Test 2"),
Tuple.Create("test3", "Hello Test 3")
};
await robot.Run();
Console.WriteLine("Testing Adapter 1");
expectedMessages.ForEach(t => adapter1.SimulateMessage(t.Item1, "mmbot " + t.Item2));
var expectedMessagesValues = expectedMessages.Select(t => string.Concat(t.Item1, t.Item2));
Console.WriteLine("Expected:");
Console.WriteLine(string.Join(Environment.NewLine, expectedMessagesValues));
var actualMessagesValues = adapter1.Messages.Select(t => string.Concat(t.Item1.User.Name, t.Item2.FirstOrDefault()));
Console.WriteLine("Actual:");
Console.WriteLine(string.Join(Environment.NewLine, actualMessagesValues));
Assert.True(expectedMessagesValues.SequenceEqual(actualMessagesValues));
Assert.Equal(0, adapter2.Messages.Count());
Console.WriteLine("Testing Adapter 2");
expectedMessages.ForEach(t => adapter2.SimulateMessage(t.Item1, "mmbot " + t.Item2));
Console.WriteLine("Expected:");
Console.WriteLine(string.Join(Environment.NewLine, expectedMessagesValues));
actualMessagesValues = adapter2.Messages.Select(t => string.Concat(t.Item1.User.Name, t.Item2.FirstOrDefault()));
Console.WriteLine("Actual:");
Console.WriteLine(string.Join(Environment.NewLine, actualMessagesValues));
Assert.True(expectedMessagesValues.SequenceEqual(actualMessagesValues));
Assert.Equal(3, adapter1.Messages.Count());
}
public Startup(IHostingEnvironment env)
{
SetDefaultApplicationConfiguration();
Configuration = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", true, true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", true)
.AddEnvironmentVariables().Build();
Log.Logger = LoggerConfigurator.Configure(Configuration);
}
public static IScriptServicesBuilder Create(ScriptCsArgs commandArgs, string[] scriptArgs)
{
Guard.AgainstNullArgument("commandArgs", commandArgs);
Guard.AgainstNullArgument("scriptArgs", scriptArgs);
IConsole console = new ScriptConsole();
if (!string.IsNullOrWhiteSpace(commandArgs.Output))
{
console = new FileConsole(commandArgs.Output, console);
}
var configurator = new LoggerConfigurator(commandArgs.LogLevel);
configurator.Configure(console);
var logger = configurator.GetLogger();
var initializationServices = new InitializationServices(logger);
initializationServices.GetAppDomainAssemblyResolver().Initialize();
var scriptServicesBuilder = new ScriptServicesBuilder(console, logger, null, null, initializationServices)
.Cache(commandArgs.Cache)
.Debug(commandArgs.Debug)
.LogLevel(commandArgs.LogLevel)
.ScriptName(commandArgs.ScriptName)
.Repl(commandArgs.Repl);
var modules = commandArgs.Modules == null
? new string[0]
: commandArgs.Modules.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
var extension = Path.GetExtension(commandArgs.ScriptName);
if (string.IsNullOrWhiteSpace(extension) && !commandArgs.Repl)
{
// No extension was given, i.e we might have something like
// "scriptcs foo" to deal with. We activate the default extension,
// to make sure it's given to the LoadModules below.
extension = ".csx";
if (!string.IsNullOrWhiteSpace(commandArgs.ScriptName))
{
// If the was in fact a script specified, we'll extend it
// with the default extension, assuming the user giving
// "scriptcs foo" actually meant "scriptcs foo.csx". We
// perform no validation here thought; let it be done by
// the activated command. If the file don't exist, it's
// up to the command to detect and report.
commandArgs.ScriptName += extension;
}
}
return scriptServicesBuilder.LoadModules(extension, modules);
}
private ScriptServices CreateScriptServices(bool useLogging)
{
var console = new ScriptConsole();
var configurator = new LoggerConfigurator(useLogging ? LogLevel.Debug : LogLevel.Info);
configurator.Configure(console);
var logger = configurator.GetLogger();
var builder = new ScriptServicesBuilder(console, logger);
builder.ScriptEngine<RoslynScriptEngine>();
return builder.Build();
}
public async Task XmppRobot()
{
//enter config values to enable this test
var config = new Dictionary <string, string>();
//config.Add("MMBOT_XMPP_HOST", "userver");
//config.Add("MMBOT_XMPP_CONNECT_HOST", "userver");
//config.Add("MMBOT_XMPP_USERNAME", "mmbot");
//config.Add("MMBOT_XMPP_PASSWORD", "password");
//config.Add("MMBOT_XMPP_CONFERENCE_SERVER", "conference.userver");
//config.Add("MMBOT_XMPP_ROOMS", "testroom");
//config.Add("MMBOT_XMPP_LOGROOMS", "logroom");
if (config.Count() == 0)
{
return;
}
var logConfig = new LoggerConfigurator(LogLevel.Trace);
logConfig.AddTraceListener();
var robot = new RobotBuilder(logConfig)
.WithConfiguration(config)
.UseAdapter <XmppAdapter>()
.Build();
robot.AutoLoadScripts = false;
robot.LoadScript <CompiledScripts.Ping>();
bool robotReady = false;
robot.On <bool>("RobotReady", result =>
{
robotReady = result;
});
await robot.Run();
Assert.True(robotReady);
int cmdReceived = 0;
robot.Hear("mmbot", msg => { cmdReceived++; });
//will wait for two commands
while (cmdReceived < 2)
{
Thread.Sleep(1000);
}
}
void Application_Start(object sender, EventArgs e)
{
DependencyRegistrar.EnsureDependenciesRegistered();
LoggerConfigurator.ConfigureLogging();
EnsureAppDataFolderExists();
IoC.Resolver.Resolve <IDatabaseBootstrapper>().InitializeDatabase();
IoC.Resolver.Resolve <IMapperBootstrapper>().RegisterMappings();
RegisterWcfRoutes();
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
}
private static void RegisterDependencies()
{
try
{
DependencyRegistrar.EnsureDependenciesRegistered();
IoC.Resolver.Register <IHttpRuntime, FakeHttpRuntime>();
IoC.Resolver.Register <IConfigSettings, IntegrationTestConfigSettings>();
LoggerConfigurator.ConfigureLogging();
}
catch (Exception ex)
{
throw new IntegrationTesterBaseSetupFailedException("Dependency registration failed", ex);
}
}
public async Task Initialize()
{
LoggerConfigurator.Setup();
_userInformationService.StartListening();
var result = _storageService.LoadUserData();
Mapper.Initialize(cfg =>
{
cfg.AddProfile <GitMappingsProfile>();
BitBucketEnterpriseMappings.AddEnterpriseProfile(cfg);
});
await GitClientLogin(result);
}
/// <summary>
/// Creates new Logger.
/// </summary>
/// <returns>ILogger object</returns>
private Logger.ILogger GetLogger()
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", true, true)
.Build();
string logFile = configuration["DefaultLogFileName"];
LoggerFactory logFactory = new LoggerFactory();
LoggerConfigurator loggerConfigurator = new LoggerConfigurator();
if (!string.IsNullOrEmpty(logFile))
{
loggerConfigurator.AddWriter(new FileWriter(logFile));
}
var logger = logFactory.GetLogger(loggerConfigurator);
return(logger);
}
public void TestLogger()
{
LoggerConfigurator.Configure();
var logger = LoggerManager.GetLogger(this.GetType());
logger.Info("logger info");
logger.Warn("logger warn");
logger.Debug("logger debug");
logger.Error("logger error");
logger.Fatal("logger fatal");
try
{
var i = 0;
var j = 2 / i;
}
catch (Exception ex)
{
logger.Error(ex.Message, ex);
}
}
public async Task Initialize()
{
try
{
LoggerConfigurator.Setup();
_userInformationService.StartListening();
var result = _storageService.LoadUserData();
Mapper.Initialize(cfg =>
{
cfg.AddProfile <YouTrackMappingsProfile>();
BitBucketEnterpriseMappings.AddEnterpriseProfile(cfg);
});
await YouTrackClientLogin(result);
}
catch (Exception e)
{
_logger.Error("Error during App initialization: " + e);
}
}
private static ScriptServices BuildScriptServices(InOutConsole console)
{
var logConfiguration = new LoggerConfigurator(LogLevel.Info);
logConfiguration.Configure(console);
var logger = logConfiguration.GetLogger();
var initializationServices = new InitializationServices(logger);
initializationServices.GetAppDomainAssemblyResolver().Initialize();
var scriptServicesBuilder = new ScriptServicesBuilder(console, logger, null, null, initializationServices)
.Repl(true);
scriptServicesBuilder.LoadModules("");
var scriptServices = scriptServicesBuilder.Build();
initializationServices.GetInstallationProvider().Initialize();
scriptServices.Repl.Initialize(Enumerable.Empty<string>(), Enumerable.Empty<IScriptPack>());
return scriptServices;
}
private MyLogger(String db) {
// your code
logger = LoggerConfigurator.AddNamedLogger(db);
}
static GitClientVSPackage()
{
LoggerConfigurator.Setup();
HttpWebRequest.DefaultMaximumErrorResponseLength = 1048576;
AssemblyResolver.InitializeAssemblyResolver();
}
public LoggerFunctions(LoggerConfigurator LoggerConfig)
{
_loggerConfigurator = LoggerConfig;
}
public void Test1()
{
LoggerConfigurator loggerConfigurator = new LoggerConfigurator();
LoggerFunctions loggerFunctions = new LoggerFunctions(loggerConfigurator);
LogMessage lm1 = new LogMessage
{
Computer = "Comp1",
User = "******",
Logged = DateTime.Now,
LogName = "lofName",
Application = "App",
Sourse = "qweqweqweqe",
EventID = 1234,
Keywords = "qwe",
Level = Level.Critical,
Message = "qweqweqweqe",
TaskCategory = "None"
};
loggerFunctions.Report(lm1);
LogMessage lm = new LogMessage
{
Computer = "Comp",
User = "******",
Logged = DateTime.Now,
LogName = "lofName",
Application = "App",
Sourse = "Sourse1",
EventID = 1234,
Keywords = "qwe",
Level = Level.Warning,
Message = "Message",
TaskCategory = "None"
};
loggerFunctions.Report(lm);
StringBuilder result = new StringBuilder();
switch (lm.Level)
{
case Level.Warning:
result.Append("WARN | ");
break;
case Level.Error:
result.Append("ERROR | ");
break;
case Level.Critical:
result.Append("FATAL | ");
break;
default:
result.Append("INFO | ");
break;
}
result.Append($"{lm.Computer} | {lm.User} | {lm.Logged} | {lm.Application} | {lm.Sourse} | {lm.EventID} | {lm.LogName} | {lm.TaskCategory} | {lm.Keywords} | {lm.Message}");
string filepath = Path.Combine(Environment.CurrentDirectory, $@"logs\{DateTime.Now.Date.ToString("yyyy-MM-dd")}.log");
List <string> list = new List <string>();
using (StreamReader sr = new StreamReader(filepath))
{
while (!sr.EndOfStream)
{
list.Add(sr.ReadLine());
}
}
bool found = false;
for (int i = 0; i < list.Count; i++)
{
if (list[i].Contains(result.ToString()))
{
found = true;
}
}
Assert.AreEqual(found, true);
}
public NuGetPackageAssemblyResolver(LoggerConfigurator logConfig)
{
_log = logConfig.GetLogger();
AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
RefreshAssemblies(_log);
}
/// <summary>
/// Initialize the logger
/// </summary>
private static void InitializeLogger()
{
LoggerConfigurator.ConfigureLogger();
}
