public void LoadShapePositions(string solutionFolder) { FilePath = Path.Combine(solutionFolder, "DiagramShapePositions.json"); tracer.Verbose("Loading shape positions from {0}", FilePath); // Load shape positions from file try { if (File.Exists(FilePath)) { var fileContent = File.ReadAllText(FilePath); ShapePositions = JsonConvert.DeserializeObject <Dictionary <Guid, Point> >(fileContent); tracer.Info("Loaded shape positions from {0}", FilePath); } else { tracer.Info("Could not find shape positions file at {0}", FilePath); } } catch (Exception ex) { tracer.Error(ex, "Cannot load shape positions from {0}.", FilePath); } // If File not exists or an error ocurred if (ShapePositions == null) { ShapePositions = new Dictionary <Guid, Point>(); } }
public bool Initialize(Endpoint endpoint) { NetworkStream clientStream; NetworkStream serverStream; try { m_serverEndpoint = endpoint; clientStream = m_clientConnection.GetStream(); m_serverConnection = new TcpClient(endpoint.Hostname, endpoint.Port) { NoDelay = true }; serverStream = m_serverConnection.GetStream(); } catch (Exception ex) when(ex is SocketException || ex is InvalidOperationException) { m_tracer.Error(ex.ToString()); return(false); } HandleClientTraffic(clientStream, serverStream); HandleServerTraffic(serverStream, clientStream); return(true); }
void PublishXaml(string fileName) { // Make sure we can read it as XML, just to safeguard the client. try { using (var reader = XmlReader.Create(fileName)) { var xdoc = XDocument.Load(reader); // Strip the x:Class attribute since it doesn't make // sense for the deserialization and might break stuff. var xclass = xdoc.Root.Attribute("{http://schemas.microsoft.com/winfx/2009/xaml}Class"); if (xclass != null) { xclass.Remove(); } xclass = xdoc.Root.Attribute("{http://schemas.microsoft.com/winfx/2006/xaml}Class"); if (xclass != null) { xclass.Remove(); } var xml = xdoc.ToString(SaveOptions.DisableFormatting); tracer.Info("!Publishing XAML payload"); proxy.Invoke("Xaml", SessionId, xml) .ContinueWith(t => tracer.Error(t.Exception.InnerException, "Failed to publish XAML payload."), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); } } catch (XmlException) { return; } }
internal void ValidateCustomizedSettingsOverriddenByCustomizableState(ValidationContext context) { try { if (this.IsCustomizationEnabled) { if ((this.IsCustomizable == CustomizationState.False) && (this.Policy.IsModified == true)) { context.LogWarning( string.Format(CultureInfo.CurrentCulture, Properties.Resources.Validate_CustomizedSettingsOverriddenByCustomizableState, this.Name), Properties.Resources.Validate_CustomizedSettingsOverriddenByCustomizableStateCode, this); } } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector <CustomizableElementSchemaBase> .GetMethod(n => n.ValidateCustomizedSettingsOverriddenByCustomizableState(context)).Name); throw; } }
internal void ValidateNameIsUnique(ValidationContext context) { try { IEnumerable <PatternElementSchema> sameNamedElements; if (this.View != null) { // Get siblings in the owning view sameNamedElements = this.View.AllElements() .Where(element => element.Name.Equals(this.Name, System.StringComparison.OrdinalIgnoreCase)); } else { // Get siblings in the owning element sameNamedElements = this.Owner.AllElements() .Where(element => element.Name.Equals(this.Name, System.StringComparison.OrdinalIgnoreCase)); } if (sameNamedElements.Count() > 1) { context.LogError( string.Format(CultureInfo.CurrentCulture, Resources.Validate_PatternElementNameIsNotUnique, this.Name), Resources.Validate_PatternElementNameIsNotUniqueCode, this); } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector <ExtensionPointSchema> .GetMethod(n => n.ValidateNameIsUnique(context)).Name); throw; } }
internal void ValidateCommandIdAndWizardIdIsNotEmpty(ValidationContext context, DragDropSettings settings) { Guard.NotNull(() => context, context); Guard.NotNull(() => settings, settings); try { // Ensure not empty if (settings.CommandId == Guid.Empty && settings.WizardId == Guid.Empty) { context.LogError( string.Format( CultureInfo.CurrentCulture, Resources.Validate_DragDropSettingsCommandIdAndWizardIdIsNotEmpty, settings.Name), Resources.Validate_DragDropSettingsCommandIdAndWizardIdIsNotEmptyCode, settings.Extends); } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector <DragDropSettingsValidations> .GetMethod(n => n.ValidateCommandIdAndWizardIdIsNotEmpty(null, null)).Name); throw; } }
async Task HandleConnectionExceptionAsync(Exception exception) { if (exception is TimeoutException) { await NotifyErrorAsync(ServerProperties.Resources.ServerPacketListener_NoConnectReceived, exception) .ConfigureAwait(continueOnCapturedContext: false); } else if (exception is MqttConnectionException) { tracer.Error(exception, ServerProperties.Resources.ServerPacketListener_ConnectionError, clientId ?? "N/A"); var connectEx = exception as MqttConnectionException; var errorAck = new ConnectAck(connectEx.ReturnCode, existingSession: false); try { await channel.SendAsync(errorAck) .ConfigureAwait(continueOnCapturedContext: false); } catch (Exception ex) { await NotifyErrorAsync(ex).ConfigureAwait(continueOnCapturedContext: false); } } else { await NotifyErrorAsync(exception).ConfigureAwait(continueOnCapturedContext: false); } }
public override void EndInit() { base.EndInit(); this.statusBar = serviceProvider.GetService <SVsStatusbar, IVsStatusbar>(); //this.DragEnterEvent = GetObservableEvent(typeof(IOnSolutionBuilderDragEnter)); //this.DragLeaveEvent = GetObservableEvent(typeof(IOnSolutionBuilderDragLeave)); //this.DropEvent = GetObservableEvent(typeof(IOnSolutionBuilderDrop)); this.dragEnterEventSubscription = this.DragEnterEvent.Subscribe(this.OnDragEnterEvent); this.dragLeaveEventSubscription = this.DragLeaveEvent.Subscribe(this.OnDragLeaveEvent); this.dropEventSubscription = this.DropEvent.Subscribe(this.OnDropEvent); if (this.BindingFactory != null) { try { this.Conditions = this.Settings.ConditionSettings.Select(x => this.BindingFactory.CreateBinding <ICondition>(x)).ToArray(); } catch (Exception e) { tracer.Error(e, Resources.EventAutomation_FailedToParseConditions, this.Name); if (Microsoft.VisualStudio.ErrorHandler.IsCriticalException(e)) { throw; } } } }
/// <summary> /// Load native symbols and modules (i.e. dac, dbi). /// </summary> /// <param name="callback">called back for each symbol file loaded</param> /// <param name="parameter">callback parameter</param> /// <param name="tempDirectory">temp directory unique to this instance of SOS</param> /// <param name="moduleFilePath">module path</param> /// <param name="address">module base address</param> /// <param name="size">module size</param> /// <param name="readMemory">read memory callback delegate</param> public static void LoadNativeSymbols(SymbolFileCallback callback, IntPtr parameter, string tempDirectory, string moduleFilePath, ulong address, int size, ReadMemoryDelegate readMemory) { if (IsSymbolStoreEnabled()) { Debug.Assert(s_tracer != null); Stream stream = new TargetStream(address, size, readMemory); KeyTypeFlags flags = KeyTypeFlags.SymbolKey | KeyTypeFlags.ClrKeys; KeyGenerator generator = null; if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { var elfFile = new ELFFile(new StreamAddressSpace(stream), 0, true); generator = new ELFFileKeyGenerator(s_tracer, elfFile, moduleFilePath); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { var machOFile = new MachOFile(new StreamAddressSpace(stream), 0, true); generator = new MachOFileKeyGenerator(s_tracer, machOFile, moduleFilePath); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { var peFile = new PEFile(new StreamAddressSpace(stream), true); generator = new PEFileKeyGenerator(s_tracer, peFile, moduleFilePath); } else { return; } try { IEnumerable <SymbolStoreKey> keys = generator.GetKeys(flags); foreach (SymbolStoreKey key in keys) { string moduleFileName = Path.GetFileName(key.FullPathName); s_tracer.Verbose("{0} {1}", key.FullPathName, key.Index); // Don't download the sos binaries that come with the runtime if (moduleFileName != "SOS.NETCore.dll" && !moduleFileName.StartsWith("libsos.")) { string downloadFilePath = GetSymbolFile(key, tempDirectory); if (downloadFilePath != null) { s_tracer.Information("{0}: {1}", moduleFileName, downloadFilePath); callback(parameter, moduleFileName, downloadFilePath); } } } } catch (Exception ex) when(ex is BadInputFormatException || ex is InvalidVirtualAddressException) { s_tracer.Error("{0}/{1:X16}: {2}", moduleFilePath, address, ex.Message); } } }
/// <summary> /// Sets the value of the binding /// </summary> protected void SetValue(object target, object value) { var property = TypeDescriptor.GetProperties(target) .Cast <PropertyDescriptor>() .FirstOrDefault(d => d.Name == this.PropertyName); if (property != null) { if (value != null && !property.PropertyType.IsAssignableFrom(value.GetType())) { if (property.Converter != null) { if (property.Converter.CanConvertFrom(value.GetType())) { property.SetValue(target, property.Converter.ConvertFrom(value)); } else { var message = string.Format(CultureInfo.CurrentCulture, Resources.PropertyBinding_PropertyNotCompatible, ObjectDumper.ToString(value, 5), target, this.PropertyName, property.PropertyType, property.Converter); tracer.Error(message); throw new ArgumentException(message); } } else { var message = string.Format(CultureInfo.CurrentCulture, Resources.PropertyBinding_TracePropertyCustomNotCompatible, ObjectDumper.ToString(value, 5), target, this.PropertyName, property.PropertyType); tracer.Error(message); throw new ArgumentException(message); } } else { property.SetValue(target, value); } } else { var message = string.Format(CultureInfo.CurrentCulture, Resources.PropertyBinding_TracePropertyNotFound, target, this.PropertyName); tracer.Error(message); throw new ArgumentException(message); } }
public async Task <IMqttChannel <byte[]> > CreateAsync() { TcpClient tcpClient = new TcpClient(); try { Task connectTask = tcpClient.ConnectAsync(_hostAddress, _configuration.Port); Task timeoutTask = Task.Delay(TimeSpan.FromSeconds(_configuration.ConnectionTimeoutSecs)); Task resultTask = await Task .WhenAny(connectTask, timeoutTask); if (resultTask == timeoutTask) { throw new TimeoutException(); } if (resultTask.IsFaulted) { ExceptionDispatchInfo.Capture(resultTask.Exception.InnerException).Throw(); } return(new TcpChannel(tcpClient, new PacketBuffer(), _configuration)); } catch (SocketException socketEx) { string message = ClientProperties.TcpChannelFactory_TcpClient_Failed(_hostAddress, _configuration.Port); _tracer.Error(socketEx, message); throw new MqttException(message, socketEx); } catch (TimeoutException timeoutEx) { try { // Just in case the connection is a little late, // dispose the tcpClient. This may throw an exception, // which we should just eat. tcpClient.Dispose(); } catch { } string message = ClientProperties.TcpChannelFactory_TcpClient_Failed(_hostAddress, _configuration.Port); _tracer.Error(timeoutEx, message); throw new MqttException(message, timeoutEx); } }
public void Dispose() { _cancellationTokenSource.Cancel(false); _attachedMessages.Clear(); _renewalQueue.CompleteAdding(); try { _renewalManager.Wait(); _renewer.Wait(); } catch (Exception ex) { _tracer.Error(ex, "Renewal producer/consumer finished with failures"); } }
internal void ValidateArtifactReferences(ValidationContext context, IProductElement element) { if (this.UriReferenceService == null) { return; } try { var references = SolutionArtifactLinkReference.GetReferenceValues(element); foreach (var reference in references) { if (this.UriReferenceService.TryResolveUri <IItemContainer>(reference) == null) { context.LogError( string.Format(CultureInfo.InvariantCulture, Properties.Resources.Validate_ArtifactReferenceNotFound, element.InstanceName, reference.ToString(), ReflectionExtensions.DisplayName(typeof(SolutionArtifactLinkReference))), Properties.Resources.Validate_ArtifactReferenceNotFoundCode, element as ModelElement); } } } catch (Exception ex) { tracer.Error( ex, Properties.Resources.ValidationMethodFailed_Error, Reflector <ArtifactReferenceValidation> .GetMethod(n => n.ValidateArtifactReferences(context, element)).Name); throw; } }
public static void ActivateSharedGuidanceWorkflow(this IGuidanceManager guidanceManager, IServiceProvider provider, string extensionId) { Guard.NotNull(() => guidanceManager, guidanceManager); Guard.NotNull(() => provider, provider); Guard.NotNullOrEmpty(() => extensionId, extensionId); var registration = guidanceManager.InstalledGuidanceExtensions.First(e => e.ExtensionId == extensionId); if (registration == null) { tracer.Error(Resources.GuidanceManagerExtensions_ErrorNoRegistration, extensionId); return; } else { // Ensure at least one instance exists var instance = guidanceManager.InstantiatedGuidanceExtensions.FirstOrDefault(e => e.ExtensionId == extensionId); if (instance == null) { // Create the first instance of the guidance tracer.ShieldUI(() => { instance = guidanceManager.Instantiate(extensionId, registration.DefaultName); }, Resources.GuidanceManagerExtensions_ErrorGuidanceInstantiationFailed, registration.DefaultName, extensionId); } // Activate the instance if (instance != null) { guidanceManager.ActivateGuidanceInstance(provider, instance); } } }
internal void ValidateTypeNameNotEmpty(ValidationContext context) { try { // Ensure not empty if (string.IsNullOrEmpty(this.TypeName)) { context.LogError( string.Format( CultureInfo.CurrentCulture, Resources.Validate_WizardSettingsTypeIsNotEmpty, this.Name), Resources.Validate_WizardSettingsTypeIsNotEmptyCode, this.Extends); } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector <WizardSettings> .GetMethod(n => n.ValidateTypeNameNotEmpty(context)).Name); throw; } }
public static Exception ShieldUI(this ITracer tracer, Action action, string errorMessageFormat, params string[] errorArgs) { Guard.NotNull(() => tracer, tracer); Guard.NotNull(() => action, action); Guard.NotNullOrEmpty(() => errorMessageFormat, errorMessageFormat); Guard.NotNull(() => errorArgs, errorArgs); try { action(); } catch (Exception ex) { if (ErrorHandler.IsCriticalException(ex)) { throw; } else { tracer.Error(ex, errorMessageFormat, errorArgs); ShowExceptionAction(ex, errorMessageFormat, errorArgs); return(ex); } } return(null); }
public bool CanExecute(object parameter) { var propertyChanged = this.automation as INotifyPropertyChanged; try { // Prevent re-entrancy on query status if (propertyChanged != null) { propertyChanged.PropertyChanged -= this.OnMenuPropertyChanged; } this.status.QueryStatus(this.menu); parent.IsEnabled = this.menu.Enabled; parent.IsVisible = this.menu.Visible; } catch (Exception e) { tracer.Error(e, Resources.AutomationCommand_QueryStatusFailed); return(false); } finally { // Enable status monitoring again. if (propertyChanged != null) { propertyChanged.PropertyChanged += this.OnMenuPropertyChanged; } } return(this.menu.Enabled); }
internal void ValidateNameIsUnique(ValidationContext context) { try { IEnumerable <AutomationSettingsSchema> sameNamedElements = this.Owner.AutomationSettings .Where(setting => setting.Name.Equals(this.Name, System.StringComparison.OrdinalIgnoreCase)); if (sameNamedElements.Count() > 1) { // Check if one of the properties is a system property if (sameNamedElements.FirstOrDefault(property => property.IsSystem == true) != null) { context.LogError( string.Format(CultureInfo.CurrentCulture, Properties.Resources.Validate_AutomationSettingsNameSameAsSystem, this.Name), Properties.Resources.Validate_AutomationSettingsNameSameAsSystemCode, this); } else { context.LogError( string.Format(CultureInfo.CurrentCulture, Properties.Resources.Validate_AutomationSettingsNameIsNotUnique, this.Name), Properties.Resources.Validate_AutomationSettingsNameIsNotUniqueCode, this); } } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector <AutomationSettingsSchema> .GetMethod(n => n.ValidateNameIsUnique(context)).Name); throw; } }
protected virtual void Dispose(bool disposing) { if (disposed) { return; } if (disposing) { tracer.Info(Properties.Resources.Mqtt_Disposing, GetType().FullName); streamSubscription.Dispose(); receiver.OnCompleted(); try { client?.CloseAsync(WebSocketCloseStatus.NormalClosure, "Dispose", CancellationToken.None).Wait(); client?.Dispose(); } catch (SocketException socketEx) { tracer.Error(socketEx, Properties.Resources.MqttChannel_DisposeError, socketEx.SocketErrorCode); } disposed = true; } }
protected async override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); SetContentView(Resource.Layout.SimpleMain); //UI Logic ConfigureUI(); Console.WriteLine("Welcome to Raspberry Extensions tests"); var relay = new IoTRelay(Connectors.GPIO17, Connectors.GPIO27); hubContainer = new RelayHubTest(); hubContainer.Step += (sender, step) => { RunOnUiThread(() => lblLog.Text = $"Step {step}"); }; hubContainer.Finished += delegate { RunOnUiThread(() => lblLog.Text = $"Finished"); }; hubContainer.Configure(relay); try { await hubContainer.StartAsync(loop : true); } catch (Exception ex) { tracer.Error(ex); } }
async Task HandleConnectionExceptionAsync(Exception exception) { if (exception is TimeoutException) { await NotifyErrorAsync(ServerProperties.ServerPacketListener_NoConnectReceived, exception); } else if (exception is MqttConnectionException) { _tracer.Error(exception, ServerProperties.ServerPacketListener_ConnectionError(_clientId ?? "N/A")); MqttConnectionException connectEx = exception as MqttConnectionException; ConnectAck errorAck = new ConnectAck(connectEx.ReturnCode, existingSession: false); try { await _channel.SendAsync(errorAck); } catch (Exception ex) { await NotifyErrorAsync(ex); } } else { await NotifyErrorAsync(exception); } }
public CommandRegistrar([ImportMany] IEnumerable <Lazy <ICommandExtension, ICommandMetadata> > commands) { commandsByPackage = new Lazy <ConcurrentDictionary <Guid, List <Lazy <ICommandExtension, ICommandMetadata> > > >( () => { var result = new ConcurrentDictionary <Guid, List <Lazy <ICommandExtension, ICommandMetadata> > >(); foreach (var groupedCommands in commands.GroupBy(x => x.Metadata.PackageId)) { try { result .AddOrUpdate( new Guid(groupedCommands.Key), key => new List <Lazy <ICommandExtension, ICommandMetadata> >(groupedCommands), (key, value) => { value.AddRange(groupedCommands); return(value); }); } catch (Exception ex) { tracer.Error(ex, Strings.CommandRegistrar.ErrorImportingCommandForPackage(groupedCommands.Key)); } } return(result); }); }
internal void ValidateGuidanceReference(ValidationContext context, IProductElement element) { try { if (this.GuidanceManager == null) { return; } var reference = element.TryGetReference(ReferenceKindConstants.GuidanceTopic); if (!string.IsNullOrEmpty(reference)) { var uri = GuidanceReference.GetResolvedReferences(element, this.GuidanceManager).FirstOrDefault(); if (uri == null) { context.LogError( string.Format(CultureInfo.InvariantCulture, Properties.Resources.Validate_GuidanceReferenceNotFound, element.InstanceName, reference, ReflectionExtensions.DisplayName(typeof(GuidanceReference))), Properties.Resources.Validate_GuidanceReferenceNotFoundCode, element as ModelElement); } } } catch (Exception ex) { tracer.Error( ex, Properties.Resources.ValidationMethodFailed_Error, Reflector <GuidanceReferenceValidation> .GetMethod(n => n.ValidateGuidanceReference(context, element)).Name); throw; } }
/// <summary> /// Builds the URI for the given template based on the containing project VSIX manifest identifier. /// </summary> internal static Uri BuildUri(IItemContainer selectedItem) { var manifest = selectedItem.GetToolkitManifest(); var owningProject = selectedItem.Traverse(x => x.Parent, item => item.Kind == ItemKind.Project); tracer.Info(Properties.Resources.TextTemplateUriEditor_TraceReadingManifest, manifest.GetLogicalPath()); string vsixId; try { vsixId = Vsix.ReadManifestIdentifier(manifest.PhysicalPath); } catch (Exception e) { tracer.Error(e, String.Format(CultureInfo.CurrentCulture, Properties.Resources.TextTemplateUriEditor_TraceReadingManifestFailed, manifest.GetLogicalPath())); throw; } var path = GetLogicalPath(selectedItem).Replace(owningProject.GetLogicalPath(), string.Empty); // Use alternative name if IncludeInVSIXAs defined var templateItem = (IItem)selectedItem; if (IsIncludeInVSIXAs(templateItem)) { path = Path.Combine(Path.GetDirectoryName(path), templateItem.Data.IncludeInVSIXAs); } return(new Uri(new Uri(TextTemplateUri.UriHostPrefix), new Uri(vsixId + path, UriKind.Relative))); }
internal void ValidateTypeIsNotEmpty(ValidationContext context, CommandSettings settings) { Guard.NotNull(() => context, context); Guard.NotNull(() => settings, settings); try { // Ensure not empty if (string.IsNullOrEmpty(settings.TypeId)) { context.LogError( string.Format( CultureInfo.CurrentCulture, Resources.Validate_CommandSettingsTypeIsNotEmpty, settings.Name), Resources.Validate_CommandSettingsTypeIsNotEmptyCode, settings.Extends); } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector <CommandSettingsValidations> .GetMethod(n => n.ValidateTypeIsNotEmpty(null, null)).Name); throw; } }
/// <summary> /// Called when validations are needed for the command /// </summary> /// <param name="context">Validation Context where to add validation errors</param> /// <param name="settingsElement">The settings element in the model being validated</param> /// <param name="settings">Settings for the command</param> public void Validate(Microsoft.VisualStudio.Modeling.Validation.ValidationContext context, IAutomationSettingsSchema settingsElement, ICommandSettings settings) { try { Guard.NotNull(() => settings, settings); var templateValidator = new TemplateValidator(settings.Name, new UnfoldVsTemplateCommand.UnfoldVsTemplateSettings { SanitizeName = settings.GetPropertyValue <bool>(Reflector <UnfoldVsTemplateCommand> .GetPropertyName(u => u.SanitizeName)), SyncName = settings.GetPropertyValue <bool>(Reflector <UnfoldVsTemplateCommand> .GetPropertyName(u => u.SyncName)), TemplateAuthoringUri = settings.GetPropertyValue <string>(Reflector <UnfoldVsTemplateCommand> .GetPropertyName(u => u.TemplateAuthoringUri)), TemplateUri = settings.GetPropertyValue <string>(Reflector <UnfoldVsTemplateCommand> .GetPropertyName(u => u.TemplateUri)), SettingsElement = settingsElement, OwnerElement = settings.Owner, }, context, ((ModelElement)settings).Store); templateValidator.ValidateCommandSettings(tracer); } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector <TemplateValidator> .GetMethod(n => n.ValidateCommandSettings(null)).Name); throw; } }
public IEnumerable <StageResult> Handle(IReadOnlyDictionary <Guid, List <IAggregatableMessage> > processingResultsMap) { try { var commands = processingResultsMap.SelectMany(x => x.Value).Cast <AggregatableMessage <ICommand> >().SelectMany(x => x.Commands).ToList(); using (Probe.Create("ETL2 Transforming")) using (var transaction = new TransactionScope(TransactionScopeOption.Required, _transactionOptions)) { var syncEvents = Handle(commands.OfType <IAggregateCommand>().ToList()) .Select(x => new FlowEvent(AggregatesFlow.Instance, x)).ToList(); using (new TransactionScope(TransactionScopeOption.Suppress)) _eventLogger.Log <IEvent>(syncEvents); transaction.Complete(); } var stateEvents = Handle(commands.OfType <IncrementErmStateCommand>().ToList()).Concat( Handle(commands.OfType <IncrementAmsStateCommand>().ToList())).Concat( Handle(commands.OfType <LogDelayCommand>().ToList())) .Select(x => new FlowEvent(AggregatesFlow.Instance, x)).ToList(); _eventLogger.Log <IEvent>(stateEvents); return(processingResultsMap.Keys.Select(bucketId => MessageProcessingStage.Handling.ResultFor(bucketId).AsSucceeded())); } catch (Exception ex) { _tracer.Error(ex, "Error when calculating aggregates"); return(processingResultsMap.Keys.Select(bucketId => MessageProcessingStage.Handling.ResultFor(bucketId).AsFailed().WithExceptions(ex))); } }
public async Task <IMqttConnectedClient> CreateClientAsync(MqttConfiguration configuration) { try { //Adding this to not break backwards compatibility related to the method signature //Yielding at this point will cause the method to return immediately after it's called, //running the rest of the logic acynchronously await Task.Yield(); var binding = new PrivateBinding(privateStreamListener, EndpointIdentifier.Client); var topicEvaluator = new MqttTopicEvaluator(configuration); var innerChannelFactory = binding.GetChannelFactory(IPAddress.Loopback.ToString(), configuration); var channelFactory = new PacketChannelFactory(innerChannelFactory, topicEvaluator, configuration); var packetIdProvider = new PacketIdProvider(); var repositoryProvider = new InMemoryRepositoryProvider(); var flowProvider = new ClientProtocolFlowProvider(topicEvaluator, repositoryProvider, configuration); return(new MqttConnectedClient(channelFactory, flowProvider, repositoryProvider, packetIdProvider, configuration)); } catch (Exception ex) { tracer.Error(ex, Properties.Resources.Client_InitializeError); throw new MqttClientException(Properties.Resources.Client_InitializeError, ex); } }
/// <summary> /// Discards changes since the last <see cref="M:System.ComponentModel.IEditableObject.BeginEdit" /> call. /// </summary> public virtual void CancelEdit() { tracer.Verbose("CancelEdit"); if (this.editing) { this.editing = false; // Restore a clean copy of the object, as if it was brand-new created. try { var clean = Activator.CreateInstance(this.GetType(), this.manager); foreach (var property in TypeDescriptor.GetProperties(this).Cast <PropertyDescriptor>()) { property.SetValue(this, property.GetValue(clean)); } this.IsInitialized = false; this.manager.Read(this); } catch (Exception ex) { tracer.Error(ex, Strings.Settings.FailedToRestore); // TODO: failed to restore some properties. Leave current object state as-is? } } }
/// <summary> /// Creates an MQTT Client /// </summary> /// <param name="configuration"> /// The configuration used for creating the Client /// See <see cref="MqttConfiguration" /> for more details about the supported values /// </param> /// <returns>A new MQTT Client</returns> /// <exception cref="MqttClientException">MqttClientException</exception> public async Task <IMqttClient> CreateClientAsync(MqttConfiguration configuration) { try { //Adding this to not break backwards compatibility related to the method signature //Yielding at this point will cause the method to return immediately after it's called, //running the rest of the logic acynchronously await Task.Yield(); MqttTopicEvaluator topicEvaluator = new MqttTopicEvaluator(configuration); IMqttChannelFactory innerChannelFactory = _binding.GetChannelFactory(_hostAddress, configuration); PacketChannelFactory channelFactory = new PacketChannelFactory(innerChannelFactory, topicEvaluator, configuration); PacketIdProvider packetIdProvider = new PacketIdProvider(); InMemoryRepositoryProvider repositoryProvider = new InMemoryRepositoryProvider(); ClientProtocolFlowProvider flowProvider = new ClientProtocolFlowProvider(topicEvaluator, repositoryProvider, configuration); return(new MqttClientImpl(channelFactory, flowProvider, repositoryProvider, packetIdProvider, configuration)); } catch (Exception ex) { _tracer.Error(ex, ClientProperties.Client_InitializeError); throw new MqttClientException(ClientProperties.Client_InitializeError, ex); } }
/// <summary> /// Synchronizes the targets file on disk with targets file in this version of the toolkit. /// </summary> internal static void SyncTargets(ITracer tracer, TargetsInfo targetsInfo) { try { tracer.Info(Resources.AuthoringPackage_TraceSyncTargetsInitial); //Write updated targets file WriteUpdatedTargets(tracer, targetsInfo); } catch (Exception ex) { tracer.Error(ex, Resources.AuthoringPackage_FailedSyncTargets); } }
public static string Evaluate(this IPropertyBindingSettings settings, IBindingFactory bindingFactory, ITracer tracer, Action<IDynamicBindingContext> contextInitializer = null) { string result; if (settings.ValueProvider != null) { var binding = bindingFactory.CreateBinding<IValueProvider>(settings.ValueProvider); // Make the entire set of element interfaces available to VP bindings. // We add the owner with its full interfaces. And we add the IProperty as well. using (var context = binding.CreateDynamicContext()) { if (contextInitializer != null) contextInitializer(context); if (binding.Evaluate(context)) { result = binding.Value.Evaluate() as string; } else { var failMessage = string.Format(CultureInfo.CurrentCulture, Resources.ValueProviderBinding_FailedToEvaluate, settings.Name, settings.Name, ObjectDumper.ToString(binding.EvaluationResults, 5)); tracer.Error(failMessage); throw new InvalidOperationException(failMessage); } } } else { result = settings.Value; } return result; }