public override async Task WriteQueryToStream(Stream stream, ILogger logger, Spec.Query query, CancellationToken cancellationToken)
{
using (var memoryBuffer = new MemoryStream(1024))
using (var streamWriter = new StreamWriter(memoryBuffer, utf8Encoding))
{
WriteQuery(new JsonWriter(streamWriter), query);
streamWriter.Flush();
var data = memoryBuffer.ToArray();
memoryBuffer.Seek(0, SeekOrigin.Begin);
if (logger.InformationEnabled())
{
string dataStr = Encoding.UTF8.GetString(data);
logger.Information("JSON query: {0}", dataStr);
}
var tokenHeader = BitConverter.GetBytes(query.token);
if (!BitConverter.IsLittleEndian)
Array.Reverse(tokenHeader, 0, tokenHeader.Length);
memoryBuffer.Write(tokenHeader, 0, tokenHeader.Length);
var lengthHeader = BitConverter.GetBytes(data.Length);
if (!BitConverter.IsLittleEndian)
Array.Reverse(lengthHeader, 0, lengthHeader.Length);
memoryBuffer.Write(lengthHeader, 0, lengthHeader.Length);
memoryBuffer.Write(data, 0, data.Length);
logger.Debug("Writing packet, {0} bytes", data.Length);
data = memoryBuffer.ToArray();
await stream.WriteAsync(data, 0, data.Length, cancellationToken);
}
}
static ProductsController()
{
Logger = Log.ForContext<ProductsController>();
Products = new Fixture().CreateMany<Product>(500).OrderBy(p => p.Id).ToList();
Logger.Information("created the products {ProductCount}", Products.Count());
}
internal static string FixAreaPathInTargetQuery(string sourceWIQLQueryBit, string sourceProject, string targetProject, string[] nodeBasePaths, ILogger?contextLog)
{
string targetWIQLQueryBit = sourceWIQLQueryBit;
if (nodeBasePaths != null && nodeBasePaths.Any() && targetWIQLQueryBit.Contains("[System.AreaPath]"))
{
if (sourceProject != targetProject)
{
//Switch out source Area Path with destination
foreach (var nodeBasePath in nodeBasePaths)
{
if (sourceWIQLQueryBit.Contains(nodeBasePath))
{
contextLog?.Information("[NodeBasePaths] has been set and QueryBit contains [System.AreaPath]. Since {nodeBasePath} was found in the query, updating the projectName from {source} to {target}", nodeBasePath, sourceProject, targetProject);
StringBuilder myStringBuilder = new StringBuilder(sourceWIQLQueryBit);
int locationOfAreaPath = sourceWIQLQueryBit.IndexOf("[System.AreaPath]");
int querySegmentSize = (sourceWIQLQueryBit.IndexOf(nodeBasePath) + nodeBasePath.Length) - locationOfAreaPath;
myStringBuilder.Replace(sourceProject, targetProject, locationOfAreaPath, querySegmentSize);
targetWIQLQueryBit = myStringBuilder.ToString();
}
}
}
}
return(targetWIQLQueryBit);
}
/// <summary> Dispose logger if it is not null </summary>
public static void TryDispose(this ILogger?logger)
{
logger?.Information("Finish");
var dsp = logger as IDisposable;
dsp?.Dispose();
}
private static void PatchGame(ILogger log)
{
log.Information("Creating {0}", Paths.PatchedAssemblyFolder);
Directory.CreateDirectory(Paths.PatchedAssemblyFolder);
log.Information("Loading original assembly {0}", Paths.OriginalAssembly);
var patcher = new AssemblyPatcher(Paths.OriginalAssembly, log);
patcher.EmbedHistory = false;
patcher.UseBackup = false;
log.Information("Patching");
patcher.PatchAssembly(typeof(W2PWMod.ModType).Assembly.Location);
log.Information("Saving patched file");
patcher.WriteTo(Paths.PatchedAssembly);
}
internal LoggingScope(ILogger logger, string messageTemplate, params object[] propertyValues)
{
_Logger = logger;
_MessageTemplate = messageTemplate;
_PropertyValues = propertyValues;
_StopWatch = new Stopwatch();
_StopWatch.Start();
_Logger.Information($">> Started: \"{_MessageTemplate}\"", _PropertyValues);
}
public void Setup()
{
_exception = new Exception("An Error");
_log = new LoggerConfiguration()
.WriteTo.Sink(new NullSink())
.CreateLogger();
// Ensure template is cached
_log.Information(_exception, "Hello, {Name}!", "World");
}
public NamedPipePoshGitServer(IRepositoryCache repoCache, ILifetimeScope lifetimeScope, ILogger log)
{
_log = log;
_cancellationTokenSource = new CancellationTokenSource();
_repoCache = repoCache;
_serializer = JsonSerializer.Create();
_lifetimeScope = lifetimeScope;
log.Information("Server started");
}
public static void Before()
{
logger = new LoggerConfiguration()
.ReadFrom.AppSettings()
.Enrich.WithMachineName()
.Enrich.FromLogContext()
.CreateLogger();
Log.Logger = logger;
logger.Information("Logger has been initialized!");
}
/// <inheritdoc />
public string Execute()
{
var outputRedirect = new StringBuilder();
var lastOutputString = string.Empty;
_console.RedirectOutput(outputRedirect);
foreach (var scriptLine in _scriptLines)
{
if (!scriptLine.IsScript)
{
_logger?.Information($"Line {scriptLine.LineNumber} [{scriptLine.RawLine}] : Line skipped");
continue;
}
_registry.RootCommand.Invoke(scriptLine.CommandArguments.ToArray());
lastOutputString = outputRedirect.ToString().Trim();
outputRedirect.Clear();
_logger?.Information($"Line {scriptLine.LineNumber} [{scriptLine.RawLine}] : {lastOutputString}");
}
return(lastOutputString);
}
public NinjectCore(IKernel kernel, ILogger logger, ICoreSettings settings)
{
_kernel = kernel;
_logger = logger;
_settings = settings;
_logger.Information("Initializing Core.");
InitializeKernel();
InitializeExtensions();
_logger.Verbose("Core initilized.");
}
public WindowMessageHook(
IEnumerable<IWindowMessageInterceptor> windowMessageInterceptors,
ILogger logger,
IConsumerThreadLoop consumerLoop)
{
this.windowMessageInterceptors = windowMessageInterceptors;
this.logger = logger;
this.consumerLoop = consumerLoop;
pendingMessages = new Queue<WindowMessageReceivedArgument>();
cancellationTokenSource = new CancellationTokenSource();
logger.Information($"Window message hook was constructed using {windowMessageInterceptors.Count()} interceptors.");
}
public OneTimePhoneEmulatorDialogMonitor(ILogger logger)
{
_logger = logger;
_windowsPhoneEmulatorDialogMonitor = new WindowsPhoneEmulatorDialogMonitor(logger);
_timer = new Timer(1000);
_timer.Elapsed += (sender, e) => _windowsPhoneEmulatorDialogMonitor.ExecuteDialogSlapDown(msg =>
{
_logger.Information(msg);
_timer.Stop();
_timer = null;
_windowsPhoneEmulatorDialogMonitor = null;
});
_timer.Start();
}
public WindowMessageHook(
IReadOnlyCollection<IWindowMessageInterceptor> windowMessageInterceptors,
ILogger logger,
IConsumerThreadLoop consumerLoop,
IMainWindowHandleContainer mainWindowHandleContainer)
{
this.windowMessageInterceptors = windowMessageInterceptors;
this.logger = logger;
this.consumerLoop = consumerLoop;
this.mainWindowHandleContainer = mainWindowHandleContainer;
pendingMessages = new Queue<WindowMessageReceivedArgument>();
cancellationTokenSource = new CancellationTokenSource();
logger.Information(
$"Window message hook was constructed using {windowMessageInterceptors.Count} interceptors.");
}
public EfMigrator(string assemblyPath, string qualifiedDbConfigName, string appConfigPath, string connectionString, string connectionProvider,
ILogger logger)
{
_logger = logger;
appConfigPath = Path.GetFullPath(appConfigPath);
if (!File.Exists(appConfigPath))
{
throw new EfMigrationException($"The {nameof(appConfigPath)} '{appConfigPath}' must exist.");
}
var domainSetup = AppDomain.CurrentDomain.SetupInformation;
domainSetup.ConfigurationFile = appConfigPath;
_logger.Debug($"Prepared AppDomain setup using {appConfigPath} as the appconfig.");
var domainName = $"EfMigrator:{Guid.NewGuid()}";
_domain = AppDomain.CreateDomain(domainName, null, domainSetup);
_logger.Debug($"Created new AppDomain named {domainName}.");
var type = typeof(EfMigratorBackend);
var fullPath = Assembly.GetAssembly(typeof(EfMigratorBackend)).Location;
//var domain = AppDomain.CurrentDomain.GetAssemblies()
// .Where(x => !x.IsDynamic)
// .Where(x => !x.GlobalAssemblyCache)
// .Select(x => Path.GetDirectoryName(x.Location))
// .Distinct();
//var domains = string.Join(", ", domain);
//logger.Debug($"Loading assemblies into appDomain: {domains}.");
Debug.Assert(fullPath != null, "fullPath != null");
var migrator = (EfMigratorBackend) _domain.CreateInstanceFromAndUnwrap(fullPath, type.FullName);
_logger.Debug("Created new instance.");
migrator.Initialize(assemblyPath, qualifiedDbConfigName, connectionString, connectionProvider);
_logger.Debug($"Initialized new {nameof(EfMigratorBackend)} within {domainName}.");
CurrentMigration = migrator.GetCurrentMigration() ?? InitialDatabase;
var currentMigrationStr = CurrentMigration == InitialDatabase ? "$InitialDatabase" : CurrentMigration;
_logger.Information($"Current Migration is {currentMigrationStr}.");
_migratorBackend = migrator;
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
_container = new UnityContainer();
AccidentalFish.ApplicationSupport.Core.Bootstrapper.RegisterDependencies(_container);
AccidentalFish.ApplicationSupport.Azure.Bootstrapper.RegisterDependencies(_container);
Domain.Bootstrapper.RegisterDependencies(_container);
Domain.Bootstrapper.RegisterInfrastructure(_container);
AccidentalFish.ApplicationSupport.Processes.Bootstrapper.RegisterDependencies(_container);
ILoggerFactory loggerFactory = _container.Resolve<ILoggerFactory>();
_logger = loggerFactory.CreateLongLivedLogger(new LoggerSource("com.accidentalfish.azurelinkboard.background.worker-role"));
_logger.Information("Starting background worker role instance");
return base.OnStart();
}
public MessagePathConfigurator(IPathTemplatesProvider pathTemplateProvider, ILogger logger)
{
if (pathTemplateProvider == null) throw new ArgumentNullException("pathTemplateProvider");
if (logger == null) throw new ArgumentNullException("logger");
_logger = logger;
_pathTemplateProvider = pathTemplateProvider;
_pathTemplateProvider.PathTemplates.CollectionChanged += PathTemplatesCollectionChanged;
DefaultSavePath = AppDomain.CurrentDomain.BaseDirectory;
RenderLoadPaths();
if (LoadPaths.Any()) DefaultSavePath = LoadPaths.First();
_logger.Information(
"Default Message Save Path is Set to {DefaultSavePath}",
DefaultSavePath);
}
internal static string FixAreaPathAndIterationPathForTargetQuery(string sourceWIQLQueryBit, string sourceProject, string targetProject, ILogger?contextLog)
{
string targetWIQLQueryBit = sourceWIQLQueryBit;
if (string.IsNullOrWhiteSpace(targetWIQLQueryBit) ||
string.IsNullOrWhiteSpace(sourceProject) ||
string.IsNullOrWhiteSpace(targetProject) ||
sourceProject == targetProject)
{
return(targetWIQLQueryBit);
}
var matches = Regex.Matches(targetWIQLQueryBit, RegexPatterForAreaAndIterationPathsFix);
foreach (Match match in matches)
{
if (!match.Success)
{
continue;
}
var value = match.Groups["value"].Value;
if (string.IsNullOrWhiteSpace(value) || !value.StartsWith(sourceProject))
{
continue;
}
var slashIndex = value.IndexOf('\\');
if (slashIndex > 0)
{
var subValue = value.Substring(0, slashIndex);
if (subValue == sourceProject)
{
var targetValue = targetProject + value.Substring(slashIndex);
var targetMatchValue = match.Value.Replace(value, targetValue);
targetWIQLQueryBit = targetWIQLQueryBit.Replace(match.Value, targetMatchValue);
}
}
}
contextLog?.Information("[FilterWorkItemsThatAlreadyExistInTarget] is enabled. Source project {sourceProject} is replaced with target project {targetProject} on the WIQLQueryBit which resulted into this target WIQLQueryBit \"{targetWIQLQueryBit}\" .", sourceProject, targetProject, targetWIQLQueryBit);
return(targetWIQLQueryBit);
}
public static T DeserializeObject <T>(ILogger?logger, string value)
{
try
{
JsonSerializerSettings settings = new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Error,
};
#pragma warning disable CS8603 // Possible null reference return.
return(JsonConvert.DeserializeObject <T>(value, settings));
#pragma warning restore CS8603 // Possible null reference return.
}
catch (JsonSerializationException e)
{
if (logger == null)
{
Debug.WriteLine(e.ToString());
}
logger?.Information("## MODEL UPDATE NEEDED ## Fields found we don't know yet in class '{ClassName}'\r\nError message: {ErrorMessage}; value is \r\n{@Value}", typeof(T), e.Message, value);
return(JsonConvert.DeserializeObject <T>(value));
}
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
var builder = new ContainerBuilder();
builder.RegisterType<FixItQueueManager>().As<IFixItQueueManager>();
builder.RegisterType<FixItTaskRepository>().As<IFixItTaskRepository>().SingleInstance();
builder.RegisterType<Logger>().As<ILogger>().SingleInstance();
container = builder.Build();
logger = container.Resolve<ILogger>();
bool result = base.OnStart();
logger.Information("MyFixItWorkerRole has been started");
return result;
}
protected override void Decode(IChannelHandlerContext context, IByteBuffer message, List <object> output)
{
var continueToDecode = true;
var temp = new List <IPacket>();
var encryptedString = "";
var mapper = SessionFactory.Instance.Sessions[context.Channel.Id.AsLongText()];
_region = mapper.RegionType;
_sessionId = mapper.SessionId;
var str = ((Span <byte>)message.Array).Slice(message.ArrayOffset, message.ReadableBytes).ToArray();
if (_sessionId == 0)
{
var pack =
_deserializer.Deserialize(DecryptCustomParameter(str, out var endofPacket)) as UnresolvedPacket;
if (!int.TryParse(pack.Header, out _sessionId))
{
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.ERROR_SESSIONID));
return;
}
SessionFactory.Instance.Sessions[context.Channel.Id.AsLongText()].SessionId = _sessionId;
_logger.Information(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.CLIENT_CONNECTED),
mapper.SessionId);
temp.Add(pack);
if (endofPacket.Length == 0)
{
continueToDecode = false;
}
str = endofPacket;
}
if (continueToDecode)
{
var sessionKey = _sessionId & 0xFF;
var sessionNumber = unchecked ((byte)(_sessionId >> 6));
sessionNumber &= 0xFF;
sessionNumber &= unchecked ((byte)0x80000003);
switch (sessionNumber)
{
case 0:
encryptedString =
(from character in str
let firstbyte = unchecked ((byte)(sessionKey + 0x40))
select unchecked ((byte)(character - firstbyte))).Aggregate(encryptedString,
(current, highbyte) => current + (char)highbyte);
break;
case 1:
encryptedString =
(from character in str
let firstbyte = unchecked ((byte)(sessionKey + 0x40))
select unchecked ((byte)(character + firstbyte))).Aggregate(encryptedString,
(current, highbyte) => current + (char)highbyte);
break;
case 2:
encryptedString =
(from character in str
let firstbyte = unchecked ((byte)(sessionKey + 0x40))
select unchecked ((byte)((character - firstbyte) ^ 0xC3))).Aggregate(encryptedString,
(current, highbyte) => current + (char)highbyte);
break;
case 3:
encryptedString =
(from character in str
let firstbyte = unchecked ((byte)(sessionKey + 0x40))
select unchecked ((byte)((character + firstbyte) ^ 0xC3))).Aggregate(encryptedString,
(current, highbyte) => current + (char)highbyte);
break;
default:
encryptedString += (char)0xF;
break;
}
temp.AddRange(encryptedString.Split((char)0xFF, StringSplitOptions.RemoveEmptyEntries).Select(p =>
{
try
{
var packet = _deserializer.Deserialize(DecryptPrivate(p));
if (!packet.IsValid)
{
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.CORRUPT_PACKET),
packet);
}
return(packet);
}
catch (Exception ex)
{
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.ERROR_DECODING),
ex.Data["Packet"]);
return(new UnresolvedPacket
{
KeepAliveId = ushort.Parse(ex.Data["Packet"].ToString().Split(" ")[0]), Header = "0"
});
}
}));
}
if (temp.Count > 0)
{
output.Add(temp);
}
}
/// <summary>
/// Starts the primary thread where all the work is done.
/// Outputs all of the hosts info so that if we're starting it up, the user can see if anything is wrong, allowing them time to make changes.
/// </summary>
public void Start()
{
Logger.Debug("Start()");
RunThread = new Thread(new ThreadStart(StartLogging))
{
Name = $"{Host.HostName}-MainThread"
};
Logger.Information("Starting ping logging for host {0} ({1})", Host.HostName, Host.IP);
Logger.Information("Using the following options:");
Logger.Information("Threshold: {0}ms", Host.Threshold);
Logger.Information("Timeout: {0}ms", Host.Timeout);
Logger.Information("Interval: {0}ms", Host.Interval);
Logger.Information("Packet Size: {0} bytes", Host.PacketSize);
Logger.Debug("RunThread.Start()");
RunThread.Start();
}
public async Task ProcessAsync(string[] arguments)
{
logger.Information("Running installation procedure.");
await InstallAsync();
}
public async Task <HttpResponseMessage> Relay(string fullPathToOnPremiseEndpoint)
{
_logger?.Debug("Relaying request. method={RequestMethod}, path={RequestPath}", ControllerContext.Request.Method, fullPathToOnPremiseEndpoint);
if (fullPathToOnPremiseEndpoint == null)
{
_logger?.Information("Path to on premise endpoint is not set");
return(NotFound());
}
var pathInformation = _pathSplitter.Split(fullPathToOnPremiseEndpoint);
var link = _linkRepository.GetLink(pathInformation.UserName);
if (!CanRequestBeHandled(fullPathToOnPremiseEndpoint, pathInformation, link))
{
_logger?.Information("Request cannot be handled");
return(NotFound());
}
var request = await _onPremiseRequestBuilder.BuildFromHttpRequest(Request, _backendCommunication.OriginId, pathInformation.PathWithoutUserName).ConfigureAwait(false);
var statusCode = HttpStatusCode.GatewayTimeout;
IOnPremiseConnectorResponse response = null;
try
{
request = _interceptorManager.HandleRequest(request, Request, User, out var message);
if (message != null)
{
_logger?.Verbose("Interceptor caused direct answering of request. request-id={RequestId}, status-code={ResponseStatusCode}", request.RequestId, message.StatusCode);
statusCode = message.StatusCode;
if (request.AlwaysSendToOnPremiseConnector)
{
_logger?.Verbose("Interceptor caused always sending of request. request-id={RequestId}", request.RequestId);
SendOnPremiseConnectorRequest(link.Id, request);
}
return(message);
}
var task = _backendCommunication.GetResponseAsync(request.RequestId);
SendOnPremiseConnectorRequest(link.Id, request);
_logger?.Verbose("Waiting for response. request-id={RequestId}, link-id={LinkId}", request.RequestId, link.Id);
response = await task.ConfigureAwait(false);
if (response != null)
{
_logger?.Verbose("Response received. request-id={RequestId}, link-id={LinkId}", request.RequestId, link.Id);
statusCode = response.StatusCode;
}
else
{
_logger?.Verbose("No response received because of on-premise timeout. request-id={RequestId}, link-id={LinkId}", request.RequestId, link.Id);
}
return(_interceptorManager.HandleResponse(request, Request, User, response) ?? _httpResponseMessageBuilder.BuildFromConnectorResponse(response, link, request.RequestId));
}
finally
{
FinishRequest(request, response, link.Id, fullPathToOnPremiseEndpoint, statusCode);
}
}
public async Task <ImportResult> ImportSystem(DataFileSystem data, PKSystem system, ulong accountId)
{
// TODO: make atomic, somehow - we'd need to obtain one IDbConnection and reuse it
// which probably means refactoring SystemStore.Save and friends etc
var result = new ImportResult {
AddedNames = new List <string>(),
ModifiedNames = new List <string>(),
Success = true // Assume success unless indicated otherwise
};
var dataFileToMemberMapping = new Dictionary <string, PKMember>();
var unmappedMembers = new List <DataFileMember>();
// If we don't already have a system to save to, create one
if (system == null)
{
system = await _data.CreateSystem(data.Name);
}
result.System = system;
// Apply system info
system.Name = data.Name;
if (data.Description != null)
{
system.Description = data.Description;
}
if (data.Tag != null)
{
system.Tag = data.Tag;
}
if (data.AvatarUrl != null)
{
system.AvatarUrl = data.AvatarUrl;
}
if (data.TimeZone != null)
{
system.UiTz = data.TimeZone ?? "UTC";
}
await _data.SaveSystem(system);
// Make sure to link the sender account, too
await _data.AddAccount(system, accountId);
// Determine which members already exist and which ones need to be created
var membersByHid = new Dictionary <string, PKMember>();
var membersByName = new Dictionary <string, PKMember>();
await foreach (var member in _data.GetSystemMembers(system))
{
membersByHid[member.Hid] = member;
membersByName[member.Name] = member;
}
foreach (var d in data.Members)
{
PKMember match = null;
if (membersByHid.TryGetValue(d.Id, out var matchByHid))
{
match = matchByHid; // Try to look up the member with the given ID
}
else if (membersByName.TryGetValue(d.Name, out var matchByName))
{
match = matchByName; // Try with the name instead
}
if (match != null)
{
dataFileToMemberMapping.Add(d.Id, match); // Relate the data file ID to the PKMember for importing switches
result.ModifiedNames.Add(d.Name);
}
else
{
unmappedMembers.Add(d); // Track members that weren't found so we can create them all
result.AddedNames.Add(d.Name);
}
}
// If creating the unmatched members would put us over the member limit, abort before creating any members
// new total: # in the system + (# in the file - # in the file that already exist)
if (data.Members.Count - dataFileToMemberMapping.Count + membersByHid.Count > Limits.MaxMemberCount)
{
result.Success = false;
result.Message = $"Import would exceed the maximum number of members ({Limits.MaxMemberCount}).";
result.AddedNames.Clear();
result.ModifiedNames.Clear();
return(result);
}
// Create all unmapped members in one transaction
// These consist of members from another PluralKit system or another framework (e.g. Tupperbox)
var membersToCreate = new Dictionary <string, string>();
unmappedMembers.ForEach(x => membersToCreate.Add(x.Id, x.Name));
var newMembers = await _data.CreateMembersBulk(system, membersToCreate);
foreach (var member in newMembers)
{
dataFileToMemberMapping.Add(member.Key, member.Value);
}
// Update members with data file properties
// TODO: parallelize?
foreach (var dataMember in data.Members)
{
dataFileToMemberMapping.TryGetValue(dataMember.Id, out PKMember member);
if (member == null)
{
continue;
}
// Apply member info
member.Name = dataMember.Name;
if (dataMember.DisplayName != null)
{
member.DisplayName = dataMember.DisplayName;
}
if (dataMember.Description != null)
{
member.Description = dataMember.Description;
}
if (dataMember.Color != null)
{
member.Color = dataMember.Color.ToLower();
}
if (dataMember.AvatarUrl != null)
{
member.AvatarUrl = dataMember.AvatarUrl;
}
if (dataMember.Prefix != null || dataMember.Suffix != null)
{
member.ProxyTags = new List <ProxyTag> {
new ProxyTag(dataMember.Prefix, dataMember.Suffix)
};
}
else
{
// Ignore proxy tags where both prefix and suffix are set to null (would be invalid anyway)
member.ProxyTags = (dataMember.ProxyTags ?? new ProxyTag[] { }).Where(tag => !tag.IsEmpty).ToList();
}
member.KeepProxy = dataMember.KeepProxy;
if (dataMember.Birthday != null)
{
var birthdayParse = DateTimeFormats.DateExportFormat.Parse(dataMember.Birthday);
member.Birthday = birthdayParse.Success ? (LocalDate?)birthdayParse.Value : null;
}
await _data.SaveMember(member);
}
// Re-map the switch members in the likely case IDs have changed
var mappedSwitches = new List <ImportedSwitch>();
foreach (var sw in data.Switches)
{
var timestamp = InstantPattern.ExtendedIso.Parse(sw.Timestamp).Value;
var swMembers = new List <PKMember>();
swMembers.AddRange(sw.Members.Select(x =>
dataFileToMemberMapping.FirstOrDefault(y => y.Key.Equals(x)).Value));
mappedSwitches.Add(new ImportedSwitch
{
Timestamp = timestamp,
Members = swMembers
});
}
// Import switches
if (mappedSwitches.Any())
{
await _data.AddSwitchesBulk(system, mappedSwitches);
}
_logger.Information("Imported system {System}", system.Hid);
return(result);
}
public Startup(IConfiguration configuration)
{
logger.Information($"{nameof(Startup)}");
Configuration = configuration;
}
private void FactorioOutputHandler(object sender, DataReceivedEventArgs e)
{
_logger.Information(e.Data);
if (e.Data.Contains("Starting RCON interface"))
{
_logger.Debug("Factorio says RCON interface is ready!");
OnRconReady?.Invoke(this, e);
}
OnOutputData?.Invoke(this, e);
}
private static void Main(string[] args)
{
if (args.Length < 1 || args[0] != "--startProxy")
{
Console.WriteLine("Please don't start the voting proxy process manually as it's only supposed to be launched by the mod itself."
+ "\nPass --startProxy as an argument if you want to start the proxy yourself for debugging purposes.");
Console.ReadKey();
return;
}
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.File("./chaosmod/chaosProxy.log", outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] [{SourceContext:l}] {Message:lj}{NewLine}{Exception}")
.CreateLogger();
logger = Log.Logger.ForContext <TwitchChatVotingProxy>();
logger.Information("===============================");
logger.Information("Starting chaos mod twitch proxy");
logger.Information("===============================");
// Read big config file WIP
var config = new Config.Config("./chaosmod/twitch.ini");
// Validate voting mode
EVotingMode votingMode;
if (config.VotingMode == null)
{
votingMode = EVotingMode.MAJORITY;
logger.Warning($"voting mode is null, using default \"{VotingMode.Lookup(votingMode)}\"");
}
else
{
votingMode = (EVotingMode)config.VotingMode;
}
/*
* // Create twitch config
* TwitchVotingReceiverConfig twitchVotingReceiverConfig;
* try
* {
* twitchVotingReceiverConfig = new TwitchVotingReceiverConfig(config.TwitchChannelName, config.TwitchOAuth, config.TwitchUserName);
* } catch (Exception e)
* {
* logger.Fatal(e, "failed to create twitch voting receiver config");
* return;
* }
*
*/
// Check if OBS overlay should be shown
OverlayServer.OverlayServer overlayServer = null;
if (config.OverlayMode == EOverlayMode.OVERLAY_OBS)
{
// Create overlay server config
OverlayServerConfig overlayServerConfig = new OverlayServerConfig(votingMode, config.RetainInitalVotes, config.OverlayServerPort);
// Create component
overlayServer = new OverlayServer.OverlayServer(overlayServerConfig);
}
// Create components
//var votingReceiver = new TwitchVotingReceiver(twitchVotingReceiverConfig);
TwitchChatVotingProxy.votingReceiver = new WSVotingReceiver(null);
var chaosPipe = new ChaosPipeClient();
// Start the chaos mod controller
new ChaosModController(chaosPipe, overlayServer, votingReceiver, config);
while (true)
{
}
logger.Information("Pipe disconnected, ending program");
}
public static void Information(string template, params object[] args)
{
_logger.Information(template, args);
}
public async Task Invoke(HttpContext context)
{
var displayUrl = context.Request.GetDisplayUrl();
_log.Information(FormatEntryLogMessage(context.Request.Method, displayUrl));
var stopWatch = new Stopwatch();
stopWatch.Start();
try
{
await _next.Invoke(context);
stopWatch.Stop();
var message = FormatExitLogMessage(MakeRequestName(context), displayUrl, stopWatch.ElapsedMilliseconds, context.Response.StatusCode);
if (context.Response.StatusCode >= 200 && context.Response.StatusCode <= 399)
{
_log.Information(message);
}
else
{
_log.Error(message);
}
}
catch (BadRequestException e)
{
stopWatch.Stop();
if (context.Response.StatusCode != e.Error.Status)
{
context.Response.StatusCode = e.Error.Status;
}
if (string.IsNullOrWhiteSpace(e.Error.TraceId))
{
e.Error.TraceId = context.TraceIdentifier;
}
var details = JsonConvert.SerializeObject(e.Error, SerializerSettings);
_log.Error(e,
FormatExceptionLogMessage(MakeRequestName(context), displayUrl, stopWatch.ElapsedMilliseconds, context.Response.StatusCode, details));
await WriteJsonDetails(context, details);
}
catch (Exception e)
{
stopWatch.Stop();
if (context.Response.StatusCode < 500)
{
context.Response.StatusCode = 500;
}
_log.Error(e, FormatExceptionLogMessage(MakeRequestName(context), displayUrl, stopWatch.ElapsedMilliseconds, context.Response.StatusCode));
await WriteExceptionResponse(context, e);
}
}
protected void LogInfo(string text)
{
_logger.Information($"[{Tag}] {text}");
}
/// <summary>
/// This class is where all of the actual pinging work is done.
/// I creates a thread that loops until canceled.
/// The thread fires an event to do the actual pinging.
/// </summary>
/// <param name="host">The host that will be pinged.</param>
public Pinger(Host host)
{
Host = host;
if (!Directory.Exists("./Logs"))
{
Directory.CreateDirectory("./Logs");
}
if (!Directory.Exists($"./Logs/{Host.HostName}/"))
{
Directory.CreateDirectory($"./Logs/{Host.HostName}/");
}
var outputTemp = "[{Timestamp:HH:mm:ss} {Level:u4}] {Message:lj}{NewLine}{Exception}";
var errorOutputTemp = "[{Timestamp:HH:mm:ss} {Level:u5}] {Message:lj}{NewLine}{Exception}";
var filePath = "./Logs/" + Host.HostName + "/" + Host.HostName + "-{Date}.log";
var errorPathName = "./Logs/" + Host.HostName + "/" + Host.HostName + "-Errors-{Date}.log";
var warnPathName = "./Logs/" + Host.HostName + "/" + Host.HostName + "-Warnings-{Date}.log";
#if DEBUG
var debugOutputTemp = "[{Timestamp:HH:mm:ss.fff} {Level}] ({ThreadId}) {Message:lj}{NewLine}{Exception}";
var debugPathName = "./Logs/" + Host.HostName + "/" + Host.HostName + "-Debug-{Date}.log";
#endif
Logger = new LoggerConfiguration()
#if DEBUG
.Enrich.With(new ThreadIdEnricher())
.MinimumLevel.Verbose()
#endif
.WriteTo.Logger(
l => l.Filter.ByIncludingOnly(e => e.Level == Serilog.Events.LogEventLevel.Error)
.WriteTo.RollingFile(
errorPathName,
restrictedToMinimumLevel: Serilog.Events.LogEventLevel.Error,
retainedFileCountLimit: Config.DaysToKeepLogs,
shared: true,
outputTemplate: errorOutputTemp,
flushToDiskInterval: TimeSpan.FromSeconds(2) //Added this because I noticed that it wasn't consistently flushing to disk at a good interval.
)
)
.WriteTo.Logger(
l => l.Filter.ByIncludingOnly(e => e.Level == Serilog.Events.LogEventLevel.Warning)
.WriteTo.RollingFile(
warnPathName,
shared: true,
retainedFileCountLimit: Config.DaysToKeepLogs,
outputTemplate: outputTemp,
flushToDiskInterval: TimeSpan.FromSeconds(2)
)
)
#if DEBUG
.WriteTo.Logger(
l => l.Filter.ByIncludingOnly(e => e.Level == Serilog.Events.LogEventLevel.Debug)
.WriteTo.RollingFile(
debugPathName,
shared: true,
retainedFileCountLimit: Config.DaysToKeepLogs,
restrictedToMinimumLevel: Serilog.Events.LogEventLevel.Debug,
outputTemplate: debugOutputTemp,
flushToDiskInterval: TimeSpan.FromSeconds(2)
)
)
#endif
.WriteTo.RollingFile(
filePath,
shared: true,
outputTemplate: outputTemp,
retainedFileCountLimit: Config.DaysToKeepLogs,
restrictedToMinimumLevel: Serilog.Events.LogEventLevel.Information,
flushToDiskInterval: TimeSpan.FromSeconds(2)
)
.CreateLogger();
//Check to make sure the packet size isn't too large. Don't want to abuse this.
if (Host.PacketSize > 65500)
{
Logger.Error("Packet size too large. Resetting to 65500 bytes");
Host.PacketSize = 65500;
}
//Make sure that the interval isn't too short. If you set it to be too frequent, it might get flagged as DDoS attack.
if (Host.Interval < 500)
{
Logger.Error("Interval too short. Setting to 500ms");
Host.Interval = 500;
}
//Verify that the IP stored in the settings file matches what it currently resolves to.
//Mostly in cases of local network and DHCP
Logger.Information("Verifying IP address of hostname is current.");
foreach (var ip in Dns.GetHostAddresses(Host.HostName))
{
Logger.Debug($"IP: {ip}");
if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
if (ip.ToString() == Host.IP)
{
Logger.Information("IP matches. Continuing");
}
else
{
Logger.Warning("IP address does not match last stored. Saving new IP address");
Host.IP = ip.ToString();
}
break;
}
}
}
public ActionResult <IEnumerable <string> > Get()
{
_logger.Information(messageTemplate: "Log informaton from {0} - OK", propertyValue: nameof(ValuesController));
_logger.Error("Move to ElasticSearch logstash");
return(new string[] { "value1", "value2" });
}
} // ...for the "Warnings-dict" (the old WF-stuff)
public string ProcessShipments(OrderGroup orderGroup)
{
Logger = LogManager.GetLogger(GetType());
ShippingMethodDto methods = ShippingManager.GetShippingMethods
(/*Thread.CurrentThread.CurrentUICulture.Name*/ String.Empty);
OrderGroup order = orderGroup;
var billingCurrency = order.BillingCurrency;
// request rates, make sure we request rates not bound to selected delivery method
foreach (OrderForm form in order.OrderForms)
{
foreach (Shipment shipment in form.Shipments)
{
bool processThisShipment = true;
// is this in use?
string discountName = "@ShipmentSkipRateCalc"; // ...this is the "old" promos
// If you find the shipment discount which represents ... OLD?
if (shipment.Discounts.Cast <ShipmentDiscount>().Any(
x => x.ShipmentId == shipment.ShipmentId && x.DiscountName.Equals(discountName)))
{
processThisShipment = false;
}
if (!processThisShipment)
{
continue;
}
ShippingMethodDto.ShippingMethodRow row =
methods.ShippingMethod.FindByShippingMethodId(shipment.ShippingMethodId);
// If shipping method is not found, set it to 0 and continue
if (row == null)
{
Logger.Information(String.Format("Total shipment is 0 so skip shipment calculations."));
shipment.ShippingSubTotal = 0;
continue;
}
// Check if package contains shippable items, if it does not use the default shipping method instead of the one specified
Logger.Debug(String.Format("Getting the type \"{0}\".", row.ShippingOptionRow.ClassName));
Type type = Type.GetType(row.ShippingOptionRow.ClassName); // ...the gateway
if (type == null)
{
throw new TypeInitializationException(row.ShippingOptionRow.ClassName, null);
}
Logger.Debug(String.Format("Creating instance of \"{0}\".", type.Name));
// where it starts happening things
IShippingGateway provider = null;
var orderMarket = ServiceLocator.Current.GetInstance <IMarketService>()
.GetMarket(order.MarketId);
if (orderMarket != null)
{
provider = (IShippingGateway)Activator.CreateInstance(type, orderMarket);
}
else
{
provider = (IShippingGateway)Activator.CreateInstance(type);
}
Logger.Debug(String.Format("Calculating the rates."));
string message = String.Empty;
ShippingRate rate = provider.GetRate(row.ShippingMethodId, shipment, ref message);
if (rate != null)
{
Logger.Debug(String.Format("Rates calculated."));
// check if shipment currency is convertable to Billing currency, and then convert it
// Added the namespace below
if (!Mediachase.Commerce.Shared.CurrencyFormatter.CanBeConverted
(rate.Money, billingCurrency))
{
Logger.Debug(String.Format("Cannot convert selected shipping's currency({0}) to current currency({1}).", rate.Money.Currency.CurrencyCode, billingCurrency));
throw new Exception(String.Format("Cannot convert selected shipping's currency({0}) to current currency({1}).", rate.Money.Currency.CurrencyCode, billingCurrency));
}
else
{
Money convertedRate = Mediachase.Commerce.Shared.CurrencyFormatter.ConvertCurrency(rate.Money, billingCurrency);
shipment.ShippingSubTotal = convertedRate.Amount;
}
//return "In Rate";
}
else
{
Warnings[String.Concat("NoShipmentRateFound-", shipment.ShippingMethodName)] =
String.Concat("No rates have been found for ", shipment.ShippingMethodName);
Logger.Debug(String.Format("No rates have been found."));
//return "else";
}
}
//return "Near end";
}
return("Hello");
} // end method
// A production app would also include an OnStop override to provide for
// graceful shut-downs of worker-role VMs. See
// http://azure.microsoft.com/en-us/documentation/articles/cloud-services-dotnet-multi-tier-app-storage-3-web-role/#restarts
public override bool OnStart()
{
// creare logger
logger = new Logger();
// Set the maximum number of concurrent connections.
ServicePointManager.DefaultConnectionLimit = 12;
// Read database connection string and open database.
var dbConnString = CloudConfigurationManager.GetSetting("moviesassignment03DbConnectionString");
db = new MovieContext(dbConnString);
// Open storage account using credentials from .cscfg file.
var storageAccount = CloudStorageAccount.Parse
(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString"));
logger.Information("Creating images blob container named images");
//Trace.TraceInformation("Creating images blob container named images");
var blobClient = storageAccount.CreateCloudBlobClient();
imagesBlobContainer = blobClient.GetContainerReference("images");
if (imagesBlobContainer.CreateIfNotExists())
{
// Enable public access on the newly created "images" container.
imagesBlobContainer.SetPermissions(
new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
logger.Information("Creating images queue");
//Trace.TraceInformation("Creating images queue");
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
imagesQueue = queueClient.GetQueueReference("images");
imagesQueue.CreateIfNotExists();
logger.Information("Storage initialized");
//Trace.TraceInformation("Storage initialized");
return base.OnStart();
}
public async Task ProcessPayment(string userId, string paymentIntentId, string pricePlanId, CancellationToken cancellationToken)
{
Guard.Argument(userId, nameof(userId)).NotNull().NotEmpty().NotWhiteSpace();
Guard.Argument(paymentIntentId, nameof(paymentIntentId)).NotNull().NotEmpty().NotWhiteSpace();
Guard.Argument(pricePlanId, nameof(pricePlanId)).NotNull().NotEmpty().NotWhiteSpace();
var user = await _userRepository.GetUserById(userId, cancellationToken);
if (user == null)
{
throw new UserException("Please create the user first.");
}
if (string.IsNullOrWhiteSpace(user.PaymentCustomerId))
{
throw new UserException("PaymentCustomerId is missing. Please create the user first.");
}
var pricePlan = await _pricePlanRepository.GetPricePlanById(pricePlanId, cancellationToken);
if (pricePlan == null)
{
throw new SubscriptionException($"Unable to find the price plan with '{user.CurrentPricePlanId}' identifier.");
}
var paymentIntent = await _paymentService.GetPaymentIntent(paymentIntentId, cancellationToken);
if (pricePlan.Price != paymentIntent.Amount)
{
_logger.Error($"Payment amount is not matching with price plan '{pricePlan.Id}'. Expected '{pricePlan.Price}' and actual '{paymentIntent.Amount}'");
}
_logger.Information($"Collected payment of '{paymentIntent.Amount}' in minimum unit for user '{user.Id}'.");
var nextInvoiceNumberDao = await _invoiceNumberRepository.GetNextInvoiceNumber(cancellationToken);
var invoiceNumber = _invoiceHelper.CalculateInvoiceNumber(nextInvoiceNumberDao.Number);
try
{
await _invoiceHelper.SendInvoiceAsEmailAttachment(user, paymentIntent, pricePlan.Title, _systemDateTime.GetUtcDateTime(), paymentIntent.Amount, invoiceNumber, Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), cancellationToken);
}
catch (Exception ex)
{
_logger.Error($"Unable to send and invoice for an user {user.Id}. Exception: {ex.Message}");
}
var paymentDao = new ProcessedPaymentDao
{
UserId = user.Id,
PaymentServiceId = paymentIntent.Id,
Amount = paymentIntent.Amount,
PricePlanId = pricePlan.Id,
NoOfStamps = pricePlan.NoOfStamps,
Created = paymentIntent.Created,
InvoiceNumber = invoiceNumber
};
await _paymentRepository.CreatePaymentReceived(paymentDao, cancellationToken);
_logger.Information($"Previous remaining stamp for the user '{user.Id}' is '{user.RemainingTimeStamps}'.");
user.CurrentPricePlanId = pricePlan.Id;
user.PendingPricePlanId = null;
user.RemainingTimeStamps = pricePlan.NoOfStamps;
user.PaymentIntentId = paymentIntentId;
user.MembershipRenewDate = _systemDateTime.GetUtcDateTime().AddMonths(1);
user.MembershipRenewEpoch = user.MembershipRenewDate.Date.ToEpoch();
await _userRepository.UpdateUser(user, cancellationToken);
}
public static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration().MinimumLevel.Debug()
.MinimumLevel.Override(nameof(Microsoft), LogEventLevel.Information)
.MinimumLevel.Override("Microsoft.AspNetCore", LogEventLevel.Warning)
.Enrich.FromLogContext()
.WriteTo.Console()
.WriteTo.Graylog(new GraylogSinkOptions()
{
Facility = "project-ivy-imdb-ratings",
HostnameOrAddress = Environment.GetEnvironmentVariable("GRAYLOG_HOST"),
Port = Convert.ToInt32(Environment.GetEnvironmentVariable("GRAYLOG_PORT")),
TransportType = TransportType.Udp
})
.CreateLogger();
_logger = Log.Logger;
_logger.Information("Application started");
try
{
string connectionString = Environment.GetEnvironmentVariable("CONNECTION_STRING");
var users = (await DbHandler.GetImdbUsers(connectionString)).ToList();
_logger.Information("Found {UserCount} users with an Imdb account", users.Count);
foreach (var user in users)
{
_logger.Information("Processing movies for userId: {UserId}", user.userId);
var existingIds = await DbHandler.GetMovieIds(connectionString, user.userId);
var imdbCookies = await DbHandler.GetImdbUserSecrets(connectionString, user.userId);
if (imdbCookies.Count() == 0)
{
_logger.Information("User {UserId} does not have imdb cookies", user.userId);
continue;
}
var imdbRatings = await ImdbHandler.GetRatings(ImdbRatingsUrl, imdbCookies, user.imdbUsername);
var csvOptions = new CsvParserOptions(true, ',');
var movieMapping = new MovieMapping();
var csvParser = new CsvParser <Movie>(csvOptions, movieMapping);
var csvReaderOptions = new CsvReaderOptions(new[] { "\n" });
var movies = csvParser.ReadFromString(csvReaderOptions, imdbRatings).Where(x => x.IsValid).Select(x => x.Result).ToList();
var newMovies = movies.Where(x => !existingIds.Contains(x.ImdbId));
foreach (var newMovie in newMovies)
{
newMovie.UserId = user.userId;
await DbHandler.InsertMovie(connectionString, newMovie);
_logger.Information("Movie {Title} added for userId: {UserId}", newMovie.Title, newMovie.UserId);
}
}
}
catch (Exception e)
{
_logger.Error(e.Message);
}
_logger.Information("Application ended");
}
private Response ReadJsonResponse(JsonReader json, long token, ILogger logger)
{
Spec.Response retval = new Spec.Response();
retval.token = token;
if (!json.Read() || json.CurrentToken != JsonToken.ObjectStart)
throw new RethinkDbInternalErrorException("Expected a readable JSON object in response");
while (true)
{
if (!json.Read())
throw new RethinkDbInternalErrorException("Unexpected end-of-frame reading JSON response");
if (json.CurrentToken == JsonToken.ObjectEnd)
break;
if (json.CurrentToken != JsonToken.MemberName)
throw new RethinkDbInternalErrorException("Unexpected JSON state");
string property = (string)json.CurrentTokenValue;
if (property == "t")
retval.type = ReadResponseType(json);
else if (property == "r")
retval.response.AddRange(ReadDatumArray(json));
else if (property == "b")
retval.backtrace = ReadBacktrace(json);
else if (property == "p")
logger.Warning("Profiling is not currently supported by rethinkdb-net; profiling data will be discarded");
else
logger.Information("Unexpected property {0} in JSON response; ignoring", property);
}
return retval;
}
public async Task Study(string name)
{
try
{
var list = new List <CustomRequest>
{
new CustomRequest {
a = 1
},
new CustomRequest {
a = 2
},
new CustomRequest {
a = 3
},
};
////单播
//Console.WriteLine("_mediator.Send");
_mediator.Send(list.FirstOrDefault());
Console.WriteLine("zasdasd");
//Console.WriteLine("_mediator.SendAllAsync");
////异步广播
//try
//{
// await _mediator.SendAllAsync(list);
//}
//catch (AggregateException ex)
//{
// var exM = string.Join(",", ex.InnerExceptions.Select(s => s.Message));
// Console.WriteLine(exM);
//}
//Console.WriteLine("_mediator.SendAll");
////同步广播
//await _mediator.SendAll(list);
////异步发布订阅
//Console.WriteLine("_asyncPublisher.Publish");
//try
//{
// await _asyncPublisher.Publish(new CustomNotification { MsgId = "1" }, PublishStrategy.ParallelNoWait);
//}
//catch (AggregateException ex)
//{
// Console.WriteLine(ex.Message);
//}
//catch (Exception ex)
//{
// Console.WriteLine(ex.Message);
//}
throw new Exception("aaa");
//同步发布订阅
//Console.WriteLine("_mediator.PublishOne");
//await _mediator.Publish(new CustomNotification { MsgId = "1" });
}
catch (Exception ex)
{
_logger.Error(ex, "异常", 1, 1);
_logger.Information(ex, "异常", 1, 1);
_logger.Warning(ex, "异常", 1, 1);
_logger.Fatal(ex, "异常", 1, 1);
_logger.Debug(ex, "异常", 1, 1);
_logger.Verbose(ex, "异常", 1, 1);
}
}
static void Main(string[] args)
{
#if !DEBUG // Catch any unhandled exceptions if we are in release mode.
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler;
#endif
// use invariant culture - we have to set it explicitly for every thread we create to
// prevent any file-reading problems (mostly because of number formats).
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
// start the ioc kernel.
var kernel = TinyIoCContainer.Current;
var bootstrapper = new Bootstrapper(kernel);
var objectFactory = kernel.Resolve<IObjectFactory>();
var configFactory = kernel.Resolve<IConfigFactory>();
// print intro texts.
ConsoleWindow.PrintBanner();
ConsoleWindow.PrintLicense();
// check if we have a valid config file.
var configManager = configFactory.GetConfigManager();
if (!configManager.ConfigExists)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Couldn't read config/config.json! Make sure you rename config/config-sample.json as config/config.json.");
Console.ResetColor();
return;
}
// initialize log-manager.
var logManager = objectFactory.GetLogManager();
logManager.Initialize();
// print a version banner.
_logger = Log.ForContext<Program>();
_logger.Information("CoiniumServ {0} {1:l} warming-up..", VersionInfo.CodeName, Assembly.GetAssembly(typeof(Program)).GetName().Version);
PlatformManager.PrintPlatformBanner();
// initialize config manager.
configManager.Initialize();
// start pool manager.
var poolManager = objectFactory.GetPoolManager();
poolManager.Run();
// start web server.
var webServer = objectFactory.GetWebServer();
while (true) // idle loop & command parser
{
var line = Console.ReadLine();
CommandManager.Parse(line);
}
}
//private async Task<ServiceDto> CallConsul(HttpContext context, ILogger log, string serviceName)
//{
// try
// {
// var data = new ServiceDto();
// log.Verbose("Searching service in Consul...");
// using (var client = new ConsulClient())
// {
// var consulCatalog = await client.Catalog.Service(serviceName);
// if (consulCatalog.Response.Length > 0)
// {
// var service = consulCatalog.Response[0];
// data.Address = IPAddress.Parse(service.Address);
// data.Port = service.ServicePort;
// log.Information("Sending request to {Host}:{port}...", service.Address, data.Port);
// }
// else
// {
// log.Warning("Service not found!");
// context.Response.Send(404);
// }
// }
// return data;
// }
// catch (Exception e)
// {
// log.Error(e, "Cannot call Consul");
// context.Response.Send(500);
// return null;
// }
//}
private static async Task CallService(HttpContext context, HttpRequest request, ILogger log, ServiceInfo serviceInfo)
{
IPAddress serviceAdress = IPAddress.Parse(serviceInfo.Address);
int servicePort = serviceInfo.Port;
using (context)
{
try
{
using (var client = new TcpClient())
{
client.Connect(serviceAdress, servicePort);
using (var realService = client.GetStream())
{
log.Verbose("Sending request...");
await request.RedirectToAsync(realService);
log.Verbose("Waiting response...");
await context.Response.RedirectFromAsync(realService);
log.Information("Finished!");
}
}
}
catch (Exception e)
{
log.Error(e, "Cannot call service");
context.Response.Send(500);
}
}
}
private void LogAll(ILogger logger)
{
logger.Error("Error Logged");
logger.Warning("Warning Logged");
logger.Information("Information Logged");
logger.Debug("Debug Logged");
}
static void RunLoggingStuff(ILogger logger)
{
var timer = Stopwatch.StartNew();
foreach (var s in _stuffToLog) logger.Information(s);
logger.Information(timer.ElapsedMilliseconds.ToString());
}
public void Info(string msg, params object[] args)
{
_logger.Information(msg, args);
}
public async Task <OrphanageDataModel.Persons.Father> GetFather(int Fid)
{
_logger.Information($"trying to get father with Id ({Fid})");
using (var dbContext = new OrphanageDbCNoBinary())
{
var father = await dbContext.Fathers.AsNoTracking()
.Include(f => f.Families)
.Include(f => f.Name)
.FirstOrDefaultAsync(f => f.Id == Fid);
if (father == null)
{
_logger.Warning($"Father with id{Fid} cannot be found null is returned");
return(null);
}
_selfLoopBlocking.BlockFatherSelfLoop(ref father);
setFatherEntities(ref father, dbContext);
_uriGenerator.SetFatherUris(ref father);
father.OrphansCount = await GetOrphansCount(Fid, dbContext);
father.WifeName = await(GetWifeName(father));
_logger.Information($"returned Father with id {Fid}");
return(father);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PoolConfig"/> class.
/// </summary>
/// <param name="config">The configuration.</param>
/// <param name="coinConfig"></param>
public PoolConfig(dynamic config, ICoinConfig coinConfig)
{
try
{
_logger = Log.ForContext<PoolConfig>().ForContext("Component", coinConfig.Name);
Enabled = config.enabled ? config.enabled : false;
if (Enabled == false) // if the configuration is not enabled
return; // just skip reading rest of the parameters.
// load the sections.
Coin = coinConfig; // assign the coin config.
Daemon = new DaemonConfig(config.daemon);
Meta = new MetaConfig(config.meta);
Wallet = new WalletConfig(config.wallet);
Rewards = new RewardsConfig(config.rewards);
Payments = new PaymentConfig(config.payments);
Miner = new MinerConfig(config.miner);
Job = new JobConfig(config.job);
Stratum = new StratumServerConfig(config.stratum);
Banning = new BanConfig(config.banning);
Storage = new StorageConfig(config.storage);
Getwork = new GetworkServerConfig(config.getwork);
// process extra checks
if (Storage.Layer is MposStorageConfig)
{
if (Payments.Enabled)
{
Payments.Disable();
_logger.Information("Disabled payment processor as it can not be enabled when MPOS mode is on");
}
}
Valid = true;
}
catch (Exception e)
{
Valid = false;
_logger.Error(e, "Error loading pool configuration");
}
}
public async Task StartAsync()
{
try
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Sentry(o =>
{
o.Dsn = new Dsn(Config.Bot.SentryDsn);
o.Environment = Config.Bot.Environment;
o.MinimumBreadcrumbLevel = LogEventLevel.Verbose;
o.MinimumEventLevel = LogEventLevel.Error;
o.SendDefaultPii = true;
o.AttachStacktrace = true;
})
.MinimumLevel.Verbose()
.WriteTo.File("logs/rabbot.log", rollingInterval: RollingInterval.Day)
.WriteTo.Console()
.CreateLogger();
var config = new DiscordSocketConfig
{
TotalShards = 1,
LogLevel = LogSeverity.Verbose,
MessageCacheSize = 1000,
ExclusiveBulkDelete = true
};
var services = new ServiceCollection()
.AddSingleton(_client = new DiscordShardedClient(config))
.AddSingleton(_commandService = new CommandService(new CommandServiceConfig
{
DefaultRunMode = RunMode.Async,
LogLevel = LogSeverity.Verbose,
CaseSensitiveCommands = false,
ThrowOnError = false
}))
.AddSingleton <TwitchService>()
.AddSingleton <YouTubeVideoService>()
.AddSingleton <CommandHandler>()
.AddSingleton <StartupService>()
.AddSingleton <AudioService>()
.AddSingleton <LoggingService>()
.AddSingleton <Logging>()
.AddSingleton <StreakService>()
.AddSingleton <AttackService>()
.AddSingleton <LevelService>()
.AddSingleton <MuteService>()
.AddSingleton <WarnService>()
.AddSingleton <EventService>()
.AddSingleton <ApiService>()
.AddSingleton <DiscordApiService>()
.AddSingleton <InteractiveService>()
.AddSingleton <EasterEventService>()
.AddSingleton <ImageService>()
.AddSingleton <CacheService>()
.AddSingleton <RuleAcceptService>()
.AddSingleton <Helper>();
//Add logging
ConfigureServices(services);
//Build services
var serviceProvider = services.BuildServiceProvider();
//Instantiate logger/tie-in logging
serviceProvider.GetRequiredService <LoggingService>();
// Run Migrations
var db = DatabaseService.Instance.Open();
_logger.Information($"Checking database={db.GetType().Name}...");
using (db)
{
if (db.Database.GetPendingMigrations().Any())
{
_logger.Information($"Applying database={db.GetType().Name} migrations...");
db.Database.Migrate();
}
else
{
_logger.Information($"{db.GetType().Name} is up2date!");
}
}
//Start the bot
await serviceProvider.GetRequiredService <StartupService>().StartAsync();
//Load up services
serviceProvider.GetRequiredService <CommandHandler>();
serviceProvider.GetRequiredService <TwitchService>();
serviceProvider.GetRequiredService <YouTubeVideoService>();
serviceProvider.GetRequiredService <StreakService>();
serviceProvider.GetRequiredService <AttackService>();
serviceProvider.GetRequiredService <LevelService>();
serviceProvider.GetRequiredService <Logging>();
serviceProvider.GetRequiredService <MuteService>();
serviceProvider.GetRequiredService <WarnService>();
serviceProvider.GetRequiredService <EventService>();
serviceProvider.GetRequiredService <ApiService>();
serviceProvider.GetRequiredService <EasterEventService>();
serviceProvider.GetRequiredService <ImageService>();
serviceProvider.GetRequiredService <CacheService>();
serviceProvider.GetRequiredService <RuleAcceptService>();
serviceProvider.GetRequiredService <Helper>();
new Task(() => RunConsoleCommand(), TaskCreationOptions.LongRunning).Start();
//Block this program until it is closed.
await Task.Delay(-1);
}
catch (Exception e)
{
_logger.Error(e, $"Error in {nameof(StartAsync)}");
Console.WriteLine($"Startup failed. Please check the config file.");
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
Environment.Exit(0);
}
}
void RenderToVSTS(ActivityElement element, ILogger log, string indent)
{
if (!IsPrintable(element))
return;
log.Information("{Indent:l} {Status:l}: {Name:l}", indent, element.Status, element.Name);
foreach (var logEntry in element.LogElements)
{
log.Information("{Category,-8:l}{Indent:l} {Message:l}", logEntry.Category, logEntry.MessageText);
}
foreach (var child in element.Children)
{
RenderToVSTS(child, log, indent + " ");
}
}
private void OnApplicationExit(object sender, EventArgs e)
{
FiddlerOptions.SaveProfile();
Map.SaveMapOverlays();
_logger.Information("UOFiddler - Application exit.");
}
public async Task <byte[]> ConvertToXlsx(IDictionary <string, IList <string> > data, CancellationToken cancellationToken)
{
return(await Task.Factory.StartNew(() =>
{
_logger.Information("trying to convert lists of data to xlsx file");
_logger.Information("trying to open Excel Work Book.");
ClosedXML.Excel.XLWorkbook wbook = new ClosedXML.Excel.XLWorkbook(ClosedXML.Excel.XLEventTracking.Disabled);
_logger.Information("trying to add Excel Work Sheet.");
var sheet = wbook.Worksheets.Add("sheet1");
int row = 1;
int col = 1;
int rowsCount = data[data.Keys.First()].Count;
int columnsCount = data.Keys.Count;
var keys = data.Keys.ToArray();
_logger.Information($"start printing data to excel file, ColumnsCount={columnsCount} . RowsCount={rowsCount}");
for (row = 1; row <= rowsCount + 1; row++)
{
for (col = 1; col <= columnsCount; col++)
{
string key = keys[col - 1];
var values = data[key];
if (row == 1)
{
//write the column header
sheet.Cell(1, col).Value = key;
}
else
{
sheet.Cell(row, col).Value = values[row - 2];
}
}
if (cancellationToken != null && cancellationToken.IsCancellationRequested)
{
_logger.Information($"the operation has broken, a cancellation request has been sent.");
break;
}
}
_logger.Information($"all data has been printed successfully to the excel file.");
sheet.ExpandColumns();
setHeaderStyle(sheet, 1, 1, 1, columnsCount);
setBorder(sheet, 2, 1, rowsCount + 1, columnsCount);
wbook.Author = "Orphanage Service V" + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
using (MemoryStream memoryStream = new MemoryStream())
{
wbook.SaveAs(memoryStream);
_logger.Information($"the excel file has been saved successfully, an array of bytes will be returned.");
return memoryStream.ToArray();
}
}));
}
/// <summary>
/// Create redirects table and SP for version number
/// </summary>
private static void Create()
{
bool create = true;
var dba = DataAccessBaseEx.GetWorker();
_log.Information("Create 404 handler redirects table START");
string createTableScript = @"CREATE TABLE [dbo].[BVN.NotFoundRequests](
[ID] [int] IDENTITY(1,1) NOT NULL,
[OldUrl] [nvarchar](2000) NOT NULL,
[Requested] [datetime] NULL,
[Referer] [nvarchar](2000) NULL
) ON [PRIMARY]";
create = dba.ExecuteNonQuery(createTableScript);
_log.Information("Create 404 handler redirects table END");
if (create)
{
_log.Information("Create 404 handler version SP START");
string versionSP = @"CREATE PROCEDURE [dbo].[bvn_notfoundversion] AS RETURN " + Configuration.Configuration.CURRENT_VERSION;
if (!dba.ExecuteNonQuery(versionSP))
{
create = false;
_log.Error("An error occured during the creation of the 404 handler version stored procedure. Canceling.");
}
_log.Information("Create 404 handler version SP END");
}
if (create)
{
_log.Information("Create Clustered index START");
string clusteredIndex =
"CREATE CLUSTERED INDEX NotFoundRequests_ID ON [dbo].[BVN.NotFoundRequests] (ID)";
if (!dba.ExecuteNonQuery(clusteredIndex))
{
create = false;
_log.Error("An error occurred during the creation of the 404 handler redirects clustered index. Canceling.");
}
_log.Information("Create Clustered index END");
}
Valid = create;
// copy dds items, if there are any.
try
{
// the old redirect class is obsolete, and should only be used for this upgrade
#pragma warning disable CS0618
var oldCustomrRedirectStore = DataStoreFactory.GetStore(typeof(FileNotFound.CustomRedirects.CustomRedirect));
var oldCustomRedirects = oldCustomrRedirectStore.Items <FileNotFound.CustomRedirects.CustomRedirect>().ToList();
#pragma warning restore CS0618
if (oldCustomRedirects.Count > 0)
{
var newCustomrRedirectStore = DataStoreFactory.GetStore(typeof(CustomRedirect));
DataStoreHandler dsHandler = new DataStoreHandler();
foreach (var oldCustomRedirect in oldCustomRedirects)
{
var newRedirect = new CustomRedirect(oldCustomRedirect.OldUrl, oldCustomRedirect.NewUrl, oldCustomRedirect.WildCardSkipAppend);
dsHandler.SaveCustomRedirect(newRedirect);
}
// oldCustomrRedirectStore.DeleteAll();
}
}
catch (Exception ex)
{
_log.Error("Error during DDS upgrade: " + ex);
}
}
public void LogInformation(ILogger log, string title, string content)
{
log.Information("userId: " + this.userId + ", sessionId:" + this.sessionId + "\n" + title + " " + content);
}
public Task Handle(MyEvent @event, EventContext eventContext)
{
_logger.Information("Processing event : '{Event}'", @event);
return(Task.CompletedTask);
}