?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
unset.perms.too
[tfs.git] / class / Microsoft.TeamFoundation.VersionControl.Client / Workspace.cs
blob7af677009ad0d9e42ae629abe9c2ac88c8ee3efa
1 //
2 // Microsoft.TeamFoundation.VersionControl.Client.Workspace
3 //
4 // Authors:
5 // Joel Reed (joelwreed@gmail.com)
6 //
7
8 //
9 // Permission is hereby granted, free of charge, to any person obtaining
10 // a copy of this software and associated documentation files (the
11 // "Software"), to deal in the Software without restriction, including
12 // without limitation the rights to use, copy, modify, merge, publish,
13 // distribute, sublicense, and/or sell copies of the Software, and to
14 // permit persons to whom the Software is furnished to do so, subject to
15 // the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be
18 // included in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28
29 using System;
30 using System.Collections.Generic;
31 using System.IO;
32 using System.Net;
33 using System.Text;
34 using System.Xml;
35 using System.Web.Services;
36 using Microsoft.TeamFoundation.VersionControl.Common;
37
38 namespace Microsoft.TeamFoundation.VersionControl.Client
39 {
40 public sealed class Workspace : IComparable
41 {
42 private string comment;
43 private string computer;
44 private string name;
45 private string ownerName;
46 private DateTime lastAccessDate;
47 private WorkingFolder[] folders;
48 private VersionControlServer versionControlServer;
49 internal bool readWriteSetting;
50
51 internal Workspace(VersionControlServer versionControlServer, string name,
52 string ownerName, string comment,
53 WorkingFolder[] folders, string computer)
54 {
55 this.versionControlServer = versionControlServer;
56 this.name = name;
57 this.ownerName = ownerName;
58 this.comment = comment;
59 this.folders = folders;
60 this.computer = computer;
61
62 readWriteSetting = Workstation.Settings["File.ReadWrite"];
63 }
64
65 internal Workspace(VersionControlServer versionControlServer,
66 WorkspaceInfo info)
67 {
68 this.versionControlServer = versionControlServer;
69 this.name = info.Name;
70 this.ownerName = info.OwnerName;
71 this.comment = info.Comment;
72 this.folders = new WorkingFolder[0];
73 this.computer = info.Computer;
74
75 readWriteSetting = Workstation.Settings["File.ReadWrite"];
76 }
77
78 public int CheckIn(PendingChange[] changes, string comment)
79 {
80 if (changes.Length == 0) return 0;
81
82 List<string> serverItems = new List<string>();
83 foreach (PendingChange change in changes)
84 {
85 // upload new or changed files only
86 if ((change.ItemType == ItemType.File) &&
87 (change.IsAdd || change.IsEdit ))
88 {
89 Repository.UploadFile(Name, OwnerName, change);
90 SetFileAttributes(change.LocalItem);
91 }
92
93 serverItems.Add(change.ServerItem);
94 }
95
96 return Repository.CheckIn(this, serverItems.ToArray(), comment);
97 }
98
99 public int CompareTo (object o)
100 {
101 Workspace a = this, b = (Workspace)o;
102
103 int r0 = a.VersionControlServer.ServerGuid.CompareTo (b.VersionControlServer.ServerGuid);
104 if (r0 != 0) return r0;
105
106 int r1 = a.Name.CompareTo (b.Name);
107 if (r1 != 0) return r1;
108
109 int r2 = a.OwnerName.CompareTo (b.OwnerName);
110 return r2;
111 }
112
113 public PendingChange[] GetPendingChanges()
114 {
115 return GetPendingChanges(VersionControlPath.RootFolder, RecursionType.Full);
116 }
117
118 public PendingChange[] GetPendingChanges(string item)
119 {
120 return GetPendingChanges(item, RecursionType.None);
121 }
122
123 public PendingChange[] GetPendingChanges(string item, RecursionType rtype)
124 {
125 return GetPendingChanges(item, rtype, false);
126 }
127
128 public PendingChange[] GetPendingChanges(string item, RecursionType rtype,
129 bool includeDownloadInfo)
130 {
131 string[] items = new string[1];
132 items[0] = item;
133 return GetPendingChanges(items, rtype, includeDownloadInfo);
134 }
135
136 public PendingChange[] GetPendingChanges(string[] items, RecursionType rtype)
137 {
138 return GetPendingChanges(items, rtype, false);
139 }
140
141 public PendingChange[] GetPendingChanges(string[] items, RecursionType rtype,
142 bool includeDownloadInfo)
143 {
144 List<ItemSpec> itemSpecs = new List<ItemSpec>();
145 foreach (string item in items)
146 {
147 itemSpecs.Add(new ItemSpec(item, rtype));
148 }
149
150 Failure[] failures = null;
151 PendingChange[] changes = Repository.QueryPendingSets(Name, OwnerName, Name, OwnerName,
152 itemSpecs.ToArray(), includeDownloadInfo,
153 out failures);
154 foreach (Failure failure in failures)
155 {
156 Console.WriteLine(failure.ToString());
157 }
158
159 return changes;
160 }
161
162 public void Delete()
163 {
164 Repository.DeleteWorkspace(Name, OwnerName);
165 Workstation.Current.RemoveCachedWorkspaceInfo(VersionControlServer.Uri, Name);
166 }
167
168 public GetStatus Get()
169 {
170 return Get(VersionSpec.Latest, GetOptions.None);
171 }
172
173 public GetStatus Get(VersionSpec versionSpec, GetOptions options)
174 {
175 GetRequest request = new GetRequest(versionSpec);
176 return Get(request, GetOptions.None, null, null);
177 }
178
179 public GetStatus Get(GetRequest request, GetOptions options)
180 {
181 return Get(request, options, null, null);
182 }
183
184 public GetStatus Get(GetRequest[] requests, GetOptions options)
185 {
186 return Get(requests, options, null, null);
187 }
188
189 public GetStatus Get(GetRequest request, GetOptions options,
190 GetFilterCallback filterCallback, object userData)
191 {
192 GetRequest[] requests = new GetRequest[1];
193 requests[0] = request;
194 return Get(requests, options, filterCallback, userData);
195 }
196
197 public GetStatus Get (string[] items, VersionSpec version,
198 RecursionType recursion, GetOptions options)
199 {
200 List<GetRequest> requests = new List<GetRequest>();
201 foreach (string item in items)
202 {
203 requests.Add(new GetRequest(item, recursion, version));
204 }
205
206 return Get(requests.ToArray(), options, null, null);
207 }
208
209 public GetStatus Get(GetRequest[] requests, GetOptions options,
210 GetFilterCallback filterCallback, object userData)
211 {
212 bool force = ((GetOptions.Overwrite & options) == GetOptions.Overwrite);
213 bool noGet = ! ((GetOptions.GetAll & options) == GetOptions.GetAll);
214
215 GetOperation[] getOperations = Repository.Get(Name, OwnerName, requests, force, noGet);
216 if (null != filterCallback) filterCallback(this, getOperations, userData);
217
218 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
219 foreach (GetOperation getOperation in getOperations)
220 {
221 string uPath = null;
222 GettingEventArgs args = new GettingEventArgs(this, getOperation);
223
224 //Console.WriteLine(getOperation.ToString());
225
226 if (getOperation.DeletionId != 0)
227 {
228 if ((getOperation.ItemType == ItemType.Folder)&&
229 (Directory.Exists(getOperation.SourceLocalItem)))
230 {
231 Directory.Delete(getOperation.SourceLocalItem, true);
232 }
233 else if ((getOperation.ItemType == ItemType.File)&&
234 (File.Exists(getOperation.SourceLocalItem)))
235 {
236 UnsetFileAttributes(getOperation.SourceLocalItem);
237 File.Delete(getOperation.SourceLocalItem);
238 }
239 }
240 else if ((!String.IsNullOrEmpty(getOperation.TargetLocalItem))&&
241 (!String.IsNullOrEmpty(getOperation.SourceLocalItem))&&
242 (getOperation.SourceLocalItem != getOperation.TargetLocalItem))
243 {
244 uPath = getOperation.TargetLocalItem;
245 try
246 {
247 File.Move(getOperation.SourceLocalItem, getOperation.TargetLocalItem);
248 }
249 catch (IOException)
250 {
251 args.Status = OperationStatus.TargetIsDirectory;
252 }
253 }
254 else if (getOperation.ChangeType == ChangeType.None)
255 {
256 uPath = getOperation.TargetLocalItem;
257 string directory = uPath;
258
259 if (getOperation.ItemType == ItemType.File)
260 directory = Path.GetDirectoryName(uPath);
261
262 if (!Directory.Exists(directory))
263 Directory.CreateDirectory(directory);
264
265 if (getOperation.ItemType == ItemType.File)
266 {
267 DownloadFile.WriteTo(uPath, Repository, getOperation.ArtifactUri);
268 SetFileAttributes(uPath);
269 }
270 }
271
272 versionControlServer.OnDownloading(args);
273 updates.QueueUpdate(getOperation.ItemId, uPath, getOperation.VersionServer);
274 }
275
276 updates.Flush();
277 return new GetStatus(getOperations.Length);
278 }
279
280 public ExtendedItem[][] GetExtendedItems (ItemSpec[] itemSpecs,
281 DeletedState deletedState,
282 ItemType itemType)
283 {
284 return Repository.QueryItemsExtended(Name, OwnerName,
285 itemSpecs, deletedState, itemType);
286 }
287
288 public string GetServerItemForLocalItem(string localItem)
289 {
290 string item = TryGetServerItemForLocalItem(localItem);
291 if (item == null)
292 throw new ItemNotMappedException(localItem);
293 return item;
294 }
295
296 public string GetLocalItemForServerItem(string serverItem)
297 {
298 string item = TryGetLocalItemForServerItem(serverItem);
299 if (item == null)
300 throw new ItemNotMappedException(serverItem);
301 return item;
302 }
303
304 public bool IsLocalPathMapped(string localPath)
305 {
306 foreach (WorkingFolder workingFolder in Folders)
307 {
308 if (workingFolder.LocalItem == localPath) return true;
309 }
310
311 return false;
312 }
313
314 public bool IsServerPathMapped(string serverPath)
315 {
316 foreach (WorkingFolder workingFolder in Folders)
317 {
318 if (workingFolder.ServerItem == serverPath) return true;
319 }
320
321 return false;
322 }
323
324 public void Map(string teamProject, string sourceProject) {
325 WorkingFolder[] folders = new WorkingFolder[1];
326 folders[0] = new WorkingFolder(sourceProject, teamProject);
327 Update(Name, OwnerName, folders);
328 }
329
330 public int PendAdd(string path)
331 {
332 return PendAdd(path, false);
333 }
334
335 public int PendAdd(string path, bool isRecursive)
336 {
337 string[] paths = new string[1];
338 paths[0] = path;
339 return PendAdd(paths, isRecursive);
340 }
341
342 public int PendAdd(string[] paths, bool isRecursive)
343 {
344 List<ChangeRequest> changes = new List<ChangeRequest>();
345
346 foreach (string path in paths)
347 {
348 ItemType itemType = ItemType.File;
349 if (Directory.Exists(path)) itemType = ItemType.Folder;
350 changes.Add(new ChangeRequest(path, RequestType.Add, itemType));
351
352 if (!isRecursive || itemType != ItemType.Folder) continue;
353
354 DirectoryInfo dir = new DirectoryInfo(path);
355 FileInfo[] localFiles = dir.GetFiles("*", SearchOption.AllDirectories);
356
357 foreach (FileInfo file in localFiles)
358 changes.Add(new ChangeRequest(file.FullName, RequestType.Add, ItemType.File));
359 }
360
361 if (changes.Count == 0) return 0;
362
363 GetOperation[] operations = Repository.PendChanges(this, changes.ToArray());
364 return operations.Length;
365 }
366
367 public int PendDelete(string path)
368 {
369 return PendDelete(path, RecursionType.None);
370 }
371
372 public int PendDelete(string path, RecursionType recursionType)
373 {
374 string[] paths = new string[1];
375 paths[0] = path;
376
377 return PendDelete(paths, recursionType);
378 }
379
380 public int PendDelete(string[] paths, RecursionType recursionType)
381 {
382 List<ChangeRequest> changes = new List<ChangeRequest>();
383 foreach (string path in paths)
384 {
385 ItemType itemType = ItemType.File;
386 if (Directory.Exists(path)) itemType = ItemType.Folder;
387 changes.Add(new ChangeRequest(path, RequestType.Delete, itemType));
388 }
389
390 if (changes.Count == 0) return 0;
391
392 GetOperation[] operations = Repository.PendChanges(this, changes.ToArray());
393 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
394
395 foreach (GetOperation operation in operations)
396 {
397 if (File.Exists(operation.SourceLocalItem))
398 {
399 UnsetFileAttributes(operation.SourceLocalItem);
400 File.Delete(operation.SourceLocalItem);
401 }
402 else
403 {
404 DirectoryInfo dir = new DirectoryInfo(operation.SourceLocalItem);
405 FileInfo[] localFiles = dir.GetFiles("*", SearchOption.AllDirectories);
406 foreach (FileInfo file in localFiles)
407 UnsetFileAttributes(file.FullName);
408
409 Directory.Delete(operation.SourceLocalItem, true);
410 }
411
412 updates.QueueUpdate(operation.ItemId, null, operation.VersionServer);
413 }
414
415 updates.Flush();
416 return operations.Length;
417 }
418
419 public int PendEdit(string path)
420 {
421 // Annotation[] annotations = Repository.QueryAnnotation("ExclusiveCheckout",
422 // path, 0);
423 // foreach (Annotation annotation in annotations)
424 // {
425 // Console.WriteLine(annotation.ToString());
426 // }
427
428 return PendEdit(path, RecursionType.None);
429 }
430
431 public int PendEdit(string path, RecursionType recursionType)
432 {
433 string[] paths = new string[1];
434 paths[0] = path;
435
436 return PendEdit(paths, recursionType);
437 }
438
439 public int PendEdit(string[] paths, RecursionType recursionType)
440 {
441 List<ChangeRequest> changes = new List<ChangeRequest>();
442 foreach (string path in paths)
443 {
444 changes.Add(new ChangeRequest(path, RequestType.Edit, ItemType.File));
445 }
446
447 if (changes.Count == 0) return 0;
448
449 GetOperation[] getOperations = Repository.PendChanges(this, changes.ToArray());
450 foreach (GetOperation getOperation in getOperations)
451 {
452 UnsetFileAttributes(getOperation.TargetLocalItem);
453 }
454
455 return getOperations.Length;
456 }
457
458 public int PendRename(string oldPath, string newPath)
459 {
460 string newServerPath;
461 if (VersionControlPath.IsServerItem(newPath)) newServerPath = GetServerItemForLocalItem(newPath);
462 else newServerPath = newPath;
463
464 ItemType itemType = ItemType.File;
465 if (Directory.Exists(oldPath)) itemType = ItemType.Folder;
466
467 List<ChangeRequest> changes = new List<ChangeRequest>();
468 changes.Add(new ChangeRequest(oldPath, newServerPath, RequestType.Rename, itemType));
469
470 GetOperation[] getOperations = Repository.PendChanges(this, changes.ToArray());
471
472 UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
473 foreach (GetOperation getOperation in getOperations)
474 {
475 File.Move(oldPath, getOperation.TargetLocalItem);
476 updates.QueueUpdate(getOperation.ItemId, getOperation.TargetLocalItem, getOperation.VersionServer);
477 }
478
479 updates.Flush();
480 return 1;
481 }
482
483 internal static Workspace FromXml(Repository repository, XmlReader reader)
484 {
485 string elementName = reader.Name;
486
487 string computer = reader.GetAttribute("computer");
488 string name = reader.GetAttribute("name");
489 string owner = reader.GetAttribute("owner");
490
491 string comment = "";
492 DateTime lastAccessDate = DateTime.Now;
493 List<WorkingFolder> folders = new List<WorkingFolder>();
494
495 while (reader.Read())
496 {
497 if (reader.NodeType == XmlNodeType.EndElement && reader.Name == elementName)
498 break;
499
500 if (reader.NodeType == XmlNodeType.Element)
501 {
502 switch (reader.Name)
503 {
504 case "WorkingFolder":
505 folders.Add(WorkingFolder.FromXml(repository, reader));
506 break;
507 case "Comment":
508 comment = reader.ReadString();
509 break;
510 case "LastAccessDate":
511 lastAccessDate = reader.ReadElementContentAsDateTime();
512 break;
513 }
514 }
515 }
516
517 Workspace w = new Workspace(repository.VersionControlServer, name, owner, comment, folders.ToArray(), computer);
518 w.lastAccessDate = lastAccessDate;
519 return w;
520 }
521
522 internal void ToXml(XmlWriter writer, string element)
523 {
524 writer.WriteStartElement(element);
525 writer.WriteAttributeString("computer", Computer);
526 writer.WriteAttributeString("name", Name);
527 writer.WriteAttributeString("owner", OwnerName);
528 writer.WriteElementString("Comment", Comment);
529
530 if (folders != null)
531 {
532 writer.WriteStartElement("Folders");
533
534 foreach (WorkingFolder folder in folders)
535 {
536 folder.ToXml(writer, element);
537 }
538
539 writer.WriteEndElement();
540 }
541
542 writer.WriteEndElement();
543 }
544
545 public override string ToString()
546 {
547 StringBuilder sb = new StringBuilder();
548
549 sb.Append("Workspace instance ");
550 sb.Append(GetHashCode());
551
552 sb.Append("\n Comment: ");
553 sb.Append(Comment);
554
555 sb.Append("\n LastAccessDate: ");
556 sb.Append(LastAccessDate);
557
558 sb.Append("\n Folders: ");
559 if (folders != null)
560 {
561 foreach (WorkingFolder folder in folders)
562 {
563 sb.Append(folder.ToString());
564 }
565 }
566
567 sb.Append("\n Computer: ");
568 sb.Append(Computer);
569
570 sb.Append("\n Name: ");
571 sb.Append(Name);
572
573 sb.Append("\n OwnerName: ");
574 sb.Append(OwnerName);
575
576 return sb.ToString();
577 }
578
579 public string TryGetServerItemForLocalItem(string localItem)
580 {
581 foreach (WorkingFolder folder in folders)
582 {
583 if (!localItem.StartsWith(folder.LocalItem, StringComparison.InvariantCultureIgnoreCase)) continue;
584 string suffix = localItem.Substring(folder.LocalItem.Length);
585 return String.Format("{0}{1}", folder.ServerItem, suffix);
586 }
587
588 return null;
589 }
590
591 public string TryGetLocalItemForServerItem(string serverItem)
592 {
593 foreach (WorkingFolder folder in folders)
594 {
595 if (!serverItem.StartsWith(folder.ServerItem, StringComparison.InvariantCultureIgnoreCase)) continue;
596 string suffix = serverItem.Substring(folder.ServerItem.Length);
597 return String.Format("{0}{1}", folder.LocalItem, suffix);
598 }
599
600 return null;
601 }
602
603 public WorkingFolder TryGetWorkingFolderForServerItem(string serverItem)
604 {
605 int maxPath = 0;
606 WorkingFolder workingFolder = null;
607
608 foreach (WorkingFolder folder in folders)
609 {
610 if (!serverItem.StartsWith(folder.ServerItem, StringComparison.InvariantCultureIgnoreCase)) continue;
611
612 if (folder.LocalItem.Length > maxPath)
613 {
614 workingFolder = folder;
615 maxPath = folder.LocalItem.Length;
616 }
617 }
618
619 return workingFolder;
620 }
621
622 public int Undo(string path)
623 {
624 return Undo(path, RecursionType.None);
625 }
626
627 public int Undo(string path, RecursionType recursionType)
628 {
629 string[] paths = new string[1];
630 paths[0] = path;
631 return Undo(paths, recursionType);
632 }
633
634 public int Undo(string[] paths, RecursionType recursionType)
635 {
636 List<ItemSpec> specs = new List<ItemSpec>();
637
638 foreach (string path in paths)
639 {
640 specs.Add(new ItemSpec(path, recursionType));
641 }
642
643 // is this the same logic as a workspace Get?
644 // can we make one function to handle both cases?
645
646 GetOperation[] getOperations = Repository.UndoPendingChanges(Name, OwnerName, specs.ToArray());
647 foreach (GetOperation getOperation in getOperations)
648 {
649 if (getOperation.ChangeType == ChangeType.Edit ||
650 getOperation.ChangeType == ChangeType.Delete)
651 {
652 string uPath = getOperation.TargetLocalItem;
653 string directory = uPath;
654
655 if (getOperation.ItemType == ItemType.File)
656 directory = Path.GetDirectoryName(uPath);
657
658 if (!Directory.Exists(directory))
659 Directory.CreateDirectory(directory);
660
661 if (getOperation.ItemType == ItemType.File)
662 {
663 DownloadFile.WriteTo(uPath, Repository, getOperation.ArtifactUri);
664 SetFileAttributes(uPath);
665 }
666 }
667 }
668
669 return getOperations.Length;
670 }
671
672 public void Update (string newName, string newComment, WorkingFolder[] newMappings)
673 {
674 Workspace w1 = new Workspace(VersionControlServer, newName, OwnerName,
675 newComment, newMappings, Computer);
676 Workspace w2 = Repository.UpdateWorkspace(Name, OwnerName, w1);
677
678 Workstation.Current.UpdateCachedWorkspaceInfo(VersionControlServer.Uri,
679 w2, newMappings);
680
681 folders = w2.Folders;
682 }
683
684 public void RefreshMappings ()
685 {
686 Workspace w = Repository.QueryWorkspace(Name, OwnerName);
687 this.folders = w.folders;
688 }
689
690 public string Comment
691 {
692 get { return comment; }
693 }
694
695 public string Computer
696 {
697 get { return computer; }
698 }
699
700 public WorkingFolder[] Folders
701 {
702 get { return folders; }
703 }
704
705 public string Name
706 {
707 get { return name; }
708 }
709
710 public DateTime LastAccessDate
711 {
712 get { return lastAccessDate; }
713 }
714
715 public string OwnerName
716 {
717 get { return ownerName; }
718 }
719
720 public VersionControlServer VersionControlServer
721 {
722 get { return versionControlServer; }
723 }
724
725 internal Repository Repository
726 {
727 get { return versionControlServer.Repository; }
728 }
729
730 internal void SetFileAttributes(string path)
731 {
732 if (!readWriteSetting)
733 File.SetAttributes(path, FileAttributes.ReadOnly);
734 }
735
736 internal void UnsetFileAttributes(string path)
737 {
738 if (!readWriteSetting)
739 File.SetAttributes(path, FileAttributes.Normal);
740 }
741
742 }
743 }
Team Foundation for Mono