コード例 #1
0
        public async Task <WeatherDescription> GetWeatherAsync(GeoTagsEntry geoTags)
        {
            var requestUri = string.Format(RequestWeatherUri, geoTags.LatitudeValue, geoTags.LongitudeValue, InternalUtils.GetOpenWeatherApiCode());

#if DEBUG
            Logging.Write(requestUri);
#endif

            using (var order = KillerOrder.Create(new WebClient(), 5000)) {
                var data = await order.Victim.DownloadStringTaskAsync(requestUri);

                XDocument doc;
                try {
                    doc = XDocument.Parse(data);
                } catch (XmlException) {
                    Logging.Warning("response: " + data);
                    throw;
                }

                var temperatureValue = doc.Descendants(@"temperature").FirstOrDefault()?.Attribute(@"value")?.Value;
                var weatherNode      = doc.Descendants(@"weather").FirstOrDefault();
                if (temperatureValue == null || weatherNode == null)
                {
                    throw new Exception("Invalid response");
                }

                var temperature = FlexibleParser.ParseDouble(temperatureValue);
                var type        = OpenWeatherTypeToCommonType((OpenWeatherType)int.Parse(weatherNode.Attribute(@"number")?.Value, NumberStyles.Any, CultureInfo.InvariantCulture));
                var description = weatherNode.Attribute(@"value")?.Value;
                var icon        = weatherNode.Attribute(@"icon")?.Value;
                var iconUri     = icon == null ? null : string.Format(IconUri, icon);
                return(new WeatherDescription(type, temperature, description, iconUri));
            }
        }
コード例 #2
0
ファイル: GoogleApiProvider.cs プロジェクト: windygu/actools
        public static async Task <TimeZoneInfo> DetermineTimeZoneAsync(GeoTagsEntry geoTags)
        {
            var requestUri = string.Format(RequestTimeZoneUri, geoTags.LatitudeValue, geoTags.LongitudeValue,
                                           DateTime.Now.ToUnixTimestamp());

            Logging.Debug(requestUri);

            using (var order = KillerOrder.Create(new WebClient(), 5000)) {
                var data = await order.Victim.DownloadStringTaskAsync(requestUri);

                var doc    = XDocument.Parse(data);
                var zoneId = doc.Descendants(@"time_zone_id").FirstOrDefault()?.Value;
                if (zoneId == null)
                {
                    throw new Exception("Invalid response");
                }

                try {
                    return(TimeZoneInfo.FindSystemTimeZoneById(zoneId));
                } catch (TimeZoneNotFoundException) {
                    var rawOffset = doc.Descendants(@"raw_offset").FirstOrDefault()?.Value;
                    var zoneName  = doc.Descendants(@"time_zone_name").FirstOrDefault()?.Value;
                    if (rawOffset == null || zoneName == null)
                    {
                        throw new Exception("Invalid response");
                    }
                    return(TimeZoneInfo.CreateCustomTimeZone(zoneId, TimeSpan.FromSeconds(FlexibleParser.ParseDouble(rawOffset)), zoneName, zoneName));
                }
            }
        }
コード例 #3
0
        public static async Task <string> UnwrapLink(string argument, CancellationToken cancellation = default(CancellationToken))
        {
            var loader = CreateLoader(argument);

            using (var order = KillerOrder.Create(new CookieAwareWebClient {
                Headers =
                {
                    [HttpRequestHeader.UserAgent] = CmApiProvider.UserAgent
                }
            }, TimeSpan.FromMinutes(10))) {
                var client = order.Victim;

                if (_proxy != null)
                {
                    client.Proxy = _proxy;
                }

                if (!await loader.PrepareAsync(client, cancellation))
                {
                    throw new InformativeException("Can’t load file", "Loader preparation failed.");
                }

                return(await loader.GetDownloadLink(cancellation));
            }
        }
コード例 #4
0
ファイル: CmInGameAppHelper.cs プロジェクト: windygu/actools
        private async Task <bool> EnsureConnectedAsync(bool reconnect)
        {
            if (_socket == null || !_socket.Connected)
            {
                if (!reconnect || _lastConnectionAttempt?.ElapsedMilliseconds < 3000)
                {
                    return(false);
                }

                Logging.Debug("Close socket before reconnecting…");
                CloseSocket();

                try {
                    _socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                    _killer = KillerOrder.Create(_socket, TimeSpan.FromSeconds(1));
                    await _socket.ConnectTaskAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), OptionSocketPort)).ConfigureAwait(false);

                    Logging.Debug("Connected to CM in-game app");
                    _killer?.Pause();
                } catch (Exception e) {
                    Logging.Warning(e);
                    CloseSocket();
                }
            }

            return(_socket != null);
        }
コード例 #5
0
 public static async Task <AcServerStatus> GetCurrentStateAsync(string ip, int port, string password)
 {
     try {
         using (var killer = KillerOrder.Create(new CookieAwareWebClient(), OptionTimeout)) {
             return(JsonConvert.DeserializeObject <AcServerStatus>(await killer.Victim.DownloadStringTaskAsync(
                                                                       $"http://{ip}:{port}/api/control/acserver?password={EncodePassword(password)}&_method=STATUS")));
         }
     } catch (Exception e) when(e.IsCancelled())
     {
         throw new WebException("Timeout exceeded", WebExceptionStatus.Timeout);
     }
 }
コード例 #6
0
 private static async Task <string> LoadUsingClientAsync(string uri, TimeSpan timeout)
 {
     using (var order = KillerOrder.Create(new TimeoutyWebClient(timeout)
     {
         Headers =
         {
             [HttpRequestHeader.UserAgent] = InternalUtils.GetKunosUserAgent()
         }
     }, timeout)) {
         return(await order.Victim.DownloadStringTaskAsync(uri));
     }
 }
コード例 #7
0
ファイル: FtpClient.cs プロジェクト: windygu/actools
        private KillerOrder <FtpWebRequest> Request([NotNull] string remoteFile, [NotNull] string method, CancellationToken cancellation)
        {
            cancellation.ThrowIfCancellationRequested();
            var killer  = KillerOrder.Create((FtpWebRequest)WebRequest.Create($"{_hostName}/{remoteFile}"), Timeout, cancellation);
            var request = killer.Victim;

            request.Credentials = new NetworkCredential(_userName, _password);
            request.UseBinary   = UseBinary;
            request.UsePassive  = UsePassive;
            request.KeepAlive   = KeepAlive;
            request.Method      = method;
            return(killer);
        }
コード例 #8
0
        public static async Task <GeoTagsEntry> LocateAsync([CanBeNull] string address)
        {
            var requestUri = string.Format(RequestLocationUri, InternalUtils.GetPositionStackApiKey().Item1,
                                           HttpUtility.UrlEncode(CleanUpRegex.Replace(address ?? "", " ")));

            using (var order = KillerOrder.Create(new WebClient(), 5000)) {
                var data = await order.Victim.DownloadStringTaskAsync(requestUri);

                var item = JObject.Parse(data)[@"data"][0];
                return(new GeoTagsEntry(
                           item.GetDoubleValueOnly("latitude") ?? throw new Exception("Invalid response: no latitude"),
                           item.GetDoubleValueOnly("longitude") ?? throw new Exception("Invalid response: no longitude")));
            }
        }
コード例 #9
0
ファイル: Request.cs プロジェクト: windygu/actools
        public async Task <string> Send([Localizable(false)] string method, string url, object data, string authToken,
                                        [CanBeNull] IProgress <AsyncProgressEntry> progress, CancellationToken cancellation, NameValueCollection extraHeaders)
        {
            try {
                using (var order = KillerOrder.Create(new CookieAwareWebClient {
                    Headers = { [@"Accept"] = @"application/json" }
                }, TimeSpan.FromMinutes(10))) {
                    var client = order.Victim;

                    if (authToken != null)
                    {
                        client.Headers[@"Authorization"] = $@"{AuthorizationTokenType} {authToken}";
                    }

                    client.SetUserAgent(InternalUtils.GetKunosUserAgent());
                    cancellation.Register(client.CancelAsync);

                    if (extraHeaders != null)
                    {
                        foreach (string header in extraHeaders)
                        {
                            client.Headers[header] = extraHeaders[header];
#if DEBUG
                            Logging.Debug($"Header: {header}: {extraHeaders[header]}");
#endif
                        }
                    }

                    if (data == null)
                    {
                        client.SetMethod(method);
                        client.SetDownloadProgress(progress, null, order.Delay);
                        return((await client.DownloadDataTaskAsync(url)).ToUtf8String());
                    }

                    var bytes = GetBytes(data, out var contentType);
                    client.SetContentType(contentType);
                    client.SetUploadProgress(progress, bytes.Length, order.Delay);
                    return((await client.UploadDataTaskAsync(url, method, bytes)).ToUtf8String());
                }
            } catch (Exception e) {
                var wrapped = ApiException.Wrap(e, cancellation);
                if (wrapped == null)
                {
                    throw;
                }
                throw wrapped;
            }
        }
コード例 #10
0
        public static async Task <TimeZoneInfo> DetermineTimeZoneAsync(GeoTagsEntry geoTags)
        {
            var requestUri = string.Format(RequestTimeZoneUri, geoTags.LatitudeValue, geoTags.LongitudeValue,
                                           InternalUtils.GetTimeZoneDbApiCode());

            #if DEBUG
            Logging.Debug(requestUri);
            #endif

            using (var order = KillerOrder.Create(new CookieAwareWebClient(), 15000)) {
                var data = await order.Victim.DownloadStringTaskAsync(requestUri);

                var doc    = JObject.Parse(data);
                var zoneId = doc.GetStringValueOnly("zoneName");
                if (zoneId == null)
                {
                    throw new Exception("Invalid response");
                }

                Logging.Write("Returned zone ID: " + zoneId);

                try {
                    Logging.Write("Parsed as: " + TZConvert.GetTimeZoneInfo(zoneId).ToSerializedString());
                    return(TZConvert.GetTimeZoneInfo(zoneId));
                } catch (TimeZoneNotFoundException) {
                    var rawOffset = doc.GetStringValueOnly(@"gmtOffset");
                    return(TimeZoneInfo.CreateCustomTimeZone(zoneId, TimeSpan.FromSeconds(FlexibleParser.ParseDouble(rawOffset)), zoneId, zoneId));
                }
            }

            /*var requestUri = string.Format(RequestTimeZoneUri, geoTags.LatitudeValue, geoTags.LongitudeValue,
             *                             DateTime.Now.ToUnixTimestamp(), InternalUtils.GetGoogleMapsApiCode());
             *
             * using (var order = KillerOrder.Create(new WebClient(), 5000)) {
             *  var data = await order.Victim.DownloadStringTaskAsync(requestUri);
             *  var doc = XDocument.Parse(data);
             *  var zoneId = doc.Descendants(@"time_zone_id").FirstOrDefault()?.Value;
             *  if (zoneId == null) throw new Exception("Invalid response");
             *
             *  try {
             *      return TZConvert.GetTimeZoneInfo(zoneId);
             *  } catch (TimeZoneNotFoundException) {
             *      var rawOffset = doc.Descendants(@"raw_offset").FirstOrDefault()?.Value;
             *      var zoneName = doc.Descendants(@"time_zone_name").FirstOrDefault()?.Value;
             *      if (rawOffset == null || zoneName == null) throw new Exception("Invalid response");
             *      return TimeZoneInfo.CreateCustomTimeZone(zoneId, TimeSpan.FromSeconds(FlexibleParser.ParseDouble(rawOffset)), zoneName, zoneName);
             *  }
             * }*/
        }
コード例 #11
0
        public static async Task <Tuple <int, TimeSpan> > TryToPingServerAsync(string ip, int port, int timeout)
        {
            using (var order = KillerOrder.Create(new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
            {
                SendTimeout = timeout,
                ReceiveTimeout = timeout
            }, timeout)) {
                var socket = order.Victim;
                var buffer = new byte[3];

                try {
                    var bytes    = BitConverter.GetBytes(200);
                    var endpoint = new IPEndPoint(IPAddress.Parse(ip), port);

                    await Task.Factory.FromAsync(socket.BeginSendTo(bytes, 0, bytes.Length, SocketFlags.None, endpoint, null, socket),
                                                 socket.EndSendTo);

                    if (order.Killed)
                    {
                        return(null);
                    }

                    var timer   = Stopwatch.StartNew();
                    var elapsed = TimeSpan.Zero;

                    var begin = socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, a => { elapsed = timer.Elapsed; }, socket);
                    if (begin == null)
                    {
                        return(null);
                    }

                    await Task.Factory.FromAsync(begin, socket.EndReceive);

                    if (order.Killed)
                    {
                        return(null);
                    }

                    return(buffer[0] != 200 || buffer[1] + buffer[2] <= 0 ? null :
                           new Tuple <int, TimeSpan>(BitConverter.ToInt16(buffer, 1), elapsed));
                } catch (Exception) {
                    return(null);
                }
            }
        }
コード例 #12
0
ファイル: YahooApiProvider.cs プロジェクト: windygu/actools
        public static async Task <GeoTagsEntry> LocateAsync([CanBeNull] string address)
        {
            var requestUri = string.Format(RequestLocationUri, HttpUtility.UrlEncode(CleanUpRegex.Replace(address ?? "", " ")));

            using (var order = KillerOrder.Create(new WebClient(), 5000)) {
                var data = await order.Victim.DownloadStringTaskAsync(requestUri);

                var ns        = XNamespace.Get(@"http://where.yahooapis.com/v1/schema.rng");
                var centroid  = XDocument.Parse(data).Descendants(ns + @"centroid").FirstOrDefault();
                var latitude  = centroid?.Element(ns + @"latitude");
                var longitude = centroid?.Element(ns + @"longitude");
                if (latitude == null || longitude == null)
                {
                    throw new Exception("Invalid response");
                }
                return(new GeoTagsEntry(FlexibleParser.ParseDouble(latitude.Value),
                                        FlexibleParser.ParseDouble(longitude.Value)));
            }
        }
コード例 #13
0
ファイル: FlexibleLoader.cs プロジェクト: killvxk/actools
        public static async Task <string> UnwrapLink(string argument, CancellationToken cancellation = default)
        {
            var loader = await CreateLoaderAsync(argument, cancellation) ?? throw new OperationCanceledException();

            using (var order = KillerOrder.Create(new CookieAwareWebClient(), TimeSpan.FromMinutes(10))) {
                var client = order.Victim;

                if (_proxy != null)
                {
                    client.Proxy = _proxy;
                }

                if (!await loader.PrepareAsync(client, cancellation))
                {
                    throw new InformativeException("Can’t load file", "Loader preparation failed.");
                }

                return(await loader.GetDownloadLink(cancellation));
            }
        }
コード例 #14
0
ファイル: KunosApiProvider.cs プロジェクト: mdupuis13/actools
        public static async Task <Tuple <int, TimeSpan> > TryToPingServerAsync(string ip, int port, int timeout, bool logging = false)
        {
            using (var order = KillerOrder.Create(new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
            {
                SendTimeout = timeout,
                ReceiveTimeout = timeout
            }, timeout)) {
                var socket = order.Victim;
                var buffer = new byte[3];
                if (logging)
                {
                    Logging.Debug("Socket created");
                }

                try {
                    var bytes    = BitConverter.GetBytes(200);
                    var endpoint = new IPEndPoint(await ParseIPAddressAsync(ip), port);
                    if (logging)
                    {
                        Logging.Debug("Sending bytes to: " + endpoint);
                    }

                    await Task.Factory.FromAsync(socket.BeginSendTo(bytes, 0, bytes.Length, SocketFlags.None, endpoint, null, socket),
                                                 socket.EndSendTo);

                    if (logging)
                    {
                        Logging.Debug("Bytes sent");
                    }

                    if (order.Killed)
                    {
                        if (logging)
                        {
                            Logging.Warning("Timeout exceeded");
                        }
                        return(null);
                    }

                    var timer   = Stopwatch.StartNew();
                    var elapsed = TimeSpan.Zero;

                    if (logging)
                    {
                        Logging.Debug("Receiving response…");
                    }
                    var begin = socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, a => { elapsed = timer.Elapsed; }, socket);
                    if (begin == null)
                    {
                        if (logging)
                        {
                            Logging.Warning("Failed to begin receiving response");
                        }
                        return(null);
                    }

                    if (logging)
                    {
                        Logging.Debug("Waiting for the end of response");
                    }
                    await Task.Factory.FromAsync(begin, socket.EndReceive);

                    if (order.Killed)
                    {
                        if (logging)
                        {
                            Logging.Warning("Timeout exceeded");
                        }
                        return(null);
                    }

                    if (logging)
                    {
                        Logging.Debug("Response: " + buffer.JoinToString(", "));
                    }
                    if (buffer[0] != 200 || buffer[1] + buffer[2] <= 0)
                    {
                        if (logging)
                        {
                            Logging.Warning("Invalid response, consider as an error");
                        }
                        return(null);
                    }

                    if (logging)
                    {
                        Logging.Write("Pinging is a success");
                    }
                    return(new Tuple <int, TimeSpan>(BitConverter.ToInt16(buffer, 1), elapsed));
                } catch (Exception) {
                    return(null);
                }
            }
        }
コード例 #15
0
        public static async Task <string> LoadAsyncTo(string argument, string destination, IProgress <AsyncProgressEntry> progress = null,
                                                      Action <FlexibleLoaderMetaInformation> metaInformationCallback = null, CancellationToken cancellation = default(CancellationToken))
        {
            var loader = CreateLoader(argument);

            try {
                using (var order = KillerOrder.Create(new CookieAwareWebClient {
                    Headers =
                    {
                        [HttpRequestHeader.UserAgent] = CmApiProvider.UserAgent
                    }
                }, TimeSpan.FromMinutes(10))) {
                    var client = order.Victim;

                    if (_proxy != null)
                    {
                        client.Proxy = _proxy;
                    }

                    progress?.Report(AsyncProgressEntry.Indetermitate);

                    cancellation.ThrowIfCancellationRequested();
                    cancellation.Register(client.CancelAsync);

                    if (!await loader.PrepareAsync(client, cancellation))
                    {
                        throw new InformativeException("Can’t load file", "Loader preparation failed.");
                    }

                    cancellation.ThrowIfCancellationRequested();
                    metaInformationCallback?.Invoke(new FlexibleLoaderMetaInformation(loader.TotalSize, loader.FileName, loader.Version));

                    var s = Stopwatch.StartNew();
                    if (loader.UsesClientToDownload)
                    {
                        client.DownloadProgressChanged += (sender, args) => {
                            if (s.Elapsed.TotalMilliseconds > 20)
                            {
                                order.Delay();
                                s.Restart();
                            }
                            else
                            {
                                return;
                            }

                            var total = args.TotalBytesToReceive;
                            if (total == -1 && loader.TotalSize != -1)
                            {
                                total = Math.Max(loader.TotalSize, args.BytesReceived);
                            }

                            progress?.Report(AsyncProgressEntry.CreateDownloading(args.BytesReceived, total));
                        };
                    }

                    await loader.DownloadAsync(client, destination, loader.UsesClientToDownload?null : new Progress <double>(p => {
                        if (s.Elapsed.TotalMilliseconds > 20)
                        {
                            order.Delay();
                            s.Restart();
                        }
                        else
                        {
                            return;
                        }

                        var total = loader.TotalSize;
                        progress?.Report(total == -1 ?
                                         new AsyncProgressEntry("Loading…", p) :
                                         AsyncProgressEntry.CreateDownloading((long)(p * total), total));
                    }), cancellation);

                    cancellation.ThrowIfCancellationRequested();
                }
            } catch (Exception) when(cancellation.IsCancellationRequested)
            {
                throw new OperationCanceledException();
            }

            return(destination);
        }
コード例 #16
0
        private static async Task <string> LoadUsingRequestAsync(string uri, TimeSpan timeout)
        {
            using (var order = KillerOrder.Create((HttpWebRequest)WebRequest.Create(uri), timeout)) {
                var request = order.Victim;
                request.Method    = "GET";
                request.UserAgent = InternalUtils.GetKunosUserAgent();
                request.Headers.Add("Accept-Encoding", "gzip");

                if (OptionNoProxy)
                {
                    request.Proxy = null;
                }

                if (OptionForceDisabledCache)
                {
                    request.CachePolicy = _cachePolicy ??
                                          (_cachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore));
                }

                request.Timeout = (int)timeout.TotalMilliseconds;

                string result;
                using (var response = (HttpWebResponse)await request.GetResponseAsync()) {
                    if (response.StatusCode != HttpStatusCode.OK)
                    {
                        throw new Exception($@"StatusCode = {response.StatusCode}");
                    }

                    using (var stream = response.GetResponseStream()) {
                        if (stream == null)
                        {
                            throw new Exception(@"ResponseStream = null");
                        }

                        if (string.Equals(response.Headers.Get("Content-Encoding"), @"gzip", StringComparison.OrdinalIgnoreCase))
                        {
                            using (var deflateStream = new GZipStream(stream, CompressionMode.Decompress)) {
                                using (var reader = new StreamReader(deflateStream, Encoding.UTF8)) {
                                    result = await reader.ReadToEndAsync();
                                }
                            }
                        }
                        else
                        {
                            using (var reader = new StreamReader(stream, Encoding.UTF8)) {
                                result = await reader.ReadToEndAsync();
                            }
                        }
                    }
                }

                if (OptionSaveResponses)
                {
                    var filename = FilesStorage.Instance.GetFilename("Logs",
                                                                     $"Dump_{Regex.Replace(uri.Split('/').Last(), @"\W+", "_")}.json");
                    if (!File.Exists(filename))
                    {
                        File.WriteAllText(FilesStorage.Instance.GetFilename(filename), result);
                    }
                }

                return(result);
            }
        }
コード例 #17
0
ファイル: FlexibleLoader.cs プロジェクト: killvxk/actools
        public static async Task <string> LoadAsyncTo(string argument,
                                                      FlexibleLoaderGetPreferredDestinationCallback getPreferredDestination, [CanBeNull] FlexibleLoaderReportDestinationCallback reportDestination,
                                                      Action <FlexibleLoaderMetaInformation> reportMetaInformation = null, Func <bool> checkIfPaused = null,
                                                      IProgress <AsyncProgressEntry> progress = null, CancellationToken cancellation = default)
        {
            progress?.Report(AsyncProgressEntry.FromStringIndetermitate("Finding fitting loader…"));
            var loader = await CreateLoaderAsync(argument, cancellation) ?? throw new OperationCanceledException();

            try {
                using (var order = KillerOrder.Create(new CookieAwareWebClient(), TimeSpan.FromMinutes(10))) {
                    var client = order.Victim;

                    if (_proxy != null)
                    {
                        client.Proxy = _proxy;
                    }

                    progress?.Report(AsyncProgressEntry.Indetermitate);

                    cancellation.ThrowIfCancellationRequested();
                    cancellation.Register(client.CancelAsync);

                    if (!await loader.PrepareAsync(client, cancellation))
                    {
                        throw new InformativeException("Can’t load file", "Loader preparation failed.");
                    }

                    cancellation.ThrowIfCancellationRequested();
                    reportMetaInformation?.Invoke(FlexibleLoaderMetaInformation.FromLoader(loader));

                    var initialProgressCallback = true;
                    var reportStopwatch         = Stopwatch.StartNew();
                    var progressStopwatch       = new AsyncProgressBytesStopwatch();

                    if (loader.UsesClientToDownload)
                    {
                        client.DownloadProgressChanged += (sender, args) => {
                            if (initialProgressCallback)
                            {
                                reportMetaInformation?.Invoke(FlexibleLoaderMetaInformation.FromLoader(loader));
                                initialProgressCallback = false;
                            }

                            if (reportStopwatch.Elapsed.TotalMilliseconds < 20)
                            {
                                return;
                            }
                            order.Delay();
                            reportStopwatch.Restart();
                            progress?.Report(AsyncProgressEntry.CreateDownloading(args.BytesReceived, args.TotalBytesToReceive == -1 &&
                                                                                  loader.TotalSize.HasValue ? Math.Max(loader.TotalSize.Value, args.BytesReceived) : args.TotalBytesToReceive,
                                                                                  progressStopwatch));
                        };
                    }

                    var loaded = await loader.DownloadAsync(client, getPreferredDestination, reportDestination, checkIfPaused,
                                                            loader.UsesClientToDownload?null : new Progress <long>(p => {
                        if (initialProgressCallback)
                        {
                            reportMetaInformation?.Invoke(FlexibleLoaderMetaInformation.FromLoader(loader));
                            initialProgressCallback = false;
                        }

                        if (reportStopwatch.Elapsed.TotalMilliseconds < 20)
                        {
                            return;
                        }
                        order.Delay();
                        reportStopwatch.Restart();
                        progress?.Report(loader.TotalSize.HasValue ? AsyncProgressEntry.CreateDownloading(p, loader.TotalSize.Value, progressStopwatch)
                                        : new AsyncProgressEntry(string.Format(UiStrings.Progress_Downloading, p.ToReadableSize(1)), null));
                    }), cancellation);

                    cancellation.ThrowIfCancellationRequested();
                    Logging.Write("Loaded: " + loaded);
                    return(loaded);
                }
            } catch (Exception e) when(cancellation.IsCancellationRequested || e.IsCancelled())
            {
                Logging.Warning("Cancelled");
                throw new OperationCanceledException();
            } catch (Exception e) {
                Logging.Warning(e);
                throw;
            }
        }
コード例 #18
0
 private static async Task <IpGeoEntry> GetAsyncFn()
 {
     using (var killer = KillerOrder.Create(new CookieAwareWebClient(), 10000)) {
         return(JsonConvert.DeserializeObject <IpGeoEntry>(await killer.Victim.DownloadStringTaskAsync(RequestUri)));
     }
 }