private uint GetHashCode(string str)
{
var hash32 = MurmurHash.Create32();
var bytes = hash32.ComputeHash(Encoding.UTF32.GetBytes(str));
return(BitConverter.ToUInt32(bytes));
}
private static long GetHash(string key)
{
var hashAlgorithm = MurmurHash.Create32(0);
var bytes = Encoding.UTF8.GetBytes(key);
return(BitConverter.ToUInt32(hashAlgorithm.ComputeHash(bytes, 0, bytes.Length), 0));
}
public static byte[] GetMurmurHashBytes(string str)
{
var hash = MurmurHash.Create32();
var bytes = hash.ComputeHash(Encoding.UTF8.GetBytes(str));
return(bytes);
}
/// <summary>
/// Constructs a <see cref="StringId"/> by hashing a string value.
/// </summary>
/// <param name="str">The string value.</param>
public StringId(string str)
{
// string_id values are just Murmur3_32 hashes
var murmur32 = MurmurHash.Create32(managed: false);
var hash = murmur32.ComputeHash(Encoding.UTF8.GetBytes(str));
Value = (uint)((hash[3] << 24) | (hash[2] << 16) | (hash[1] << 8) | hash[0]);
}
static string CalculatePartitionKey(int packetId)
{
const int PartitionCountModulusMask = 0xF;
byte[] hash = MurmurHash.Create32(0, true).ComputeHash(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(packetId))); // hash of big-endian value representation
return(PartitionKeys[hash[3] & PartitionCountModulusMask]);
}
/// <summary>
/// Get computed shard index
/// </summary>
/// <param name="key">Sharded identifier</param>
/// <param name="buckets">Total number of shards</param>
/// <returns>Index of a shard that is tied to the key</returns>
public Int32 GetShard(String key, Int32 buckets)
{
var murmur128 = MurmurHash.Create32(managed: false);
var data = murmur128.ComputeHash(Encoding.ASCII.GetBytes(key));
return(JumpConsistentHash(BitConverter.ToUInt32(data, 0), buckets));
}
protected override void Append(StringBuilder builder, LogEventInfo logEvent)
{
var murmur = MurmurHash.Create32();
var bytes = Encoding.UTF8.GetBytes(logEvent.Message);
var hash = murmur.ComputeHash(bytes);
var numericHash = BitConverter.ToUInt32(hash, 0);
builder.Append($"{numericHash:x8}");
}
public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
{
var murmurHash = MurmurHash.Create32();
var bytes = Encoding.UTF8.GetBytes(logEvent.MessageTemplate.Text);
var hash = murmurHash.ComputeHash(bytes);
var numericHash = BitConverter.ToUInt32(hash, 0);
var messageTemplateHashProperty = propertyFactory.CreateProperty("MessageTemplateHash", numericHash.ToString("x8"));
logEvent.AddPropertyIfAbsent(messageTemplateHashProperty);
}
/// <summary>
/// Hashes event code based on message to group event types.
/// </summary>
/// <param name="messageTemplate">Message Template to hash.</param>
/// <returns>The numeric hash (in hex) used to identify this event type.</returns>
/// <remarks>Hashing done based on Murmur, compatible with Seq event identification.</remarks>
public static string GetTemplateCode(this string messageTemplate)
{
using var murmur = MurmurHash.Create32();
var bytes = Encoding.UTF8.GetBytes(messageTemplate
?? throw new ArgumentNullException(nameof(messageTemplate)));
var hash = murmur.ComputeHash(bytes);
var numerichash = BitConverter.ToUInt32(hash, 0);
return($"${numerichash:X}");
}
public void Add(byte[] data)
{
for (var i = 0; i < HashCount; i++)
{
var seed = (uint)i * bip37Constant + Tweak;
var hash = BitConverter.ToUInt32(MurmurHash.Create32(seed).ComputeHash(data));
var bit = (int)(hash % bitCount);
bits[bit] = true;
}
}
public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
{
var murmur = MurmurHash.Create32();
var bytes = Encoding.UTF8.GetBytes(logEvent.MessageTemplate.Text);
var hash = murmur.ComputeHash(bytes);
var numericHash = BitConverter.ToUInt32(hash, 0);
var eventId = propertyFactory.CreateProperty("HashTag", numericHash);
logEvent.AddPropertyIfAbsent(eventId);
}
public long Hash(string key, int seed)
{
var unsignedSeed = (uint)seed;
HashAlgorithm hashAlgorithm = MurmurHash.Create32(unsignedSeed); // returns a managed 32-bit algorithm with seed
byte[] keyToBytes = Encoding.UTF8.GetBytes(key);
byte[] seedResult = hashAlgorithm.ComputeHash(keyToBytes, 0, keyToBytes.Length);
var result = BitConverter.ToUInt32(seedResult, 0);
return(result);
}
/// <summary>
/// Takes to string inputs concat them, produce a hashCode and return a normalized value between 0 and 100;
/// </summary>
public static int GetNormalizedNumber(string identifier, string groupId, int normalizer = 100)
{
const int one = 1;
const string separator = ":";
byte[] bytes = Encoding.UTF8.GetBytes(string.Concat(groupId, separator, identifier));
using (var algorithm = MurmurHash.Create32())
{
var hash = algorithm.ComputeHash(bytes);
var value = BitConverter.ToUInt32(hash, 0);
return((int)(value % normalizer + one));
}
}
public string CriarHash(string resource, uint seed = 128)
{
HashAlgorithm hashAlgorithm = MurmurHash.Create32(seed: seed);
byte[] computedHash = hashAlgorithm.ComputeHash(System.Text.Encoding.UTF8.GetBytes(resource));
StringBuilder sOutput = new StringBuilder(computedHash.Length);
for (var i = 0; i < computedHash.Length; i++)
{
sOutput.Append(computedHash[i].ToString("x2"));
}
return(sOutput.ToString());
}
public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
{
var builder = new StringBuilder(logEvent.MessageTemplate.Text);
for (var exception = logEvent.Exception; exception != null; exception = exception.InnerException)
{
builder.AppendLine(exception.GetType().AssemblyQualifiedName);
builder.AppendLine(exception.StackTrace);
}
var bytes = Encoding.UTF8.GetBytes(builder.ToString());
var hash = MurmurHash.Create32().ComputeHash(bytes);
var numericHash = BitConverter.ToUInt32(hash, 0);
logEvent.AddPropertyIfAbsent(
propertyFactory.CreateProperty("LogEventHash", numericHash.ToString("x8"))
);
}
/// <summary>
/// Verify if the last build of the container's metadata still match with the sql servers (application's connectionStrings).
/// </summary>
/// <param name="dispatcher">Query dispatcher</param>
/// <param name="proj">Project config</param>
/// <param name="container">Metadata container</param>
public static void VerifyIntegrityOfSqlMetadata(IQueryDispatcher dispatcher, ProjectContainer proj, ref MetadataContainer container)
{
if (dispatcher == null)
{
throw new ArgumentNullException(nameof(dispatcher));
}
if (proj == null)
{
throw new ArgumentNullException(nameof(proj));
}
if (proj.ConnectionStrings != null && !proj.ConnectionStrings.Any())
{
throw new NullReferenceException("ConnectionStrings");
}
var containerFileName = proj.Name + ".schema";
//Hash the connnectionStrings to see if it match the last build
var configData = new MemoryStream();
var bf = SerializationHelper.DefaultFormatter;
bf.Serialize(configData, proj.ConnectionStrings);
configData.Position = 0;
HashAlgorithm murmur = MurmurHash.Create32(managed: false);
var configHash = Encoding.Default.GetString(murmur.ComputeHash(configData));
//If in-memory container is good, we use it
if (container != null && container.ConfigFileHash == configHash)
{
return;
}
//If container on disk is good, we use it
container = TryLoadContainer(containerFileName, configHash);
if (container != null)
{
dispatcher.InitProviders(container.Metadatas, container.ConnectionStrings);
}
//We rebuild the container
else
{
container = BuildMetadata(dispatcher, containerFileName, proj.ConnectionStrings, configHash);
}
}
public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
{
if (logEvent == null)
{
throw new ArgumentNullException(nameof(logEvent));
}
if (propertyFactory == null)
{
throw new ArgumentNullException(nameof(propertyFactory));
}
Murmur32 murmur = MurmurHash.Create32();
byte[] bytes = Encoding.UTF8.GetBytes(logEvent.MessageTemplate.Text);
byte[] hash = murmur.ComputeHash(bytes);
string hexadecimalHash = BitConverter.ToString(hash).Replace("-", "");
LogEventProperty eventId = propertyFactory.CreateProperty("EventType", hexadecimalHash);
logEvent.AddPropertyIfAbsent(eventId);
}
public void UpdateCrc()
{
HashAlgorithm murmur = MurmurHash.Create32();
HashLookup[] lookups;
switch (Name)
{
case "main":
lookups = HashLookup.MainLookups;
break;
case "Villager0/personal":
lookups = HashLookup.PersonalLookups;
break;
case "Villager0/photo_studio_island":
lookups = HashLookup.PhotoStudioIslandLookups;
break;
case "Villager0/postbox":
lookups = HashLookup.PostboxLookups;
break;
case "Villager0/profile":
lookups = HashLookup.ProfileLookups;
break;
default:
Console.WriteLine($"{Name} not supported for updating hashes.");
return;
}
foreach (HashLookup lookup in lookups)
{
murmur.TransformFinalBlock(Data, lookup.Data, lookup.Length);
Console.WriteLine($"{murmur.Hash.ToHexString()} == {Data.Skip(lookup.Hash).Take(4).ToHexString()}");
}
}
public PercentageMurmur3Calculator()
{
_hashAlgorithm = MurmurHash.Create32();
}
public MurmurHashAlgorithmService()
{
_hashAlgorithm = MurmurHash.Create32();
}
public PercentageMurmur3Calculator(uint seed)
{
_hashAlgorithm = MurmurHash.Create32(seed: seed);
}
protected static uint Hash32(byte[] value)
{
var hashalg = MurmurHash.Create32(managed: false);
return(hashalg.ComputeHash32(value));
}
public Node(string name)
{
this.Name = name;
this.Murmur = MurmurHash.Create32();
this.Items = new List <Item>();
}
static string CalculatePartitionKey(string rowKey)
{
byte[] hash = MurmurHash.Create32(0, false).ComputeHash(Encoding.ASCII.GetBytes(rowKey));
return(PartitionKeys[hash[BitConverter.IsLittleEndian ? 0 : 3] & PartitionCountModulusMask]);
}
public Item(string name)
{
this.Name = name;
this.Murmur = MurmurHash.Create32();
}
public MURMUR3_32()
: base(HashType.MURMUR3_32, "murmur3-32", 4)
{
_factory = () => MurmurHash.Create32(managed: false);
}
/// <summary>
/// Verify if the last build of the container's metadata still match with the current cloning settings.
/// </summary>
/// <param name="dispatcher">Query dispatcher</param>
/// <param name="app">Application user config</param>
/// <param name="mapId">MapId</param>
/// <param name="behaviourId">BehaviourId</param>
/// <param name="container">Container</param>
public static void VerifyIntegrityWithSettings(IQueryDispatcher dispatcher, Settings settings, ref MetadataContainer container)
{
if (dispatcher == null)
{
throw new ArgumentNullException(nameof(dispatcher));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (settings.Project == null)
{
throw new ArgumentNullException(nameof(settings.Project));
}
if (String.IsNullOrWhiteSpace(settings.Project.Name))
{
throw new ArgumentException(nameof(settings.Project.Name));
}
if (settings.Project.ConnectionStrings != null &&
!settings.Project.ConnectionStrings.Any())
{
throw new NullReferenceException("settings.Project.ConnectionStrings");
}
var project = settings.Project;
var containerFileName = project.Name + "_";
Map map = null;
Behaviour clonerBehaviour = null;
//Hash the selected map, connnectionStrings and the cloner
//configuration to see if it match the lasted builded container
var configData = new MemoryStream();
var bf = SerializationHelper.DefaultFormatter;
bf.Serialize(configData, project.ConnectionStrings);
if (settings.MapId.HasValue)
{
map = settings.Project.Maps.FirstOrDefault(m => m.Id == settings.MapId);
if (map == null)
{
throw new Exception($"Map id '{settings.MapId}' not found in configuration file for application '{project.Name}'!");
}
containerFileName += map.From + "-" + map.To;
bf.Serialize(configData, map);
if (map.UsableBehaviours != null && map.UsableBehaviours.Split(',').ToList().Contains(settings.BehaviourId.ToString()))
{
clonerBehaviour = project.Behaviours.FirstOrDefault(c => c.Id == settings.BehaviourId);
if (clonerBehaviour == null)
{
throw new KeyNotFoundException(
$"There is no behaviour '{settings.BehaviourId}' in the configuration for the appName name '{project.Name}'.");
}
bf.Serialize(configData, clonerBehaviour);
bf.Serialize(configData, project.Templates);
}
}
else
{
containerFileName += "defaultMap";
}
if (settings.BehaviourId != null)
{
containerFileName += "_" + settings.BehaviourId;
}
containerFileName += ".cache";
//Hash user config
configData.Position = 0;
var murmur = MurmurHash.Create32(managed: false);
var configHash = Encoding.Default.GetString(murmur.ComputeHash(configData));
//If in-memory container is good, we use it
if (container != null && container.ConfigFileHash == configHash)
{
return;
}
if (!settings.UseInMemoryCacheOnly)
{
//If container on disk is good, we use it
container = TryLoadContainer(containerFileName, configHash);
if (container != null)
{
dispatcher.InitProviders(container.Metadatas, container.ConnectionStrings);
return;
}
}
//We rebuild the container
container = BuildMetadataWithSettings(dispatcher, containerFileName, project, clonerBehaviour, map, configHash);
//Persist container
if (!settings.UseInMemoryCacheOnly)
{
container.Save(containerFileName);
}
}
