/// <summary> /// Common exception handler for all channels. /// </summary> /// <param name="exception">A communication or service exception.</param> public static void HandleException(Exception exception) { // When the endpoint isn't available, the client will sleep for a few milliseconds and try again. if (exception is EndpointNotFoundException) { Thread.Sleep(1000); } // This will allow the user to try another identity. There doesn't appear to be any way to just tell a channel to // prompt the client again for the credentials, so a new channel needs to be constructed. if (exception is SecurityAccessDeniedException || exception is MessageSecurityException) { ChannelStatus.IsPrompted = true; } // This exception comes from the user aborting out of a set of user credentials. In this situation, it wouldn't be // useful to prompt the user again: they must have had a good reason for cancelling instead of just re-entering the // credentials. This will prevent any further activity on any of the channels until the user decides to try again. // An external thread will need to reset this signal for the communications to start up again. if (exception is CommunicationObjectAbortedException) { ChannelStatus.LoginEvent.Reset(); } // Write the error and stack trace out to the debug listener. EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace); }
/// <summary> /// ctor /// </summary> /// <param name="message">fault message</param> /// <param name="eventType">Logging level for this fault TraceEventType.Stop == No logging</param> protected FaultBase(string message, TraceEventType eventType) { this.Message = message; switch (eventType) { case TraceEventType.Error: case TraceEventType.Information: case TraceEventType.Warning: break; default: return; } string stackTrace = UnhandledExceptionHelper.GetStackString(); string logString = string.Format("{0}\r\n{1}\r\n{2}", this.GetType().Name, message, stackTrace); switch (eventType) { case TraceEventType.Error: EventLog.Error(logString); break; case TraceEventType.Information: EventLog.Information(logString); break; case TraceEventType.Warning: EventLog.Warning(logString); break; } }
/// <summary> /// Prompts the user for a certificate to authenticate that user on the channel. /// </summary> /// <param name="state">A generic parameter used to initialize the thread.</param> private void PromptBasic(object state) { // Extract the thread parameters. PromptData promptData = state as PromptData; // This creates the Basic credentials prompt and initializes it with the current user name and password. WindowUserName windowUsername = new WindowUserName(); windowUsername.NetworkCredentials = promptData.NetworkCredentials; windowUsername.EndpointAddress = promptData.EndpointAddress; try { // This presents the credentials to the user and allows them to be modified. if (windowUsername.ShowDialog() == true) { promptData.IsCanceled = false; promptData.NetworkCredentials = windowUsername.NetworkCredentials; } else { promptData.IsCanceled = true; } } catch (InvalidOperationException ioe) { // TODO: Re-visit this later for now we are going to silently log that we got this exception. // Some case we are getting duplicate login dialog boxes. EventLog.Error(string.Format("{0} {1}\n {2}", ioe.Message, ioe.ToString(), ioe.StackTrace)); } }
public WebPage(params object[] parameter) { try { // Initialize the object. this.Uri = new System.Uri((string)parameter[0]); } catch (Exception exception) { EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace); } }
/// <summary> /// call the worker thread callback with the state /// </summary> public void Invoke() { try { this.callBack(this.state); } catch (Exception ex) { System.Diagnostics.Debug.Assert(false, ex.Message, ex.ToString()); //catch the exception and log EventLog.Error(ex); } }
/// <summary> /// Validate the credentials. /// </summary> /// <param name="userName"></param> /// <param name="password"></param> public override void Validate(string lookupId, string password) { bool authenticated = false; ErrorCode errorCode = ErrorCode.AccessDenied; if (String.IsNullOrEmpty(lookupId)) { throw CreateAccessDeniedFault(ErrorCode.UserNotFound); } if (String.IsNullOrEmpty(password)) { throw CreateAccessDeniedFault(ErrorCode.BadPassword); } try { ConnectionStringSettings connectionStringSettings = ConfigurationManager.ConnectionStrings["ADConnectionString"]; if (String.IsNullOrEmpty(connectionStringSettings.ConnectionString) == true && password != "q") { return; } //put the correct partition distinguished name. DirectoryEntry directory = new DirectoryEntry(connectionStringSettings.ConnectionString + "RootDSE", lookupId, password, AuthenticationTypes.None); //Bind to AD. If this succeedes then we have valid credentials object obj = directory.NativeObject; authenticated = true; } catch (DirectoryServicesCOMException deCOMException) { errorCode = ParseADErrorMessage(deCOMException.ExtendedErrorMessage); EventLog.Error(deCOMException); } catch (Exception exception) { EventLog.Error(exception); } //Send a fault back to the client. if (authenticated == false) { throw CreateAccessDeniedFault(errorCode); } }
/// <summary> /// Parses a section of the configuration file for information about the persistent stores. /// </summary> /// <param name="parent">The configuration settings in a corresponding parent configuration section.</param> /// <param name="configContext">An HttpConfigurationContext when Create is called from the ASP.NET configuration system. /// Otherwise, this parameter is reserved and is a null reference.</param> /// <param name="section">The XmlNode that contains the configuration information from the configuration file. Provides direct access to the XML contents of the configuration section.</param> /// <returns>A ToolSection object created from the data in the configuration file.</returns> public object Create(object parent, object configContext, System.Xml.XmlNode section) { // Create an object to hold the data from the 'tool' section of the application configuration file. ToolSection toolSection = new ToolSection(); try { // Read each of the nodes that contain information about the persistent stores and place them in the table. foreach (XmlNode xmlNode in section.SelectNodes("add")) { // The 'type' section of the configuration file is modeled after other places in the OS where the type and // assembly information are combined in the same string. A simpler method might have been to break aprart the // type string from the assembly string, but it's also a good idea to use standards where you find them. In // any event, when the 'type' specification is done this way, the padded spaces need to be removed from the // values onced they're broken out from the original string. XmlAttribute keyAttribute = xmlNode.Attributes["key"]; if (keyAttribute == null) { throw new Exception("Syntax error in configuration file section 'tools'."); } string name = keyAttribute.Value; // The text appears in the 'Tools' menu. XmlAttribute textAttribute = xmlNode.Attributes["text"]; if (textAttribute == null) { throw new Exception("Syntax error in configuration file section 'tools'."); } string text = textAttribute.Value; // Pull apart the tool specification from the attributes. XmlAttribute toolSpecificationAttribute = xmlNode.Attributes["tool"]; if (toolSpecificationAttribute == null) { throw new Exception("Syntax error in configuration file section 'tools'."); } string[] toolParts = toolSpecificationAttribute.Value.Split(new char[] { ',' }); if (toolParts.Length != 2) { throw new Exception("Syntax error in configuration file section 'tools'."); } // Attempt to load the tool into memory and find the type used to instantiate the tool. Assembly toolAssembly = Assembly.Load(toolParts[ToolSectionHandler.AssemblyIndex].Trim()); System.Type toolType = toolAssembly.GetType(toolParts[ToolSectionHandler.TypeIndex]); // Add the tool information to the section. Each of these ToolInfo items describes what kind of object the // tool is associated with and where to find the tool. toolSection.Add(new ToolInfo(name, text, toolType)); } } catch (Exception exception) { // Make sure that any errors caught while trying to load the tool info is recorded in the log. A system // administrator can look through these to figure out why the tool information isn't formatted correctly. EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace); } // This object can be used to find a persistent store by nane and connect to it. return(toolSection); }
/// <summary> /// Log the exception /// </summary> /// <param name="error"></param> /// <returns></returns> public bool HandleError(Exception error) { EventLog.Error(error); return(true); }
private void LoadUnsafe() { // This flag is set when an error occurs anywhere in the processing of the XML file. this.HasErrors = false; // Read the XML data from the specified file. if (NotifyMessage != null) { this.NotifyMessage(this, new MessageEventArgs(string.Format("Loading {0}", FileName))); } XDocument xDocument = XDocument.Load(this.FileName); if (NotifyMessage != null) { this.NotifyMessage(this, new MessageEventArgs("Processing")); } // The script name is stored in the root node. The name is used in status and debugging messages. XAttribute nameAttribute = xDocument.Root.Attribute("name"); this.ScriptName = nameAttribute == null ? "Unnamed Transaction" : nameAttribute.Value; // This will force the user interface to appear the next time a channel is opened. It also releases any threads that // may have been waiting for the user to provide a set of credentials. Threads enter this waiting state when the user // hits the 'Cancel' button on any screen that prompts for credentials. if (this.ForceLogin && this.LocalMode == false) { ChannelStatus.IsPrompted = true; } if (this.LocalMode == false) { ChannelStatus.LoginEvent.Set(); } List <XElement> xElementList = new List <XElement>(); foreach (XElement xElement in xDocument.Root.Elements()) { xElementList.Add(xElement); } //default to be 10% int tickPercent = xElementList.Count / 10; if (tickPercent < 50) { tickPercent = 50; } else if (tickPercent > 1000) { tickPercent = 1000; } // Cycle through all of the children of the root node. Transactions are executed as a unit. Methods outside of a // transaction element are executed alone. for (int elementIndex = 0; elementIndex < xElementList.Count; elementIndex++) { XElement xElement = xElementList[elementIndex]; try { if (NotifyMessage != null && elementIndex % tickPercent == 0) { MessageEventArgs mea = new MessageEventArgs("Next Tick"); mea.IsProgressTick = true; this.NotifyMessage(this, mea); } switch (xElement.Name.LocalName) { case "client": // A channel is required for each endpont that will be contacted during his load. CreateClient(xElement); break; case "method": if (this.tranactionScopeStack.Count == 0) { using (TransactionScope transactionScope = new TransactionScope()) { // Parse and execute a single method out of the script. if (ExecuteMethod(xElement)) { this.MethodCount++; } transactionScope.Complete(); } } else { // Parse and execute a single method out of the script. if (ExecuteMethod(xElement)) { this.MethodCount++; } } break; case "transaction": // This creates a collection of methods that are executed as a unit. ExecuteTransaction(xElement); break; } } catch (Exception exception) { EventLog.Error(string.Format("{0} {1} {2}", exception.Message, exception.ToString(), exception.StackTrace)); ScriptLoaderException slEx = new ScriptLoaderException("Error in " + this.FileName, exception, xElement, this.MethodCount); if (NotifyMessage != null) { this.NotifyMessage(this, new MessageEventArgs(slEx.Message)); } throw slEx; } } if (NotifyMessage != null) { this.NotifyMessage(this, new MessageEventArgs(string.Format("Processed {0} methods in file: {1}", MethodCount, Path.GetFileName(FileName)))); } // One or more channels may have been created dynamicall from the information in the scripts. These dynamic channels // should be shut down gracefully before exiting. if (this.LocalMode == false) { foreach (KeyValuePair <String, ClientChannel> clientPair in this.clientTable) { MethodInfo closeMethod = clientPair.Value.ChannelType.GetMethod("Close"); closeMethod.Invoke(clientPair.Value.ChannelObject, null); } } }