public DefaultUrlManager(IOptions<SmidgeOptions> options, ISmidgeConfig config, IHasher hasher, IUrlHelper urlHelper)
{
_hasher = hasher;
_urlHelper = urlHelper;
_options = options.Value.UrlOptions;
_config = config;
}
public CSSAssetsFileHasher(string hashQueryStringKeyName, IResolver fileResolver, IHasher hasher, IPathTranslator pathTranslator)
{
HashQueryStringKeyName = hashQueryStringKeyName;
FileSystemResolver = fileResolver;
Hasher = hasher;
this.pathTranslator = pathTranslator;
}
public ReadIndex(IPublisher bus,
int readerCount,
Func<ITransactionFileSequentialReader> seqReaderFactory,
Func<ITransactionFileReader> readerFactory,
ITableIndex tableIndex,
IHasher hasher,
ILRUCache<string, StreamCacheInfo> streamInfoCache)
{
Ensure.NotNull(bus, "bus");
Ensure.Positive(readerCount, "readerCount");
Ensure.NotNull(seqReaderFactory, "seqReaderFactory");
Ensure.NotNull(readerFactory, "readerFactory");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(hasher, "hasher");
Ensure.NotNull(streamInfoCache, "streamInfoCache");
_bus = bus;
_tableIndex = tableIndex;
_hasher = hasher;
_streamInfoCache = streamInfoCache;
for (int i = 0; i < readerCount; ++i)
{
_seqReaders.Push(seqReaderFactory());
_readers.Push(readerFactory());
}
}
public RetryableFileWriter(int bufferSize, IRetryableFileOpener retryableFileOpener, IHasher hasher)
{
BufferSize = bufferSize;
RetryableFileOpener = retryableFileOpener;
Hasher = hasher;
_encoding = Encoding.UTF8;
}
public PaymentManager(IOrderFacade orderFacade, IHasher hasher, IResultParser resultParser, IPayExSettings payExSettings)
{
_orderFacade = orderFacade;
_hasher = hasher;
_resultParser = resultParser;
_payExSettings = payExSettings;
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_indexDir = PathName;
var fakeReader = new TFReaderLease(new FakeTfReader());
_lowHasher = new XXHashUnsafe();
_highHasher = new Murmur3AUnsafe();
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(_ptableVersion, maxSize: 10),
() => fakeReader,
_ptableVersion,
maxSizeForMemory: 5);
_tableIndex.Initialize(long.MaxValue);
_tableIndex.Add(0, "0xDEAD", 0, 0xFF00);
_tableIndex.Add(0, "0xDEAD", 1, 0xFF01);
_tableIndex.Add(0, "0xBEEF", 0, 0xFF00);
_tableIndex.Add(0, "0xBEEF", 1, 0xFF01);
_tableIndex.Add(0, "0xABBA", 0, 0xFF00); // 1st ptable0
_tableIndex.Add(0, "0xABBA", 1, 0xFF01);
_tableIndex.Add(0, "0xABBA", 2, 0xFF02);
_tableIndex.Add(0, "0xABBA", 3, 0xFF03);
_tableIndex.Add(0, "0xADA", 0, 0xFF00); // simulates duplicate due to concurrency in TableIndex (see memtable below)
_tableIndex.Add(0, "0xDEAD", 0, 0xFF10); // 2nd ptable0
_tableIndex.Add(0, "0xDEAD", 1, 0xFF11); // in memtable
_tableIndex.Add(0, "0xADA", 0, 0xFF00); // in memtable
}
public Key(string value, IHasher hasher)
{
this.Value = value;
this.bytes = hasher.GetBytes(string.Format("{0}_{1}_{2}",
value, Common.Properties.SqlServer, Common.Properties.SqlDatabase));
this.Hash = BitConverter.ToString(this.bytes).Replace("-", ""); ;
}
public RetryableFileWriter(int bufferSize, Encoding encoding, IRetryableFileOpener retryableFileOpener, IHasher hasher)
{
BufferSize = bufferSize;
Encoding = encoding;
RetryableFileOpener = retryableFileOpener;
Hasher = hasher;
}
public void TestFixtureSetUp()
{
hasher = new SHA1Hasher();
instances = new MemcachedInstances(100, Common.Properties.MainCacheServerIPEndPoints);
mc = new MemcachedClient(instances, hasher);
}
public ReadIndex(IPublisher bus,
int initialReaderCount,
int maxReaderCount,
Func<ITransactionFileReader> readerFactory,
ITableIndex tableIndex,
IHasher hasher,
ILRUCache<string, StreamCacheInfo> streamInfoCache,
bool additionalCommitChecks,
int metastreamMaxCount)
{
Ensure.NotNull(bus, "bus");
Ensure.Positive(initialReaderCount, "initialReaderCount");
Ensure.Positive(maxReaderCount, "maxReaderCount");
if (initialReaderCount > maxReaderCount)
throw new ArgumentOutOfRangeException("initialReaderCount", "initialReaderCount is greater than maxReaderCount.");
Ensure.NotNull(readerFactory, "readerFactory");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(hasher, "hasher");
Ensure.NotNull(streamInfoCache, "streamInfoCache");
Ensure.Positive(metastreamMaxCount, "metastreamMaxCount");
_tableIndex = tableIndex;
_hasher = hasher;
_bus = bus;
_streamInfoCache = streamInfoCache;
_readers = new ObjectPool<ITransactionFileReader>("ReadIndex readers pool", initialReaderCount, maxReaderCount, readerFactory);
_additionalCommitChecks = additionalCommitChecks;
_metastreamMetadata = new StreamMetadata(metastreamMaxCount, null, null, null);
}
public EmbeddedResourceEntityResponder(ICacheManager cacheManager, IMimeTyper mimeTyper, IHasher hasher, long maxFileSizeToServe, int bufferSize, MimeSettingProvider mimeSettingProvider, Assembly assembly, string resourcePath)
{
_assembly = assembly;
_resourcePath = resourcePath;
ResourcePath = string.Format("{0}.{1}", assembly.GetName().Name, resourcePath.Replace("/", "."));
ResourceExtension = Path.GetExtension(ResourcePath);
var version = _assembly.GetName().Version;
ResourceLastModified = new DateTime(2000, 1, 1)
.AddDays(version.Build)
.AddSeconds(version.Revision * 2)
.ToUniversalTime();
using (var bodyStream = assembly.GetManifestResourceStream(ResourcePath))
{
if (bodyStream != null)
{
ResourceSize = (int)bodyStream.Length;
}
}
MimeSetting = mimeSettingProvider.GetSetting(ResourceExtension.ToLower());
BufferSize = bufferSize;
MaxFileSizeToServe = maxFileSizeToServe;
Hasher = hasher;
MimeTyper = mimeTyper;
CacheManager = cacheManager;
}
public CssControl()
{
QuerystringKeyName = CurrentCrusherConfiguration.Current.QuerystringKeyName;
CssGroups = CurrentCrusherConfiguration.Current.CssGroups;
RetryableFileOpener = new RetryableFileOpener();
Hasher = new Hasher(RetryableFileOpener);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_lowHasher = new XXHashUnsafe();
_highHasher = new Murmur3AUnsafe();
_tableIndex = new TableIndex(PathName, _lowHasher, _highHasher,
() => new HashListMemTable(version: _ptableVersion, maxSize: 40),
() => { throw new InvalidOperationException(); },
_ptableVersion,
maxSizeForMemory: 20);
_tableIndex.Initialize(long.MaxValue);
_tableIndex.Add(0, "0xDEAD", 0, 0xFF00);
_tableIndex.Add(0, "0xDEAD", 1, 0xFF01);
_tableIndex.Add(0, "0xJEEP", 0, 0xFF00);
_tableIndex.Add(0, "0xJEEP", 1, 0xFF01);
_tableIndex.Add(0, "0xABBA", 0, 0xFF00);
_tableIndex.Add(0, "0xABBA", 1, 0xFF01);
_tableIndex.Add(0, "0xABBA", 2, 0xFF02);
_tableIndex.Add(0, "0xABBA", 3, 0xFF03);
_tableIndex.Add(0, "0xDEAD", 0, 0xFF10);
_tableIndex.Add(0, "0xDEAD", 1, 0xFF11);
_tableIndex.Add(0, "0xADA", 0, 0xFF00);
}
public VerificationManager(IVerificationFacade verificationFacade, IHasher hasher, IResultParser resultParser, IPayExSettings payExSettings)
{
_verificationFacade = verificationFacade;
_hasher = hasher;
_resultParser = resultParser;
_payExSettings = payExSettings;
}
protected BundleBase(IFileWriterFactory fileWriterFactory, IFileReaderFactory fileReaderFactory, IDebugStatusReader debugStatusReader, ICurrentDirectoryWrapper currentDirectoryWrapper, IHasher hasher)
{
this.fileWriterFactory = fileWriterFactory;
this.fileReaderFactory = fileReaderFactory;
this.debugStatusReader = debugStatusReader;
this.currentDirectoryWrapper = currentDirectoryWrapper;
this.hasher = hasher;
}
private StaticFileManager()
{
_retryableFileOpener = new RetryableFileOpener();
_mimeTyper = new MimeTyper();
_hasher = new Hasher(_retryableFileOpener);
_httpRequestHeaderHelper = new HttpRequestHeaderHelper();
_fileEntitySettingProvider = new FileEntitySettingProvider();
}
//----------------------------------------------------------------------------
// Basic sanity checks:
// - A hash function should not be reading outside the bounds of the key.
// - Flipping a bit of a key should, with overwhelmingly high probability, result in a different hash.
// - Hashing the same key twice should always produce the same result.
// - The memory alignment of the key should not affect the hash result.
public static bool SanityTest(IHasher hasher)
{
var rnd = new Random(883741);
bool result = true;
const int reps = 10;
const int keymax = 256;
const int pad = 16;
const int buflen = keymax + pad*3;
byte[] buffer1 = new byte[buflen];
byte[] buffer2 = new byte[buflen];
//----------
for (int irep = 0; irep < reps; irep++)
{
if (irep % (reps/10) == 0) Console.Write(".");
for (int len = 4; len <= keymax; len++)
{
for(int offset = pad; offset < pad*2; offset++)
{
// byte* key1 = &buffer1[pad];
// byte* key2 = &buffer2[pad+offset];
rnd.NextBytes(buffer1);
rnd.NextBytes(buffer2);
//memcpy(key2, key1, len);
Buffer.BlockCopy(buffer2, pad + offset, buffer1, pad, len);
// hash1 = hash(key1, len, 0)
var hash1 = hasher.Hash(buffer1, pad, (uint)len, 0);
for(int bit = 0; bit < (len * 8); bit++)
{
// Flip a bit, hash the key -> we should get a different result.
//Flipbit(key2,len,bit);
Flipbit(buffer2, pad + offset, len, bit);
var hash2 = hasher.Hash(buffer2, pad + offset, (uint)len, 0);
if (hash1 == hash2)
result = false;
// Flip it back, hash again -> we should get the original result.
//flipbit(key2,len,bit);
Flipbit(buffer2, pad + offset, len, bit);
//hash(key2, len, 0, hash2);
hash2 = hasher.Hash(buffer2, pad + offset, (uint)len, 0);
if (hash1 != hash2)
result = false;
}
}
}
}
return result;
}
private CrusherHelper()
{
CacheManager = new HttpCacheManager();
QuerystringKeyName = CurrentCrusherConfiguration.Current.QuerystringKeyName;
CssGroups = CurrentCrusherConfiguration.Current.CssGroups;
JsGroups = CurrentCrusherConfiguration.Current.JsGroups;
RetryableFileOpener = new RetryableFileOpener();
Hasher = new Hasher(RetryableFileOpener);
}
/// <summary>
/// ctor the Mighty
/// </summary>
public DefaultOAuthService(IFacebookConnectService facebookService, IBrewgrRepository repository, IHasher hasher, IUserService userService)
{
this.FacebookService = facebookService;
this.Repository = repository;
this.Hasher = hasher;
this.UserService = userService;
Mapper.CreateMap<OAuthUserInfo, User>();
}
public IndexCommitter(IPublisher bus, IIndexBackend backend, IIndexReader indexReader,
ITableIndex tableIndex, IHasher hasher, bool additionalCommitChecks)
{
_bus = bus;
_backend = backend;
_indexReader = indexReader;
_tableIndex = tableIndex;
_hasher = hasher;
_additionalCommitChecks = additionalCommitChecks;
}
private StaticFileManager()
{
_cacheManager = new HttpCacheManager();
_retryableFileOpener = new RetryableFileOpener();
_mimeTyper = new MimeTyper(_cacheManager);
_hasher = new Md5Hasher(_retryableFileOpener);
_embeddedResourceLoader = new EmbeddedResourceLoader();
_httpRequestHeaderHelper = new HttpRequestHeaderHelper();
_mimeSettingProvider = new MimeSettingProvider();
}
public FileEntity(IRetryableFileOpener retryableFileOpener, IMimeTyper mimeTyper, IHasher hasher, long maxFileSizeToServe, int bufferSize, FileInfo fileInfo, FileEntitySetting fileEntitySetting)
{
RetryableFileOpener = retryableFileOpener;
MimeTyper = mimeTyper;
Hasher = hasher;
BufferSize = bufferSize;
MaxFileSizeToServe = maxFileSizeToServe;
FileInfo = fileInfo;
FileEntitySetting = fileEntitySetting;
}
public FileEntityResponder(ICacheManager cacheManager, IRetryableFileOpener retryableFileOpener, IMimeTyper mimeTyper, IHasher hasher, long maxFileSizeToServe, int bufferSize, MimeSettingProvider mimeSettingProvider, FileInfo fileInfo)
{
CacheManager = cacheManager;
RetryableFileOpener = retryableFileOpener;
MimeTyper = mimeTyper;
Hasher = hasher;
BufferSize = bufferSize;
MaxFileSizeToServe = maxFileSizeToServe;
FileInfo = fileInfo;
MimeSetting = mimeSettingProvider.GetSetting(fileInfo);
}
public TestHarnessBuilder(
IReferenceProcessor referenceProcessor,
IFileSystemWrapper fileSystem,
IFileProbe fileProbe,
IHasher hasher)
{
this.referenceProcessor = referenceProcessor;
this.fileSystem = fileSystem;
this.fileProbe = fileProbe;
this.hasher = hasher;
}
public AccountValidatorTests()
{
context = new TestingContext();
hasher = Substitute.For<IHasher>();
hasher.VerifyPassword(Arg.Any<String>(), Arg.Any<String>()).Returns(true);
validator = new AccountValidator(new UnitOfWork(context), hasher);
validator.ModelState = new ModelStateDictionary();
TearDownData();
SetUpData();
}
public AccountValidatorTests()
{
context = new TestingContext();
hasher = Substitute.For<IHasher>();
hasher.VerifyPassword(Arg.Any<String>(), Arg.Any<String>()).Returns(true);
context.DropData();
SetUpData();
validator = new AccountValidator(new UnitOfWork(context), hasher);
validator.CurrentAccountId = account.Id;
}
public IndexReader(IIndexBackend backend, IHasher hasher, ITableIndex tableIndex, StreamMetadata metastreamMetadata)
{
Ensure.NotNull(backend, "backend");
Ensure.NotNull(hasher, "hasher");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(metastreamMetadata, "metastreamMetadata");
_backend = backend;
_hasher = hasher;
_tableIndex = tableIndex;
_metastreamMetadata = metastreamMetadata;
}
public IndexReader(IIndexCache cache, IHasher hasher, ITableIndex tableIndex, StreamMetadata metastreamMetadata)
{
Ensure.NotNull(cache, "backend");
Ensure.NotNull(hasher, "hasher");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(metastreamMetadata, "metastreamMetadata");
_cache = cache;
_hasher = hasher;
_tableIndex = tableIndex;
_metastreamMetadata = metastreamMetadata;
}
public AccountServiceTests()
{
context = TestingContext.Create();
hasher = Substitute.For <IHasher>();
httpContext = new DefaultHttpContext();
service = new AccountService(new UnitOfWork(TestingContext.Create()), hasher);
hasher.HashPassword(Arg.Any <String>()).Returns(info => $"{info.Arg<String>()}Hashed");
context.Drop().Add(account = ObjectsFactory.CreateAccount(0));
context.SaveChanges();
service.CurrentAccountId = account.Id;
}
public TestHarnessBuilder(
IReferenceProcessor referenceProcessor,
IFileSystemWrapper fileSystem,
IFileProbe fileProbe,
IHasher hasher,
IUrlBuilder urlBuilder)
{
this.urlBuilder = urlBuilder;
this.referenceProcessor = referenceProcessor;
this.fileSystem = fileSystem;
this.fileProbe = fileProbe;
this.hasher = hasher;
}
/// <summary>
/// Initializes a new instance of the <see cref="FileSystemScriptProvider" /> class.
/// </summary>
/// <param name="directoryPath">Path to SQL upgrade scripts</param>
/// <param name="options">Different options for the file system script provider</param>
/// <param name="sqlScriptOptions">The sql script options</param>
/// <param name="hasher">The hasher.</param>
/// <exception cref="ArgumentNullException">options</exception>
public FileSystemScriptProvider(string directoryPath, FileSystemScriptOptions options, SqlScriptOptions sqlScriptOptions, IHasher hasher)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
this.directoryPath = directoryPath;
this.filter = options.Filter;
this.encoding = options.Encoding;
this.options = options;
this.sqlScriptOptions = sqlScriptOptions;
this.hasher = hasher;
}
public AccountServiceTests()
{
context = new TestingContext();
hasher = Substitute.For<IHasher>();
hasher.HashPassword(Arg.Any<String>()).Returns(info => info.Arg<String>() + "Hashed");
context.DropData();
SetUpData();
Authorization.Provider = Substitute.For<IAuthorizationProvider>();
service = new AccountService(new UnitOfWork(context), hasher);
service.CurrentAccountId = account.Id;
}
public AccountServiceTests()
{
context = new TestingContext();
hasher = Substitute.For <IHasher>();
authorizationProvider = Substitute.For <IAuthorizationProvider>();
hasher.HashPassword(Arg.Any <String>()).Returns(info => info.Arg <String>() + "Hashed");
context.DropData();
SetUpData();
service = new AccountService(new UnitOfWork(context), hasher, authorizationProvider);
service.CurrentAccountId = account.Id;
}
public TFChunkScavenger(TFChunkDb db, ITableIndex tableIndex, IHasher hasher, IReadIndex readIndex, long?maxChunkDataSize = null)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(hasher, "hasher");
Ensure.NotNull(readIndex, "readIndex");
_db = db;
_tableIndex = tableIndex;
_hasher = hasher;
_readIndex = readIndex;
_maxChunkDataSize = maxChunkDataSize ?? db.Config.ChunkSize;
}
public TFChunkScavenger(TFChunkDb db, ITableIndex tableIndex, IHasher hasher, IReadIndex readIndex, long? maxChunkDataSize = null)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(hasher, "hasher");
Ensure.NotNull(readIndex, "readIndex");
_db = db;
_tableIndex = tableIndex;
_hasher = hasher;
_readIndex = readIndex;
_maxChunkDataSize = maxChunkDataSize ?? db.Config.ChunkSize;
}
public override async Task TestFixtureSetUp() {
await base.TestFixtureSetUp();
_indexDir = PathName;
var fakeReader = new TFReaderLease(new FakeIndexReader());
_lowHasher = new XXHashUnsafe();
_highHasher = new Murmur3AUnsafe();
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(PTableVersions.IndexV1, maxSize: 5),
() => fakeReader,
PTableVersions.IndexV1,
5, Constants.PTableMaxReaderCountDefault,
maxSizeForMemory: 5 + _extraStreamHashesAtBeginning + _extraStreamHashesAtEnd,
maxTablesPerLevel: 2);
_tableIndex.Initialize(long.MaxValue);
Assert.Greater(_lowHasher.Hash("abcd"), _lowHasher.Hash("LPN-FC002_LPK51001"));
for (int i = 0; i < _extraStreamHashesAtBeginning; i++) {
_tableIndex.Add(1, "abcd", i, i + 1);
}
Assert.Less(_lowHasher.Hash("wxyz"), _lowHasher.Hash("LPN-FC002_LPK51001"));
for (int i = 0; i < _extraStreamHashesAtEnd; i++) {
_tableIndex.Add(1, "wxyz", i, i + 1);
}
_tableIndex.Add(1, "LPN-FC002_LPK51001", 0, 1);
_tableIndex.Add(1, "account--696193173", 0, 2);
_tableIndex.Add(1, "LPN-FC002_LPK51001", 1, 3);
_tableIndex.Add(1, "account--696193173", 1, 4);
_tableIndex.Add(1, "LPN-FC002_LPK51001", 2, 5);
_tableIndex.Close(false);
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(_ptableVersion, maxSize: 5),
() => fakeReader,
_ptableVersion,
5, Constants.PTableMaxReaderCountDefault,
maxSizeForMemory: 5,
maxTablesPerLevel: 2);
_tableIndex.Initialize(long.MaxValue);
_tableIndex.Add(1, "account--696193173", 2, 6);
_tableIndex.Add(1, "LPN-FC002_LPK51001", 3, 7);
_tableIndex.Add(1, "account--696193173", 3, 8);
_tableIndex.Add(1, "LPN-FC002_LPK51001", 4, 9);
_tableIndex.Add(1, "account--696193173", 4, 10);
await Task.Delay(500);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_indexDir = PathName;
var fakeReader = new TFReaderLease(new FakeIndexReader());
int readerCount = 0;
_lowHasher = new XXHashUnsafe();
_highHasher = new Murmur3AUnsafe();
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
() =>
{
readerCount++;
if (readerCount < 4) // One for each table add.
{
return(fakeReader);
}
throw new Exception("Expected exception");
},
PTableVersions.IndexV4,
maxSizeForMemory: 2,
maxTablesPerLevel: 5);
_tableIndex.Initialize(long.MaxValue);
_tableIndex.Add(1, "testStream-1", 0, 0);
_tableIndex.Add(1, "testStream-1", 1, 100);
_tableIndex.Add(1, "testStream-1", 2, 200);
_tableIndex.Add(1, "testStream-1", 3, 300);
_tableIndex.Add(1, "testStream-1", 4, 400);
_tableIndex.Add(1, "testStream-1", 5, 500);
_log = new FakeTFScavengerLog();
Assert.That(() => _tableIndex.Scavenge(_log, CancellationToken.None), Throws.Exception.With.Message.EqualTo("Expected exception"));
// Check it's loadable still.
_tableIndex.Close(false);
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
() => fakeReader,
PTableVersions.IndexV4,
maxSizeForMemory: 2,
maxTablesPerLevel: 5);
_tableIndex.Initialize(long.MaxValue);
}
private CrusherManager()
{
_crusherConfiguration = CurrentCrusherConfiguration.Current;
_retryableFileOpener = new RetryableFileOpener();
_hasher = new Md5Hasher(_retryableFileOpener);
_retryableFileWriter = new RetryableFileWriter(BufferSize, _encoding, _retryableFileOpener, _hasher);
_pathProvider = new PathProvider();
_cacheManager = new HttpCacheManager();
_fileMetaData = new MultiFileMetaData(_retryableFileOpener, _retryableFileWriter);
InitManager();
}
public static string Hash([NotNull] this IHasher hasher, [NotNull] string content)
{
if (hasher == null)
{
throw new ArgumentNullException(nameof(hasher));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
return(hasher.Hash(Encoding.UTF8.GetBytes(content.Normalize())));
}
public IdentityService(UserManager <ApplicationUser> userManager, RoleManager <ApplicationRole> roleManger, IHasher hasher, ITokenHandler tokenHandler, IMessagerService messager, IStringLocalizer <SharedResources> localizer, IUnitOfWork unitOfWork, IUserDetectionService userDetectionService, IMapper mapper, IHostEnvironment _environment, ILogger <IdentityService> logger)
{
this.userManager = userManager;
this.roleManger = roleManger;
this.hasher = hasher;
this.tokenHandler = tokenHandler;
this.messager = messager;
this.localizer = localizer;
this.unitOfWork = unitOfWork;
this.userDetectionService = userDetectionService;
this.mapper = mapper;
this.environment = _environment;
this.logger = logger;
}
table_index_when_merging_upgrading_to_64bit_if_single_stream_entry_doesnt_exist_drops_entry_and_carries_on(
IHasher <TStreamId> lowHasher,
IHasher <TStreamId> highHasher,
TStreamId streamId1,
TStreamId streamId2,
TStreamId streamId3)
{
_ptableVersion = PTableVersions.IndexV2;
_lowHasher = lowHasher;
_highHasher = highHasher;
_streamId1 = streamId1;
_streamId2 = streamId2;
_streamId3 = streamId3;
}
public IndexWriter(IPublisher bus, ITableIndex tableIndex, IHasher hasher, IIndexCache indexCache, IIndexReader indexReader, bool additionalCommitChecks)
{
Ensure.NotNull(indexCache, "indexBackend");
Ensure.NotNull(indexReader, "indexReader");
Ensure.NotNull(bus, "bus");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(hasher, "hasher");
_bus = bus;
_tableIndex = tableIndex;
_hasher = hasher;
_indexCache = indexCache;
_indexReader = indexReader;
_additionalCommitChecks = additionalCommitChecks;
}
public EntryPointPacketHandler(IDao <CharacterDto, long> characterDao,
IDao <AccountDto, long> accountDao,
IDao <MateDto, long> mateDao, ILogger logger, IAuthHttpClient authHttpClient,
IConnectedAccountHttpClient connectedAccountHttpClient,
IChannelHttpClient channelHttpClient, IHasher hasher)
{
_characterDao = characterDao;
_accountDao = accountDao;
_mateDao = mateDao;
_logger = logger;
_authHttpClient = authHttpClient;
_connectedAccountHttpClient = connectedAccountHttpClient;
_channelHttpClient = channelHttpClient;
}
public void HashingMethods_ProducesValidHashFor_Array(IHasher hashFunc)
{
var sourceNames = new[]
{
"basic_sprite",
"audio",
"prefabs",
"shaderwithcollection",
"multi_sprite_packed"
};
// Use (object) cast so Calculate doesn't expand the array and use params object[] objects case
Assert.AreEqual(TestResults[hashFunc.HashType()][(int)TestIndex.Array], hashFunc.Calculate((object)sourceNames).ToString());
}
public void HashingMethods_ProducesValidHashFor_UnicodeStrings(IHasher hashFunc)
{
// It might not look it at first glance, but the below 2 strings are indeed different!
// The ASCII byte representation of both of these strings is identical, which was causing
// hashing methods to return identical hashes as we had used ASCII for everything.
string str1 = "[기본]양손무기";
string str2 = "[기본]한손무기";
RawHash hash1 = hashFunc.Calculate(str1);
RawHash hash2 = hashFunc.Calculate(str2);
Assert.AreNotEqual(str1, str2);
Assert.AreNotEqual(hash1, hash2);
Assert.AreEqual(TestResults[hashFunc.HashType()][(int)TestIndex.Unicode], hash1.ToString());
}
public TableIndex(string directory,
IHasher lowHasher,
IHasher highHasher,
Func <IMemTable> memTableFactory,
Func <TFReaderLease> tfReaderFactory,
byte ptableVersion,
int maxSizeForMemory = 1000000,
int maxTablesPerLevel = 4,
bool additionalReclaim = false,
bool inMem = false,
bool skipIndexVerify = false,
int indexCacheDepth = 16,
int initializationThreads = 1)
{
Ensure.NotNullOrEmpty(directory, "directory");
Ensure.NotNull(memTableFactory, "memTableFactory");
Ensure.NotNull(lowHasher, "lowHasher");
Ensure.NotNull(highHasher, "highHasher");
Ensure.NotNull(tfReaderFactory, "tfReaderFactory");
Ensure.Positive(initializationThreads, "initializationThreads");
if (maxTablesPerLevel <= 1)
{
throw new ArgumentOutOfRangeException("maxTablesPerLevel");
}
if (indexCacheDepth > 28 || indexCacheDepth < 8)
{
throw new ArgumentOutOfRangeException("indexCacheDepth");
}
_directory = directory;
_memTableFactory = memTableFactory;
_tfReaderFactory = tfReaderFactory;
_fileNameProvider = new GuidFilenameProvider(directory);
_maxSizeForMemory = maxSizeForMemory;
_maxTablesPerLevel = maxTablesPerLevel;
_additionalReclaim = additionalReclaim;
_inMem = inMem;
_skipIndexVerify = ShouldForceIndexVerify() ? false: skipIndexVerify;
_indexCacheDepth = indexCacheDepth;
_initializationThreads = initializationThreads;
_ptableVersion = ptableVersion;
_awaitingMemTables = new List <TableItem> {
new TableItem(_memTableFactory(), -1, -1)
};
_lowHasher = lowHasher;
_highHasher = highHasher;
}
public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
_indexDir = PathName;
var cancellationTokenSource = new CancellationTokenSource();
var fakeReader = new TFReaderLease(new FakeIndexReader(l => {
cancellationTokenSource.Cancel();
return(true);
}));
_lowHasher = new XXHashUnsafe();
_highHasher = new Murmur3AUnsafe();
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
() => fakeReader,
PTableVersions.IndexV4,
5, Constants.PTableMaxReaderCountDefault,
maxSizeForMemory: 2,
maxTablesPerLevel: 5);
_tableIndex.Initialize(long.MaxValue);
_tableIndex.Add(1, "testStream-1", 0, 0);
_tableIndex.Add(1, "testStream-1", 1, 100);
_tableIndex.Add(1, "testStream-1", 2, 200);
_tableIndex.Add(1, "testStream-1", 3, 300);
_tableIndex.Add(1, "testStream-1", 4, 400);
_tableIndex.Add(1, "testStream-1", 5, 500);
_log = new FakeTFScavengerLog();
Assert.That(() => _tableIndex.Scavenge(_log, cancellationTokenSource.Token),
Throws.InstanceOf <OperationCanceledException>());
// Check it's loadable still.
_tableIndex.Close(false);
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
() => fakeReader,
PTableVersions.IndexV4,
5, Constants.PTableMaxReaderCountDefault,
maxSizeForMemory: 2,
maxTablesPerLevel: 5);
_tableIndex.Initialize(long.MaxValue);
}
public AuthService(
IMongoManager mongoManager,
ILogger <AuthService> logger,
IHasher hasher,
IJwtSigningEncodingKey signingEncodingKey,
IJwtEncryptingEncodingKey encryptingEncodingKey
)
{
_mongoManager = mongoManager;
_logger = logger;
_hasher = hasher;
_signingEncodingKey = signingEncodingKey;
_encryptingEncodingKey = encryptingEncodingKey;
}
public DataImporter(IImportRepository importRepo, IHasher hasher, IEncryptor encryptor)
: base(hasher, encryptor)
{
this.IsDisposed = false;
ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings["PrismDatabase"];
HibernateUtil.Initialize(settings.ConnectionString, true);
this.importRepo = Program.Kernel.Get <IImportRepository>();
progressMessage = Program.LanguageManager.GetString(StringResources.Import_Progress_Message_Counter) + " {0} / {1} " + ". " +
Program.LanguageManager.GetString(StringResources.Import_Progress_Message_Type) + " {2}";
currentStation = (importRepo.ProjectRepo.GetSingle()).WorkstationType;
}
public IdentityService(IUserRepository userRepository,
IHasher hasher,
IJwtHandler jwtHandler,
IRefreshTokenRepository refreshTokenRepository,
IUserFactory userFactory,
IEventDispatcher eventDispatcher)
{
_userRepository = userRepository;
_hasher = hasher;
_jwtHandler = jwtHandler;
_refreshTokenRepository = refreshTokenRepository;
_userFactory = userFactory;
_eventDispatcher = eventDispatcher;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="env"></param>
/// <param name="config"></param>
/// <param name="fileSystemHelper"></param>
/// <param name="hasher"></param>
/// <param name="bundleManager"></param>
/// <param name="urlManager"></param>
public SmidgeController(
IApplicationEnvironment env,
ISmidgeConfig config,
FileSystemHelper fileSystemHelper,
IHasher hasher,
BundleManager bundleManager,
IUrlManager urlManager)
{
_urlManager = urlManager;
_hasher = hasher;
_env = env;
_config = config;
_fileSystemHelper = fileSystemHelper;
_bundleManager = bundleManager;
}
public Scheduler(int jobParallelism, IItemCache itemCache, bool rejectCachedFailures)
{
targets = new HashSet <BuildObject>();
waitIndex = new WaitIndex();
nuObjContents = BuildEngine.theEngine.getNuObjContents();
resultCache = new ResultCache(itemCache, nuObjContents);
unrecordableFailures = new Dictionary <IVerb, Disposition>();
this.hasher = BuildEngine.theEngine.getHasher();
verbToposorter = new VerbToposorter(hasher);
asyncRunner = new AsyncRunner(verbToposorter, jobParallelism);
resolvedVerbs = new HashSet <IVerb>();
completedVerbs = new HashSet <IVerb>();
depCache = new DependencyCache();
this.rejectCachedFailures = rejectCachedFailures;
}
public UserService(
//DataContext dataContext,
IUserRepository userRepository,
IHasher hasher,
IHttpContextAccessor httpContextAccessor,
IOptions <AppSettings> appSettings,
ILoggerFactory loggerFactory)
{
//this.dataContext = dataContext;
this.userRepository = userRepository;
this.hasher = hasher;
this.httpContextAccessor = httpContextAccessor;
this.appSettings = appSettings.Value;
this.logger = loggerFactory.CreateLogger <UserService>();
}
protected BundleBase(IFileWriterFactory fileWriterFactory, IFileReaderFactory fileReaderFactory, IDebugStatusReader debugStatusReader, IDirectoryWrapper directoryWrapper, IHasher hasher, IBundleCache bundleCache)
{
this.fileWriterFactory = fileWriterFactory;
this.fileReaderFactory = fileReaderFactory;
this.debugStatusReader = debugStatusReader;
this.directoryWrapper = directoryWrapper;
this.hasher = hasher;
bundleState = new BundleState
{
DebugPredicate = Configuration.Instance.DefaultDebugPredicate(),
ShouldRenderOnlyIfOutputFileIsMissing = false,
HashKeyName = "r"
};
this.bundleCache = bundleCache;
}
public StorageScavenger(TFChunkDb db, ITableIndex tableIndex, IHasher hasher,
IReadIndex readIndex, bool alwaysKeepScavenged, bool mergeChunks)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(hasher, "hasher");
Ensure.NotNull(readIndex, "readIndex");
_db = db;
_tableIndex = tableIndex;
_hasher = hasher;
_readIndex = readIndex;
_alwaysKeepScavenged = alwaysKeepScavenged;
_mergeChunks = mergeChunks;
}
public IEnumerable <BuildObject> getIncludes(BuildObject beatsrc)
{
IHasher hasher = BuildEngine.theEngine.getHasher();
OrderPreservingSet <BuildObject> includes = new OrderPreservingSet <BuildObject>();
//-BuildObject ifcFile = includePathSearcher.search(beatsrc.getFileNameWithoutExtension(), ModPart.Ifc);
//-BuildObject impFile = includePathSearcher.search(beatsrc.getFileNameWithoutExtension(), ModPart.Imp);
BuildObject ifcFile = hasher.search(includePathSearcher, beatsrc.getFileNameWithoutExtension(), ModPart.Ifc);
BuildObject impFile = hasher.search(includePathSearcher, beatsrc.getFileNameWithoutExtension(), ModPart.Imp);
Util.Assert(ifcFile.Equals(beatsrc) || impFile.Equals(beatsrc));
includes.AddRange(directIncludes.getBasmIncludes(ifcFile));
includes.AddRange(directIncludes.getBasmIncludes(impFile));
return(includes);
}
/// <summary>
/// Initializes an instance of the <see cref="UserService"/> class.
/// </summary>
/// <param name="userRepository">The user repository.</param>
/// <param name="credentialRepository">The credential repository.</param>
/// <param name="credentialTypeRepository">The credential type repository.</param>
/// <param name="hasher">The hasher.</param>
/// <param name="saltGenerator">The salt generator.</param>
/// <param name="accessTokenService">The access token service.</param>
public UserService(
IRepository <User> userRepository,
IRepository <Credential> credentialRepository,
IRepository <CredentialType> credentialTypeRepository,
IHasher hasher,
ISaltGenerator saltGenerator,
IAccessTokenService accessTokenService)
{
_userRepository = userRepository;
_credentialRepository = credentialRepository;
_credentialTypeRepository = credentialTypeRepository;
_hasher = hasher;
_saltGenerator = saltGenerator;
_accessTokenService = accessTokenService;
}
public TextHasher(Encoding encoding, IHasher hasher)
{
if (encoding == null)
{
throw new ArgumentNullException(nameof(encoding));
}
if (hasher == null)
{
throw new ArgumentNullException(nameof(hasher));
}
this.encoding = encoding;
this.hasher = hasher;
}
private static bool ScriptIsNewOrChanged(
SqlScript sqlScript,
ScriptNameComparer comparer,
IEnumerable <ExecutedSqlScript> executedScripts,
IHasher hasher) =>
!executedScripts.Any(
executedScript =>
{
if (comparer.Equals(executedScript.Name, sqlScript.Name))
{
return(executedScript.Hash == null || executedScript.Hash == hasher.GetHash(sqlScript.Contents));
}
return(false);
});
public void HashRobotSpawnPoints(IHasher hasher)
{
var locators = ExtractRobotSpawnPoints();
hasher.Hash(locators.Length);
for (int i = 0, cnt = locators.Length; i < cnt; ++i)
{
hasher.Hash(locators[i].Pos.X);
hasher.Hash(locators[i].Pos.Y);
hasher.Hash(locators[i].Pos.Z);
hasher.Hash(locators[i].Rotation.X);
hasher.Hash(locators[i].Rotation.Y);
hasher.Hash(locators[i].Rotation.Z);
hasher.Hash(locators[i].Rotation.W);
}
}
