public static void LoadAuthenticatedUserFromCache(ILoginMethods login, ISecureBlobCache loginCache) { Observable.Zip(loginCache.GetObjectAsync <string>("BaseUrl"), loginCache.GetObjectAsync <string>("Token"), (url, name) => new Tuple <string, string>(url, name)) .Catch(Observable.Return <Tuple <string, string> >(null)) .Subscribe(x => { }); }
/// <summary> /// Saves a username and password. /// </summary> /// <param name="blobCache">The blob cache to insert the item into.</param> /// <param name="user">The username to store.</param> /// <param name="password">The password to store.</param> /// <param name="host">The host to store against.</param> /// <param name="expiration">A timespan that will be added to the current DateTime.</param> /// <returns>A observable which will signal when the item is added.</returns> public static IObservable <Unit> SaveLogin(this ISecureBlobCache blobCache, string user, string password, string host, TimeSpan expiration) { if (blobCache is null) { throw new ArgumentNullException(nameof(blobCache)); } return(blobCache.SaveLogin(user, password, host, blobCache.Scheduler.Now + expiration)); }
static BlobCache() { if (RxApp.InUnitTestRunner()) { localMachine = new TestBlobCache(RxApp.TaskpoolScheduler); userAccount = new TestBlobCache(RxApp.TaskpoolScheduler); secure = new TestBlobCache(RxApp.TaskpoolScheduler); } }
private void GetSecretLocalMachineCache() { var secretCache = new Lazy <ISecureBlobCache>(() => { _filesystemProvider.CreateRecursive(_filesystemProvider.GetDefaultSecretCacheDirectory()).SubscribeOn(BlobCache.TaskpoolScheduler).Wait(); return(new SQLiteEncryptedBlobCache(Path.Combine(_filesystemProvider.GetDefaultSecretCacheDirectory(), "secret.db"), new PlatformCustomAkavacheEncryptionProvider(), BlobCache.TaskpoolScheduler)); }); this.SecretLocalMachineCache = secretCache.Value; }
protected SharedCache(IBlobCache userAccountCache, IBlobCache localMachineCache, ISecureBlobCache secureCache) { if (secureCache == null) { try { BlobCache.Secure = new CredentialCache(); secureCache = BlobCache.Secure; } catch (Exception e) { log.Error("Failed to set up secure cache.", e); secureCache = new InMemoryBlobCache(); } } UserAccount = userAccountCache ?? GetBlobCacheWithFallback(() => BlobCache.UserAccount, "UserAccount"); LocalMachine = localMachineCache ?? GetBlobCacheWithFallback(() => BlobCache.LocalMachine, "LocalMachine"); Secure = secureCache; }
protected SharedCache(IBlobCache userAccountCache, IBlobCache localMachineCache, ISecureBlobCache secureCache) { if (secureCache == null) { try { BlobCache.Secure = new CredentialCache(); secureCache = BlobCache.Secure; } catch (Exception e) { log.Error(e, "Failed to set up secure cache"); secureCache = new InMemoryBlobCache(); } } UserAccount = userAccountCache ?? GetBlobCacheWithFallback(() => BlobCache.UserAccount, "UserAccount"); LocalMachine = localMachineCache ?? GetBlobCacheWithFallback(() => BlobCache.LocalMachine, "LocalMachine"); Secure = secureCache; }
public SettingsService(ILogger logger = null, ISecureBlobCache secureBlobCache = null, IBlobCache localMachineCache = null) { _logger = logger ?? Locator.Current.GetService <ILogger>(); _secureBlobCache = secureBlobCache ?? Locator.Current.GetService <ISecureBlobCache>(); _localMachineCache = localMachineCache ?? Locator.Current.GetService <IBlobCache>(); BaseApiUrl = @"http://test.test.no/api"; var log = _logger.ForContext <SettingsService>(); log.Information($"Instantiated: {nameof(SettingsService)}"); // Check and set access token GetToken() .ToObservable() .LogException(log, "Unable to get access token") .Subscribe(); _localMachineCache.GetObject <bool>(IsNewUserKey) .Catch <bool, Exception>(ex => Observable.Return(true)) .Subscribe(newUser => IsNewUser = newUser); }
/// <summary> /// Returns the currently cached user/password. If the cache does not /// contain a user/password, this returns an Observable which /// OnError's with KeyNotFoundException. /// </summary> /// <param name="blobCache">The blob cache where to get the data.</param> /// <param name="host">The host associated with the data.</param> /// <returns>A Future result representing the user/password Tuple.</returns> public static IObservable <LoginInfo> GetLoginAsync(this ISecureBlobCache blobCache, string host = "default") { return(blobCache.GetObject <Tuple <string, string> >("login:" + host).Select(x => new LoginInfo(x))); }
/// <summary> /// Save a user/password combination in a secure blob cache. Note that /// this method only allows exactly *one* user/pass combo to be saved, /// calling this more than once will overwrite the previous entry. /// </summary> /// <param name="blobCache">The blob cache where to store the data.</param> /// <param name="user">The user name to save.</param> /// <param name="password">The associated password.</param> /// <param name="host">The host to associate with the data.</param> /// <param name="absoluteExpiration">An optional expiration date.</param> /// <returns>A observable which signals when the insert is completed.</returns> public static IObservable <Unit> SaveLogin(this ISecureBlobCache blobCache, string user, string password, string host = "default", DateTimeOffset?absoluteExpiration = null) { return(blobCache.InsertObject("login:" + host, new Tuple <string, string>(user, password), absoluteExpiration)); }
public GitHubCredentialProvider(ISharedCache sharedCache) { Guard.ArgumentNotNull(sharedCache, nameof(sharedCache)); secureCache = sharedCache.Secure; }
public static void LoadAuthenticatedUserFromCache(ILoginMethods login, ISecureBlobCache loginCache) { Observable.Zip(loginCache.GetObjectAsync<string>("BaseUrl"), loginCache.GetObjectAsync<string>("Token"), (url, name) => new Tuple<string, string>(url, name)) .Catch(Observable.Return<Tuple<string, string>>(null)) .Subscribe(x => { }); }
public static void SaveLogin(this ISecureBlobCache This, string user, string password, string host, TimeSpan expiration) { This.SaveLogin(user, password, host, This.Scheduler.Now + expiration); }
/// <summary> /// Erases the login associated with the specified host /// </summary> public static void EraseLogin(this ISecureBlobCache This, string host = "default") { This.InvalidateObject <Tuple <string, string> >("login:" + host); }
public GitHubCredentialProvider(ISharedCache sharedCache) { secureCache = sharedCache.Secure; }
/// <summary> /// Save a user/password combination in a secure blob cache. Note that /// this method only allows exactly *one* user/pass combo to be saved, /// calling this more than once will overwrite the previous entry. /// </summary> /// <param name="user">The user name to save.</param> /// <param name="password">The associated password</param> /// <param name="absoluteExpiration">An optional expiration date.</param> public static void SaveLogin(this ISecureBlobCache This, string user, string password, string host = "default", DateTimeOffset?absoluteExpiration = null) { This.InsertObject("login:" + host, new Tuple <string, string>(user, password), absoluteExpiration); }
/// <summary> /// Erases the login associated with the specified host. /// </summary> /// <param name="blobCache">The blob cache where to erase the data.</param> /// <param name="host">The host associated with the data.</param> /// <returns>A observable which signals when the erase is completed.</returns> public static IObservable <Unit> EraseLogin(this ISecureBlobCache blobCache, string host = "default") { return(blobCache.InvalidateObject <Tuple <string, string> >("login:" + host)); }
public static IObservable <Unit> SaveLogin(this ISecureBlobCache This, string user, string password, string host, TimeSpan expiration) { return(This.SaveLogin(user, password, host, This.Scheduler.Now + expiration)); }