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); } }