Beispiel #1
0
 protected WorkerThread(string name, ThreadPriority priority, ApartmentState apartmentState)
 {
     _thread = new Thread(new ThreadStart(this.InternalRun));
     _thread.Name = name;
     _thread.Priority = priority;
     _thread.SetApartmentState(apartmentState);
 }
			/// <summary>
			/// Runs in the specified apartment
			/// </summary>
			private void RunInApartment(ThreadStart userDelegate, ApartmentState apartmentState)
			{
				Exception thrownException = null;

				Thread thread = new Thread(
				  delegate()
				  {
					  try
					  {
						  userDelegate.Invoke();
					  }
					  catch (Exception e)
					  {
						  thrownException = e;
					  }
				  });
				thread.SetApartmentState(apartmentState);

				thread.Start();
				thread.Join();

				if (thrownException != null)
				{
					ThrowExceptionPreservingStack(thrownException);
				}
			}
        private void Run(ThreadStart userDelegate, ApartmentState apartmentState)
        {
            lastException = null;

            var thread = new Thread(
                delegate()
                    {
                        try
                        {
                            userDelegate.Invoke();
                        }
                        catch (Exception e)
                        {
                            lastException = e;
                        }
                    });
            thread.SetApartmentState(apartmentState);

            thread.Start();
            thread.Join();

            if (ExceptionWasThrown())
            {
                ThrowExceptionPreservingStack(lastException);
            }
        }
		public AssemblyItem( string path, ApartmentState apartment )
		{
			if ( !System.IO.Path.IsPathRooted( path ) )
				throw new ArgumentException( "Assembly path must be absolute", "path" );
			this.path = path;
			this.apartment = apartment;
		}
		/// <summary>
		/// A common helper method that tests running a test in an apartment from an apartment.
		/// </summary>
		private bool RunInApartmentFromApartment(ApartmentState fromApartMent, ApartmentState inApartment)
		{
			bool wasRunInCorrectApartment = false;

			Thread runnerThread = new Thread((ThreadStart)delegate
			{
				if (inApartment == ApartmentState.MTA)
				{
					ThreadRunner.RunInMTA(delegate
					{
						wasRunInCorrectApartment = Thread.CurrentThread.GetApartmentState() == inApartment;
					});
				}
				else if (inApartment == ApartmentState.STA)
				{
					ThreadRunner.RunInSTA(delegate
					{
						wasRunInCorrectApartment = Thread.CurrentThread.GetApartmentState() == inApartment;
					});
				}
			}
			);
			runnerThread.SetApartmentState(fromApartMent);
			runnerThread.Start();
			runnerThread.Join();

			return wasRunInCorrectApartment;
		}
		/// <summary>Invokes the specified delegate with the specified parameters in the specified kind of apartment state.</summary>
		/// <param name="d">The delegate to be invoked.</param>
		/// <param name="parameters">The parameters to pass to the delegate being invoked.</param>
		/// <param name="state">The apartment state to run under.</param>
		/// <returns>The result of calling the delegate.</returns>
		public static object Execute(
			Delegate d, object[] parameters, ApartmentState state)
		{
			if (d == null) throw new ArgumentNullException("d");
			if (state != ApartmentState.MTA && state != ApartmentState.STA)
				throw new ArgumentOutOfRangeException("state");

			if (Thread.CurrentThread.ApartmentState == state)
			{
				return d.DynamicInvoke(parameters);
			}
			else
			{
				ApartmentStateSwitcher switcher = new ApartmentStateSwitcher();
				switcher._delegate = d;
				switcher._parameters = parameters;

				Thread t = new Thread(new ThreadStart(switcher.Run));
				t.ApartmentState = state;
				t.IsBackground = true;
				t.Start();
				t.Join();

				if (switcher._exc != null) throw switcher._exc;
				return switcher._rv;
			}
		}
        private void Run(ThreadStart userDelegate, ApartmentState apartmentState)
        {
            lastException = null;

            Thread thread = new Thread(
                delegate()
                    {
#if !DEBUG
                        try
                        {
#endif
                        userDelegate.Invoke();
#if !DEBUG
                        }
                        catch (Exception e)
                        {
                            lastException = e;
                        }
#endif
                    });
            thread.SetApartmentState(apartmentState);

            thread.Start();
            thread.Join();

            if (ExceptionWasThrown())
                ThrowExceptionPreservingStack(lastException);
        }
 internal ServerSteppablePipelineDriver(PowerShell powershell, bool noInput, Guid clientPowerShellId, Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver, ApartmentState apartmentState, HostInfo hostInfo, System.Management.Automation.RemoteStreamOptions streamOptions, bool addToHistory, Runspace rsToUse, ServerSteppablePipelineSubscriber eventSubscriber, PSDataCollection<object> powershellInput)
 {
     this.localPowerShell = powershell;
     this.clientPowerShellId = clientPowerShellId;
     this.clientRunspacePoolId = clientRunspacePoolId;
     this.remoteStreamOptions = streamOptions;
     this.apartmentState = apartmentState;
     this.noInput = noInput;
     this.addToHistory = addToHistory;
     this.eventSubscriber = eventSubscriber;
     this.powershellInput = powershellInput;
     this.input = new PSDataCollection<object>();
     this.inputEnumerator = this.input.GetEnumerator();
     this.input.ReleaseOnEnumeration = true;
     this.dsHandler = runspacePoolDriver.DataStructureHandler.CreatePowerShellDataStructureHandler(clientPowerShellId, clientRunspacePoolId, this.remoteStreamOptions, null);
     this.remoteHost = this.dsHandler.GetHostAssociatedWithPowerShell(hostInfo, runspacePoolDriver.ServerRemoteHost);
     this.dsHandler.InputEndReceived += new EventHandler(this.HandleInputEndReceived);
     this.dsHandler.InputReceived += new EventHandler<RemoteDataEventArgs<object>>(this.HandleInputReceived);
     this.dsHandler.StopPowerShellReceived += new EventHandler(this.HandleStopReceived);
     this.dsHandler.HostResponseReceived += new EventHandler<RemoteDataEventArgs<RemoteHostResponse>>(this.HandleHostResponseReceived);
     this.dsHandler.OnSessionConnected += new EventHandler(this.HandleSessionConnected);
     if (rsToUse == null)
     {
         throw PSTraceSource.NewInvalidOperationException("RemotingErrorIdStrings", "NestedPipelineMissingRunspace", new object[0]);
     }
     this.localPowerShell.Runspace = rsToUse;
     eventSubscriber.SubscribeEvents(this);
     this.stateOfSteppablePipeline = PSInvocationState.NotStarted;
 }
Beispiel #9
0
        /// <summary>
        /// Class constructor initializes fields from config file
        /// </summary>
        static NUnitConfiguration()
        {
            try
            {
                NameValueCollection settings = GetConfigSection("NUnit/TestCaseBuilder");
                if (settings != null)
                {
                    string oldStyle = settings["OldStyleTestCases"];
                    if (oldStyle != null)
                            allowOldStyleTests = Boolean.Parse(oldStyle);
                }

                settings = GetConfigSection("NUnit/TestRunner");
                if (settings != null)
                {
                    string apartment = settings["ApartmentState"];
                    if (apartment != null)
                        apartmentState = (ApartmentState)
                            System.Enum.Parse(typeof(ApartmentState), apartment, true);

                    string priority = settings["ThreadPriority"];
                    if (priority != null)
                        threadPriority = (ThreadPriority)
                            System.Enum.Parse(typeof(ThreadPriority), priority, true);
                }
            }
            catch (Exception ex)
            {
                string msg = string.Format("Invalid configuration setting in {0}",
                    AppDomain.CurrentDomain.SetupInformation.ConfigurationFile);
                throw new ApplicationException(msg, ex);
            }
        }
Beispiel #10
0
 /// <summary>
 /// Initialies a new <see cref="DispatcherContext"/> synchronized with a new <see cref="Thread"/> instance
 /// </summary>
 /// <param name="threadApartmentState">The <see cref="ApartmentState"/> of the <see cref="Dispatcher"/>'s <see cref="Thread"/></param>
 ///<param name="owner">The <see cref="Dispatcher"/> that owns the <see cref="DispatcherContext"/></param>
 public DispatcherContext(Dispatcher owner, ApartmentState threadApartmentState)
 {
     Thread dispatcherThread;
     this.Owner = owner;
     dispatcherThread = new Thread(new ParameterizedThreadStart(this.ExecuteOperations));
     dispatcherThread.SetApartmentState(threadApartmentState);
 }
		public SingleThreadTaskScheduler(string name = null, ThreadPriority priority = ThreadPriority.Normal, ApartmentState apartmentState = ApartmentState.STA)
		{
#if DEBUG
			_allocStackTrace = new StackTrace();
#endif

			_thread = new Thread(
				() =>
				{
					try
					{
						foreach (var task in _queue.GetConsumingEnumerable())
							TryExecuteTask(task);
					}
					finally
					{
						_queue.Dispose();
					}
				});

			_thread.IsBackground = true;
			_thread.Name = name;
			_thread.Priority = priority;
			_thread.SetApartmentState(apartmentState);

			_thread.Start();
		}
        private void StartNewDispatcherThread(ApartmentState apartmentState)
        {
            var reset = new ManualResetEvent(false);

            var t = new Thread((ThreadStart)delegate
            {
                Thread.CurrentThread.Name = string.Format("WorkDispatcherThread");

                Dispatcher.Run(reset);
            })
            {
                IsBackground = true
            };

            t.SetApartmentState(apartmentState);

            t.Priority = ThreadPriority.Normal;

            /* Starts the thread and creates the object */
            t.Start();
           
            /* We wait until our dispatcher is initialized and
             * the new Dispatcher is running */
            reset.WaitOne();
        }
Beispiel #13
0
        public void GetParentThreadInfo()
        {
            ParentThread = Thread.CurrentThread;
#if !NETCF
            ParentThreadApartment = GetApartmentState(ParentThread);
#endif
        }
 private void InitializeThreadState(object threadParams, ThreadWorkerMethodWithReturn workerMethod, ApartmentState aptState, bool background)
 {
     this.threadParams = threadParams;
     this.threadWorkerMethodWithReturn = workerMethod;
     this.thread = new Thread(new ThreadStart(this.ThreadEntryPointMethodWithReturn));
     this.thread.SetApartmentState(aptState);
     this.backgroundThread = background;
 }
        private IRSPDriverInvoke _psDriverInvoker;  // Handles nested invocation of PS drivers.

        #endregion Private Members

        #region Constructors

#if !CORECLR
        /// <summary>
        /// Default constructor for creating ServerPowerShellDrivers
        /// </summary>
        /// <param name="powershell">decoded powershell object</param>
        /// <param name="extraPowerShell">extra pipeline to be run after <paramref name="powershell"/> completes</param>
        /// <param name="noInput">whether there is input for this powershell</param>
        /// <param name="clientPowerShellId">the client powershell id</param>
        /// <param name="clientRunspacePoolId">the client runspacepool id</param>
        /// <param name="runspacePoolDriver">runspace pool driver 
        /// which is creating this powershell driver</param>
        /// <param name="apartmentState">apartment state for this powershell</param>
        /// <param name="hostInfo">host info using which the host for
        /// this powershell will be constructed</param>
        /// <param name="streamOptions">serialization options for the streams in this powershell</param>
        /// <param name="addToHistory">
        /// true if the command is to be added to history list of the runspace. false, otherwise.
        /// </param>
        /// <param name="rsToUse">
        /// If not null, this Runspace will be used to invoke Powershell.
        /// If null, the RunspacePool pointed by <paramref name="runspacePoolDriver"/> will be used.
        /// </param>
        internal ServerPowerShellDriver(PowerShell powershell, PowerShell extraPowerShell, bool noInput, Guid clientPowerShellId,
            Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver,
            ApartmentState apartmentState, HostInfo hostInfo, RemoteStreamOptions streamOptions,
            bool addToHistory, Runspace rsToUse)
            : this(powershell, extraPowerShell, noInput, clientPowerShellId, clientRunspacePoolId, runspacePoolDriver,
                   apartmentState, hostInfo, streamOptions, addToHistory, rsToUse, null)
        {
        }
        /// <summary>
        /// Construct a new TestWorker.
        /// </summary>
        /// <param name="queue">The queue from which to pull work items</param>
        /// <param name="name">The name of this worker</param>
        /// <param name="apartmentState">The apartment state to use for running tests</param>
        public TestWorker(WorkItemQueue queue, string name, ApartmentState apartmentState)
        {
            _readyQueue = queue;

            _workerThread = new Thread(new ThreadStart(TestWorkerThreadProc));
            _workerThread.Name = name;
            _workerThread.SetApartmentState(apartmentState);
        }
 public DedicatedThreadPoolSettings(int numThreads,
                                    string name = null,
                                    TimeSpan? deadlockTimeout = null,
                                    ApartmentState apartmentState = ApartmentState.Unknown,
                                    Action<Exception> exceptionHandler = null,
                                    int threadMaxStackSize = 0)
     : this(numThreads, DefaultThreadType, name, deadlockTimeout, apartmentState, exceptionHandler, threadMaxStackSize)
 { }
Beispiel #18
0
 public void Start(ApartmentState state = ApartmentState.MTA)
 {
     if (thread == null)
     {
         thread = new Thread(WorkThread);
         thread.SetApartmentState(state);
         thread.Start();
     }
 }
Beispiel #19
0
 public BackgroundWorker(IPendingWorkCollection<IScheduledTask> pendingWorkCollection, ApartmentState apartmentState)
 {
     _cancellationTokenSource = new CancellationTokenSource();
     _pendingWorkCollection = pendingWorkCollection;
     _apartmentState = apartmentState;
     _isDisposing = false;
     _isDisposed = false;
     _isStarted = false;
 }
Beispiel #20
0
 public ExecutionQueue(ApartmentState state)
 {
     _executionThread = new Thread(ExecutionThread);
     _executionThread.IsBackground = true;
     _executionThread.Name = "ExecutionThread";
     _executionThread.SetApartmentState(state);
     _executionThread.Start();
     _commandDispatcher = (action) => action();
 }
Beispiel #21
0
 public static Thread RunInThread(this Action func,ApartmentState? model = null,bool isBackground = true)
 {
     Thread thread = new Thread(new ThreadStart(func));
     if (model.HasValue) {
         thread.SetApartmentState(model.Value);
     }
     thread.IsBackground = isBackground;
     thread.Start();
     return thread;
 }
Beispiel #22
0
        /// <summary>
        /// Evaluates expression within the given environment on
        /// a new thread - Returns immediately, but the new thread 
        /// continues to execute expression asynchronously.
        /// </summary>
        /// <param name="expression"></param>
        /// <param name="environment"></param>
        /// <returns>The new Thread</returns>
        public static Thread Fork(Object expression, Environment environment, ApartmentState apartmentState)
        {
            ThreadAdapter threadAdapter = new ThreadAdapter(expression, environment);

            ThreadStart job = new ThreadStart(threadAdapter.Invoke);
            Thread thread = new Thread(job);
            thread.SetApartmentState(apartmentState);
            thread.Start();
            return thread;
        }
		/// <summary>
		/// Runs the specified delegate in the specified apartment
		/// </summary>
		private static void RunInApartment(ThreadStart userDelegate, ApartmentState apartment)
		{
			if (apartment == ApartmentState.Unknown)
			{
				throw new InvalidOperationException("Can only run in STAs or MTAs");
			}

			ApartmentOperationRunner runner = new ApartmentOperationRunner();
			runner.Run(userDelegate, apartment);
		}
 /// <summary>
 /// Initializes a new instance of the <see cref="ThreadedWorkerBase" /> class.
 /// </summary>
 /// <param name="logger">The logger.</param>
 /// <param name="apartmentState"></param>
 /// <param name="isBackgroundThread">Specifies whether or not the thread should be marked as a Background Thread</param>
 protected ThreadedWorkerBase(ILogger logger, ApartmentState apartmentState = ApartmentState.MTA, bool isBackgroundThread = true)
 {
     this.logger = Guard.IsNull(() => logger);
     Id = Guid.NewGuid();
     thread = new Thread(DoExecute)
     {
         IsBackground = isBackgroundThread
     };
     thread.SetApartmentState(apartmentState);
 }
 public void append(BackgroundWorkerItem item, Object[] parameters, TimeSpan timeout, ApartmentState apartmentState, ThreadPriority priority)
 {
     StackItem sItem = new StackItem();
     sItem.bWItem = item;
     sItem.parameters = parameters;
     sItem.timeout = timeout;
     sItem.apartmentState = apartmentState;
     sItem.priority = priority;
     //
     this._methodStack.Add(sItem);
 }
Beispiel #26
0
 internal PipelineThread(ApartmentState apartmentState)
 {
     this.worker = new Thread(new ThreadStart(this.WorkerProc), LocalPipeline.MaxStack);
     this.workItem = null;
     this.workItemReady = new AutoResetEvent(false);
     this.closed = false;
     if (apartmentState != ApartmentState.Unknown)
     {
         this.worker.SetApartmentState(apartmentState);
     }
 }
Beispiel #27
0
 public int Run(string[] arguments, Configuration configuration, ProgressReporter reporter)
 {
     LastArguments = arguments;
     ApartmentState = Thread.CurrentThread.GetApartmentState();
     try {
         return int.Parse(ConfigurationManager.AppSettings.Get("returnCode"));
     }
     catch (Exception) {
         return Result;
     }
 }
Beispiel #28
0
 public static Thread AlterThread(Action action, bool isBackground, ApartmentState apartmentState)
 {
     Thread t = new Thread(() =>
     {
         action();
     });
     t.SetApartmentState(apartmentState);
     t.IsBackground = isBackground;
     t.Start();
     return t;
 }
Beispiel #29
0
        /// <summary>
        /// 创建线程
        /// </summary>
        /// <param name="name"></param>
        /// <param name="task"></param>
        /// <param name="isBackground"></param>
        /// <param name="apartmentState"></param>
        public SmartThread(Action task, string name = null, bool isBackground = true, ApartmentState apartmentState = ApartmentState.MTA)
        {
            if (task == null)
                throw new ArgumentNullException("task");

            InnerThread = new System.Threading.Thread(()=>task()) { Name = name, IsBackground = isBackground };
            InnerThread.SetApartmentState(apartmentState);

            mutex = new ResetEvent(false);
            State = ThreadState.NotStarted;
        }
 public void SetApartmentState(ApartmentState state)
 {
     try
     {
         thread.SetApartmentState(state);
     }
     catch (Exception exception)
     {
         if (logger != null) logger.Log("HomeOS SafeThread exception in setapartmentstate() : " + exception.GetType());
     }
 }
Beispiel #31
0
 /// <summary>
 ///     Sets the threading apartment state of the Thread. This must be called before starting the thread
 /// </summary>
 /// <param name="state">The new state</param>
 public void SetApartmentState(ApartmentState state)
 {
     _thread.SetApartmentState(state);
 }
Beispiel #32
0
        /// <summary>
        /// Performs the update.
        /// </summary>
        /// <returns><c>true</c> if the update completed successfully;
        /// <c>false</c> otherwise.</returns>
        public override bool Update()
        {
            Trace.TraceInformation("Checking for new client version...");
            Trace.Indent();
            SetProgressMaximum(2);
            SetMessage(String.Format("Checking for new {0} version...", EnvironmentInfo.Settings.ModManagerName));
            string  strDownloadUri = String.Empty;
            Version verNew         = GetNewProgrammeVersion(out strDownloadUri);

            SetProgress(1);

            if (CancelRequested)
            {
                Trace.Unindent();
                return(CancelUpdate());
            }

            if (verNew == new Version("69.69.69.69"))
            {
                SetMessage("Could not get version information from the update server.");
                return(false);
            }

            StringBuilder stbPromptMessage = new StringBuilder();
            DialogResult  drResult         = DialogResult.No;

            string strReleaseNotes = String.Empty;

            if ((verNew > new Version(ProgrammeMetadata.VersionString)) && !String.IsNullOrEmpty(strDownloadUri))
            {
                string strCheckDownloadedInstaller = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Temp", Path.GetFileName(strDownloadUri));

                stbPromptMessage.AppendFormat("A new version of {0} is available ({1}).{2}Would you like to download and install it?", EnvironmentInfo.Settings.ModManagerName, verNew, Environment.NewLine).AppendLine();
                stbPromptMessage.AppendLine();
                stbPromptMessage.AppendLine();
                stbPromptMessage.AppendLine("Below you can find the change log for the new release:");

                try
                {
                    HttpWebRequest  request  = (HttpWebRequest)WebRequest.Create(m_strURI);
                    HttpWebResponse response = (HttpWebResponse)request.GetResponse();

                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        Stream       receiveStream = response.GetResponseStream();
                        StreamReader readStream    = null;

                        if (response.CharacterSet == null)
                        {
                            readStream = new StreamReader(receiveStream);
                        }
                        else
                        {
                            readStream = new StreamReader(receiveStream, Encoding.GetEncoding(response.CharacterSet));
                        }

                        strReleaseNotes = readStream.ReadToEnd();

                        response.Close();
                        readStream.Close();
                    }
                }
                catch
                {
                    strReleaseNotes = "Unable to retrieve the Release Notes.";
                }

                try
                {
                    //the extended message box contains an activex control wich must be run in an STA thread,
                    // we can't control what thread this gets called on, so create one if we need to
                    ThreadStart    actShowMessage = () => drResult = ExtendedMessageBox.Show(null, stbPromptMessage.ToString(), "New version available", strReleaseNotes, 700, 450, ExtendedMessageBoxButtons.Backup, MessageBoxIcon.Question);
                    ApartmentState astState       = ApartmentState.Unknown;
                    Thread.CurrentThread.TrySetApartmentState(astState);
                    if (astState == ApartmentState.STA)
                    {
                        actShowMessage();
                    }
                    else
                    {
                        Thread thdMessage = new Thread(actShowMessage);
                        thdMessage.SetApartmentState(ApartmentState.STA);
                        thdMessage.Start();
                        thdMessage.Join();
                    }
                }
                catch
                {
                }

                if (drResult == DialogResult.Cancel)
                {
                    Trace.Unindent();
                    return(CancelUpdate());
                }

                if (drResult == DialogResult.Yes)
                {
                    UpdateManager.CreateBackup();
                }

                if (File.Exists(strCheckDownloadedInstaller))
                {
                    SetMessage("Launching installer...");
                    ProcessStartInfo psiInfo = new ProcessStartInfo(strCheckDownloadedInstaller);
                    Process.Start(psiInfo);
                    Trace.Unindent();
                    return(true);
                }

                SetMessage(String.Format("Downloading new {0} version...", EnvironmentInfo.Settings.ModManagerName));

                string strNewInstaller = string.Empty;
                try
                {
                    strNewInstaller = DownloadFile(new Uri(String.Format(strDownloadUri)));
                }
                catch (FileNotFoundException)
                {
                    StringBuilder stbAVMessage = new StringBuilder();
                    stbAVMessage.AppendLine("Unable to find the installer to download:");
                    stbAVMessage.AppendLine("this could be caused by a network issue or by your Firewall.");
                    stbAVMessage.AppendLine("As a result you won't be able to automatically update the program.");
                    stbAVMessage.AppendLine();
                    stbAVMessage.AppendFormat("You can download the update manually from:");
                    stbAVMessage.AppendLine("http://skyrim.nexusmods.com/mods/modmanager/");
                    try
                    {
                        //the extended message box contains an activex control wich must be run in an STA thread,
                        // we can't control what thread this gets called on, so create one if we need to
                        ThreadStart    actShowMessage = () => drResult = ExtendedMessageBox.Show(null, stbAVMessage.ToString(), "Unable to update", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        ApartmentState astState       = ApartmentState.Unknown;
                        Thread.CurrentThread.TrySetApartmentState(astState);
                        if (astState == ApartmentState.STA)
                        {
                            actShowMessage();
                        }
                        else
                        {
                            Thread thdMessage = new Thread(actShowMessage);
                            thdMessage.SetApartmentState(ApartmentState.STA);
                            thdMessage.Start();
                            thdMessage.Join();
                        }
                    }
                    catch
                    {
                    }

                    Trace.Unindent();
                    return(CancelUpdate());
                }

                SetProgress(2);

                if (CancelRequested)
                {
                    Trace.Unindent();
                    return(CancelUpdate());
                }

                if (!String.IsNullOrEmpty(strNewInstaller))
                {
                    string strOldPath = strNewInstaller;
                    strNewInstaller = Path.Combine(Path.GetTempPath(), Path.GetFileName(strNewInstaller));
                    FileUtil.ForceDelete(strNewInstaller);

                    try
                    {
                        File.Move(strOldPath, strNewInstaller);
                    }
                    catch (FileNotFoundException)
                    {
                        StringBuilder stbAVMessage = new StringBuilder();
                        stbAVMessage.AppendLine("Unable to find the downloaded update:");
                        stbAVMessage.AppendLine("this could be caused by a network issue or by your anti-virus software deleting it falsely flagging the installer as a virus.");
                        stbAVMessage.AppendLine("As a result you won't be able to automatically update the program.");
                        stbAVMessage.AppendLine();
                        stbAVMessage.AppendFormat("To fix this issue you need to add {0}'s executable and all its folders to your", EnvironmentInfo.Settings.ModManagerName).AppendLine();
                        stbAVMessage.AppendLine("anti-virus exception list. You can also download the update manually from:");
                        stbAVMessage.AppendLine("http://skyrim.nexusmods.com/mods/modmanager/");

                        try
                        {
                            //the extended message box contains an activex control wich must be run in an STA thread,
                            // we can't control what thread this gets called on, so create one if we need to
                            ThreadStart    actShowMessage = () => drResult = ExtendedMessageBox.Show(null, stbAVMessage.ToString(), "Unable to update", MessageBoxButtons.OK, MessageBoxIcon.Information);
                            ApartmentState astState       = ApartmentState.Unknown;
                            Thread.CurrentThread.TrySetApartmentState(astState);
                            if (astState == ApartmentState.STA)
                            {
                                actShowMessage();
                            }
                            else
                            {
                                Thread thdMessage = new Thread(actShowMessage);
                                thdMessage.SetApartmentState(ApartmentState.STA);
                                thdMessage.Start();
                                thdMessage.Join();
                            }
                        }
                        catch
                        {
                        }

                        Trace.Unindent();
                        return(CancelUpdate());
                    }

                    SetMessage("Launching installer...");
                    ProcessStartInfo psiInfo = new ProcessStartInfo(strNewInstaller);
                    Process.Start(psiInfo);
                    Trace.Unindent();
                    return(true);
                }
            }
            else if (!m_booIsAutoCheck)
            {
                stbPromptMessage.AppendFormat("{0} is already up to date.", EnvironmentInfo.Settings.ModManagerName).AppendLine();
                stbPromptMessage.AppendLine();
                stbPromptMessage.AppendLine();
                stbPromptMessage.AppendLine("NOTE: You can find the release notes, planned features and past versions here:");
                stbPromptMessage.AppendLine("http://forums.nexusmods.com/index.php?/topic/896029-nexus-mod-manager-release-notes/");

                try
                {
                    //the extended message box contains an activex control wich must be run in an STA thread,
                    // we can't control what thread this gets called on, so create one if we need to
                    ThreadStart    actShowMessage = () => drResult = ExtendedMessageBox.Show(null, stbPromptMessage.ToString(), "Up to date", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    ApartmentState astState       = ApartmentState.Unknown;
                    Thread.CurrentThread.TrySetApartmentState(astState);
                    if (astState == ApartmentState.STA)
                    {
                        actShowMessage();
                    }
                    else
                    {
                        Thread thdMessage = new Thread(actShowMessage);
                        thdMessage.SetApartmentState(ApartmentState.STA);
                        thdMessage.Start();
                        thdMessage.Join();
                    }
                }
                catch
                {
                }
            }

            SetMessage(String.Format("{0} is already up to date.", EnvironmentInfo.Settings.ModManagerName));
            SetProgress(2);
            Trace.Unindent();
            return(true);
        }
Beispiel #33
0
        private ISynchronizedThread StartSynchronizedThread(ThreadStart threadMethod, string threadName, ApartmentState state)
        {
            _logger.Debug($"Starting {threadName} thread");

            var t = new SynchronizedThread(threadMethod);

            t.Name = threadName;
            t.SetApartmentState(state);

            StartSynchronizedThread(t);
            return(t);
        }
Beispiel #34
0
        public void GetsTargetApartmentFromParentTests(Test test, ApartmentState expected)
        {
            var work = new FakeWorkItem(test, TestFilter.Empty);

            Assert.That(work.TargetApartment, Is.EqualTo(expected));
        }
Beispiel #35
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ThreadedWorker" /> class.
 /// </summary>
 /// <param name="target">The target.</param>
 /// <param name="logger">The logger.</param>
 /// <param name="apartmentState">State of the apartment.</param>
 public ThreadedWorker(Action target, ILogger logger, ApartmentState apartmentState) : base(logger, apartmentState)
 {
     target.Guard("target");
     this.target = target;
 }
        /// <summary>
        /// Default constructor for creating ServerPowerShellDrivers
        /// </summary>
        /// <param name="powershell">Decoded powershell object.</param>
        /// <param name="extraPowerShell">Extra pipeline to be run after <paramref name="powershell"/> completes.</param>
        /// <param name="noInput">Whether there is input for this powershell.</param>
        /// <param name="clientPowerShellId">The client powershell id.</param>
        /// <param name="clientRunspacePoolId">The client runspacepool id.</param>
        /// <param name="runspacePoolDriver">runspace pool driver
        /// which is creating this powershell driver</param>
        /// <param name="apartmentState">Apartment state for this powershell.</param>
        /// <param name="hostInfo">host info using which the host for
        /// this powershell will be constructed</param>
        /// <param name="streamOptions">Serialization options for the streams in this powershell.</param>
        /// <param name="addToHistory">
        /// true if the command is to be added to history list of the runspace. false, otherwise.
        /// </param>
        /// <param name="rsToUse">
        /// If not null, this Runspace will be used to invoke Powershell.
        /// If null, the RunspacePool pointed by <paramref name="runspacePoolDriver"/> will be used.
        /// </param>
        /// <param name="output">
        /// If not null, this is used as another source of output sent to the client.
        /// </param>
        internal ServerPowerShellDriver(PowerShell powershell, PowerShell extraPowerShell, bool noInput, Guid clientPowerShellId,
                                        Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver,
                                        ApartmentState apartmentState, HostInfo hostInfo, RemoteStreamOptions streamOptions,
                                        bool addToHistory, Runspace rsToUse, PSDataCollection <PSObject> output)
#endif
        {
            InstanceId          = clientPowerShellId;
            RunspacePoolId      = clientRunspacePoolId;
            RemoteStreamOptions = streamOptions;
#if !CORECLR // No ApartmentState In CoreCLR
            this.apartmentState = apartmentState;
#endif
            LocalPowerShell        = powershell;
            _extraPowerShell       = extraPowerShell;
            _localPowerShellOutput = new PSDataCollection <PSObject>();
            _noInput         = noInput;
            _addToHistory    = addToHistory;
            _psDriverInvoker = runspacePoolDriver;

            DataStructureHandler = runspacePoolDriver.DataStructureHandler.CreatePowerShellDataStructureHandler(clientPowerShellId, clientRunspacePoolId, RemoteStreamOptions, LocalPowerShell);
            _remoteHost          = DataStructureHandler.GetHostAssociatedWithPowerShell(hostInfo, runspacePoolDriver.ServerRemoteHost);

            if (!noInput)
            {
                InputCollection = new PSDataCollection <object>();
                InputCollection.ReleaseOnEnumeration = true;
                InputCollection.IdleEvent           += new EventHandler <EventArgs>(HandleIdleEvent);
            }

            RegisterPipelineOutputEventHandlers(_localPowerShellOutput);

            if (LocalPowerShell != null)
            {
                RegisterPowerShellEventHandlers(LocalPowerShell);
                _datasent[0] = false;
            }

            if (extraPowerShell != null)
            {
                RegisterPowerShellEventHandlers(extraPowerShell);
                _datasent[1] = false;
            }

            RegisterDataStructureHandlerEventHandlers(DataStructureHandler);

            // set the runspace pool and invoke this powershell
            if (rsToUse != null)
            {
                LocalPowerShell.Runspace = rsToUse;
                if (extraPowerShell != null)
                {
                    extraPowerShell.Runspace = rsToUse;
                }
            }
            else
            {
                LocalPowerShell.RunspacePool = runspacePoolDriver.RunspacePool;
                if (extraPowerShell != null)
                {
                    extraPowerShell.RunspacePool = runspacePoolDriver.RunspacePool;
                }
            }

            if (output != null)
            {
                output.DataAdded += (sender, args) =>
                {
                    if (_localPowerShellOutput.IsOpen)
                    {
                        var items = output.ReadAll();
                        foreach (var item in items)
                        {
                            _localPowerShellOutput.Add(item);
                        }
                    }
                };
            }
        }
 internal ServerPowerShellDriver(PowerShell powershell, PowerShell extraPowerShell, bool noInput, Guid clientPowerShellId, Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver, ApartmentState apartmentState, HostInfo hostInfo, System.Management.Automation.RemoteStreamOptions streamOptions, bool addToHistory, Runspace rsToUse)
 {
     this.clientPowerShellId    = clientPowerShellId;
     this.clientRunspacePoolId  = clientRunspacePoolId;
     this.remoteStreamOptions   = streamOptions;
     this.apartmentState        = apartmentState;
     this.localPowerShell       = powershell;
     this.extraPowerShell       = extraPowerShell;
     this.localPowerShellOutput = new PSDataCollection <PSObject>();
     this.noInput      = noInput;
     this.addToHistory = addToHistory;
     this.dsHandler    = runspacePoolDriver.DataStructureHandler.CreatePowerShellDataStructureHandler(clientPowerShellId, clientRunspacePoolId, this.remoteStreamOptions, this.localPowerShell);
     this.remoteHost   = this.dsHandler.GetHostAssociatedWithPowerShell(hostInfo, runspacePoolDriver.ServerRemoteHost);
     if (!noInput)
     {
         this.input = new PSDataCollection <object>();
         this.input.ReleaseOnEnumeration = true;
         this.input.IdleEvent           += new EventHandler <EventArgs>(this.HandleIdleEvent);
     }
     this.RegisterPipelineOutputEventHandlers(this.localPowerShellOutput);
     if (this.localPowerShell != null)
     {
         this.RegisterPowerShellEventHandlers(this.localPowerShell);
         this.datasent[0] = false;
     }
     if (extraPowerShell != null)
     {
         this.RegisterPowerShellEventHandlers(extraPowerShell);
         this.datasent[1] = false;
     }
     this.RegisterDataStructureHandlerEventHandlers(this.dsHandler);
     if (rsToUse != null)
     {
         this.localPowerShell.Runspace = rsToUse;
         if (extraPowerShell != null)
         {
             extraPowerShell.Runspace = rsToUse;
         }
     }
     else
     {
         this.localPowerShell.RunspacePool = runspacePoolDriver.RunspacePool;
         if (extraPowerShell != null)
         {
             extraPowerShell.RunspacePool = runspacePoolDriver.RunspacePool;
         }
     }
 }
Beispiel #38
0
        /// <summary>
        /// This lets the user know a problem has occurred, and logs the exception.
        /// </summary>
        /// <param name="ex">The exception that is being handled.</param>
        private static void HandleException(Exception ex)
        {
            HeaderlessTextWriterTraceListener htlListener = (HeaderlessTextWriterTraceListener)Trace.Listeners["DefaultListener"];
            DialogResult drResult = DialogResult.No;

            Trace.WriteLine("");
            Trace.TraceError("Tracing an Unhandled Exception:");
            TraceUtil.TraceException(ex);

            if (!htlListener.TraceIsForced)
            {
                htlListener.SaveToFile();
            }

            StringBuilder stbPromptMessage = new StringBuilder();

            stbPromptMessage.AppendFormat("{0} has encountered an error and needs to close.", EnvironmentInfo.Settings.ModManagerName).AppendLine();
            stbPromptMessage.AppendLine("A Trace Log file was created at:");
            stbPromptMessage.AppendLine(htlListener.FilePath);
            stbPromptMessage.AppendLine("Before reporting the issue, don't close this window and check for a fix here (you can close it afterwards):");
            stbPromptMessage.AppendLine(NexusLinks.FAQs);
            stbPromptMessage.AppendLine("If you can't find a solution, please make a bug report and attach the TraceLog file here:");
            stbPromptMessage.AppendLine(NexusLinks.Issues);
            stbPromptMessage.AppendLine(Environment.NewLine + "Do you want to open the TraceLog folder?");
            try
            {
                //the extended message box contains an activex control wich must be run in an STA thread,
                // we can't control what thread this gets called on, so create one if we need to
                string      strException   = "The following information is in the Trace Log:" + Environment.NewLine + TraceUtil.CreateTraceExceptionString(ex);
                ThreadStart actShowMessage = () => drResult = ExtendedMessageBox.Show(null, stbPromptMessage.ToString(), "Error", strException, MessageBoxButtons.YesNo, MessageBoxIcon.Information);

                ApartmentState astState = ApartmentState.Unknown;
                Thread.CurrentThread.TrySetApartmentState(astState);
                if (astState == ApartmentState.STA)
                {
                    actShowMessage();
                }
                else
                {
                    Thread thdMessage = new Thread(actShowMessage);
                    thdMessage.SetApartmentState(ApartmentState.STA);
                    thdMessage.Start();
                    thdMessage.Join();
                    if (drResult == DialogResult.Yes)
                    {
                        try
                        {
                            System.Diagnostics.Process prc = new System.Diagnostics.Process();
                            prc.StartInfo.FileName = Path.GetDirectoryName(htlListener.FilePath);
                            prc.Start();
                        }
                        catch { }
                    }
                }
            }
            catch
            {
                //backup, in case on extended message box starts to act up
                MessageBox.Show(stbPromptMessage.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Beispiel #39
0
		public void SetApartmentState(ApartmentState aptState) {
			_thread.SetApartmentState(aptState);
		}
Beispiel #40
0
 public void GetParentThreadInfo()
 {
     this.parentThread          = Thread.CurrentThread;
     this.parentThreadApartment = parentThread.ApartmentState;
 }
Beispiel #41
0
 public void SetApartmentState(ApartmentState state)
 {
 }
Beispiel #42
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ParameterizedThreadedResultWorker{TArgs,TResult}" /> class.
 /// </summary>
 /// <param name="target">The target.</param>
 /// <param name="logger">The logger.</param>
 /// <param name="apartmentState">State of the apartment.</param>
 /// <param name="isBackgroundThread"></param>
 public ParameterizedThreadedResultWorker(Func <TArgs, TResult> target, ILogger logger, ApartmentState apartmentState = ApartmentState.MTA, bool isBackgroundThread = true)
     : base(logger, apartmentState, isBackgroundThread)
 {
     this.target = target ?? throw new ArgumentNullException(nameof(target));
 }
 private static void InitializeApartmentState(ApartmentState state)
 {
     Thread.CurrentThread.SetApartmentState(state);
 }
Beispiel #44
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ForegroundThreadWithDispatcher"/> class.
 /// </summary>
 /// <param name="name">The name of the thread.</param>
 /// <param name="state">The apartment state of the thread.</param>
 /// <param name="priority">The priority of the thread.</param>
 public ForegroundThreadWithDispatcher([NotNull] string name, ApartmentState state, ThreadPriority priority)
     : base(name, state, priority, false)
 {
     ShutdownPriority = DispatcherPriority.Normal;
 }
Beispiel #45
0
        public static Thread StartThread(VoidResultVoidParams function, bool background = false, ApartmentState state = ApartmentState.MTA, string threadName = "")
        {
            var thread = new Thread(new ThreadStart(function))
            {
                IsBackground = background,
                Name         = threadName
            };

            thread.SetApartmentState(state);
            thread.Start();
            return(thread);
        }
Beispiel #46
0
 /// <summary>
 /// Initializes a new instance of the <see cref="BackgroundThreadWithDispatcher"/> class.
 /// </summary>
 /// <param name="name">The name of the thread.</param>
 /// <param name="state">The apartment state of the thread.</param>
 public BackgroundThreadWithDispatcher([NotNull] string name, ApartmentState state)
     : base(name, state, ThreadPriority.Normal, true)
 {
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ForegroundThreadWithDispatcher"/> class with normal thread priority.
 /// </summary>
 /// <param name="name">The name of the thread.</param>
 /// <param name="state">The apartment state of the thread.</param>
 public ForegroundThreadWithDispatcher([NotNull] string name, ApartmentState state)
     : this(name, state, ThreadPriority.Normal)
 {
     Contract.Requires(!string.IsNullOrEmpty(name));
 }
Beispiel #48
0
 public void GetParentThreadInfo()
 {
     ParentThread          = Thread.CurrentThread;
     ParentThreadApartment = GetApartmentState(ParentThread);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="BackgroundThreadWithDispatcher"/> class.
 /// </summary>
 /// <param name="name">The name of the thread.</param>
 /// <param name="state">The apartment state of the thread.</param>
 /// <param name="priority">The priority of the thread.</param>
 public BackgroundThreadWithDispatcher([NotNull] string name, ApartmentState state, ThreadPriority priority)
     : base(name, state, priority, true)
 {
     Contract.Requires(!string.IsNullOrEmpty(name));
 }
Beispiel #50
0
 static ITest CreateFakeTests(ApartmentState assemblyApartment, ApartmentState fixtureApartment, ApartmentState methodApartment) =>
 new FakeTest("Method", methodApartment)
 {
     Parent = new FakeTest("Fixture", fixtureApartment)
     {
         Parent = new FakeTest("Assembly", assemblyApartment)
     }
 };
Beispiel #51
0
        public static Thread StartTry(Action code, ErrorHandler onError = null, Action finallyCode = null, bool background = true, ApartmentState state = ApartmentState.Unknown)
        {
            Thread t = new Thread(
                () =>
            {
                try
                {
                    code.Invoke();
                }
                catch (ThreadAbortException)
                {
                    Thread.ResetAbort();
                }
                catch (Exception e)
                {
                    try
                    {
                        if (onError == null)
                        {
                            throw e;
                        }
                        onError.Invoke(e);
                    }
                    catch (ThreadAbortException)
                    {
                        Thread.ResetAbort();
                    }
                }
                finally
                {
                    finallyCode?.Invoke();
                }
            }
                );

            if (state != ApartmentState.Unknown)
            {
                t.SetApartmentState(state);
            }
            t.IsBackground = background;
            t.Start();
            return(t);
        }
Beispiel #52
0
 private void RunOnSeparateThread(ApartmentState apartment)
Beispiel #53
0
        public DEThread(IServiceProvider sp, string name, ThreadDelegate action, string categoryName = ThreadCategory, ThreadPriority priority = ThreadPriority.Normal, bool isBackground = false, ApartmentState apartmentState = ApartmentState.MTA)
            : base(sp, name, categoryName)
        {
            this.action = action;

            StartThread(name, priority, isBackground, apartmentState);
        } // ctor
Beispiel #54
0
 public bool TrySetApartmentStateUnchecked(ApartmentState state) => false;
Beispiel #55
0
 public bool TrySetApartmentStateUnchecked(ApartmentState state)
 {
     return(state == GetApartmentState());
 }
Beispiel #56
0
        }         // ctor

        protected void StartThread(string name, ThreadPriority priority = ThreadPriority.Normal, bool isBackground = false, ApartmentState apartmentState = ApartmentState.MTA)
        {
            // create the thread
            thread = new Thread(Execute);
            thread.SetApartmentState(apartmentState);
            thread.IsBackground = isBackground;
            thread.Priority     = priority;
            thread.Name         = name;

            // start the thread
            startedEvent  = new ManualResetEventSlim(false);
            stoppingEvent = new ManualResetEventSlim(false);
            thread.Start();
            if (!startedEvent.Wait(3000))
            {
                throw new Exception(String.Format("Could not start thread '{0}'.", name));
            }

            Procs.FreeAndNil(ref startedEvent);
        }         // proc StartThread
Beispiel #57
0
        /// <summary>
        /// Execute the current work item, including any
        /// child work items.
        /// </summary>
        public virtual void Execute()
        {
            // Timeout set at a higher level
            int timeout = Context.TestCaseTimeout;

            // Timeout set on this test
            if (Test.Properties.ContainsKey(PropertyNames.Timeout))
            {
                timeout = (int)Test.Properties.Get(PropertyNames.Timeout);
            }

            // Unless the context is single threaded, a supplementary thread
            // is created on the various platforms...
            // 1. If the test used the RequiresThreadAttribute.
            // 2. If a test method has a timeout.
            // 3. If the test needs to run in a different apartment.
            //
            // NOTE: We want to eliminate or significantly reduce
            //       cases 2 and 3 in the future.
            //
            // Case 2 requires the ability to stop and start test workers
            // dynamically. We would cancel the worker thread, dispose of
            // the worker and start a new worker on a new thread.
            //
            // Case 3 occurs when using either dispatcher whenever a
            // child test calls for a different apartment from the one
            // used by it's parent. It routinely occurs under the simple
            // dispatcher (--workers=0 option). Under the parallel dispatcher
            // it is needed when test cases are not enabled for parallel
            // execution. Currently, test cases are always run sequentially,
            // so this continues to apply fairly generally.

            var ownThreadReason = OwnThreadReason.NotNeeded;

#if !PORTABLE
            if (Test.RequiresThread)
            {
                ownThreadReason |= OwnThreadReason.RequiresThread;
            }
            if (timeout > 0 && Test is TestMethod)
            {
                ownThreadReason |= OwnThreadReason.Timeout;
            }
#if !SILVERLIGHT && !NETCF
            CurrentApartment = Thread.CurrentThread.GetApartmentState();
            if (CurrentApartment != TargetApartment && TargetApartment != ApartmentState.Unknown)
            {
                ownThreadReason |= OwnThreadReason.DifferentApartment;
            }
#endif
#endif

            if (ownThreadReason == OwnThreadReason.NotNeeded)
            {
                RunTest();
            }
            else if (Context.IsSingleThreaded)
            {
                var msg = "Test is not runnable in single-threaded context. " + ownThreadReason;
                log.Error(msg);
                Result.SetResult(ResultState.NotRunnable, msg);
                WorkItemComplete();
            }
            else
            {
                log.Debug("Running test on own thread. " + ownThreadReason);
#if SILVERLIGHT || NETCF
                RunTestOnOwnThread(timeout);
#elif !PORTABLE
                var apartment = (ownThreadReason | OwnThreadReason.DifferentApartment) != 0
                    ? TargetApartment
                    : CurrentApartment;
                RunTestOnOwnThread(timeout, apartment);
#endif
            }
        }
Beispiel #58
0
 private void RunTestOnOwnThread(int timeout, ApartmentState apartment)
 {
     thread = new Thread(new ThreadStart(RunTest));
     thread.SetApartmentState(apartment);
     RunThread(timeout);
 }
Beispiel #59
0
 public bool TrySetApartmentState(ApartmentState state)
 {
 }
Beispiel #60
0
 private static bool TrySetApartmentStateUnchecked(ApartmentState state) => state == ApartmentState.Unknown;