示例#1
0
        private void UninstallPackage_CanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            PipPackageView view = e.Parameter as PipPackageView;

            e.CanExecute = _provider.CanExecute && view != null && _provider._packageManager.CanUninstall(view.Package);
            e.Handled    = true;
        }
示例#2
0
        protected async Task ReadCacheFromDiskAsync(CancellationToken cancel)
        {
            Debug.Assert(_cacheLock.CurrentCount == 0, "Cache must be locked before calling ReadCacheFromDiskAsync");

            var newCacheAge = DateTime.Now;
            var newCache    = new Dictionary <string, PipPackageView>();

            using (await LockFile(_cachePath + ".lock", cancel).ConfigureAwait(false))
                using (var file = new StreamReader(_cachePath, Encoding.UTF8)) {
                    try {
                        newCacheAge = File.GetLastWriteTime(_cachePath);
                    } catch (IOException) {
                    }

                    string spec;
                    while ((spec = await file.ReadLineAsync()) != null)
                    {
                        cancel.ThrowIfCancellationRequested();
                        try {
                            var pv = new PipPackageView(this, spec, versionIsInstalled: false);
                            newCache[pv.Name] = pv;
                        } catch (FormatException) {
                        }
                    }
                }

            _cache.Clear();
            foreach (var kv in newCache)
            {
                _cache[kv.Key] = kv.Value;
            }
            _cacheAge = newCacheAge;
        }
示例#3
0
        private async Task RefreshCacheAsync(CancellationToken cancel)
        {
            Debug.Assert(_cacheLock.CurrentCount == 0, "Cache must be locked before calling RefreshCacheAsync");

            string htmlList;

            using (var client = new WebClient()) {
                // ../simple is a list of <a href="package">package</a>
                try {
                    htmlList = await client.DownloadStringTaskAsync(
                        new Uri(_index ?? DefaultIndex, "../simple")
                        ).ConfigureAwait(false);
                } catch (WebException) {
                    // No net access, so can't refresh
                    return;
                }
            }

            bool changed  = false;
            var  toRemove = new HashSet <string>(_cache.Keys);

            // We only want to add new packages so we don't blow away
            // existing package specs in the cache.
            foreach (Match match in SimpleListRegex.Matches(htmlList))
            {
                var package = match.Groups["package"].Value;
                if (string.IsNullOrEmpty(package))
                {
                    continue;
                }

                if (!toRemove.Remove(package))
                {
                    try {
                        _cache[package] = new PipPackageView(this, package);
                        changed         = true;
                    } catch (FormatException) {
                    }
                }
            }

            foreach (var package in toRemove)
            {
                _cache.Remove(package);
                changed = true;
            }

            if (changed)
            {
                TriggerWriteCacheToDisk();
            }

            _cacheAge = DateTime.Now;
        }
示例#4
0
 private async Task UninstallPackage_ExecutedAsync(object sender, ExecutedRoutedEventArgs e)
 {
     try
     {
         PipPackageView view = (PipPackageView)e.Parameter;
         await _provider.UninstallPackage(view.Package);
     }
     catch (OperationCanceledException)
     {
     }
     catch (Exception ex) when(!ex.IsCriticalException())
     {
         ToolWindow.SendUnhandledException(this, ExceptionDispatchInfo.Capture(ex));
     }
 }
示例#5
0
 private async Task UpgradePackage_ExecutedAsync(object sender, ExecutedRoutedEventArgs e)
 {
     try
     {
         PipPackageView view = (PipPackageView)e.Parameter;
         // Construct a PackageSpec with the upgraded version.
         await _provider.InstallPackage(new PackageSpec(view.Package.Name, view.UpgradeVersion));
     }
     catch (OperationCanceledException)
     {
     }
     catch (Exception ex) when(!ex.IsCriticalException())
     {
         ToolWindow.SendUnhandledException(this, ExceptionDispatchInfo.Capture(ex));
     }
 }
示例#6
0
        private void UpgradePackage_CanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.Handled = true;

            if (!_provider.CanExecute)
            {
                e.CanExecute = false;
                return;
            }

            PipPackageView view = e.Parameter as PipPackageView;

            if (view == null)
            {
                e.CanExecute = false;
                return;
            }

            e.CanExecute = !view.UpgradeVersion.IsEmpty && view.UpgradeVersion.CompareTo(view.Version) > 0;
        }
示例#7
0
 public PackageResultView(PipEnvironmentView view, PipPackageView package)
 {
     View    = view;
     Package = package;
     Package.PropertyChanged += Package_PropertyChanged;
 }
示例#8
0
 public PackageResultView(PipEnvironmentView view, PipPackageView package)
 {
     _view    = view;
     _package = package;
 }
示例#9
0
        protected async Task ReadCacheFromDiskAsync(CancellationToken cancel) {
            Debug.Assert(_cacheLock.CurrentCount == 0, "Cache must be locked before calling ReadCacheFromDiskAsync");

            var newCacheAge = DateTime.Now;
            var newCache = new Dictionary<string, PipPackageView>();
            using (await LockFile(_cachePath + ".lock", cancel).ConfigureAwait(false))
            using (var file = new StreamReader(_cachePath, Encoding.UTF8)) {
                try {
                    newCacheAge = File.GetLastWriteTime(_cachePath);
                } catch (IOException) {
                }

                string spec;
                while ((spec = await file.ReadLineAsync()) != null) {
                    cancel.ThrowIfCancellationRequested();
                    try {
                        var pv = new PipPackageView(this, spec, versionIsInstalled: false);
                        newCache[pv.Name] = pv;
                    } catch (FormatException) {
                    }
                }
            }

            _cache.Clear();
            foreach (var kv in newCache) {
                _cache[kv.Key] = kv.Value;
            }
            _cacheAge = newCacheAge;
        }
示例#10
0
        private async Task RefreshCacheAsync(CancellationToken cancel) {
            Debug.Assert(_cacheLock.CurrentCount == 0, "Cache must be locked before calling RefreshCacheAsync");

            string htmlList;
            using (var client = new WebClient()) {
                // ../simple is a list of <a href="package">package</a>
                try {
                    htmlList = await client.DownloadStringTaskAsync(
                        new Uri(_index ?? DefaultIndex, "../simple")
                    ).ConfigureAwait(false);
                } catch (WebException) {
                    // No net access, so can't refresh
                    return;
                }
            }

            bool changed = false;
            var toRemove = new HashSet<string>(_cache.Keys);

            // We only want to add new packages so we don't blow away
            // existing package specs in the cache.
            foreach (Match match in SimpleListRegex.Matches(htmlList)) {
                var package = match.Groups["package"].Value;
                if (string.IsNullOrEmpty(package)) {
                    continue;
                }

                if (!toRemove.Remove(package)) {
                    try {
                        _cache[package] = new PipPackageView(this, package);
                        changed = true;
                    } catch (FormatException) {
                    }
                }
            }

            foreach (var package in toRemove) {
                _cache.Remove(package);
                changed = true;
            }

            if (changed) {
                TriggerWriteCacheToDisk();
            }

            _cacheAge = DateTime.Now;
        }
示例#11
0
        public async Task UpdatePackageInfoAsync(PipPackageView package, CancellationToken cancel) {
            string description = null;
            List<string> versions = null;

            using (var client = new WebClient()) {
                Stream data;
                try {
                    data = await client.OpenReadTaskAsync(new Uri(_index ?? DefaultIndex, package.Name + "/json"));
                } catch (WebException) {
                    // No net access
                    return;
                }

                try {
                    using (var reader = JsonReaderWriterFactory.CreateJsonReader(data, new XmlDictionaryReaderQuotas())) {
                        var doc = XDocument.Load(reader);

                        // TODO: Get package URL
                        //url = (string)doc.Document
                        //    .Elements("root")
                        //    .Elements("info")
                        //    .Elements("package_url")
                        //    .FirstOrDefault();

                        description = (string)doc.Document
                            .Elements("root")
                            .Elements("info")
                            .Elements("description")
                            .FirstOrDefault();
                        
                        versions = doc.Document
                            .Elements("root")
                            .Elements("releases")
                            .Elements()
                            .Attributes("item")
                            .Select(a => a.Value)
                            .ToList();
                    }
                } catch (InvalidOperationException) {
                }
            }

            cancel.ThrowIfCancellationRequested();

            bool changed = false;

            await _cacheLock.WaitAsync();
            try {
                PipPackageView inCache;
                if (!_cache.TryGetValue(package.Name, out inCache)) {
                    inCache = _cache[package.Name] = new PipPackageView(this, package.Name, null, null);
                }

                if (!string.IsNullOrEmpty(description)) {
                    var lines = description.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
                    var firstLine = string.Join(
                        " ",
                        lines.TakeWhile(s => !IsSeparatorLine(s)).Select(s => s.Trim())
                    );
                    if (firstLine.Length > 500) {
                        firstLine = firstLine.Substring(0, 497) + "...";
                    }
                    if (firstLine == "UNKNOWN") {
                        firstLine = string.Empty;
                    }

                    inCache.Description = firstLine;
                    package.Description = firstLine;
                    changed = true;
                }

                if (versions != null) {
                    var updateVersion = Pep440Version.TryParseAll(versions)
                        .Where(v => v.IsFinalRelease)
                        .OrderByDescending(v => v)
                        .FirstOrDefault();
                    inCache.UpgradeVersion = updateVersion;
                    package.UpgradeVersion = updateVersion;
                    changed = true;
                }
            } finally {
                _cacheLock.Release();
            }

            if (changed) {
                TriggerWriteCacheToDisk();
            }
        }
示例#12
0
        public async Task UpdatePackageInfoAsync(PipPackageView package, CancellationToken cancel)
        {
            string        description = null;
            List <string> versions    = null;

            using (var client = new WebClient()) {
                var data = await client.OpenReadTaskAsync(new Uri(_index ?? DefaultIndex, package.Name + "/json"));

                try {
                    using (var reader = JsonReaderWriterFactory.CreateJsonReader(data, new XmlDictionaryReaderQuotas())) {
                        var doc = XDocument.Load(reader);

                        // TODO: Get package URL
                        //url = (string)doc.Document
                        //    .Elements("root")
                        //    .Elements("info")
                        //    .Elements("package_url")
                        //    .FirstOrDefault();

                        description = (string)doc.Document
                                      .Elements("root")
                                      .Elements("info")
                                      .Elements("description")
                                      .FirstOrDefault();

                        versions = doc.Document
                                   .Elements("root")
                                   .Elements("releases")
                                   .Elements()
                                   .Attributes("item")
                                   .Select(a => a.Value)
                                   .ToList();
                    }
                } catch (InvalidOperationException) {
                }
            }

            cancel.ThrowIfCancellationRequested();

            bool changed = false;

            await _cacheLock.WaitAsync();

            try {
                PipPackageView inCache;
                if (!_cache.TryGetValue(package.Name, out inCache))
                {
                    inCache = _cache[package.Name] = new PipPackageView(this, package.Name, null, null);
                }

                if (!string.IsNullOrEmpty(description))
                {
                    var lines     = description.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
                    var firstLine = string.Join(
                        " ",
                        lines.TakeWhile(s => !IsSeparatorLine(s)).Select(s => s.Trim())
                        );
                    if (firstLine.Length > 500)
                    {
                        firstLine = firstLine.Substring(0, 497) + "...";
                    }
                    if (firstLine == "UNKNOWN")
                    {
                        firstLine = string.Empty;
                    }

                    inCache.Description = firstLine;
                    package.Description = firstLine;
                    changed             = true;
                }

                if (versions != null)
                {
                    var updateVersion = Pep440Version.TryParseAll(versions)
                                        .Where(v => v.IsFinalRelease)
                                        .OrderByDescending(v => v)
                                        .FirstOrDefault();
                    inCache.UpgradeVersion = updateVersion;
                    package.UpgradeVersion = updateVersion;
                    changed = true;
                }
            } finally {
                _cacheLock.Release();
            }

            if (changed)
            {
                TriggerWriteCacheToDisk();
            }
        }