public string Authorise(AuthCredentials auth) { //Verify user is valid credentials var isValidAuth = Security.ValidateBackOfficeCredentials(auth.Username, auth.Password); //Are credentials correct? if (isValidAuth) { //Get the backoffice user from username var user = ApplicationContext.Services.UserService.GetByUsername(auth.Username); //Generate AuthToken DB object var newToken = new UmbracoAuthToken(); newToken.IdentityId = user.Id; newToken.IdentityType = IdentityAuthType.User.ToString(); //Generate a new token for the user var authToken = UmbracoAuthTokenFactory.GenerateUserAuthToken(newToken); //Store in DB (inserts or updates existing) UserAuthTokenDbHelper.InsertAuthToken(authToken); //Return the JWT token as the response //This means valid login & client in our case mobile app stores token in local storage return(authToken.AuthToken); } //Throw unauthorised HTTP error var httpUnauthorised = new HttpResponseMessage(HttpStatusCode.Unauthorized); throw new HttpResponseException(httpUnauthorised); }
public MetricProvider(string api_endpoint, string metric_name, string reponse_body_identifier, AuthCredentials auth_credentials, Dictionary <string, double> value_mapping, SortedDictionary <string, string> labels, ResponseType responseType, ExecutionType executionType) { mApiEndpoint = api_endpoint; mMetricName = metric_name; mResponsebodyIdentifier = reponse_body_identifier; mResponseType = responseType; mExecutionType = executionType; mAuthCredentials = auth_credentials; mValueMapping = value_mapping; mLabels = labels; mClient = new HttpClient(); if (mAuthCredentials != null) { if (mAuthCredentials.Token != null) { mClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", mAuthCredentials.Token); } else { if (mAuthCredentials.Username != null && mAuthCredentials.Password != null) { var byteArray = Encoding.ASCII.GetBytes(mAuthCredentials.Username + ":" + mAuthCredentials.Password); mClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray)); } } } }
public async Task <ActionResult <UserView> > Login([FromBody] AuthCredentials creds) { var user = await db.Users.Where(u => u.LoginName == creds.LoginName).FirstOrDefaultAsync(); if (user == null) { return(Unauthorized()); } if (!hasher.CompareHashAndPassword(user.PasswordHash, creds.Password)) { return(Unauthorized()); } var sessionJwt = auth.GetAuthToken(new AuthClaims(user.Id)); var cookieOptions = new CookieOptions() { HttpOnly = true, MaxAge = Constants.SESSION_EXPIRATION, #if RELEASE Secure = useSecureCookies, #endif }; Response.Cookies.Append(Constants.SESSION_COOKIE_NAME, sessionJwt, cookieOptions); return(Ok(new UserView(user))); }
public void InvalidLoginUsingTcpSimplexChannel_NoAuthClient() { var url = "tcp://localhost:8091/CustomAuthenticationTestHost_TcpSimplex"; var protocol = new TcpCustomClientProtocolSetup(true); var credentials = new AuthCredentials(UserName, Password); var connection = new ZyanConnection(url, protocol, credentials, true, true); }
private Task <XmlRpcObject> LoginAsync(AuthCredentials credentials) { authenticationToken = null; isAuthenticated = false; isVip = false; return(ApiRequest("LogIn", Arg(credentials.Username), Arg(credentials.Password), Arg("en"), Arg(UserAgent))); }
public async Task <IActionResult> Login([FromBody] AuthCredentials credentials) { if (!ValidateLogin(credentials.Login, credentials.Password)) { return(Unauthorized()); } var claims = new[] { new Claim(ClaimTypes.Name, credentials.Login), }; var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme); await HttpContext.SignInAsync( CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(identity), new AuthenticationProperties { IsPersistent = true, IssuedUtc = DateTimeOffset.UtcNow, ExpiresUtc = DateTimeOffset.UtcNow.AddDays(30) }); return(Ok()); }
public static Proto.User FromNative(this AuthCredentials native) { return(new Proto.User { Email = native.Email, EmailN = native.Email, PasswordHash = native.PasswordHash, }); }
public AuthCredentialsViewModel(AuthCredentials credentials) { _credentials = credentials; ServerCredentials = new EmailServerCredentialsViewModel() { Model = _credentials.ServerCredentials, Icon = new BitmapImage(new Uri(@"/Resources/google.png", UriKind.Relative)) }; }
/// <summary> /// Default Constructor /// </summary> /// <param name="auth">Auth Credentials for last.fm</param> public LastFmAgent(AuthCredentials auth) { if (auth == null) { throw new ArgumentNullException("auth"); } _credentials = string.Format("api_key={0}", auth.ApiKey); }
public async Task <ActionResult <AuthUser> > Authenticate(AuthCredentials credentials) { var user = await _identityService.Authenticate(credentials); if (user == null) { return(BadRequest(new { message = "Username or password is incorrect" })); } return(Ok(user)); }
private AuthResult Login(string userName, string password) { lock (LoginSyncLock) { var authCredentials = new AuthCredentials(userName, password); var authResult = this.MainActivity?.AuthenticationService.LogIn(authCredentials); return(authResult); } }
public void InvalidLoginUsingTcpSimplexChannel_NoAuthClient() { var url = "tcp://localhost:8091/CustomAuthenticationTestHost_TcpSimplex"; var protocol = new TcpCustomClientProtocolSetup(true); var credentials = new AuthCredentials(UserName, Password); using (var connection = new ZyanConnection(url, protocol, credentials, true, true)) { var proxy1 = connection.CreateProxy <ISampleServer>("SampleServer"); Assert.AreEqual("Hallo", proxy1.Echo("Hallo")); proxy1 = null; } }
private async Task <AuthenticateResult> RequestLogin(AuthCredentials credentials) { if (_service is null) { return(AuthenticateResult.Fail("Auth service not configured")); } var token = await _service.LoginAsync(credentials); return(string.IsNullOrEmpty(token) ? AuthenticateResult.Fail("Access forbidden") : AuthenticateResult.Success(ProvideTokenAuthTicket(token))); }
public IActionResult Get([FromForm] AuthCredentials authCreds) { if (!authCreds.isValid) { return(BadRequest("Inserisci username e password")); } if (_auth.AuthenticateWithCredentials(authCreds.Username, authCreds.Password)) { return(Ok(new { token = _jwtManager.GenerateTokenForUser(authCreds.Username) })); } return(Unauthorized()); }
/// <summary> /// Reestablish connection to server. /// </summary> /// <remarks> /// This method checks if the session is valid. If not, a new logon in perfomed automatically. /// Handle the NewLogonNeeded event to provide credentials. /// </remarks> /// <returns>True, if reconnecting was successfull, otherwis false </returns> internal bool InternalReconnect() { // When the session isn´t valid, the server process must have been restarted if (!RemoteDispatcher.ExistSession(_sessionID)) { AuthCredentials credentials = null; var performNewLogon = true; // If cached auto login credentials are present if (_autoLoginOnExpiredSession) { credentials = _autoLoginCredentials; } else { var newLogonNeededEventArgs = new NewLogonNeededEventArgs(); if (OnNewLogonNeeded(newLogonNeededEventArgs)) { performNewLogon = !newLogonNeededEventArgs.Cancel; credentials = newLogonNeededEventArgs.Credentials; } else { performNewLogon = false; } } if (performNewLogon) { if (credentials == null) { credentials = new AuthCredentials(); } credentials.Authenticate(_sessionID, RemoteDispatcher); ReconnectRemoteEvents(); RemoteDispatcher.ReceiveClientHeartbeat(_sessionID); return(true); } } else { RemoteDispatcher.ReceiveClientHeartbeat(_sessionID); return(true); } return(false); }
public string AuthoriseMember(AuthCredentials auth) { //Verify user is valid credentials - using current membership provider //Should be native Umbraco one var isValidAuth = Membership.ValidateUser(auth.Username, auth.Password); //Are credentials correct? if (isValidAuth) { //Get the member from username var member = ApplicationContext.Services.MemberService.GetByUsername(auth.Username); //Check if we have an Auth Token for user var hasAuthToken = UserAuthTokenDbHelper.GetAuthToken(member.Id); //If the token already exists if (hasAuthToken != null) { //Lets just return it in the request return(hasAuthToken.AuthToken); } //Else user has no token yet - so let's create one //Generate AuthToken DB object var newToken = new UmbracoAuthToken(); newToken.IdentityId = member.Id; newToken.IdentityType = IdentityAuthType.Member.ToString(); //Generate a new token for the user var authToken = UmbracoAuthTokenFactory.GenerateAuthToken(newToken); //We insert authToken as opposed to newToken //As authToken now has DateTime & JWT token string on it now //Store in DB (inserts or updates existing) UserAuthTokenDbHelper.InsertAuthToken(authToken); //Return the JWT token as the response //This means valid login & client in our case mobile app stores token in local storage return(authToken.AuthToken); } //Throw unauthorised HTTP error var httpUnauthorised = new HttpResponseMessage(HttpStatusCode.Unauthorized); throw new HttpResponseException(httpUnauthorised); }
public UserSettingsViewModel() { var user = new User() { Name = "User" }; var auth = new AuthCredentials(); auth.Login = "******"; auth.Password = "******"; auth.ServerCredentialsId = 0; user.CredentialsList.Add(auth); var z = auth.ServerCredentials; Users.Add(new UserViewModel(user)); AppStorage.Instance.Users.ForEach(x => Users.Add(new UserViewModel(x))); }
public async Task <ActionResult <UserView> > Register([FromBody] AuthCredentials creds) { if (await db.Users.AnyAsync(u => u.LoginName == creds.LoginName)) { return(BadRequest("login name already exists")); } var user = new User() { LoginName = creds.LoginName, PasswordHash = hasher.HashFromPassword(creds.Password), }; db.Add(user); await db.SaveChangesAsync(); return(Created($"/api/users/{user.Id}", new UserView(user))); }
static void CreateMetricProviders(string metricDefinitionFile) { // Read metric definition and create array of MetricDefinition objects. string definition = File.ReadAllText(metricDefinitionFile); MetricDefinition[] metricDefinitions = MetricDefinition.FromJson(definition); foreach (MetricDefinition def in metricDefinitions) { string service_name = def.ServiceName; string url = def.Url; foreach (Metric metric in def.Metrics) { string api_endpoint = metric.ApiEndpoint != null ? url + metric.ApiEndpoint : null; string metric_name = def.ServiceName + "_" + metric.MetricName; string reponse_body_identifier = metric.DesiredResponseField; AuthCredentials auth_credentials = def.AuthCredentials; Dictionary <string, double> string_value_mapping = metric.StringValueMapping; SortedDictionary <string, string> labels = metric.Labels; ResponseType responseType = metric.ResponseType; ExecutionType executionType = metric.ExecutionType; // Create MetricEndpoint which executes API calls or executes a program/script MetricProvider metricEndpoint = null; if (executionType == ExecutionType.SCRIPT && metric.Program != null && metric.Argument != null) { metricEndpoint = new MetricProvider(metric_name, metric.Program, metric.Argument, labels, executionType); } else if (executionType == ExecutionType.API_CALL && api_endpoint != null) { metricEndpoint = new MetricProvider(api_endpoint, metric_name, reponse_body_identifier, auth_credentials, string_value_mapping, labels, responseType, executionType); } // Create Prometheus Gauges GaugeConfiguration config = new GaugeConfiguration(); if (labels != null) { config.LabelNames = labels.Keys.ToArray(); } Gauge metricGauge = Metrics.CreateGauge(name: metric_name, help: metric_name, config); mPrometheusMetricManager.AddMetricStruct(metricEndpoint, metricGauge); } } }
public AuthResult LogIn(AuthCredentials authCredentials) { try { using (var webClient = new WebClient()) { var response = webClient.UploadString($"{GlobalConstants.AuthenticationServiceConstants.ApiAuthUrl}?userName={authCredentials.UserName}&password={authCredentials.Password}", string.Empty); var authModel = JsonConvert.DeserializeObject <AuthResult>(response); if (authModel.IsSuccess) { this.ServiceProvider.SharedPreferencesProvider.Save(SharedPreferencesKey, new AuthToken(authModel.AuthToken)); this.CurrentUser = IsAuthenticated ? authCredentials : null; this.CurrentAuthToken = authModel.AuthToken; FirebaseIIdService.SendRefreshedTokenToServer(FirebaseInstanceId.Instance.Token); return(new AuthResult(IsAuthenticated)); } else { this.CurrentUser = null; this.CurrentAuthToken = null; return(new AuthResult(false)); } } } catch (Exception ex) { this.CurrentUser = null; this.CurrentAuthToken = null; this.ServiceProvider.LoggingService.Log(ex, LogType.Error); } return(new AuthResult(false)); }
public IActionResult GetToken([FromBody] AuthCredentials authCredentials) { if (authCredentials.UserName == "welton" && authCredentials.Password == "1234") { var claims = new[] { new Claim(ClaimTypes.Name, "Welton Weylle Borges Lago") }; var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["SecurityKey"])); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); var token = new JwtSecurityToken( issuer: "api.fake", audience: "api.fake", claims: claims, expires: DateTime.UtcNow.AddMinutes(1), signingCredentials: creds); return(Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) })); } return(BadRequest("Invalid Credentials")); }
public async Task <AuthUser> Authenticate(AuthCredentials credentials) { var user = await _userCollection.Find <UserDTO>(user => user.Email == credentials.Email).FirstOrDefaultAsync(); if (user == null) { return(null); } if (!user.Password.Code.Equals(HashingUtility.GetHash(credentials.Password, user.Password.Salt))) { return(null); } // authentication successful so generate jwt token var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(Configuration["Jwt:Key"]); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new Claim[] { new Claim("userId", user.Id.ToString()), new Claim(ClaimTypes.Email, user.Email) }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var token = tokenHandler.CreateToken(tokenDescriptor); return(new AuthUser() { User = GetQueryUser(user), Token = tokenHandler.WriteToken(token) }); }
public HttpResponseMessage Authenticate(AuthCredentials auth) { var repo = new UserRepository(); var user = repo.GetByCredentials(auth.Login, auth.Password); if (user == null) { var resp = Request.CreateResponse(HttpStatusCode.Unauthorized); resp.Content = new StringContent("Persmission Denied"); return(resp); } var response = Request.CreateResponse(HttpStatusCode.OK); user.IpAdress = HttpContext.Current?.Request.UserHostAddress; user.Cookie = Guid.NewGuid(); var cookie = new CookieHeaderValue("msidt", user.Cookie.ToString()); cookie.Domain = Request.RequestUri.Host; cookie.Path = "/"; if (user.Expire == 0) { cookie.Expires = DateTime.Now.AddSeconds(3600); } else { cookie.Expires = DateTime.Now.AddSeconds(user.Expire); } response.Headers.AddCookies(new CookieHeaderValue[] { cookie }); repo.Complete(); response.Content = new StringContent("Persmission Granted"); return(response); }
public AuthLoginRequest(AuthCredentials credentials) : base("/login", Method.POST) { AddJsonBody(credentials); }
/// <summary> /// Test Case: /// </summary> //[TestMethod] //[TestCategory("SyncManager")] public void MergeTest() { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); string uniqueName = ((DateTime.UtcNow - epoch).TotalSeconds).ToString(); string uniqueName2 = uniqueName + "_"; string failureMessage = string.Empty; UnAuthCredentials.Clear(); using (CognitoSyncManager sm1 = new CognitoSyncManager(AuthCredentials)) { sm1.WipeData(false); Thread.Sleep(2000); using (Dataset d = sm1.OpenOrCreateDataset("test")) { d.Put(uniqueName, uniqueName); d.OnSyncSuccess += delegate(object s1, SyncSuccessEventArgs e1) { UnAuthCredentials.Clear(); using (CognitoSyncManager sm2 = new CognitoSyncManager(UnAuthCredentials)) { Thread.Sleep(2000); using (Dataset d2 = sm2.OpenOrCreateDataset("test")) { d2.Put(uniqueName2, uniqueName2); d2.OnSyncSuccess += delegate(object s2, SyncSuccessEventArgs e2) { AuthCredentials.Clear(); UnAuthCredentials.Clear(); //now we will use auth credentials. using (CognitoSyncManager sm3 = new CognitoSyncManager(AuthCredentials)) { Thread.Sleep(2000); using (Dataset d3 = sm3.OpenOrCreateDataset("test")) { bool mergeTriggered = false; d3.OnSyncSuccess += (object sender, SyncSuccessEventArgs e) => { if (!mergeTriggered) { failureMessage += "Expecting DatasetMerged instead of OnSyncSuccess\n"; } }; d3.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); }; d3.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d3.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d3.OnDatasetMerged += (Dataset ds, List <string> datasetNames) => { mergeTriggered = true; return(true); }; #if BCL35 d3.Synchronize(); #else RunAsSync(async() => await d3.SynchronizeAsync()); #endif } } }; d2.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); }; d2.OnSyncConflict += (Dataset dataset, List <SyncConflict> conflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d2.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d2.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) => { failureMessage += "Not expecting OnDatasetMerged\n"; return(false); }; #if BCL35 d2.Synchronize(); #else RunAsSync(async() => await d2.SynchronizeAsync()); #endif } } }; d.OnSyncFailure += delegate(object s, SyncFailureEventArgs e) { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); }; d.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) => { failureMessage += "Not expecting OnDatasetMerged\n"; return(false); }; #if BCL35 d.Synchronize(); #else RunAsSync(async() => await d.SynchronizeAsync()); #endif } } if (!string.IsNullOrEmpty(failureMessage)) { Assert.Fail(failureMessage); } }
public void MergeTest() { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); string uniqueName = ((DateTime.UtcNow - epoch).TotalSeconds).ToString(); string uniqueName2 = uniqueName + "_"; UnAuthCredentials.Clear(); AutoResetEvent ars = new AutoResetEvent(false); string failureMessage = string.Empty; CognitoSyncManager sm1 = null; AutoResetEvent mainThreadArs = new AutoResetEvent(false); Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() => { sm1 = new CognitoSyncManager(AuthCredentials, TestRunner.RegionEndpoint); mainThreadArs.Set(); }); mainThreadArs.WaitOne(); sm1.WipeData(false); Thread.Sleep(2000); Dataset d = sm1.OpenOrCreateDataset("test"); d.Put(uniqueName, uniqueName); d.OnSyncSuccess += delegate(object s1, SyncSuccessEventArgs e1) { ars.Set(); }; d.OnSyncFailure += delegate(object s, SyncFailureEventArgs e) { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); ars.Set(); }; d.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) => { failureMessage += "Not expecting OnDatasetMerged\n"; return(false); }; d.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); d.Dispose(); sm1.Dispose(); Utils.AssertStringIsNullOrEmpty(failureMessage); UnAuthCredentials.Clear(); CognitoSyncManager sm2 = null; Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() => { sm2 = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint); mainThreadArs.Set(); }); mainThreadArs.WaitOne(); Thread.Sleep(2000); Dataset d2 = sm2.OpenOrCreateDataset("test"); d2.Put(uniqueName2, uniqueName2); d2.OnSyncSuccess += delegate(object s2, SyncSuccessEventArgs e2) { ars.Set(); }; d2.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); ars.Set(); }; d2.OnSyncConflict += (Dataset dataset, List <SyncConflict> conflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d2.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d2.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) => { failureMessage += "Not expecting OnDatasetMerged\n"; return(false); }; d2.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); d2.Dispose(); sm2.Dispose(); Utils.AssertStringIsNullOrEmpty(failureMessage); AuthCredentials.Clear(); UnAuthCredentials.Clear(); CognitoSyncManager sm3 = null; Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() => { sm3 = new CognitoSyncManager(AuthCredentials, TestRunner.RegionEndpoint); mainThreadArs.Set(); }); mainThreadArs.WaitOne(); Thread.Sleep(2000); Dataset d3 = sm3.OpenOrCreateDataset("test"); bool mergeTriggered = false; d3.OnSyncSuccess += (object sender, SyncSuccessEventArgs e) => { if (!mergeTriggered) { failureMessage += "Expecting DatasetMerged instead of OnSyncSuccess\n"; } ars.Set(); }; d3.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); ars.Set(); }; d3.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d3.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d3.OnDatasetMerged += delegate(Dataset ds, List <string> datasetNames) { mergeTriggered = true; return(true); }; d3.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); Utils.AssertStringIsNullOrEmpty(failureMessage); }
/// <summary> /// Creates a new instance of the NewLogonNeededEventArgs class. /// </summary> /// <param name="credentials">Security credentials</param> /// <param name="cancel">Cancel flag</param> public NewLogonNeededEventArgs(AuthCredentials credentials, bool cancel) { Cancel = cancel; Credentials = credentials; }
/// <summary> /// Creates a new instance of the NewLogonNeededEventArgs class. /// </summary> /// <param name="credentials">Credentials for logon</param> public NewLogonNeededEventArgs(AuthCredentials credentials) { Cancel = false; Credentials = credentials; }
/// <summary> /// Creates a new instance of the ZyanConnection class. /// </summary> /// <param name="serverUrl">URL of remote server (e.G. "tcp://server1:46123/myapp").</param> /// <param name="protocolSetup">Protocol and communication settings.</param> /// <param name="credentials">Login credentials.</param> /// <param name="autoLoginOnExpiredSession">Specifies whether the proxy should relogin automatically when the session expired.</param> /// <param name="keepSessionAlive">Specifies whether the session should be automaticly kept alive.</param> public ZyanConnection(string serverUrl, IClientProtocolSetup protocolSetup, AuthCredentials credentials, bool autoLoginOnExpiredSession, bool keepSessionAlive) { if (string.IsNullOrEmpty(serverUrl)) { throw new ArgumentException(LanguageResource.ArgumentException_ServerUrlMissing, "serverUrl"); } if (protocolSetup == null) { // try to select the protocol automatically protocolSetup = ClientProtocolSetup.GetClientProtocol(serverUrl); if (protocolSetup == null) { throw new ArgumentNullException("protocolSetup"); } } if (!protocolSetup.IsUrlValid(serverUrl)) { throw new ArgumentException(LanguageResource.ArgumentException_ServerUrlIsInvalid, "serverUrl"); } _proxies = new List <WeakReference>(); _protocolSetup = protocolSetup; _sessionID = Guid.NewGuid(); _serverUrl = serverUrl; _autoLoginOnExpiredSession = autoLoginOnExpiredSession; _keepSessionAlive = keepSessionAlive; if (_autoLoginOnExpiredSession) { _autoLoginCredentials = credentials; } _serializationHandling = new SerializationHandlerRepository(); CallInterceptionEnabled = false; _callInterceptors = new CallInterceptorCollection(); RegisterStandardSerializationHandlers(); string[] addressParts = _serverUrl.Split('/'); _componentHostName = addressParts[addressParts.Length - 1]; _remotingChannel = _protocolSetup.CreateChannel(); if (!ZyanSettings.DisableUrlRandomization) { _remotingChannel = ChannelWrapper.WrapChannel(_remotingChannel, _protocolSetup.ChannelName); } if (_remotingChannel != null) { var registeredChannel = ChannelServices.GetChannel(_remotingChannel.ChannelName); if (registeredChannel == null) { ChannelServices.RegisterChannel(_remotingChannel, false); } else { _remotingChannel = registeredChannel; } } else { throw new ApplicationException(LanguageResource.ApplicationException_NoChannelCreated); } var connectionNotification = _remotingChannel as IConnectionNotification; if (connectionNotification != null) { connectionNotification.ConnectionEstablished += Channel_ConnectionEstablished; } string channelName = _remotingChannel.ChannelName; if (credentials == null) { credentials = new AuthCredentials(); } try { credentials.Authenticate(_sessionID, RemoteDispatcher); _registeredComponents = new List <ComponentInfo>(RemoteDispatcher.GetRegisteredComponents()); _sessionAgeLimit = RemoteDispatcher.SessionAgeLimit; } catch (Exception ex) { // unregister remoting channel var registeredChannel = ChannelServices.GetChannel(channelName); if (registeredChannel != null) { ChannelServices.UnregisterChannel(registeredChannel); } // dispose channel if it's disposable var disposableChannel = registeredChannel as IDisposable; if (disposableChannel != null) { disposableChannel.Dispose(); } _remotingChannel = null; _remoteDispatcher = null; throw ex.PreserveStackTrace(); } var reconnectEvents = new Action(ReconnectRemoteEventsCore); var debounceInterval = ZyanSettings.ReconnectRemoteEventsDebounceInterval.TotalMilliseconds; ReconnectRemoteEvents = reconnectEvents.Debounce((int)debounceInterval); StartKeepSessionAliveTimer(); lock (_connections) { _connections.Add(this); } }
/// <summary> /// Releases unmanaged and — optionally — managed resources. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (!disposing) { return; } if (!_isDisposed) { _isDisposed = true; if (_pollingTimer != null) { _pollingTimer.Dispose(); _pollingTimer = null; } _pollingEnabled = false; if (_keepSessionAliveTimer != null) { _keepSessionAliveTimer.Dispose(); _keepSessionAliveTimer = null; } try { foreach (var zyanProxy in AliveProxies) { zyanProxy.RemoveAllRemoteEventHandlers(); } RemoteDispatcher.Logoff(_sessionID); } catch (RemotingException) { } catch (SocketException) { } catch (WebException) { } catch (MessageException) { } catch (Exception ex) { Trace.WriteLine("Unexpected exception of type {0} caught while disposing ZyanConnection: {1}", ex.GetType(), ex.Message); } finally { lock (_connections) { _connections.Remove(this); } } if (_remotingChannel != null) { // unsubscribe from connection notifications var connectionNotification = _remotingChannel as IConnectionNotification; if (connectionNotification != null) { connectionNotification.ConnectionEstablished -= Channel_ConnectionEstablished; } // unregister remoting channel var registeredChannel = ChannelServices.GetChannel(_remotingChannel.ChannelName); if (registeredChannel != null && registeredChannel == _remotingChannel) { ChannelServices.UnregisterChannel(_remotingChannel); } // dispose remoting channel, if it's disposable var disposableChannel = _remotingChannel as IDisposable; if (disposableChannel != null) { disposableChannel.Dispose(); } _remotingChannel = null; } _remoteDispatcher = null; _serverUrl = string.Empty; _sessionID = Guid.Empty; _protocolSetup = null; _serializationHandling = null; _componentHostName = string.Empty; if (_registeredComponents != null) { _registeredComponents.Clear(); _registeredComponents = null; } if (_callInterceptors != null) { _callInterceptors.Clear(); _callInterceptors = null; } if (_autoLoginCredentials != null) { _autoLoginCredentials = null; } GC.WaitForPendingFinalizers(); } }