Example #1
0
        public static async Task <bool> Kill(NetworkObject bandit)
        {
            if (bandit == null)
            {
                GlobalLog.Error("[KillBandit] Bandit object is null.");
                return(false);
            }

            await bandit.WalkablePosition().ComeAtOnce();

            if (!await OpenBanditPanel(bandit))
            {
                return(false);
            }

            var err = LokiPoe.InGameState.BanditPanel.KillBandit();

            if (err != LokiPoe.InGameState.TalkToBanditResult.None)
            {
                GlobalLog.Error($"[KillBandit] Fail to select \"Kill\" option. Error: \"{err}\".");
                return(false);
            }
            return(true);
        }
Example #2
0
        public IAsyncResult BeginAuthenticateAsClient(
            NetworkCredential credential,
            ChannelBinding binding,
            string targetName,
            ProtectionLevel requiredProtectionLevel,
            TokenImpersonationLevel allowedImpersonationLevel,
            AsyncCallback asyncCallback,
            object asyncState)
        {
#if DEBUG
            using (GlobalLog.SetThreadKind(ThreadKinds.User | ThreadKinds.Async))
            {
#endif
            _negoState.ValidateCreateContext(_package, false, credential, targetName, binding, requiredProtectionLevel, allowedImpersonationLevel);

            LazyAsyncResult result = new LazyAsyncResult(_negoState, asyncState, asyncCallback);
            _negoState.ProcessAuthentication(result);

            return(result);

#if DEBUG
        }
#endif
        }
Example #3
0
        private void LogBuffer(long size)
        {
            if (!SocketsEventSource.Log.IsEnabled())
            {
                if (GlobalLog.IsEnabled)
                {
                    GlobalLog.AssertFormat("AcceptOverlappedAsyncResult#{0}::LogBuffer()|Logging is off!", LoggingHash.HashString(this));
                }
                Debug.Fail("AcceptOverlappedAsyncResult#" + LoggingHash.HashString(this) + "::LogBuffer()|Logging is off!");
            }
            IntPtr pinnedBuffer = Marshal.UnsafeAddrOfPinnedArrayElement(_buffer, 0);

            if (pinnedBuffer != IntPtr.Zero)
            {
                if (size > -1)
                {
                    SocketsEventSource.Dump(pinnedBuffer, (int)Math.Min(size, (long)_buffer.Length));
                }
                else
                {
                    SocketsEventSource.Dump(pinnedBuffer, (int)_buffer.Length);
                }
            }
        }
Example #4
0
        /// <summary>
        /// 执行查询的SQL语句。查询完毕后回调 callback参数。
        /// callback委派格式 delegate void OnExeQuerySQL(DbDataReader reader);
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="callback"></param>
        public void ExeQuerySQL(String sql, Action <DbDataReader> callback)
        {
            DbCommand command = conn.CreateCommand();

            command.CommandText = sql;
            command.CommandType = CommandType.Text;

            try
            {
                conn.Open();

                LogSQL(sql);
                callback(command.ExecuteReader());
            }
            catch (Exception e)
            {
                GlobalLog.Debug(string.Format("SQL Error: {0} \r\n{1}", sql, e.Message));
                throw e;
            }
            finally
            {
                conn.Close();
            }
        }
Example #5
0
        internal void SetSocketTimeoutOption(SocketShutdown mode, int timeout, bool silent)
        {
            if (GlobalLog.IsEnabled)
            {
                GlobalLog.Print("NetworkStream#" + LoggingHash.HashString(this) + "::SetSocketTimeoutOption() mode:" + mode + " silent:" + silent + " timeout:" + timeout + " m_CurrentReadTimeout:" + _currentReadTimeout + " m_CurrentWriteTimeout:" + _currentWriteTimeout);
            }
            GlobalLog.ThreadContract(ThreadKinds.Unknown, "NetworkStream#" + LoggingHash.HashString(this) + "::SetSocketTimeoutOption");

            if (timeout < 0)
            {
                timeout = 0; // -1 becomes 0 for the winsock stack
            }

            Socket chkStreamSocket = _streamSocket;

            if (chkStreamSocket == null)
            {
                return;
            }
            if (mode == SocketShutdown.Send || mode == SocketShutdown.Both)
            {
                if (timeout != _currentWriteTimeout)
                {
                    chkStreamSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, timeout, silent);
                    _currentWriteTimeout = timeout;
                }
            }
            if (mode == SocketShutdown.Receive || mode == SocketShutdown.Both)
            {
                if (timeout != _currentReadTimeout)
                {
                    chkStreamSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, timeout, silent);
                    _currentReadTimeout = timeout;
                }
            }
        }
Example #6
0
        public override UIHandlerAction HandleWindow(IntPtr topLevelhWnd, IntPtr hwnd, System.Diagnostics.Process process, string title, UIHandlerNotification notification)
        {
            // Sleep for a bit.  Takes a bit longer for window to be ready in Longhorn.
            Thread.Sleep(800);

            // Get a reference to the IE window...
            GlobalLog.LogDebug("Finding IE window");
            AutomationElement ieWindow = AutomationElement.FromHandle(topLevelhWnd);

            if (ApplicationDeploymentHelper.GetIEVersion() >= 8)
            {
                GlobalLog.LogDebug("IE8+ present, using IWebBrowser2 Navigate() for reliability");
                Thread.Sleep(3000);
                // Other approaches are fine until they meet LCIE.
                // IF this proves to be 100% reliable, this could be the only implementation.
                IENavigationHelper.NavigateInternetExplorer(uriToNavigate.ToString(), process.MainWindowHandle);
            }
            else
            {
                NavigateIEWindow(ieWindow, uriToNavigate);
            }

            return(UIHandlerAction.Unhandled);
        }
Example #7
0
        public async Task <bool> Run()
        {
            var area = World.CurrentArea;

            if (!area.IsHideoutArea && !area.IsMapRoom)
            {
                return(false);
            }

            await Coroutines.CloseBlockingWindows();

            var golemSkill = SkillBar.Skills.FirstOrDefault(s => s.IsOnSkillBar && s.SkillTags.Contains("golem"));

            if (golemSkill != null)
            {
                var golemObj = golemSkill.DeployedObjects.FirstOrDefault() as Monster;
                if (golemObj == null || golemObj.HealthPercent < MinGolemHpPercent)
                {
                    GlobalLog.Debug($"[CastAuraTask] Now summoning \"{golemSkill.Name}\".");
                    SkillBar.Use(golemSkill.Slot, false);
                    await Wait.SleepSafe(100);

                    await Coroutines.FinishCurrentAction();

                    await Wait.SleepSafe(100);
                }
            }
            var auras = GetAurasForCast();

            if (auras.Count > 0 && AllAuras.Any(a => a.IsOnSkillBar))
            {
                GlobalLog.Info($"[CastAuraTask] Found {auras.Count} aura(s) for casting.");
                await CastAuras(auras);
            }
            return(false);
        }
Example #8
0
        /// <summary>
        /// Starts the variation loop on a new thread.
        /// </summary>
        /// <remarks>
        /// The Dispatcher thread is kept seperate from the VariationPerformer thread
        /// so nested loop actions, such as opening dialogs and drag/drop, may run.
        /// </remarks>
        protected void StartLoop()
        {
            CommonStorage.Current.Store("Controller", this);

            //
            // Ensure we log any unhandled exceptions.
            //
            Dispatcher.CurrentDispatcher.UnhandledException +=
                new DispatcherUnhandledExceptionEventHandler(_OnDispatcherException);


            //
            string execDir    = DriverState.ExecutionDirectory;//Harness.Current.RemoteSite["STI_ExecutionDirectory"];
            string currentDir = Environment.CurrentDirectory;

            //
            // If the app is a new process, the current directory will likely be
            // different than the original execution directory.  Copy files
            // from the original directory to the current one.
            //
            if (!String.Equals(currentDir, execDir))
            {
                GlobalLog.LogStatus("Current directory is different than original execution directory.");
                GlobalLog.LogStatus("Execution directory: " + execDir);
                GlobalLog.LogStatus("Current directory: " + currentDir);

                GlobalLog.LogStatus("Changing current directory to original execution directory...");
                Environment.CurrentDirectory = execDir;
            }

            this.TestDispatcher = Dispatcher.CurrentDispatcher;

            Thread thread = new Thread(new ThreadStart(_RunLoop));

            thread.Start();
        }
        public static async Task <bool> TurnInQuest()
        {
            if (!Helpers.PlayerHasQuestItem(QuestItemMetadata.EyeOfDesire))
            {
                return(false);
            }

            if (World.Act4.CrystalVeins.IsCurrentArea)
            {
                var dialla = Helpers.LadyDialla;
                if (dialla == null)
                {
                    GlobalLog.Error("[KingOfDesire] Fail to detect Lady Dialla in Crystal Veins.");
                    ErrorManager.ReportCriticalError();
                    return(true);
                }
                await Helpers.TalkTo(dialla);

                return(true);
            }
            await Travel.To(World.Act4.CrystalVeins);

            return(true);
        }
        public static async Task <bool> KillGemlings()
        {
            if (_finished)
            {
                return(false);
            }

            if (World.Act8.GrainGate.IsCurrentArea)
            {
                var gemling = CachedGemlings.FirstOrDefault();
                if (gemling != null)
                {
                    var pos = gemling.Position;
                    if (pos.Distance > 30)
                    {
                        pos.Come();
                    }
                    else
                    {
                        var gemlingObj = gemling.Object;
                        if (gemlingObj == null)
                        {
                            GlobalLog.Warn($"[GemlingLegion] Gemling with id {gemling.Id} no longer exist.");
                            CachedGemlings.RemoveAt(0);
                        }
                    }
                    return(true);
                }
                await Helpers.Explore();

                return(true);
            }
            await Travel.To(World.Act8.GrainGate);

            return(true);
        }
Example #11
0
        /// <summary>
        /// Constructor for Vscan Common
        /// Master is specivif Path
        /// </summary>
        /// <param name="testwin">Window to capture image of</param>
        /// <param name="test">Calling Test</param>
        /// <param name="master">Master Name</param>
        public VScanCommon(Window testwin, object test, string master)
        {
            if (test != null && testwin != null)
            {
                masterPath = Common.ResolvePath(test);

                Index = new LayoutMasterIndex(null);

                if (master == null || master == string.Empty)
                {
                    index.FileName = test.GetType().Name;
                }
                else
                {
                    index.FileName = master;
                }

                GlobalLog.LogStatus("Master Name : {0}", index.FileName);
                index.Path = masterPath;
                GlobalLog.LogStatus("Master Path : {0}", index.Path);

                SetWindow(testwin);
            }
        }
Example #12
0
 void ConnectCallback(IAsyncResult result)
 {
     GlobalLog.Enter("SmtpClient#" + ValidationHelper.HashString(this) + "::ConnectCallback");
     try {
         transport.EndGetConnection(result);
         if (cancelled)
         {
             Complete(null, result);
         }
         else
         {
             // Detected durring Begin/EndGetConnection, restrictable using DeliveryFormat
             bool allowUnicode = IsUnicodeSupported();
             ValidateUnicodeRequirement(message, recipients, allowUnicode);
             transport.BeginSendMail(message.Sender ?? message.From, recipients,
                                     message.BuildDeliveryStatusNotificationString(), allowUnicode,
                                     new AsyncCallback(SendMailCallback), result.AsyncState);
         }
     }
     catch (Exception e) {
         Complete(e, result);
     }
     GlobalLog.Leave("SmtpClient#" + ValidationHelper.HashString(this) + "::ConnectCallback");
 }
Example #13
0
        public SecurityBuffer(byte[] data, int offset, int size, SecurityBufferType tokentype)
        {
            if (offset < 0 || offset > (data == null ? 0 : data.Length))
            {
                if (GlobalLog.IsEnabled)
                {
                    GlobalLog.Assert("SecurityBuffer::.ctor", "'offset' out of range.  [" + offset + "]");
                }
                Debug.Fail("SecurityBuffer::.ctor", "'offset' out of range.  [" + offset + "]");
            }
            if (size < 0 || size > (data == null ? 0 : data.Length - offset))
            {
                if (GlobalLog.IsEnabled)
                {
                    GlobalLog.Assert("SecurityBuffer::.ctor", "'size' out of range.  [" + size + "]");
                }
                Debug.Fail("SecurityBuffer::.ctor", "'size' out of range.  [" + size + "]");
            }

            this.offset = data == null || offset < 0 ? 0 : Math.Min(offset, data.Length);
            this.size   = data == null || size < 0 ? 0 : Math.Min(size, data.Length - this.offset);
            this.type   = tokentype;
            this.token  = size == 0 ? null : data;
        }
Example #14
0
        private bool CheckSpn()
        {
            if (_Context.IsKerberos)
            {
                return(true);
            }

            if (_ExtendedProtectionPolicy.PolicyEnforcement == PolicyEnforcement.Never ||
                _ExtendedProtectionPolicy.CustomServiceNames == null)
            {
                return(true);
            }

            if (!AuthenticationManager.OSSupportsExtendedProtection)
            {
                GlobalLog.Assert(_ExtendedProtectionPolicy.PolicyEnforcement != PolicyEnforcement.Always,
                                 "User managed to set PolicyEnforcement.Always when the OS does not support extended protection!");
                return(true);
            }

            string clientSpn = _Context.ClientSpecifiedSpn;

            if (String.IsNullOrEmpty(clientSpn))
            {
                if (_ExtendedProtectionPolicy.PolicyEnforcement == PolicyEnforcement.WhenSupported)
                {
                    return(true);
                }
            }
            else
            {
                return(_ExtendedProtectionPolicy.CustomServiceNames.Contains(clientSpn));
            }

            return(false);
        }
Example #15
0
        protected override bool ReleaseHandle()
        {
            GlobalLog.Print(
                "SafeCloseSocket#" + Logging.HashString(this) + "::ReleaseHandle() m_InnerSocket=" +
                _innerSocket == null ? "null" : Logging.HashString(_innerSocket));

            _released = true;
            InnerSafeCloseSocket innerSocket = _innerSocket == null ? null : Interlocked.Exchange <InnerSafeCloseSocket>(ref _innerSocket, null);

            if (innerSocket != null)
            {
#if DEBUG
                // On AppDomain unload we may still have pending Overlapped operations.
                // ThreadPoolBoundHandle should handle this scenario by canceling them.
                innerSocket.LogRemainingOperations();
#endif

                innerSocket.DangerousRelease();
            }

            InnerReleaseHandle();

            return(true);
        }
        // This method is called after an asynchronous call is made for the user.
        // It checks and acts accordingly if the IO:
        // 1) completed synchronously.
        // 2) was pended.
        // 3) failed.
        internal unsafe SocketError CheckAsyncCallOverlappedResult(SocketError errorCode)
        {
            if (GlobalLog.IsEnabled)
            {
                GlobalLog.Print(
                    "BaseOverlappedAsyncResult#" + LoggingHash.HashString(this) +
                    "::CheckAsyncCallOverlappedResult(" + errorCode.ToString() + ")");
            }

            if (errorCode == SocketError.Success || errorCode == SocketError.IOPending)
            {
                // Ignore cases in which a completion packet will be queued:
                // we'll deal with this IO in the callback.
                return(SocketError.Success);
            }

            // In the remaining cases a completion packet will NOT be queued:
            // we have to call the callback explicitly signaling an error.
            ErrorCode = (int)errorCode;
            Result    = -1;

            ReleaseUnmanagedStructures();  // Additional release for the completion that won't happen.
            return(errorCode);
        }
        public static async Task <bool> ClearFetidPool()
        {
            if (_finished)
            {
                return(false);
            }

            if (World.Act1.FetidPool.IsCurrentArea)
            {
                if (await TrackMobLogic.Execute())
                {
                    return(true);
                }

                if (!await CombatAreaCache.Current.Explorer.Execute())
                {
                    if (QuestManager.GetState(Quests.DirtyJob) <= FinishedStateMinimum)
                    {
                        return(false);
                    }

                    GlobalLog.Error("[ClearFetidPool] Fetid Pool is fully explored but not all monsters were killed. Now going to create a new Fetid Pool instance.");

                    Travel.RequestNewInstance(World.Act1.FetidPool);

                    if (!await PlayerAction.TpToTown())
                    {
                        ErrorManager.ReportError();
                    }
                }
                return(true);
            }
            await Travel.To(World.Act1.FetidPool);

            return(true);
        }
        //
        private void CheckRetrieveOnResponse(Stream responseStream)
        {
            GlobalLog.Assert(_ProtocolStatus == CacheValidationStatus.Continue || _ProtocolStatus == CacheValidationStatus.RetryResponseFromServer, "CheckRetrieveOnResponse()|Unexpected _ProtocolStatus = ", _ProtocolStatus);
            bool closeCacheStream = true;

            try {
                // This will inspect the live response on the correctness matter
                switch (_ProtocolStatus = ValidateResponse())
                {
                case CacheValidationStatus.Continue:
                    closeCacheStream = false;
                    // The response looks good
                    break;

                case CacheValidationStatus.RetryResponseFromServer:
                    closeCacheStream = false;
                    break;

                case CacheValidationStatus.Fail:
                    _ProtocolStatus    = CacheValidationStatus.Fail;
                    _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_validator_fail, "ValidateResponse"));
                    break;

                case CacheValidationStatus.DoNotUseCache:
                    break;

                default:
                    _ProtocolStatus    = CacheValidationStatus.Fail;
                    _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_validator_result, "ValidateResponse", _Validator.ValidationStatus.ToString()));
                    if (Logging.On)
                    {
                        Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_unexpected_status, "ValidateResponse()", _Validator.ValidationStatus.ToString()));
                    }
                    break;
                }
            }
            catch (Exception e) {
                closeCacheStream   = true;
                _ProtocolException = e;
                _ProtocolStatus    = CacheValidationStatus.Fail;
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
                {
                    throw;
                }
                if (Logging.On)
                {
                    Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_object_and_exception, "CacheProtocol#" + this.GetHashCode().ToString(NumberFormatInfo.InvariantInfo), (e is WebException? e.Message: e.ToString())));
                }
            }
            finally {
                // This is to release cache entry in case we are not interested in it
                if (closeCacheStream && _ResponseStream != null)
                {
                    _ResponseStream.Close();
                    _ResponseStream        = null;
                    _Validator.CacheStream = Stream.Null;
                }
            }

            if (_ProtocolStatus != CacheValidationStatus.Continue)
            {
                return;
            }

            //
            // only CacheValidationStatus.Continue goes here with closeCacheStream == false
            //

            try {
                //
                switch (_ProtocolStatus = RevalidateCache())
                {
                case CacheValidationStatus.DoNotUseCache:
                case CacheValidationStatus.RemoveFromCache:
                case CacheValidationStatus.DoNotTakeFromCache:
                    closeCacheStream = true;
                    break;

                case CacheValidationStatus.ReturnCachedResponse:
                    if (_Validator.CacheStream == null || _Validator.CacheStream == Stream.Null)
                    {
                        _ProtocolStatus    = CacheValidationStatus.Fail;
                        _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_no_stream, _Validator.CacheKey));
                        if (Logging.On)
                        {
                            Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_null_cached_stream, "RevalidateCache()"));
                        }
                        break;
                    }

                    Stream stream = _Validator.CacheStream;

                    if (_Validator.CacheStreamOffset != 0L || _Validator.CacheStreamLength != _Validator.CacheEntry.StreamSize)
                    {
                        stream = new RangeStream(stream, _Validator.CacheStreamOffset, _Validator.CacheStreamLength);
                        if (Logging.On)
                        {
                            Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_returned_range_cache, "RevalidateCache()", _Validator.CacheStreamOffset, _Validator.CacheStreamLength));
                        }
                    }
                    _ResponseStream       = stream;
                    _ResponseStreamLength = _Validator.CacheStreamLength;
                    break;

                case CacheValidationStatus.CombineCachedAndServerResponse:

                    if (_Validator.CacheStream == null || _Validator.CacheStream == Stream.Null)
                    {
                        _ProtocolStatus    = CacheValidationStatus.Fail;
                        _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_no_stream, _Validator.CacheKey));
                        if (Logging.On)
                        {
                            Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_requested_combined_but_null_cached_stream, "RevalidateCache()"));
                        }
                        break;
                    }
                    if (responseStream != null)
                    {
                        stream = new CombinedReadStream(_Validator.CacheStream, responseStream);
                    }
                    else
                    {
                        // So Abort can close the cache stream
                        stream = _Validator.CacheStream;
                    }
                    _ResponseStream       = stream;
                    _ResponseStreamLength = _Validator.CacheStreamLength;
                    break;


                case CacheValidationStatus.Fail:
                    closeCacheStream   = true;
                    _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_validator_fail, "RevalidateCache"));
                    break;

                default:
                    closeCacheStream   = true;
                    _ProtocolStatus    = CacheValidationStatus.Fail;
                    _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_validator_result, "RevalidateCache", _Validator.ValidationStatus.ToString()));
                    if (Logging.On)
                    {
                        Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_unexpected_status, "RevalidateCache()", _Validator.ValidationStatus.ToString()));
                    }
                    break;
                }
            }
            catch (Exception e) {
                closeCacheStream   = true;
                _ProtocolException = e;
                _ProtocolStatus    = CacheValidationStatus.Fail;
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
                {
                    throw;
                }
                if (Logging.On)
                {
                    Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_object_and_exception, "CacheProtocol#" + this.GetHashCode().ToString(NumberFormatInfo.InvariantInfo), (e is WebException? e.Message: e.ToString())));
                }
            }
            finally {
                // This is to release cache entry in case we are not interested in it
                if (closeCacheStream && _ResponseStream != null)
                {
                    _ResponseStream.Close();
                    _ResponseStream        = null;
                    _Validator.CacheStream = Stream.Null;
                }
            }
        }
Example #19
0
        /// <summary>
        /// Performs the Activation step
        /// </summary>
        /// <returns>returns true if the rest of the steps should be executed, otherwise, false</returns>
        protected override bool BeginStep()
        {
            //Create ApplicationMonitor
            appMonitor = new ApplicationMonitor();

            // If defined, set a value in property bag.  Used for communication test variations to target app
            if (PropertyBagValue != "")
            {
                // Update this code to allow > 1 prop bag values being set at once
                string[] values = PropertyBagValue.Trim().Split('=');
                if (values.Length == 2)
                {
                    DictionaryStore.Current[values[0].Trim()] = values[1].Trim();
                }
                else
                {
                    throw new System.ArgumentException("Values must be a single 'foo=bar' format");
                }
            }

            if (hostingPolicyResetter != null)
            {
                hostingPolicyResetter.Dispose();
            }

            if (StrictHostingMode)
            {
                hostingPolicyResetter = HostingRuntimePolicyHelper.SetHostingRuntimePolicyValues(
                    doNotLaunchV3AppInV4Runtime: true);
            }
            else
            {
                hostingPolicyResetter = HostingRuntimePolicyHelper.SetHostingRuntimePolicyValues(
                    doNotLaunchV3AppInV4Runtime: false);
            }

            // upload files to FileHost is specified and scheme is not local
            if (Scheme != ActivationScheme.Local)
            {
                if (SupportFiles.Length > 0)
                {
                    // Create host to copy files to...
                    fileHost = new FileHost(UserDefinedDirectory, (Scheme == ActivationScheme.HttpInternetExternal));
                    // Upload each file
                    foreach (SupportFile suppFile in SupportFiles)
                    {
                        // Whether to copy foo\bar\baz.xbap to the foo\bar created on the remote machine or just flattened
                        fileHost.PreserveDirectoryStructure = suppFile.PreserveDirectoryStructure;

                        if (suppFile.IncludeDependencies && !string.IsNullOrEmpty(suppFile.TargetDirectory))
                        {
                            GlobalLog.LogEvidence("TargetDirectory with IncludeDependencies not yet implemented");
                            throw new NotImplementedException("TargetDirectory with IncludeDependencies not yet supported");
                        }
                        if (suppFile.CustomTestScratchServerPath == null)
                        {
                            if (suppFile.IncludeDependencies)
                            {
                                fileHost.UploadFileWithDependencies(suppFile.Name);
                            }
                            else
                            {
                                fileHost.UploadFile(suppFile.Name, suppFile.TargetDirectory);
                            }
                        }
                        else
                        {
                            fileHost.UploadFileNonDefaultServer(suppFile.Name, suppFile.CustomTestScratchServerPath);
                        }
                    }
                }

                // If no support files are listed, check the parent steps to see if one is a FileHostStep.
                // If this is the case, no need to upload the files as the FileHostStep has already.
                // Don't set throttle rate; this should be set in the markup for the parent's filehost.
                else
                {
                    LoaderStep parent = this.ParentStep;

                    while (parent != null)
                    {
                        if (parent.GetType() == typeof(Microsoft.Test.Loaders.Steps.FileHostStep))
                        {
                            this.fileHost = ((FileHostStep)parent).fileHost;
                            break;
                        }
                        // Failed to find it in the immediate parent: try til we hit null or the right one
                        parent = parent.ParentStep;
                    }
                }
            }

            // register UIHandlers
            foreach (UIHandler handler in UIHandlers)
            {
                if (handler.NamedRegistration != null)
                {
                    appMonitor.RegisterUIHandler(handler, handler.NamedRegistration, handler.Notification);
                }
                else
                {
                    appMonitor.RegisterUIHandler(handler, handler.ProcessName, handler.WindowTitle, handler.Notification);
                }
            }

            string param = "";

            if (FileName.StartsWith("&") && FileName.EndsWith("&"))
            {
                param = DictionaryStore.Current[FileName.Substring(1, FileName.Length - 2)];
                if (param == null)
                {
                    throw new InvalidOperationException(FileName + " is not defined in the property bag; cannot be used to launch app");
                }
            }
            else
            {
                // Allows for launching things in %program files%, which is localized.
                param = Environment.ExpandEnvironmentVariables(FileName);
            }

            if (Scheme != ActivationScheme.Local)
            {
                FileHostUriScheme hostScheme = FileHostUriScheme.Unc;
                if (Scheme != ActivationScheme.HttpInternetExternal)
                {
                    hostScheme = (FileHostUriScheme)Enum.Parse(typeof(FileHostUriScheme), Scheme.ToString());
                }
                param = fileHost.GetUri(FileName, hostScheme).ToString();
            }

            // Clear the fusion cache by default.  Can be disabled for custom ClickOnce scenarios
            if (ClearFusionCache)
            {
                ApplicationDeploymentHelper.CleanClickOnceCache();
            }

            // Clear IE History but only if specified (defaults to false).  Only matters for history-based navigation
            if (ClearIEHistory)
            {
                ApplicationDeploymentHelper.ClearIEHistory();
            }

            // Launch the appropriate handler...
            switch (Method)
            {
            case ActivationMethod.Launch:
            {
                // This only works for local paths for security reasons.
                if (PresentationHostDebugMode)
                {
                    param = Path.GetFullPath(param);
                    // Workaround ... for some reason on XP64 there's no guarantee that it will actually find PresHost
                    // Even though it verily is in the SysWOW64 directory.  Solution... find the right one before we try
                    string presHostPath = "presentationhost.exe";
                    if ((Environment.OSVersion.Version.Major == 5))
                    {
                        presHostPath = (Directory.GetFiles(Environment.GetEnvironmentVariable("SystemRoot"), "PresentationHost.exe", SearchOption.AllDirectories))[0];
                    }
                    appMonitor.StartProcess(presHostPath, " -debug \"" + param + "\"");
                }
                else
                {
                    // Launch process with specified arguments.  If shell: specified, then start that way.
                    // If the arguments are for the URL, directly concatenate them.
                    if ((Arguments.Length > 6) && (Arguments.ToLowerInvariant().StartsWith("shell:")))
                    {
                        appMonitor.StartProcess(param, Environment.ExpandEnvironmentVariables(Arguments.Substring(6)));
                    }
                    else if ((Arguments.Length > 11) && (Arguments.ToLowerInvariant().StartsWith("currentdir:")))
                    {
                        appMonitor.StartProcess(param, Path.Combine(Environment.CurrentDirectory, Arguments.Substring(11)));
                    }
                    else
                    {
                        appMonitor.StartProcess(param + Arguments);
                    }
                }
                break;
            }

            case ActivationMethod.Navigate:
            {
                // If local we need to fully qualify the path
                if (Scheme == ActivationScheme.Local)
                {
                    param = Path.GetFullPath(param);
                }

                // Fail to IE, since it has far more tests.
                string defaultBrowserExecutable = "iexplore.exe";

                try
                {
                    defaultBrowserExecutable = Registry.GetValue(@"HKEY_CURRENT_USER\Software\Clients\StartMenuInternet", null, "iexplore.exe").ToString();
                }
                catch (Exception)
                {
                    try
                    {
                        defaultBrowserExecutable = Registry.GetValue(@"HKEY_LOCAL_MACHINE\Software\Clients\StartMenuInternet", null, "iexplore.exe").ToString();
                    }
                    catch (Exception)
                    {
                        // Do nothing, some machines have been seen in weird states where this is undefined.  Log it anyways.
                        GlobalLog.LogDebug("Unable to get StartMenuInternet key, FireFox or other non-standard browser tests may be affected.  Contact Microsoft if this is the case");
                    }
                }
                // Handle the case where this value exists but isnt set to anything usable.  IE is far more common so fall back to it.
                if (string.IsNullOrEmpty(defaultBrowserExecutable))
                {
                    defaultBrowserExecutable = "iexplore.exe";
                }

                // start the default browser... currently just FF or IE.
                if (defaultBrowserExecutable.ToLowerInvariant().Contains("iexplore"))
                {
                    // Create & register IE navigation handler
                    // IE can be strange: About:NavigateIE sometimes gets a cancelled navigation
                    // Workaround:  Be less sensitive about the window title we trigger on.
                    appMonitor.RegisterUIHandler(new NavigateIE(param + Arguments), "iexplore", "RegExp:(Internet Explorer)", UIHandlerNotification.All);
                    appMonitor.StartProcess("iexplore.exe", "about:NavigateIE");
                }
                else if (defaultBrowserExecutable.ToLowerInvariant().Contains("firefox"))
                {
                    if (Scheme == ActivationScheme.Unc)
                    {
                        param = param.Replace("file:", "").Replace("/", @"\");
                    }
                }
                else
                {
                    throw new InvalidOperationException("Don't know how to navigate an instance of \"" + defaultBrowserExecutable + "\" browser!!! Contact Microsoft with this message.");
                }

                break;
            }

            // GOTO used here for fallthrough since there's only 2 lines difference.
            case ActivationMethod.EHome:
                goto case ActivationMethod.EHomeFullScreen;

            case ActivationMethod.EHomeFullScreen:
            {
                // If local we need to fully qualify the path
                if (Scheme == ActivationScheme.Local)
                {
                    param = Path.GetFullPath(param);
                }

                // Get a reference to the path for the ehome exe...
                string eHomePath = Environment.GetEnvironmentVariable("SystemRoot") + "\\ehome\\ehshell.exe";

                // Fail hard if EHome isnt present on the system.
                // Need to mark testcases accurately in test DB to avoid this.
                if (!File.Exists(eHomePath))
                {
                    throw new InvalidOperationException("\"Ehome\" or \"EHomeFullScreen\" method selected but case was run on non-Media-Center-enabled SKU! \n Contact Microsoft for more info on this issue.");
                }

                // Construct args with path to content to launch (MUST be a Uri)
                string eHomeArgs = "/url:\"" + param + "\"";

                // Tack on the argument for full screen if requested
                if (Method == ActivationMethod.EHomeFullScreen)
                {
                    eHomeArgs += " /directmedia:general";
                }

                // Start MCE...
                appMonitor.StartProcess(eHomePath, eHomeArgs);
                break;
            }
            }

            // Store the activation path into the property bag.  This way apps or child steps can directly figure out the deployment URI
            DictionaryStore.Current["ActivationStepUri"] = param;

            return(true);
        }
        //
        // This is (optionally) called after receiveing a live response
        //
        protected internal override CacheValidationStatus RevalidateCache()
        {
            if (HttpProxyMode)
            {
                return(base.RevalidateCache());
            }


            if (Policy.Level >= RequestCacheLevel.Reload)
            {
                // For those policies cache is never returned
                GlobalLog.Assert("RevalidateCache()", "This validator should not be called for policy = " + Policy.ToString());
                if (Logging.On)
                {
                    Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_validator_invalid_for_policy, Policy.ToString()));
                }
                return(CacheValidationStatus.DoNotTakeFromCache);
            }

            // First check is do we still hold on a cached entry?
            if (CacheStream == Stream.Null)
            {
                return(CacheValidationStatus.DoNotTakeFromCache);
            }

            //
            // This is a second+ time validation after receiving at least one response
            //

            CacheValidationStatus result = CacheValidationStatus.DoNotTakeFromCache;

            FtpWebResponse resp = Response as FtpWebResponse;

            if (resp == null)
            {
                // This will result to an application error
                return(CacheValidationStatus.DoNotTakeFromCache);
            }

            if (resp.StatusCode == FtpStatusCode.FileStatus)
            {
                if (Logging.On)
                {
                    Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_response_last_modified, resp.LastModified.ToUniversalTime().ToString("r", CultureInfo.InvariantCulture), resp.ContentLength));
                }
                if (Logging.On)
                {
                    Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_cache_last_modified, CacheEntry.LastModifiedUtc.ToString("r", CultureInfo.InvariantCulture), CacheEntry.StreamSize));
                }

                if (CacheStreamOffset != 0L && CacheEntry.IsPartialEntry)
                {
                    //should never happen
                    if (Logging.On)
                    {
                        Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_partial_and_non_zero_content_offset, CacheStreamOffset.ToString(CultureInfo.InvariantCulture)));
                    }
                    result = CacheValidationStatus.DoNotTakeFromCache;
                }

                if (resp.LastModified.ToUniversalTime() == CacheEntry.LastModifiedUtc)
                {
                    if (CacheEntry.IsPartialEntry)
                    {
                        // A caller will need to use Validator.CacheEntry.StreamSize to figure out what the restart point is

                        if (resp.ContentLength > 0)
                        {
                            this.CacheStreamLength = resp.ContentLength;
                        }
                        else
                        {
                            this.CacheStreamLength = -1;
                        }

                        result = CacheValidationStatus.CombineCachedAndServerResponse;
                    }
                    else if (resp.ContentLength == CacheEntry.StreamSize)
                    {
                        result = CacheValidationStatus.ReturnCachedResponse;
                    }
                    else
                    {
                        result = CacheValidationStatus.DoNotTakeFromCache;
                    }
                }
                else
                {
                    result = CacheValidationStatus.DoNotTakeFromCache;
                }
            }
            else
            {
                result = CacheValidationStatus.DoNotTakeFromCache;
            }

            return(result);
        }
        //
        // Private methods
        //

        //
        // This method may be invoked as part of the request submission but before issuing a live request
        //
        private void CheckRetrieveBeforeSubmit()
        {
            GlobalLog.Assert(_ProtocolStatus == CacheValidationStatus.Continue, "CheckRetrieveBeforeSubmit()|Unexpected _ProtocolStatus = {0}", _ProtocolStatus);

            try {
                while (true)
                {
                    RequestCacheEntry cacheEntry;

                    if (_Validator.CacheStream != null && _Validator.CacheStream != Stream.Null)
                    {
                        // Reset to Initial state
                        _Validator.CacheStream.Close();
                        _Validator.CacheStream = Stream.Null;
                    }

                    if (_Validator.StrictCacheErrors)
                    {
                        _Validator.CacheStream = _RequestCache.Retrieve(_Validator.CacheKey, out cacheEntry);
                    }
                    else
                    {
                        Stream stream;
                        _RequestCache.TryRetrieve(_Validator.CacheKey, out cacheEntry, out stream);
                        _Validator.CacheStream = stream;
                    }

                    if (cacheEntry == null)
                    {
                        cacheEntry = new RequestCacheEntry();
                        cacheEntry.IsPrivateEntry = _RequestCache.IsPrivateCache;
                        _Validator.FetchCacheEntry(cacheEntry);
                    }

                    if (_Validator.CacheStream == null)
                    {
                        // If entry does not have a stream an empty stream wrapper must be returned.
                        // A null or Stream.Null value stands for non existent cache entry.
                        _Validator.CacheStream = Stream.Null;
                    }

                    ValidateFreshness(cacheEntry);

                    _ProtocolStatus = ValidateCache();

                    // This will tell us what to do next
                    switch (_ProtocolStatus)
                    {
                    case CacheValidationStatus.ReturnCachedResponse:
                        if (_Validator.CacheStream == null || _Validator.CacheStream == Stream.Null)
                        {
                            if (Logging.On)
                            {
                                Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_no_cache_entry, "ValidateCache()"));
                            }
                            _ProtocolStatus    = CacheValidationStatus.Fail;
                            _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_no_stream, _Validator.CacheKey));
                            break;
                        }

                        // Final decision is made, check on a range response from cache
                        Stream stream = _Validator.CacheStream;
                        // The entry can now be replaced as we are not going for cache entry metadata-only  update
                        _RequestCache.UnlockEntry(_Validator.CacheStream);

                        if (_Validator.CacheStreamOffset != 0L || _Validator.CacheStreamLength != _Validator.CacheEntry.StreamSize)
                        {
                            stream = new RangeStream(stream, _Validator.CacheStreamOffset, _Validator.CacheStreamLength);
                            if (Logging.On)
                            {
                                Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_returned_range_cache, "ValidateCache()", _Validator.CacheStreamOffset, _Validator.CacheStreamLength));
                            }
                        }
                        _ResponseStream       = stream;
                        _ResponseStreamLength = _Validator.CacheStreamLength;
                        break;

                    case CacheValidationStatus.Continue:
                        // copy a cache stream ref
                        _ResponseStream = _Validator.CacheStream;
                        break;

                    case CacheValidationStatus.RetryResponseFromCache:
                        // loop thought cache retrieve
                        continue;

                    case CacheValidationStatus.DoNotTakeFromCache:
                    case CacheValidationStatus.DoNotUseCache:
                        break;

                    case CacheValidationStatus.Fail:
                        _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_validator_fail, "ValidateCache"));
                        break;

                    default:
                        _ProtocolStatus    = CacheValidationStatus.Fail;
                        _ProtocolException = new InvalidOperationException(SR.GetString(SR.net_cache_validator_result, "ValidateCache", _Validator.ValidationStatus.ToString()));
                        if (Logging.On)
                        {
                            Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_unexpected_status, "ValidateCache()", _Validator.ValidationStatus.ToString()));
                        }
                        break;
                    }
                    break;
                }
            }
            catch (Exception e) {
                _ProtocolStatus    = CacheValidationStatus.Fail;
                _ProtocolException = e;
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
                {
                    throw;
                }
                if (Logging.On)
                {
                    Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_object_and_exception, "CacheProtocol#" + this.GetHashCode().ToString(NumberFormatInfo.InvariantInfo), (e is WebException? e.Message: e.ToString())));
                }
            }
            finally {
                // This is to release cache entry on error
                if (_ResponseStream == null && _Validator.CacheStream != null && _Validator.CacheStream != Stream.Null)
                {
                    _Validator.CacheStream.Close();
                    _Validator.CacheStream = Stream.Null;
                }
            }
        }
Example #22
0
        private static async Task GetFragment()
        {
            var tabs = new List <string>(ExSettings.Instance.GetTabsForCategory(ExSettings.StashingCategory.Fragment));

            if (tabs.Count > 1 && StashUi.IsOpened)
            {
                var currentTab = StashUi.StashTabInfo.DisplayName;
                var index      = tabs.IndexOf(currentTab);
                if (index > 0)
                {
                    var tab = tabs[index];
                    tabs.RemoveAt(index);
                    tabs.Insert(0, tab);
                }
            }

            foreach (var tab in tabs)
            {
                GlobalLog.Debug($"[TakeMapTask] Looking for Sacrifice Fragment in \"{tab}\" tab.");

                if (!await Inventories.OpenStashTab(tab))
                {
                    return;
                }

                if (StashUi.StashTabInfo.IsPremiumSpecial)
                {
                    var tabType = StashUi.StashTabInfo.TabType;
                    if (tabType == InventoryTabType.Fragment)
                    {
                        foreach (var control in SacrificeControls)
                        {
                            var fragment = control.CustomTabItem;
                            if (fragment != null)
                            {
                                GlobalLog.Debug($"[TakeMapTask] Found \"{fragment.Name}\" in \"{tab}\" tab.");
                                await Inventories.FastMoveFromPremiumStashTab(control);

                                return;
                            }
                            GlobalLog.Debug($"[TakeMapTask] There are no Sacrifice Fragments in \"{tab}\" tab.");
                        }
                    }
                    else
                    {
                        GlobalLog.Error($"[TakeMapTask] Incorrect tab type ({tabType}) for sacrifice fragments.");
                    }
                }
                else
                {
                    var fragment = Inventories.StashTabItems
                                   .Where(i => i.IsSacrificeFragment())
                                   .OrderBy(i => i.Name == "Sacrifice at Midnight") // move midnights to the end of the list
                                   .FirstOrDefault();

                    if (fragment != null)
                    {
                        GlobalLog.Debug($"[TakeMapTask] Found \"{fragment.Name}\" in \"{tab}\" tab.");
                        await Inventories.FastMoveFromStashTab(fragment.LocationTopLeft);

                        return;
                    }
                    GlobalLog.Debug($"[TakeMapTask] There are no Sacrifice Fragments in \"{tab}\" tab.");
                }
            }
            GlobalLog.Info("[TakeMapTask] There are no Sacrifice Fragments in all tabs assigned to them. Now marking them as unavailable.");
            _hasFragments = false;
        }
        // This method may add headers under the "Warning" header name
        protected internal override CacheValidationStatus ValidateCache()
        {
            if (HttpProxyMode)
            {
                return(base.ValidateCache());
            }

            if (Policy.Level >= RequestCacheLevel.Reload)
            {
                // For those policies cache is never returned
                GlobalLog.Assert("OnValidateCache()", "This validator should not be called for policy = " + Policy.ToString());
                if (Logging.On)
                {
                    Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_validator_invalid_for_policy, Policy.ToString()));
                }
                return(CacheValidationStatus.DoNotTakeFromCache);
            }

            // First check is do we have a cached entry at all?
            if (CacheStream == Stream.Null || CacheEntry.IsPartialEntry)
            {
                if (Policy.Level == RequestCacheLevel.CacheOnly)
                {
                    // Throw because entry was not found and it's cache-only policy
                    FailRequest(WebExceptionStatus.CacheEntryNotFound);
                }
                if (CacheStream == Stream.Null)
                {
                    return(CacheValidationStatus.DoNotTakeFromCache);
                }
                // Otherwise it's a partial entry and we can go on the wire
            }

            CacheStreamOffset = 0L;
            CacheStreamLength = CacheEntry.StreamSize;

            //
            // Before request submission validation
            //
            if (Policy.Level == RequestCacheLevel.Revalidate || CacheEntry.IsPartialEntry)
            {
                return(TryConditionalRequest());
            }

            long contentOffset = Request is FtpWebRequest ? ((FtpWebRequest)Request).ContentOffset: 0L;

            if (CacheFreshnessStatus == CacheFreshnessStatus.Fresh || Policy.Level == RequestCacheLevel.CacheOnly || Policy.Level == RequestCacheLevel.CacheIfAvailable)
            {
                if (contentOffset != 0)
                {
                    if (contentOffset >= CacheStreamLength)
                    {
                        if (Policy.Level == RequestCacheLevel.CacheOnly)
                        {
                            // Throw because request is outside of cached size and it's cache-only policy
                            FailRequest(WebExceptionStatus.CacheEntryNotFound);
                        }
                        return(CacheValidationStatus.DoNotTakeFromCache);
                    }
                    CacheStreamOffset = contentOffset;
                }
                return(CacheValidationStatus.ReturnCachedResponse);
            }

            return(CacheValidationStatus.DoNotTakeFromCache);
        }
Example #24
0
        // BeginWrite - provide async write functionality.
        //
        // This method provides async write functionality. All we do is
        // call through to the underlying socket async send.
        //
        // Input:
        //
        //     buffer  - Buffer to write into.
        //     offset  - Offset into the buffer where we're to write.
        //     size   - Number of bytes to written.
        //
        // Returns:
        //
        //     An IASyncResult, representing the write.
        public IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback callback, Object state)
        {
#if DEBUG
            using (GlobalLog.SetThreadKind(ThreadKinds.User | ThreadKinds.Async))
            {
#endif
            bool canWrite = CanWrite;     // Prevent race with Dispose.
            if (_cleanedUp)
            {
                throw new ObjectDisposedException(this.GetType().FullName);
            }
            if (!canWrite)
            {
                throw new InvalidOperationException(SR.net_readonlystream);
            }

            // Validate input parameters.
            if (buffer == null)
            {
                throw new ArgumentNullException(nameof(buffer));
            }
            if (offset < 0 || offset > buffer.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(offset));
            }
            if (size < 0 || size > buffer.Length - offset)
            {
                throw new ArgumentOutOfRangeException(nameof(size));
            }

            Socket chkStreamSocket = _streamSocket;
            if (chkStreamSocket == null)
            {
                throw new IOException(SR.Format(SR.net_io_writefailure, SR.net_io_connectionclosed));
            }

            try
            {
                // Call BeginSend on the Socket.
                IAsyncResult asyncResult =
                    chkStreamSocket.BeginSend(
                        buffer,
                        offset,
                        size,
                        SocketFlags.None,
                        callback,
                        state);

                return(asyncResult);
            }
            catch (Exception exception)
            {
                if (exception is OutOfMemoryException)
                {
                    throw;
                }

                // Some sort of error occurred on the socket call,
                // set the SocketException as InnerException and throw.
                throw new IOException(SR.Format(SR.net_io_writefailure, exception.Message), exception);
            }
#if DEBUG
        }
#endif
        }
Example #25
0
        public async Task <bool> Run()
        {
            if (MapBot.IsOnRun)
            {
                return(false);
            }

            var area = World.CurrentArea;

            if (!area.IsTown && !area.IsHideoutArea)
            {
                return(false);
            }

            if (Settings.StopRequested)
            {
                GlobalLog.Warn("Stopping the bot by a user's request (stop after current map)");
                Settings.StopRequested = false;
                BotManager.Stop();
                return(true);
            }

            var mapTabs = ExSettings.Instance.GetTabsForCategory(ExSettings.StashingCategory.Map);

            Item map;

            foreach (var tab in mapTabs)
            {
                if (!await Inventories.OpenStashTab(tab))
                {
                    ErrorManager.ReportError();
                    return(true);
                }
                if (StashUi.StashTabInfo.IsPremiumMap)
                {
                    GlobalLog.Error("Map stash tab is unsupported and there are no plans to support it in the future. Please remove it from stashing settings.");
                    BotManager.Stop();
                    return(true);
                }

                if ((map = FindProperMap()) != null)
                {
                    goto hasProperMap;
                }

                GlobalLog.Debug($"[TakeMapTask] Fail to find a proper map in \"{tab}\" tab.");
            }

            GlobalLog.Error("[TakeMapTask] Fail to find a proper map in all map tabs. Now stopping the bot because it cannot continue.");
            BotManager.Stop();
            return(true);

hasProperMap:
            GlobalLog.Info($"[TakeMapTask] Map of choice is \"{map.Name}\" (Tier: {map.MapTier})");

            if (!await Inventories.FastMoveFromStashTab(map.LocationTopLeft))
            {
                ErrorManager.ReportError();
                return(true);
            }
            if (!await Wait.For(() => (map = Inventories.InventoryItems.Find(i => i.IsMap())) != null, "map appear in inventory"))
            {
                GlobalLog.Error("[TakeMapTask] Unexpected error. Map did not appear in player's inventory after fast move from stash.");
                return(true);
            }

            var mapPos    = map.LocationTopLeft;
            var mapRarity = map.RarityLite();

            if (mapRarity == Rarity.Unique || !map.IsIdentified || map.IsMirrored || map.IsCorrupted)
            {
                ChooseMap(mapPos);
                return(false);
            }

            switch (mapRarity)
            {
            case Rarity.Normal:
                if (!await HandleNormalMap(mapPos))
                {
                    return(true);
                }
                break;

            case Rarity.Magic:
                if (!await HandleMagicMap(mapPos))
                {
                    return(true);
                }
                break;

            case Rarity.Rare:
                if (!await HandleRareMap(mapPos))
                {
                    return(true);
                }
                break;

            default:
                GlobalLog.Error($"[TakeMapTask] Unknown map rarity: \"{mapRarity}\".");
                ErrorManager.ReportCriticalError();
                return(true);
            }

            UpdateMapReference(mapPos, ref map);

            if (map.ShouldUpgrade(Settings.VaalUpgrade) && HasCurrency(CurrencyNames.Vaal))
            {
                if (!await CorruptMap(mapPos))
                {
                    return(true);
                }

                UpdateMapReference(mapPos, ref map);
            }
            if (map.ShouldUpgrade(Settings.FragmentUpgrade) && _hasFragments)
            {
                await GetFragment();
            }
            ChooseMap(mapPos);
            return(false);
        }
Example #26
0
        //
        // This method is called after an asynchronous call is made for the user,
        // it checks and acts accordingly if the IO:
        // 1) completed synchronously.
        // 2) was pended.
        // 3) failed.
        //
        internal unsafe SocketError CheckAsyncCallOverlappedResult(SocketError errorCode)
        {
#if DEBUG
            m_SavedErrorCode = errorCode;
#endif

            //
            // Check if the Async IO call:
            // 1) was pended.
            // 2) completed synchronously.
            // 3) failed.
            //
            if (m_UseOverlappedIO)
            {
                //
                // we're using overlapped IO under Win9x (or NT with registry setting overriding
                // completion port usage)
                //
                switch (errorCode)
                {
                case 0:
                case SocketError.IOPending:

                    //
                    // the Async IO call was pended:
                    // Queue our event to the thread pool.
                    //
                    GlobalLog.Assert(m_UnmanagedBlob != null, "BaseOverlappedAsyncResult#{0}::CheckAsyncCallOverlappedResult()|Unmanaged blob isn't allocated.", ValidationHelper.HashString(this));
                    ThreadPool.UnsafeRegisterWaitForSingleObject(
                        m_OverlappedEvent,
                        new WaitOrTimerCallback(OverlappedCallback),
                        this,
                        -1,
                        true);

                    //
                    // we're done, completion will be asynchronous
                    // in the callback. return
                    //
                    return(SocketError.Success);

                default:
                    //
                    // the Async IO call failed:
                    // set the number of bytes transferred to -1 (error)
                    //
                    ErrorCode = (int)errorCode;
                    Result    = -1;
                    ReleaseUnmanagedStructures();
                    break;
                }
            }
            else
            {
#if DEBUG
                OverlappedCache cache = m_Cache;
                if (cache != null)
                {
                    unsafe
                    {
                        NativeOverlapped *nativeOverlappedPtr = (NativeOverlapped *)cache.NativeOverlapped;
                        if (nativeOverlappedPtr != null)
                        {
                            m_IntermediateNativeOverlapped = *nativeOverlappedPtr;
                        }
                    }
                }
#endif
                //
                // We're using completion ports under WinNT.  Release one reference on the structures for
                // the main thread.
                //
                ReleaseUnmanagedStructures();

                switch (errorCode)
                {
                //
                // ignore cases in which a completion packet will be queued:
                // we'll deal with this IO in the callback
                //
                case 0:
                case SocketError.IOPending:
                    //
                    // ignore, do nothing
                    //
                    return(SocketError.Success);

                //
                // in the remaining cases a completion packet will NOT be queued:
                // we'll have to call the callback explicitly signaling an error
                //
                default:
                    //
                    // call the callback with error code
                    //
                    ErrorCode = (int)errorCode;
                    Result    = -1;

                    // The AsyncResult must be cleared since the callback isn't going to be called.
                    // Not doing so leads to a leak where the pinned cached OverlappedData continues to point to the async result object,
                    // which points to the Socket (as well as user data) and to the OverlappedCache, preventing the OverlappedCache
                    // finalizer from freeing the pinned OverlappedData.
                    if (m_Cache != null)
                    {
                        // Could be null only if SetUnmanagedStructures weren't called.
                        m_Cache.Overlapped.AsyncResult = null;
                    }

                    ReleaseUnmanagedStructures();  // Additional release for the completion that won't happen.
                    break;
                }
            }
            return(errorCode);
        }
Example #27
0
        private unsafe static void CompletionPortCallback(uint errorCode, uint numBytes, NativeOverlapped *nativeOverlapped)
        {
#if DEBUG
            GlobalLog.SetThreadSource(ThreadKinds.CompletionPort);
            using (GlobalLog.SetThreadKind(ThreadKinds.System)) {
#endif
            //
            // Create an Overlapped object out of the native pointer we're provided with.
            // (this will NOT free the unmanaged memory in the native overlapped structure)
            //
            Overlapped callbackOverlapped         = Overlapped.Unpack(nativeOverlapped);
            BaseOverlappedAsyncResult asyncResult = (BaseOverlappedAsyncResult)callbackOverlapped.AsyncResult;

            // The AsyncResult must be cleared before the callback is called (i.e. before ExtractCache is called).
            // Not doing so leads to a leak where the pinned cached OverlappedData continues to point to the async result object,
            // which points to the Socket (as well as user data), which points to the OverlappedCache, preventing the OverlappedCache
            // finalizer from freeing the pinned OverlappedData.
            callbackOverlapped.AsyncResult = null;

            object returnObject = null;

            GlobalLog.Assert(!asyncResult.InternalPeekCompleted, "BaseOverlappedAsyncResult#{0}::CompletionPortCallback()|asyncResult.IsCompleted", ValidationHelper.HashString(asyncResult));

            GlobalLog.Print("BaseOverlappedAsyncResult#" + ValidationHelper.HashString(asyncResult) + "::CompletionPortCallback" +
                            " errorCode:" + errorCode.ToString() +
                            " numBytes:" + numBytes.ToString() +
                            " pOverlapped:" + ((int)nativeOverlapped).ToString());

            //
            // complete the IO and invoke the user's callback
            //
            SocketError socketError = (SocketError)errorCode;

            if (socketError != SocketError.Success && socketError != SocketError.OperationAborted)
            {
                Socket socket = asyncResult.AsyncObject as Socket;
                if (socket == null)
                {
                    socketError = SocketError.NotSocket;
                }
                else if (socket.CleanedUp)
                {
                    socketError = SocketError.OperationAborted;
                }
                else
                {
                    try {
                        //
                        // The Async IO completed with a failure.
                        // here we need to call WSAGetOverlappedResult() just so Marshal.GetLastWin32Error() will return the correct error.
                        //
                        bool success = UnsafeNclNativeMethods.OSSOCK.WSAGetOverlappedResult(
                            socket.SafeHandle,
                            (IntPtr)nativeOverlapped,
                            out numBytes,
                            false,
                            IntPtr.Zero);

                        if (!success)
                        {
                            socketError = (SocketError)Marshal.GetLastWin32Error();
                            GlobalLog.Assert(socketError != 0, "BaseOverlappedAsyncResult#{0}::CompletionPortCallback()|socketError:0 numBytes:{1}", ValidationHelper.HashString(asyncResult), numBytes);
                        }

                        GlobalLog.Assert(!success, "BaseOverlappedAsyncResult#{0}::CompletionPortCallback()|Unexpectedly succeeded. errorCode:{1} numBytes:{2}", ValidationHelper.HashString(asyncResult), errorCode, numBytes);
                    }
                    // CleanedUp check above does not always work since this code is subject to race conditions
                    catch (ObjectDisposedException)
                    {
                        socketError = SocketError.OperationAborted;
                    }
                }
            }
            asyncResult.ErrorCode = (int)socketError;
            returnObject          = asyncResult.PostCompletion((int)numBytes);
            asyncResult.ReleaseUnmanagedStructures();
            asyncResult.InvokeCallback(returnObject);
#if DEBUG
        }
#endif
        }
Example #28
0
        //
        // SetUnmanagedStructures -
        //
        //  This needs to be called for overlapped IO to function properly.
        //
        //  Fills in Overlapped Structures used in an Async Overlapped Winsock call
        //  these calls are outside the runtime and are unmanaged code, so we need
        //  to prepare specific structures and ints that lie in unmanaged memory
        //  since the Overlapped calls can be Async
        //
        internal void SetUnmanagedStructures(object objectsToPin)
        {
            if (!m_DisableOverlapped)
            {
                // Casting to object[] is very expensive.  Only do it once.
                object[] objectsToPinArray   = null;
                bool     triedCastingToArray = false;

                bool useCache = false;
                if (m_Cache != null)
                {
                    if (objectsToPin == null && m_Cache.PinnedObjects == null)
                    {
                        useCache = true;
                    }
                    else if (m_Cache.PinnedObjects != null)
                    {
                        if (m_Cache.PinnedObjectsArray == null)
                        {
                            if (objectsToPin == m_Cache.PinnedObjects)
                            {
                                useCache = true;
                            }
                        }
                        else if (objectsToPin != null)
                        {
                            triedCastingToArray = true;
                            objectsToPinArray   = objectsToPin as object[];
                            if (objectsToPinArray != null && objectsToPinArray.Length == 0)
                            {
                                objectsToPinArray = null;
                            }
                            if (objectsToPinArray != null && objectsToPinArray.Length == m_Cache.PinnedObjectsArray.Length)
                            {
                                useCache = true;
                                for (int i = 0; i < objectsToPinArray.Length; i++)
                                {
                                    if (objectsToPinArray[i] != m_Cache.PinnedObjectsArray[i])
                                    {
                                        useCache = false;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }

                if (!useCache && m_Cache != null)
                {
                    GlobalLog.Print("BaseOverlappedAsyncResult#" + ValidationHelper.HashString(this) + "::SetUnmanagedStructures() Cache miss - freeing cache.");
                    m_Cache.Free();
                    m_Cache = null;
                }

                Socket s = (Socket)AsyncObject;
                if (m_UseOverlappedIO)
                {
                    GlobalLog.Assert(m_UnmanagedBlob == null, "BaseOverlappedAsyncResult#{0}::SetUnmanagedStructures()|Unmanaged blob already allocated. (Called twice?)", ValidationHelper.HashString(this));
                    m_UnmanagedBlob = SafeOverlappedFree.Alloc(s.SafeHandle);

                    PinUnmanagedObjects(objectsToPin);

                    //
                    // create the event handle
                    //

                    m_OverlappedEvent = new AutoResetEvent(false);

                    //
                    // fill in the overlapped structure with the event handle.
                    //

                    Marshal.WriteIntPtr(m_UnmanagedBlob.DangerousGetHandle(), Win32.OverlappedhEventOffset, m_OverlappedEvent.SafeWaitHandle.DangerousGetHandle());
                }
                else
                {
                    //
                    // Bind the Win32 Socket Handle to the ThreadPool
                    //
                    s.BindToCompletionPort();

                    if (m_Cache == null)
                    {
                        GlobalLog.Print("BaseOverlappedAsyncResult#" + ValidationHelper.HashString(this) + "::EnableCompletionPort() Creating new overlapped cache.");
                        if (objectsToPinArray != null)
                        {
                            m_Cache = new OverlappedCache(new Overlapped(), objectsToPinArray, s_IOCallback);
                        }
                        else
                        {
                            m_Cache = new OverlappedCache(new Overlapped(), objectsToPin, s_IOCallback, triedCastingToArray);
                        }
                    }
                    else
                    {
                        GlobalLog.Print("BaseOverlappedAsyncResult#" + ValidationHelper.HashString(this) + "::EnableCompletionPort() Using cached overlapped.");
                    }

                    m_Cache.Overlapped.AsyncResult = this;

#if DEBUG
                    unsafe { m_InitialNativeOverlapped = *((NativeOverlapped *)m_Cache.NativeOverlapped); }
#endif

                    GlobalLog.Print("BaseOverlappedAsyncResult#" + ValidationHelper.HashString(this) + "::EnableCompletionPort() overlapped:" + ValidationHelper.HashString(m_Cache.Overlapped) + " NativeOverlapped = " + m_Cache.NativeOverlapped.ToString("x"));
                }
            }
        }
Example #29
0
        /// <summary>
        /// Displays a tree by putting it in an HwndSource and running a dispatcher.
        /// </summary>
        /// <param name="root">The root of the tree to display.</param>
        /// <param name="titleSuffix">A string to append to the window title bar.</param>
        /// <param name="continueDispatcher">Whether or not continue dispatcher after display tree. Works only with Custome Elements defined under CustomElements</param>
        public void DisplayTree(object root, string titleSuffix, bool continueDispatcher)
        {
            _continueDispatcher = continueDispatcher;
            if (root == null)
            {
                throw new ArgumentNullException("root");
            }

            if (root is UIElement && LogicalTreeHelper.GetParent((UIElement)root) != null)
            {
                throw new ArgumentException("root", "The given node has a parent.");
            }

            Dispatcher dispatcher = Dispatcher.CurrentDispatcher;

            if (dispatcher == null)
            {
                throw new InvalidOperationException("Cannot show the tree. The current thread has not entered a Dispatcher.");
            }

            if (!_AttachRenderedHandler(root))
            {
                GlobalLog.LogStatus("Not displaying element tree; root not recognized as framework element or custom test element.");
                return;
            }

            // Get window - create one if necessary.
            Window win = null;

            if (root is Window)
            {
                win = (Window)root;
            }
            else
            {
                win         = CreateWindow();
                win.Content = root;
            }


            Point point = UpdatePosition(100, 100);

            // Set window size.
            win.Top    = point.Y;
            win.Left   = point.X;
            win.Width  = 800;
            win.Height = 700;

            // Show window.
            _SetWindowVisibility(win, true);

            // Run dispatcher.
            GlobalLog.LogStatus("Running dispatcher...");
            _dispatcherFrame = new DispatcherFrame();
            Dispatcher.PushFrame(_dispatcherFrame);

            GlobalLog.LogStatus("Dispatcher is done...");
            _dispatcherFrame = null;

            // If an exception happened within the Avalon app,
            // forward that exception now.
            Exception testResultEx = RetrieveException();

            if (testResultEx != null)
            {
                StoreException(null);
                throw new Exception("Exception was logged while displaying tree.\r\n\r\n" + testResultEx);
            }

            // If an failure was "logged" while displaying the tree,
            // forward the failure now.
            string testResultMsg = testResultStore;

            if (testResultMsg != null)
            {
                testResultStore = null;
                if (testResultMsg.ToLowerInvariant() == "fail")
                {
                    throw new Exception("Fail was logged while displaying tree.");
                }
            }

            if (!_didRender)
            {
                throw new Exception("ICustomElement.RenderedEvent handler did not fire.");
            }
            else
            {
                _didRender = false;
            }

            // Hide the Window so it doesn't serialize with
            // Visibility on.
            _SetWindowVisibility(win, false);
        }
Example #30
0
        /// <summary>
        /// Callback routine to complete the round trip test.
        /// </summary>
        public void AsyncRoundTripTest(object firstTreeRoot, XamlWriterMode expressionMode, bool attemptDisplay)
        {
            try
            {
                object secondTreeRoot   = null;
                string firstSerialized  = String.Empty;
                string secondSerialized = String.Empty;

                _iteration++;

                if (null == firstTreeRoot)
                {
                    throw new Exception("First tree root is null.");
                }

                _firstTreeRoot = firstTreeRoot;

                // Fire PreFirstDisplay event
                if (PreFirstDisplay != null)
                {
                    PreFirstDisplay(_firstTreeRoot);
                }

                //
                // Display first tree.
                //
                if (attemptDisplay)
                {
                    _isFirst = true;
                    GlobalLog.LogStatus("Attempting to display the first tree root...");
                    DisplayTree(firstTreeRoot, _iteration + " " + " - first tree root", true);
                }

                // Fire PreFirstSerialization event
                if (PreFirstSerialization != null)
                {
                    PreFirstSerialization(_firstTreeRoot);
                }

                //
                // Serialize first tree.
                //
                GlobalLog.LogStatus("Serializing the first tree root...");
                firstSerialized = SerializeObjectTree(firstTreeRoot, expressionMode);
                GlobalLog.LogStatus("Done serializing the first tree root.");

                // Fire an event with the serialized xaml string.
                _FireXamlSerializedEvent(firstSerialized);

                if (this.CompareOriginalXaml && _originalXaml != null)
                {
                    GlobalLog.LogStatus("Comparing original xaml to first serialized xaml...");
                    _CompareXamls(_originalXaml, firstSerialized);
                }

                //
                // Parse the first serialized xaml.
                // Nullify _parserContext (if it's not null already) so that
                //  it can't be reused anymore
                //
                secondTreeRoot = ParseXaml(firstSerialized);
                _parserContext = null;

                _secondTreeRoot = secondTreeRoot;

                // Fire PreSecondDisplay event
                if (PreSecondDisplay != null)
                {
                    PreSecondDisplay(_secondTreeRoot);
                }

                //
                // Display the second tree.
                //
                if (attemptDisplay)
                {
                    _isFirst = false;
                    GlobalLog.LogStatus("Attempting to display the second tree root...");
                    DisplayTree(secondTreeRoot, _iteration + " " + " - second tree root");
                }

                // Fire PreSecondSerialization event
                if (PreSecondSerialization != null)
                {
                    PreSecondSerialization(_secondTreeRoot);
                }

                //
                // Serialize the second tree.
                //
                GlobalLog.LogStatus("Serializing the second tree...");
                secondSerialized = SerializeObjectTree(secondTreeRoot, expressionMode);
                GlobalLog.LogStatus("Done serializing the second tree root.");

                // Fire an event with the serialized xaml string.
                _FireXamlSerializedEvent(secondSerialized);

                //
                // Compare the first and second trees.
                //
                if (DoTreeComparison)
                {
                    GlobalLog.LogStatus("Comparing object trees...");
                    _CompareObjectTree(firstTreeRoot, secondTreeRoot);
                }

                if (XamlWriterMode.Expression != expressionMode && AlwaysTestExpressionMode)
                {
                    // For XamlWriterMode.Value, Expression mode is also verified.
                    //
                    // Serialize first tree with Expression Mode
                    //
                    GlobalLog.LogStatus("Serializing the first tree root with Expression mode...");
                    secondSerialized = SerializeObjectTree(firstTreeRoot, XamlWriterMode.Expression);
                    GlobalLog.LogStatus("Done serializing the first tree root with Expression mode.");

                    // Fire an event with the serialized xaml string.
                    _FireXamlSerializedEvent(secondSerialized);

                    //
                    // Parse the serialized xaml.
                    //
                    secondTreeRoot = ParseXaml(secondSerialized);

                    // Fire PreSecondDisplay event
                    if (PreSecondDisplay != null)
                    {
                        PreSecondDisplay(secondTreeRoot);
                    }

                    //
                    // Display the second tree.
                    //
                    if (attemptDisplay)
                    {
                        _isFirst = false;
                        GlobalLog.LogStatus("Attempting to display the tree loaded from string serialized with Expression mode ...");
                        DisplayTree(secondTreeRoot, _iteration + " " + " - additional tree", false);
                    }

                    //
                    // Compare the first and the additional tree parsed from string serialized with Expression mode.					//
                    if (DoTreeComparison)
                    {
                        GlobalLog.LogStatus("Comparing object trees...");
                        _CompareObjectTree(firstTreeRoot, secondTreeRoot);
                    }
                }

                //
                // Compare first and second serialized xaml files.
                //
                if (DoXamlComparison)
                {
                    GlobalLog.LogStatus("Comparing xamls...");
                    _CompareXamls(firstSerialized, secondSerialized);
                }
            }
            finally
            {
                //
                // Shutdown the dispatcher.
                // Set the appropriate flags to indicates the shutdown
                // is expected.
                //
                _roundTripTestExit = true;

                Dispatcher.CurrentDispatcher.ShutdownFinished -= new EventHandler(_ValidatingExitDispatcher);
                _ShutdownDispatcher();
            }
        }