public bool AsyncFetchContents(ChorusAccount chorusAccount, ChorusUrl chorusUrl, out ChorusServerException chorusException) { Uri requestUri = GetContentsUri(chorusAccount, chorusUrl); if (null == requestUri) { chorusException = null; return(true); } RequestKey requestKey = new RequestKey(chorusAccount, requestUri); lock (_lock) { ChorusContentsResponse chorusContentsResponse; if (_chorusContentsByServerUrl.TryGetValue(requestKey, out chorusContentsResponse)) { chorusException = chorusContentsResponse.ChorusException; return(chorusContentsResponse.IsComplete); } chorusException = null; if (!_fetchRequests.Add(requestKey)) { return(false); } } ActionUtil.RunAsync(() => FetchAndStoreContents(chorusAccount, requestUri), "Fetch from Chorus"); // Not L10N return(false); }
private Uri GetContentsUri(ChorusAccount chorusAccount, ChorusUrl chorusUrl) { if (chorusUrl.FileId.HasValue) { return(null); } if (chorusUrl.ExperimentId.HasValue) { return(new Uri(chorusUrl.ServerUrl + "/skyline/api/contents/experiments/" + chorusUrl.ExperimentId + "/files")); // Not L10N } if (chorusUrl.ProjectId.HasValue) { return(new Uri(chorusUrl.ServerUrl + "/skyline/api/contents/projects/" + chorusUrl.ProjectId + "/experiments")); // Not L10N } if (!chorusUrl.GetPathParts().Any()) { return(null); } string topLevelName = chorusUrl.GetPathParts().First(); TopLevelContents topLevelContents = TOP_LEVEL_ITEMS.FirstOrDefault(item => item.Name.Equals(topLevelName)); if (null != topLevelContents) { return(new Uri(chorusUrl.ServerUrl + "/skyline/api/contents" + topLevelContents.ContentsPath)); // Not L10N } return(null); }
private IEnumerable <ChorusItem> ListItems(ChorusUrl chorusUrl, ChorusContents chorusContents) { IEnumerable <ChorusItem> items = new ChorusItem[0]; if (null != chorusContents.experiments) { items = items.Concat(chorusContents.experiments.Select(experiment => new ChorusItem(chorusUrl.SetExperimentId(experiment.id).AddPathPart(experiment.GetName()), experiment.GetName(), DataSourceUtil.FOLDER_TYPE, null, 0))); } if (null != chorusContents.files) { items = items.Concat(chorusContents.files.Select( file => { ChorusUrl fileUrl = chorusUrl.SetFileId(file.id) .AddPathPart(file.GetName()) .SetFileWriteTime(file.GetModifiedDateTime()) .SetRunStartTime(file.GetAcquisitionDateTime()); return(new ChorusItem(fileUrl, file.GetName(), GetFileType(file), file.GetModifiedDateTime(), file.fileSizeBytes)); } )); } if (null != chorusContents.projects) { items = items.Concat(chorusContents.projects.Select(project => new ChorusItem(chorusUrl.SetProjectId(project.id).AddPathPart(project.GetName()), project.GetName(), DataSourceUtil.FOLDER_TYPE, null, project.GetSize()))); } return(items); }
public MsDataSpectrum[] GetMsDataFileSpectraWithCommonRetentionTime(int dataFileSpectrumStartIndex) { double precursor = Transitions.Select(transition => transition.PrecursorMz).FirstOrDefault(); ChorusAccount chorusAccount = ChorusUrl.FindChorusAccount(Settings.Default.ChorusAccountList); return(_chorusSession.GetSpectra(chorusAccount, ChorusUrl, Source, precursor, dataFileSpectrumStartIndex)); }
public ChromatogramGeneratorTask(ChromTaskList chromTaskList, ChorusAccount chorusAccount, ChorusUrl chorusUrl, ChromatogramRequestDocument chromatogramRequestDocument) { ChromTaskList = chromTaskList; ChorusAccount = chorusAccount; ChorusUrl = chorusUrl; ChromatogramRequestDocument = chromatogramRequestDocument; }
private ChorusAccount GetChorusAccount(ChorusUrl chorusUrl) { return (_chorusAccounts.FirstOrDefault( chorusAccount => Equals(chorusAccount.ServerUrl, chorusUrl.ServerUrl) && Equals(chorusAccount.Username, chorusUrl.Username))); }
public ChorusItem(ChorusUrl chorusUrl, string label, string type, DateTime?lastModified, long fileSizeBytes) { ChorusUrl = chorusUrl; Label = label; Type = type; LastModified = lastModified; FileSize = (ulong)fileSizeBytes; }
public ChorusItem(ChorusUrl chorusUrl, string label, string type, DateTime? lastModified, long fileSizeBytes) { ChorusUrl = chorusUrl; Label = label; Type = type; LastModified = lastModified; FileSize = (ulong) fileSizeBytes; }
public ChromatogramRequestProvider(SrmDocument srmDocument, ChorusUrl chorusUrl, IRetentionTimePredictor retentionTimePredictor, bool firstPass) { _srmDocument = srmDocument; _chorusUrl = chorusUrl; _retentionTimePredictor = retentionTimePredictor; _firstPass = firstPass; // Create a SpectrumFilter without an IRetentionTimeProvider in order to get the list of ChromKeys that we will eventually provide. SpectrumFilter spectrumFilter = new SpectrumFilter(_srmDocument, _chorusUrl, null); _chromKeys = ImmutableList.ValueOf(ListChromKeys(GetChromatogramRequestDocument(spectrumFilter))); }
public ChorusScanProvider(string docFilePath, ChorusUrl chorusUrl, ChromSource source, float[] times, TransitionFullScanInfo[] transitions) { ChorusUrl = chorusUrl; DocFilePath = docFilePath; DataFilePath = chorusUrl; Source = source; Times = times; Transitions = transitions; _chorusSession = new ChorusSession(); }
public MsDataSpectrum[] GetSpectra(ChorusAccount chorusAccount, ChorusUrl chorusUrl, ChromSource source, SignedMz precursor, int scanId) { string strSource; int msLevel = 1; // ReSharper disable NonLocalizedString switch (source) { case ChromSource.ms1: strSource = "ms1"; break; case ChromSource.sim: strSource = "sim"; break; case ChromSource.fragment: strSource = "ms2"; msLevel = 2; break; default: throw new ArgumentException("Unknown source " + source); } string strUri = string.Format(CultureInfo.InvariantCulture, "{0}/skyline/api/chroextract-drift/file/{1}/source/{2}/precursor/{3}/{4}", chorusUrl.ServerUrl, chorusUrl.FileId, strSource, precursor.RawValue, // This will be a negative value for negative ion mode data scanId); // ReSharper restore NonLocalizedString var webRequest = (HttpWebRequest)WebRequest.Create(new Uri(strUri)); AddAuthHeader(chorusAccount, webRequest); return(SendRequest(webRequest, response => { string strResponse = string.Empty; var responseStream = response.GetResponseStream(); if (null != responseStream) { var streamReader = new StreamReader(responseStream); strResponse = streamReader.ReadToEnd(); } JObject jObject = JsonConvert.DeserializeObject <JObject>(strResponse); JArray array = (JArray)jObject["results"]; // Not L10N return array.OfType <JObject>().Select(obj => GetSpectrumFromJObject(obj, msLevel)).ToArray(); })); }
public ChromatogramCache GenerateChromatograms(ChorusAccount chorusAccount, ChorusUrl chorusUrl, ChromatogramRequestDocument chromatogramRequestDocument) { var webRequest = (HttpWebRequest)WebRequest.Create(chorusUrl.GetChromExtractionUri()); AddAuthHeader(chorusAccount, webRequest); webRequest.Method = "POST"; // Not L10N var xmlSerializer = new XmlSerializer(typeof(ChromatogramRequestDocument)); xmlSerializer.Serialize(webRequest.GetRequestStream(), chromatogramRequestDocument); webRequest.GetRequestStream().Close(); return(SendRequest(webRequest, response => { MemoryStream memoryStream = new MemoryStream(); var responseStream = response.GetResponseStream(); if (responseStream != null) { byte[] buffer = new byte[65536]; int count; while ((count = responseStream.Read(buffer, 0, buffer.Length)) != 0) { memoryStream.Write(buffer, 0, count); } } if (0 == memoryStream.Length) { if (response.StatusCode != HttpStatusCode.OK) { throw new IOException(string.Format("Empty response: status = {0}", response.StatusCode)); // Not L10N } Debug.WriteLine("Zero byte response"); // Not L10N return null; } ChromatogramCache.RawData rawData; ChromatogramCache.LoadStructs(memoryStream, out rawData); var chromCacheFile = rawData.ChromCacheFiles[0]; rawData.ChromCacheFiles = new[] { new ChromCachedFile(chorusUrl, chromCacheFile.Flags, chromCacheFile.FileWriteTime, chromCacheFile.RunStartTime, chromCacheFile.MaxRetentionTime, chromCacheFile.MaxIntensity, chromCacheFile.InstrumentInfoList), }; return new ChromatogramCache(string.Empty, rawData, new ChromatogramGeneratorTask.MemoryPooledStream(memoryStream)); })); }
public ChromTaskList(Action checkCancelledAction, SrmDocument srmDocument, ChorusAccount chorusAccount, ChorusUrl chorusUrl, IEnumerable<ChromatogramRequestDocument> chromatogramRequestDocuments) { SrmDocument = srmDocument; ChorusSession = new ChorusSession(); _checkCancelledAction = checkCancelledAction; _chromatogramGeneratorTasks = new List<ChromatogramGeneratorTask>(); _chromKeys = new Dictionary<ChromKey, ChromatogramGeneratorTask>(); foreach (var chunk in chromatogramRequestDocuments) { ChromatogramGeneratorTask task = new ChromatogramGeneratorTask(this, chorusAccount, chorusUrl, chunk); _chromatogramGeneratorTasks.Add(task); foreach (ChromKey chromKey in ListChromKeys(chunk)) { _chromKeys[chromKey] = task; } } _executingTasks = new HashSet<ChromatogramGeneratorTask>(); }
public void RetryFetchContents(ChorusAccount chorusAccount, ChorusUrl chorusUrl) { Uri requestUri = GetContentsUri(chorusAccount, chorusUrl); if (null == requestUri) { return; } RequestKey requestKey = new RequestKey(chorusAccount, requestUri); lock (_lock) { if (_fetchRequests.Contains(requestKey)) { return; } _chorusContentsByServerUrl.Remove(requestKey); ChorusServerException exceptionIgnore; AsyncFetchContents(chorusAccount, chorusUrl, out exceptionIgnore); } }
public IEnumerable <ChorusItem> ListContents(ChorusAccount chorusAccount, ChorusUrl chorusUrl) { if (!chorusUrl.GetPathParts().Any()) { return(TOP_LEVEL_ITEMS.Select( item => new ChorusItem(chorusUrl.AddPathPart(item.Name), item.Label, DataSourceUtil.FOLDER_TYPE, null, 0))); } Uri requestUri = GetContentsUri(chorusAccount, chorusUrl); ChorusContents contents; var key = new RequestKey(chorusAccount, requestUri); lock (_lock) { ChorusContentsResponse chorusContentsResponse; if (!_chorusContentsByServerUrl.TryGetValue(key, out chorusContentsResponse)) { return(new ChorusItem[0]); } contents = chorusContentsResponse.Data; } return(ListItems(chorusUrl, contents)); }
private void populateListViewFromDirectory(MsDataFileUri directory) { _abortPopulateList = false; listView.Cursor = Cursors.Default; _waitingForData = false; listView.Items.Clear(); var listSourceInfo = new List <SourceInfo>(); if (null == directory || directory is MsDataFilePath && string.IsNullOrEmpty(((MsDataFilePath)directory).FilePath)) { foreach (DriveInfo driveInfo in DriveInfo.GetDrives()) { string label = string.Empty; string sublabel = driveInfo.Name; ImageIndex imageIndex = ImageIndex.Folder; _driveReadiness[sublabel] = false; try { switch (driveInfo.DriveType) { case DriveType.Fixed: imageIndex = ImageIndex.LocalDrive; label = Resources.OpenDataSourceDialog_populateListViewFromDirectory_Local_Drive; if (driveInfo.VolumeLabel.Length > 0) { label = driveInfo.VolumeLabel; } break; case DriveType.CDRom: imageIndex = ImageIndex.OpticalDrive; label = Resources.OpenDataSourceDialog_populateListViewFromDirectory_Optical_Drive; if (driveInfo.IsReady && driveInfo.VolumeLabel.Length > 0) { label = driveInfo.VolumeLabel; } break; case DriveType.Removable: imageIndex = ImageIndex.OpticalDrive; label = Resources.OpenDataSourceDialog_populateListViewFromDirectory_Removable_Drive; if (driveInfo.IsReady && driveInfo.VolumeLabel.Length > 0) { label = driveInfo.VolumeLabel; } break; case DriveType.Network: label = Resources.OpenDataSourceDialog_populateListViewFromDirectory_Network_Share; break; } _driveReadiness[sublabel] = IsDriveReady(driveInfo); } catch (Exception) { label += string.Format(" ({0})", Resources.OpenDataSourceDialog_populateListViewFromDirectory_access_failure); // Not L10N } string name = driveInfo.Name; if (label != string.Empty) { name = string.Format("{0} ({1})", label, name); // Not L10N } listSourceInfo.Add(new SourceInfo(new MsDataFilePath(driveInfo.RootDirectory.FullName)) { type = DataSourceUtil.FOLDER_TYPE, imageIndex = imageIndex, name = name, dateModified = GetDriveModifiedTime(driveInfo) }); } } else if (directory is ChorusUrl) { ChorusUrl chorusUrl = directory as ChorusUrl; if (null == _chorusSession) { _chorusSession = new ChorusSession(); _chorusSession.ContentsAvailable += ChorusContentsAvailable; } if (string.IsNullOrEmpty(chorusUrl.ServerUrl)) { foreach (var chorusAccount in _chorusAccounts) { listSourceInfo.Add(new SourceInfo(chorusAccount.GetChorusUrl()) { name = chorusAccount.GetKey(), type = DataSourceUtil.FOLDER_TYPE, imageIndex = ImageIndex.Chorus, }); } } else { ChorusAccount chorusAccount = GetChorusAccount(chorusUrl); ChorusServerException exception; bool isComplete = _chorusSession.AsyncFetchContents(chorusAccount, chorusUrl, out exception); foreach (var item in _chorusSession.ListContents(chorusAccount, chorusUrl)) { var imageIndex = DataSourceUtil.IsFolderType(item.Type) ? ImageIndex.Folder : ImageIndex.MassSpecFile; listSourceInfo.Add(new SourceInfo(item.ChorusUrl) { name = item.Label, type = item.Type, imageIndex = imageIndex, dateModified = item.LastModified, size = item.FileSize }); } if (null != exception) { if (MultiButtonMsgDlg.Show(this, exception.Message, Resources.OpenDataSourceDialog_populateListViewFromDirectory_Retry) != DialogResult.Cancel) { _chorusSession.RetryFetchContents(chorusAccount, chorusUrl); isComplete = false; } } if (!isComplete) { listView.Cursor = Cursors.WaitCursor; _waitingForData = true; } } } else if (directory is MsDataFilePath) { MsDataFilePath msDataFilePath = (MsDataFilePath)directory; DirectoryInfo dirInfo = new DirectoryInfo(msDataFilePath.FilePath); DirectoryInfo[] arraySubDirInfo; FileInfo[] arrayFileInfo; try { // subitems: Name, Type, Spectra, Size, Date Modified arraySubDirInfo = dirInfo.GetDirectories(); Array.Sort(arraySubDirInfo, (d1, d2) => string.Compare(d1.Name, d2.Name, StringComparison.CurrentCultureIgnoreCase)); arrayFileInfo = dirInfo.GetFiles(); Array.Sort(arrayFileInfo, (f1, f2) => string.Compare(f1.Name, f2.Name, StringComparison.CurrentCultureIgnoreCase)); } catch (Exception x) { var message = TextUtil.LineSeparate( Resources.OpenDataSourceDialog_populateListViewFromDirectory_An_error_occurred_attempting_to_retrieve_the_contents_of_this_directory, x.Message); // Might throw access violation. MessageBox.Show(this, message, Program.Name); return; } // Calculate information about the files, allowing the user to cancel foreach (var info in arraySubDirInfo) { listSourceInfo.Add(getSourceInfo(info)); Application.DoEvents(); if (_abortPopulateList) { //MessageBox.Show( "abort" ); break; } } if (!_abortPopulateList) { foreach (var info in arrayFileInfo) { listSourceInfo.Add(getSourceInfo(info)); Application.DoEvents(); if (_abortPopulateList) { //MessageBox.Show( "abort" ); break; } } } } // Populate the list var items = new List <ListViewItem>(); foreach (var sourceInfo in listSourceInfo) { if (sourceInfo != null && (sourceTypeComboBox.SelectedIndex == 0 || sourceTypeComboBox.SelectedItem.ToString() == sourceInfo.type || // Always show folders sourceInfo.isFolder)) { ListViewItem item = new ListViewItem(sourceInfo.ToArray(), (int)sourceInfo.imageIndex) { Tag = sourceInfo, }; item.SubItems[2].Tag = sourceInfo.size; item.SubItems[3].Tag = sourceInfo.dateModified; items.Add(item); } } listView.Items.AddRange(items.ToArray()); }
public ChromTaskList(Action checkCancelledAction, SrmDocument srmDocument, ChorusAccount chorusAccount, ChorusUrl chorusUrl, IEnumerable <ChromatogramRequestDocument> chromatogramRequestDocuments) { SrmDocument = srmDocument; ChorusSession = new ChorusSession(); _checkCancelledAction = checkCancelledAction; _chromatogramGeneratorTasks = new List <ChromatogramGeneratorTask>(); _chromKeys = new Dictionary <ChromKey, ChromatogramGeneratorTask>(); foreach (var chunk in chromatogramRequestDocuments) { ChromatogramGeneratorTask task = new ChromatogramGeneratorTask(this, chorusAccount, chorusUrl, chunk); _chromatogramGeneratorTasks.Add(task); foreach (ChromKey chromKey in ListChromKeys(chunk)) { _chromKeys[chromKey] = task; } } _executingTasks = new HashSet <ChromatogramGeneratorTask>(); }