コード例 #1
0
 private void ServiceConnectionHandler_ServiceHandlerInitializationCompleted(object sender, ServiceHandlerConnectionChangedEventArgs e)
 {
     if (e.Status == ProcessManagerServiceHandlerStatus.Connected)
     {
         Task.Run(() => DistributeSourceFilesThread(e.ServiceHandler.Machine));
     }
     else
     {
         ConnectionStore.RemoveConnection(e.ServiceHandler.Machine);
     }
 }
コード例 #2
0
        private void DistributionConnectionManagementThread()
        {
            try
            {
                Logger.Add("STARTUP -- Starting distribution connection management thread...");

                while (!_shutDownRequested)
                {
                    try
                    {
                        lock (_pendingDistributionWork)
                        {
                            ConnectionStore.Connections.Keys
                            .Where(machine => !_pendingDistributionWork.Any(work => Comparer.MachinesEqual(work.DestinationMachine, machine)))
                            .ToList()
                            .ForEach(ConnectionStore.RemoveConnection);
                        }

                        List <Machine> machinesToConnect;
                        lock (_pendingDistributionWork)
                        {
                            machinesToConnect = _pendingDistributionWork
                                                .Select(work => work.DestinationMachine)
                                                .Distinct(new MachineEqualityComparer())
                                                .Where(destinationMachine => !ConnectionStore.Connections.ContainsKey(destinationMachine))
                                                .ToList();
                        }

                        machinesToConnect.ForEach(destinationMachine =>
                        {
                            MachineConnection connection = ConnectionStore.CreateConnection(this, destinationMachine);
                            connection.ServiceHandler.Initialize();
                        });
                    }
                    catch (Exception ex)
                    {
                        Logger.Add("An unexpected error occurred in distribution connection management thread", ex);
                    }

                    Thread.Sleep(Settings.Service.Read <int>("DistributionConnectionCleanInterval"));
                }

                Logger.Add("SHUTDOWN -- Shutting down distribution connection management thread...");
            }
            catch (Exception ex)
            {
                Logger.Add("Fatal exception in distribution connection management thread, dying....", ex);
            }
            finally
            {
                // indicate that we are no longer running
                _distributionConnectionManagementThread = null;
            }
        }
コード例 #3
0
        private void DistributeSourceFilesThread(Machine machine)
        {
            List <DistributionWork> processedDistributionWork = new List <DistributionWork>();

            while (ConnectionStore.ConnectionCreated(machine))
            {
                DistributionWork work;

                lock (_pendingDistributionWork)
                {
                    work = _pendingDistributionWork
                           .Where(pendingWork => Comparer.MachinesEqual(pendingWork.DestinationMachine, machine))
                           .FirstOrDefault(pendingWork => !processedDistributionWork.Contains(pendingWork));
                }

                if (work == null)
                {
                    Thread.Sleep(10);
                    continue;
                }

                processedDistributionWork.Add(work);

                Task.Run(() =>
                {
                    try
                    {
                        try
                        {
                            Group destinationGroup = ConnectionStore.Connections[work.DestinationMachine].Configuration.Groups
                                                     .FirstOrDefault(group => Comparer.GroupsEqual(group, work.Group));

                            if (destinationGroup == null)
                            {
                                Logger.AddAndThrow <DistributionActionException>(LogType.Warning, $"Could not distribute application {work.Application.Name} in group {work.Group.Name}" +
                                                                                 $" to destination machine {work.DestinationMachine.HostName}. Destination machine does not contain a matching group.");
                            }

                            List <string> errorMessages = new List <string>();
                            foreach (DistributionFile file in work.Files)
                            {
                                file.DestinationGroupID = destinationGroup.ID;
                                file.Content            = FileSystemHandler.GetFileContent(Path.Combine(work.Group.Path, file.RelativePath.Trim(Path.DirectorySeparatorChar)));

                                DistributeFileResult result = ConnectionStore.Connections[work.DestinationMachine].ServiceHandler.Service.DistributeFile(new DTODistributionFile(file)).FromDTO();

                                try
                                {
                                    if (result.Success)
                                    {
                                        Logger.Add(LogType.Verbose, $"Distribution of file to {work.DestinationMachine.HostName} succeeded: {file.RelativePath}, {file.Content.Length} bytes");
                                    }
                                    else
                                    {
                                        Logger.AddAndThrow <DistributionActionException>(LogType.Error, $"Distribution of file to {work.DestinationMachine.HostName} failed: {Path.GetFileName(file.RelativePath)} | {result.ErrorMessage}");
                                    }
                                }
                                catch (DistributionActionException ex)
                                {
                                    errorMessages.Add(ex.Message);
                                }

                                file.IsDistributed = true;
                            }

                            if (errorMessages.Any())
                            {
                                throw new DistributionActionException(string.Join(Environment.NewLine, errorMessages.Select(x => x.Replace(" | ", Environment.NewLine + "\t"))));
                            }

                            RaiseDistributionCompletedEvent(new DistributionResult(work, DistributionResultValue.Success), work.ClientId);
                        }
                        catch (DistributionActionException) { throw; }
                        catch (ThreadAbortException) { }
                        catch (Exception ex)
                        {
                            Logger.AddAndThrow <DistributionActionException>("An unexpected error occurred while distributing source files, aborting..", ex);
                        }
                        finally
                        {
                            lock (_pendingDistributionWork)
                                _pendingDistributionWork.Remove(work);
                        }
                    }
                    catch (DistributionActionException ex)
                    {
                        RaiseDistributionCompletedEvent(new DistributionResult(work, DistributionResultValue.Failure, ex.Message), work.ClientId);
                    }
                });
            }
        }