class/Microsoft.TeamFoundation.VersionControl.Client/Repository.cs

   1 //
   2 // Microsoft.TeamFoundation.VersionControl.Client.Repository
   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.IO;
  31 using System.Collections.Generic;
  32 using System.Net;
  33 using System.Reflection;
  34 using System.Text;
  35 using System.Xml;
  36 using System.Xml.Schema;
  37 using System.Web.Services;
  38 using System.Web.Services.Description;
  39 using System.Web.Services.Discovery;
  40 using System.Web.Services.Protocols;
  41 using Microsoft.TeamFoundation.VersionControl.Common;
  42
  43 namespace Microsoft.TeamFoundation.VersionControl.Client
  44 {
  45         [System.Web.Services.WebServiceBinding(Name="RepositorySoap", Namespace="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03")]
  46         [System.Diagnostics.DebuggerStepThroughAttribute()]
  47         [System.ComponentModel.DesignerCategoryAttribute("code")]
  48         [System.Xml.Serialization.XmlIncludeAttribute(typeof(SecurityChange))]
  49         internal class Repository : System.Web.Services.Protocols.SoapHttpClientProtocol {
  50
  51                 private VersionControlServer versionControlServer;
  52                 private string itemUrl;
  53                 private string uploadUrl;
  54
  55                 public Repository(VersionControlServer versionControlServer,
  56                                                                                         Uri url, ICredentials credentials)
  57                         {
  58                                 this.versionControlServer = versionControlServer;
  59                                 this.Url = String.Format("{0}/{1}", url, "VersionControl/v1.0/Repository.asmx");
  60                                 this.itemUrl = String.Format("{0}/{1}", url, RepositoryConstants.DownloadUrlSuffix);
  61                                 this.uploadUrl = String.Format("{0}/{1}", url, RepositoryConstants.UploadUrlSuffix);
  62                                 this.Credentials = credentials;
  63                         }
  64
  65                 public void UploadFile(string workspaceName, string ownerName, PendingChange change)
  66                 {
  67                         FileInfo fi = new FileInfo(change.LocalItem);
  68                         long len = fi.Length;
  69
  70                         UploadFile upload = new UploadFile(uploadUrl, Credentials);
  71                         upload.AddValue(RepositoryConstants.ServerItemField, change.ServerItem);
  72                         upload.AddValue(RepositoryConstants.WorkspaceNameField, workspaceName);
  73                         upload.AddValue(RepositoryConstants.WorkspaceOwnerField, ownerName);
  74                         upload.AddValue(RepositoryConstants.LengthField, len.ToString());
  75                         upload.AddValue(RepositoryConstants.HashField, Convert.ToBase64String(change.UploadHashValue));
  76
  77                         // send byte range
  78                         // TODO: handle files to large to fit in a single POST
  79                         upload.AddValue(RepositoryConstants.RangeField,
  80                                                                                         String.Format("bytes=0-{0}/{1}", len-1, len));
  81
  82                         upload.AddFile(change.LocalItem);
  83
  84                         WebResponse response;
  85
  86                         try
  87                                 {
  88                                         response = upload.Send();
  89                                 }
  90                         catch (WebException ex)
  91                                 {
  92                                         response = ex.Response;
  93                                         HttpWebResponse http_response = response as HttpWebResponse;
  94                                         if (http_response == null || http_response.StatusCode != HttpStatusCode.InternalServerError)
  95                                                 throw ex;
  96                                 }
  97
  98                         // Get the stream associated with the response.
  99                         //Stream receiveStream = response.GetResponseStream ();
 100                         //StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);
 101                         //Console.WriteLine (readStream.ReadToEnd ());
 102
 103                         response.Close();
 104                         //readStream.Close();
 105                 }
 106
 107                 protected HttpWebResponse Invoke (Message message)
 108                 {
 109                         message.End();
 110                         HttpWebResponse response = GetWebResponse(message.Request) as HttpWebResponse;
 111
 112                         if (response == null)
 113                                 {
 114                                         throw new TeamFoundationServerException("No response from server");
 115                                 }
 116
 117                         if (response.StatusCode == HttpStatusCode.Unauthorized)
 118                                 {
 119                                         string msg = String.Format("TF30063: You are not authorized to access {0} ({1}).\n--> Did you supply the correct username, password, and domain?",
 120                                                                                                                                                  (new Uri(this.Url)).Host, message.MethodName);
 121
 122                                         //StreamReader readStream = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
 123                                         //                                      Console.Error.WriteLine (readStream.ReadToEnd ());
 124                                         //readStream.Close();
 125
 126                                         throw new TeamFoundationServerException(msg);
 127                                 }
 128
 129                         if (response.StatusCode == HttpStatusCode.InternalServerError)
 130                                 {
 131                                         throw new VersionControlException(GetExceptionMessage(response));
 132                                 }
 133
 134                         return response;
 135                 }
 136
 137                 public string GetExceptionMessage(HttpWebResponse response)
 138                 {
 139                         StreamReader sr = new StreamReader(response.GetResponseStream(), new UTF8Encoding (false), false);
 140                         XmlReader reader = new XmlTextReader(sr);
 141                         string msg = String.Empty;
 142                         while (reader.Read())
 143                                 {
 144                                         if (reader.NodeType == XmlNodeType.Element && reader.Name == "faultstring")
 145                                                 {
 146                                                         msg = reader.ReadElementContentAsString();
 147                                                         break;
 148                                                 }
 149                                 }
 150
 151                         response.Close();
 152                         return msg;
 153                 }
 154
 155                 public int CheckIn(Workspace workspace, string[] serverItems, string comment)
 156                 {
 157                         Message msg = new Message(GetWebRequest (new Uri(Url)), "CheckIn");
 158
 159                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 160                         msg.Body.WriteElementString("ownerName", workspace.OwnerName);
 161
 162                         msg.Body.WriteStartElement("serverItems");
 163                         foreach (string serverItem in serverItems)
 164                                 {
 165                                         msg.Body.WriteElementString("string", serverItem);
 166                                 }
 167                         msg.Body.WriteEndElement();
 168
 169                         // write info subtree
 170                         msg.Body.WriteStartElement("info");
 171                         msg.Body.WriteAttributeString("date", DateTime.Now.ToString("s"));
 172                         msg.Body.WriteAttributeString("cset", "0");
 173                         msg.Body.WriteAttributeString("owner", workspace.OwnerName);
 174                         msg.Body.WriteElementString("Comment", comment);
 175                         msg.Body.WriteElementString("CheckinNote", "");
 176                         msg.Body.WriteElementString("PolicyOverride", "");
 177                         msg.Body.WriteElementString("CheckinOptions", "ValidateCheckinOwner");
 178                         msg.Body.WriteEndElement();
 179
 180                         int cset = 0;
 181                         using (HttpWebResponse response = Invoke(msg))
 182                                 {
 183                                         XmlReader results = msg.ResponseReader(response);
 184                                         cset = Convert.ToInt32(results.GetAttribute("cset"));
 185
 186                                         List<Failure> failures = new List<Failure>();
 187
 188                                         //TODO: read <UndoneServerItems /> and <ImplicitItems />
 189                                         //<CheckInResponse xmlns="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03"><CheckInResult cset="11486"><UndoneServerItems /><ImplicitItems /></CheckInResult><failures /></CheckInResponse>
 190                                         while (results.Read())
 191                                                 {
 192                                                         if (results.NodeType == XmlNodeType.Element)
 193                                                                 {
 194                                                                         switch (results.Name)
 195                                                                                 {
 196                                                                                 case "Failure":
 197                                                                                         failures.Add(Failure.FromXml(this, results));
 198                                                                                         break;
 199                                                                                 }
 200                                                                 }
 201                                                 }
 202
 203                                         foreach (Failure failure in failures)
 204                                                 {
 205                                                         versionControlServer.OnNonFatalError(workspace, failure);
 206                                                 }
 207                                 }
 208
 209                         return cset;
 210                 }
 211
 212                 public void CreateTeamProjectFolder(TeamProjectFolderOptions teamProjectOptions)
 213                 {
 214                         Message msg = new Message(GetWebRequest (new Uri(Url)), "CreateTeamProjectFolder");
 215                         teamProjectOptions.ToXml(msg.Body, "");
 216                         HttpWebResponse response = Invoke(msg);
 217                         response.Close();
 218                 }
 219
 220                 public Workspace CreateWorkspace(Workspace workspace)
 221                 {
 222                         Message msg = new Message(GetWebRequest (new Uri(Url)), "CreateWorkspace");
 223                         workspace.ToXml(msg.Body, "workspace");
 224
 225                         Workspace newWorkspace;
 226                         using (HttpWebResponse response = Invoke(msg))
 227                                 {
 228                                         XmlReader results = msg.ResponseReader(response);
 229                                         newWorkspace = Workspace.FromXml(this, results);
 230                                 }
 231
 232                         return newWorkspace;
 233                 }
 234
 235                 [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03/DeleteWorkspace", RequestNamespace="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03", ResponseNamespace="http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03", ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped, Use=System.Web.Services.Description.SoapBindingUse.Literal)]
 236                         public void DeleteWorkspace(string workspaceName, string ownerName)
 237                         {
 238                                 this.Invoke("DeleteWorkspace", new object[] { workspaceName, ownerName});
 239                         }
 240
 241                 public LabelResult[] LabelItem(Workspace workspace, VersionControlLabel label,
 242                                                                                                                                          LabelItemSpec[] labelSpecs, LabelChildOption children)
 243                 {
 244                         Message msg = new Message(GetWebRequest (new Uri(Url)), "LabelItem");
 245
 246                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 247                         msg.Body.WriteElementString("workspaceOwner", workspace.OwnerName);
 248                         label.ToXml(msg.Body, "label");
 249
 250                         msg.Body.WriteStartElement("labelSpecs");
 251                         foreach (LabelItemSpec labelSpec in labelSpecs)
 252                                 {
 253                                         labelSpec.ToXml(msg.Body, "LabelItemSpec");
 254                                 }
 255                         msg.Body.WriteEndElement();
 256
 257                         msg.Body.WriteElementString("children", children.ToString());
 258
 259                         List<LabelResult> labelResults = new List<LabelResult>();
 260                         List<Failure> faillist = new List<Failure>();
 261
 262                         using (HttpWebResponse response = Invoke(msg))
 263                                 {
 264                                         XmlReader results = msg.ResponseReader(response);
 265
 266                                         while (results.Read())
 267                                                 {
 268                                                         if (results.NodeType == XmlNodeType.Element)
 269                                                                 {
 270                                                                         switch (results.Name)
 271                                                                                 {
 272                                                                                 case "LabelResult":
 273                                                                                         labelResults.Add(LabelResult.FromXml(this, results));
 274                                                                                         break;
 275                                                                                 case "Failure":
 276                                                                                         faillist.Add(Failure.FromXml(this, results));
 277                                                                                         break;
 278                                                                                 }
 279                                                                 }
 280                                                 }
 281                                 }
 282
 283                         foreach (Failure failure in faillist)
 284                                 {
 285                                         versionControlServer.OnNonFatalError(workspace, failure);
 286                                 }
 287
 288                         return labelResults.ToArray();
 289                 }
 290
 291                 public LabelResult[] UnlabelItem(Workspace workspace, string labelName,
 292                                                                                                                                                  string labelScope, ItemSpec[] itemSpecs,
 293                                                                                                                                                  VersionSpec version)
 294                 {
 295                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UnlabelItem");
 296
 297                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 298                         msg.Body.WriteElementString("workspaceOwner", workspace.OwnerName);
 299                         msg.Body.WriteElementString("labelName", labelName);
 300
 301                         if (!String.IsNullOrEmpty(labelScope))
 302                                 msg.Body.WriteElementString("labelScope", labelScope);
 303
 304                         msg.Body.WriteStartElement("items");
 305                         foreach (ItemSpec itemSpec in itemSpecs)
 306                                 {
 307                                         itemSpec.ToXml(msg.Body, "ItemSpec");
 308                                 }
 309                         msg.Body.WriteEndElement();
 310
 311                         version.ToXml(msg.Body, "version");
 312
 313                         List<LabelResult> labelResults = new List<LabelResult>();
 314                         List<Failure> faillist = new List<Failure>();
 315
 316                         using (HttpWebResponse response = Invoke(msg))
 317                                 {
 318                                         XmlReader results = msg.ResponseReader(response);
 319
 320                                         while (results.Read())
 321                                                 {
 322                                                         if (results.NodeType == XmlNodeType.Element)
 323                                                                 {
 324                                                                         switch (results.Name)
 325                                                                                 {
 326                                                                                 case "LabelResult":
 327                                                                                         labelResults.Add(LabelResult.FromXml(this, results));
 328                                                                                         break;
 329                                                                                 case "Failure":
 330                                                                                         faillist.Add(Failure.FromXml(this, results));
 331                                                                                         break;
 332                                                                                 }
 333                                                                 }
 334                                                 }
 335                                 }
 336
 337                         foreach (Failure failure in faillist)
 338                                 {
 339                                         versionControlServer.OnNonFatalError(workspace, failure);
 340                                 }
 341
 342                         return labelResults.ToArray();
 343                 }
 344
 345                 public GetOperation[] Get(string workspaceName, string ownerName,
 346                                                                                                                         GetRequest[] requests, bool force, bool noGet) {
 347
 348                         Message msg = new Message(GetWebRequest (new Uri(Url)), "Get");
 349                         msg.Body.WriteElementString("workspaceName", workspaceName);
 350                         msg.Body.WriteElementString("ownerName", ownerName);
 351
 352                         msg.Body.WriteStartElement("requests");
 353                         foreach (GetRequest request in requests)
 354                                 {
 355                                         request.ToXml(msg.Body, "");
 356                                 }
 357                         msg.Body.WriteEndElement();
 358
 359                         msg.Body.WriteElementString("force", force.ToString().ToLower());
 360                         msg.Body.WriteElementString("noGet", noGet.ToString().ToLower());
 361
 362                         List<GetOperation> operations = new List<GetOperation>();
 363                         using (HttpWebResponse response = Invoke(msg))
 364                                 {
 365                                         XmlReader results = msg.ResponseReader(response);
 366
 367                                         while (results.Read())
 368                                                 {
 369                                                         if (results.NodeType == XmlNodeType.Element &&
 370                                                                         results.Name == "GetOperation")
 371                                                                 operations.Add(GetOperation.FromXml(ItemUrl, results));
 372                                                 }
 373                                 }
 374
 375                         return operations.ToArray();
 376                 }
 377
 378                 public RepositoryProperties GetRepositoryProperties()
 379                 {
 380                         Message msg = new Message(GetWebRequest (new Uri(Url)), "GetRepositoryProperties");
 381                         RepositoryProperties properties;
 382                         using (HttpWebResponse response = Invoke(msg))
 383                                 {
 384                                         XmlReader results = msg.ResponseReader(response);
 385                                         properties = RepositoryProperties.FromXml(this, results);
 386                                 }
 387
 388                         return properties;
 389                 }
 390
 391                 public GetOperation[] PendChanges(Workspace workspace, ChangeRequest[] changes)
 392                 {
 393                         Message msg = new Message(GetWebRequest (new Uri(Url)), "PendChanges");
 394
 395                         msg.Body.WriteElementString("workspaceName", workspace.Name);
 396                         msg.Body.WriteElementString("ownerName", workspace.OwnerName);
 397                         msg.Body.WriteStartElement("changes");
 398                         foreach (ChangeRequest change in changes)
 399                                 {
 400                                         change.ToXml(msg.Body, "");
 401                                 }
 402                         msg.Body.WriteEndElement();
 403
 404                         List<GetOperation> operations = new List<GetOperation>();
 405                         List<Failure> faillist = new List<Failure>();
 406
 407                         using (HttpWebResponse response = Invoke(msg))
 408                                 {
 409                                         XmlReader results = msg.ResponseReader(response);
 410
 411                                         while (results.Read())
 412                                                 {
 413                                                         if (results.NodeType == XmlNodeType.Element)
 414                                                                 {
 415                                                                         switch (results.Name)
 416                                                                                 {
 417                                                                                 case "GetOperation":
 418                                                                                         operations.Add(GetOperation.FromXml(ItemUrl, results));
 419                                                                                         break;
 420                                                                                 case "Failure":
 421                                                                                         faillist.Add(Failure.FromXml(this, results));
 422                                                                                         break;
 423                                                                                 }
 424                                                                 }
 425                                                 }
 426                                 }
 427
 428                         foreach (Failure failure in faillist)
 429                                 {
 430                                         versionControlServer.OnNonFatalError(workspace, failure);
 431                                 }
 432
 433                         return operations.ToArray();
 434                 }
 435
 436                 public Annotation[] QueryAnnotation(string annotationName, string annotatedItem, int version)
 437                 {
 438                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryAnnotation");
 439
 440                         msg.Body.WriteElementString("annotationName", annotationName);
 441                         msg.Body.WriteElementString("annotatedItem", annotatedItem);
 442                         msg.Body.WriteElementString("version", Convert.ToString(version));
 443
 444                         List<Annotation> labels = new List<Annotation>();
 445                         using (HttpWebResponse response = Invoke(msg))
 446                                 {
 447                                         XmlReader results = msg.ResponseReader(response);
 448
 449                                         while (results.Read())
 450                                                 {
 451                                                         if (results.NodeType == XmlNodeType.Element &&
 452                                                                         results.Name == "Annotation")
 453                                                                 labels.Add(Annotation.FromXml(this, results));
 454                                                 }
 455                                 }
 456
 457                         return labels.ToArray();
 458                 }
 459
 460                 public BranchHistoryTreeItem[][] QueryBranches(string workspaceName, string workspaceOwner,
 461                                                                                                                                                                                                          ItemSpec[] itemSpecs, VersionSpec versionSpec)
 462                 {
 463                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryBranches");
 464
 465                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 466                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 467                         msg.Body.WriteStartElement("items");
 468                         foreach (ItemSpec itemSpec in itemSpecs)
 469                                 itemSpec.ToXml(msg.Body, "ItemSpec");
 470                         msg.Body.WriteEndElement();
 471
 472                         versionSpec.ToXml(msg.Body, "version");
 473
 474                         List<BranchHistoryTreeItem[]> tree = new List<BranchHistoryTreeItem[]>();
 475                         using (HttpWebResponse response = Invoke(msg))
 476                                 {
 477                                         XmlReader results = msg.ResponseReader(response);
 478                                         while (results.Read())
 479                                                 {
 480                                                         if (results.NodeType == XmlNodeType.Element &&
 481                                                                         results.Name == "ArrayOfBranchRelative")
 482                                                                 {
 483                                                                         List<BranchRelative> branches = new List<BranchRelative>();
 484                                                                         while (results.Read())
 485                                                                                 {
 486                                                                                         if (results.NodeType == XmlNodeType.EndElement &&
 487                                                                                                         results.Name == "ArrayOfBranchRelative") break;
 488                                                                                         if (results.NodeType == XmlNodeType.Element &&
 489                                                                                                         results.Name == "BranchRelative")
 490                                                                                                 branches.Add(BranchRelative.FromXml(this, results));
 491                                                                                 }
 492
 493                                                                         if (branches.Count > 0)
 494                                                                                 {
 495                                                                                         List<BranchHistoryTreeItem> items = new List<BranchHistoryTreeItem>();
 496                                                                                         items.Add(new BranchHistoryTreeItem(branches.ToArray()));
 497                                                                                         tree.Add(items.ToArray());
 498                                                                                 }
 499                                                                 }
 500                                                 }
 501                                 }
 502
 503                         return tree.ToArray();
 504                 }
 505
 506                 public Changeset QueryChangeset(int changesetId, bool includeChanges,
 507                                                                                                                                                 bool generateDownloadUrls)
 508                 {
 509                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryChangeset");
 510
 511                         msg.Body.WriteElementString("changesetId", Convert.ToString(changesetId));
 512                         msg.Body.WriteElementString("includeChanges", Convert.ToString(includeChanges).ToLower());
 513                         msg.Body.WriteElementString("generateDownloadUrls", Convert.ToString(generateDownloadUrls).ToLower());
 514
 515                         Changeset changeset = null;
 516
 517                         using (HttpWebResponse response = Invoke(msg))
 518                                 {
 519                                         XmlReader results = msg.ResponseReader(response);
 520                                         changeset = Changeset.FromXml(this, results);
 521                                 }
 522
 523                         return changeset;
 524                 }
 525
 526                 public Changeset[] QueryHistory (string workspaceName, string workspaceOwner,
 527                                                                                                                                                  ItemSpec itemSpec, VersionSpec version,
 528                                                                                                                                                  string user, VersionSpec versionFrom,
 529                                                                                                                                                  VersionSpec versionTo, int maxCount,
 530                                                                                                                                                  bool includeFiles, bool slotMode,
 531                                                                                                                                                  bool generateDownloadUrls)
 532                 {
 533                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryHistory");
 534
 535                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 536                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 537
 538                         itemSpec.ToXml(msg.Body, "itemSpec");
 539                         if (version != null) version.ToXml(msg.Body, "versionItem");
 540                         if (versionFrom != null) versionFrom.ToXml(msg.Body, "versionFrom");
 541                         if (versionTo != null) versionTo.ToXml(msg.Body, "versionTo");
 542
 543                         if (!String.IsNullOrEmpty(user)) msg.Body.WriteElementString("user", user);
 544                         msg.Body.WriteElementString("maxCount", Convert.ToString(maxCount));
 545                         msg.Body.WriteElementString("includeFiles", Convert.ToString(includeFiles).ToLower());
 546                         msg.Body.WriteElementString("generateDownloadUrls", Convert.ToString(generateDownloadUrls).ToLower());
 547                         msg.Body.WriteElementString("slotMode", Convert.ToString(slotMode).ToLower());
 548
 549                         List<Changeset> changes = new List<Changeset>();
 550                         using (HttpWebResponse response = Invoke(msg))
 551                                 {
 552                                         XmlReader results = msg.ResponseReader(response);
 553
 554                                         while (results.Read())
 555                                                 {
 556                                                         if (results.NodeType == XmlNodeType.Element &&
 557                                                                         results.Name == "Changeset")
 558                                                                 changes.Add(Changeset.FromXml(this, results));
 559                                                 }
 560                                 }
 561
 562                         return changes.ToArray();
 563                 }
 564
 565                 public ItemSet[] QueryItems(string workspaceName, string workspaceOwner,
 566                                                                                                                                 ItemSpec[] itemSpecs, VersionSpec versionSpec,
 567                                                                                                                                 DeletedState deletedState, ItemType itemType,
 568                                                                                                                                 bool generateDownloadUrls)
 569                 {
 570                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItems");
 571
 572                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 573                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 574                         msg.Body.WriteStartElement("items");
 575                         foreach (ItemSpec itemSpec in itemSpecs)
 576                                 itemSpec.ToXml(msg.Body, "ItemSpec");
 577                         msg.Body.WriteEndElement();
 578
 579                         versionSpec.ToXml(msg.Body, "version");
 580
 581                         msg.Body.WriteElementString("deletedState",
 582                                                                                                                                         deletedState.ToString());
 583                         msg.Body.WriteElementString("itemType",
 584                                                                                                                                         itemType.ToString());
 585                         msg.Body.WriteElementString("generateDownloadUrls",
 586                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 587
 588                         List<ItemSet> itemSet = new List<ItemSet>();
 589                         using (HttpWebResponse response = Invoke(msg))
 590                                 {
 591                                         XmlReader results = msg.ResponseReader(response);
 592
 593                                         while (results.Read())
 594                                                 {
 595                                                         if (results.NodeType == XmlNodeType.Element &&
 596                                                                         results.Name == "ItemSet")
 597                                                                 itemSet.Add(ItemSet.FromXml(this, results));
 598                                                 }
 599                                 }
 600
 601                         return itemSet.ToArray();
 602                 }
 603
 604                 public ExtendedItem[][] QueryItemsExtended(string workspaceName, string workspaceOwner,
 605                                                                                                                                                                                          ItemSpec[] itemSpecs,
 606                                                                                                                                                                                          DeletedState deletedState, ItemType itemType)
 607                 {
 608                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemsExtended");
 609
 610                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 611                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 612
 613                         msg.Body.WriteStartElement("items");
 614                         foreach (ItemSpec itemSpec in itemSpecs)
 615                                 {
 616                                         itemSpec.ToXml(msg.Body, "ItemSpec");
 617                                 }
 618                         msg.Body.WriteEndElement();
 619
 620                         msg.Body.WriteElementString("deletedState",
 621                                                                                                                                         deletedState.ToString());
 622                         msg.Body.WriteElementString("itemType",
 623                                                                                                                                         itemType.ToString());
 624
 625                         List< ExtendedItem[] > listOfItemArrays = new List<ExtendedItem[] >();
 626                         using (HttpWebResponse response = Invoke(msg))
 627                                 {
 628                                         XmlReader results = msg.ResponseReader(response);
 629                                         while (results.Read())
 630                                                 {
 631                                                         if (results.NodeType == XmlNodeType.Element &&
 632                                                                         results.Name == "ArrayOfExtendedItem")
 633                                                                 {
 634                                                                         List<ExtendedItem> items = new List<ExtendedItem>();
 635                                                                         while (results.Read())
 636                                                                                 {
 637                                                                                         //Console.WriteLine("    " + results.Name + ":" + results.NodeType);
 638                                                                                         if (results.NodeType == XmlNodeType.EndElement &&
 639                                                                                                         results.Name == "ArrayOfExtendedItem") break;
 640                                                                                         if (results.NodeType == XmlNodeType.Element &&
 641                                                                                                         results.Name == "ExtendedItem")
 642                                                                                                 items.Add(ExtendedItem.FromXml(this, results));
 643                                                                                 }
 644                                                                         listOfItemArrays.Add(items.ToArray());
 645                                                                 }
 646                                                 }
 647                                 }
 648
 649                         return listOfItemArrays.ToArray();
 650                 }
 651
 652                 public VersionControlLabel[] QueryLabels(string workspaceName, string workspaceOwner,
 653                                                                                                                                                                                  string labelName, string labelScope,
 654                                                                                                                                                                                  string owner, string filterItem,
 655                                                                                                                                                                                  VersionSpec versionFilterItem,
 656                                                                                                                                                                                  bool includeItems, bool generateDownloadUrls)
 657                 {
 658                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryLabels");
 659
 660                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 661                         if (!String.IsNullOrEmpty(workspaceOwner)) msg.Body.WriteElementString("workspaceOwner", workspaceOwner);
 662                         if (!String.IsNullOrEmpty(labelName)) msg.Body.WriteElementString("labelName", labelName);
 663                         if (!String.IsNullOrEmpty(labelScope)) msg.Body.WriteElementString("labelScope", labelScope);
 664                         if (!String.IsNullOrEmpty(owner)) msg.Body.WriteElementString("owner", owner);
 665                         if (!String.IsNullOrEmpty(filterItem)) msg.Body.WriteElementString("filterItem", filterItem);
 666
 667                         if (null != versionFilterItem) versionFilterItem.ToXml(msg.Body, "versionFilterItem");
 668                         msg.Body.WriteElementString("includeItems", includeItems.ToString().ToLower());
 669                         msg.Body.WriteElementString("generateDownloadUrls", generateDownloadUrls.ToString().ToLower());
 670
 671                         List<VersionControlLabel> labels = new List<VersionControlLabel>();
 672                         using (HttpWebResponse response = Invoke(msg))
 673                                 {
 674                                         XmlReader results = msg.ResponseReader(response);
 675
 676                                         while (results.Read())
 677                                                 {
 678                                                         if (results.NodeType == XmlNodeType.Element &&
 679                                                                         results.Name == "VersionControlLabel")
 680                                                                 labels.Add(VersionControlLabel.FromXml(this, results));
 681                                                 }
 682                                 }
 683
 684                         return labels.ToArray();
 685                 }
 686
 687                 public Item[] QueryItemsById(int[] ids, int changeSet,
 688                                                                                                                                  bool generateDownloadUrls)
 689                 {
 690                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemsById");
 691
 692                         msg.Body.WriteStartElement("itemIds");
 693                         foreach (int id in ids)
 694                                 {
 695                                         msg.Body.WriteElementString("int", Convert.ToString(id));
 696                                 }
 697                         msg.Body.WriteEndElement();
 698
 699                         msg.Body.WriteElementString("changeSet", Convert.ToString(changeSet));
 700                         msg.Body.WriteElementString("generateDownloadUrls",
 701                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 702
 703                         List<Item> items = new List<Item>();
 704                         using (HttpWebResponse response = Invoke(msg))
 705                                 {
 706                                         XmlReader results = msg.ResponseReader(response);
 707
 708                                         while (results.Read())
 709                                                 {
 710                                                         if (results.NodeType == XmlNodeType.Element &&
 711                                                                         results.Name == "Item")
 712                                                                 items.Add(Item.FromXml(this, results));
 713                                                 }
 714                                 }
 715
 716                         return items.ToArray();
 717                 }
 718
 719                 public ItemSecurity[] QueryItemPermissions(string[] identityNames, string[] items,
 720                                                                                                                                                                                          RecursionType recursion)
 721                 {
 722                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryItemPermissions");
 723
 724                         msg.Body.WriteStartElement("itemSpecs");
 725                         foreach (string item in items)
 726                                 {
 727                                         ItemSpec spec = new ItemSpec(item, recursion);
 728                                         spec.ToXml(msg.Body, "ItemSpec");
 729                                 }
 730                         msg.Body.WriteEndElement();
 731
 732                         List<ItemSecurity> itemSecurities = new List<ItemSecurity>();
 733                         using (HttpWebResponse response = Invoke(msg))
 734                                 {
 735                                         XmlReader results = msg.ResponseReader(response);
 736
 737                                         while (results.Read())
 738                                                 {
 739                                                         if (results.NodeType == XmlNodeType.Element &&
 740                                                                         results.Name == "ItemSecurity")
 741                                                                 itemSecurities.Add(ItemSecurity.FromXml(this, results));
 742                                                 }
 743                                 }
 744
 745                         return itemSecurities.ToArray();
 746                 }
 747
 748                 public PendingChange[] QueryPendingSets(string localWorkspaceName, string localWorkspaceOwner,
 749                                                                                                                                                                                 string queryWorkspaceName, string ownerName,
 750                                                                                                                                                                                 ItemSpec[] itemSpecs, bool generateDownloadUrls,
 751                                                                                                                                                                                 out Failure[] failures)
 752                 {
 753                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryPendingSets");
 754                         msg.Body.WriteElementString("localWorkspaceName", localWorkspaceName);
 755                         msg.Body.WriteElementString("localWorkspaceOwner", localWorkspaceOwner);
 756                         msg.Body.WriteElementString("queryWorkspaceName", queryWorkspaceName);
 757                         msg.Body.WriteElementString("ownerName", ownerName);
 758
 759                         msg.Body.WriteStartElement("itemSpecs");
 760                         foreach (ItemSpec item in itemSpecs)
 761                                 {
 762                                         item.ToXml(msg.Body, "ItemSpec");
 763                                 }
 764                         msg.Body.WriteEndElement();
 765
 766                         msg.Body.WriteElementString("generateDownloadUrls",
 767                                                                                                                                         generateDownloadUrls.ToString().ToLower());
 768
 769                         List<PendingChange> changes = new List<PendingChange>();
 770                         List<Failure> faillist = new List<Failure>();
 771
 772                         using (HttpWebResponse response = Invoke(msg))
 773                                 {
 774                                         XmlReader results = msg.ResponseReader(response);
 775
 776                                         while (results.Read())
 777                                                 {
 778                                                         if (results.NodeType == XmlNodeType.Element)
 779                                                                 {
 780                                                                         switch (results.Name)
 781                                                                                 {
 782                                                                                 case "PendingChange":
 783                                                                                         changes.Add(PendingChange.FromXml(this, results));
 784                                                                                         break;
 785                                                                                 case "Failure":
 786                                                                                         faillist.Add(Failure.FromXml(this, results));
 787                                                                                         break;
 788                                                                                 }
 789                                                                 }
 790                                                 }
 791                                 }
 792
 793                         failures = faillist.ToArray();
 794                         return changes.ToArray();
 795                 }
 796
 797                 public Shelveset[] QueryShelvesets (string shelvesetName, string shelvesetOwner)
 798                 {
 799                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryShelvesets");
 800                         msg.Body.WriteElementString("shelvesetName", shelvesetName);
 801                         msg.Body.WriteElementString("shelvesetOwner", shelvesetOwner);
 802
 803                         List<Shelveset> shelvesets = new List<Shelveset>();
 804                         using (HttpWebResponse response = Invoke(msg))
 805                                 {
 806                                         XmlReader results = msg.ResponseReader(response);
 807
 808                                         while (results.Read())
 809                                                 {
 810                                                         if (results.NodeType == XmlNodeType.Element &&
 811                                                                         results.Name == "Shelveset")
 812                                                                 shelvesets.Add(Shelveset.FromXml(this, results));
 813                                                 }
 814                                 }
 815
 816                         shelvesets.Sort(ShelvesetGenericComparer.Instance);
 817                         return shelvesets.ToArray();
 818                 }
 819
 820                 public Workspace QueryWorkspace(string workspaceName, string ownerName)
 821                 {
 822                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryWorkspace");
 823                         msg.Body.WriteElementString("workspaceName", workspaceName);
 824                         msg.Body.WriteElementString("ownerName", ownerName);
 825
 826                         Workspace workspace;
 827                         using (HttpWebResponse response = Invoke(msg))
 828                                 {
 829                                         XmlReader results = msg.ResponseReader(response);
 830                                         workspace = Workspace.FromXml(this, results);
 831                                 }
 832
 833                         return workspace;
 834                 }
 835
 836                 public Workspace[] QueryWorkspaces(string workspaceName, string ownerName,
 837                                                                                                                                                          string computer)
 838                 {
 839                         Message msg = new Message(GetWebRequest (new Uri(Url)), "QueryWorkspaces");
 840                         if (!String.IsNullOrEmpty(workspaceName)) msg.Body.WriteElementString("workspaceName", workspaceName);
 841                         if (!String.IsNullOrEmpty(ownerName)) msg.Body.WriteElementString("ownerName", ownerName);
 842                         if (!String.IsNullOrEmpty(computer)) msg.Body.WriteElementString("computer", computer);
 843
 844                         List<Workspace> workspaces = new List<Workspace>();
 845                         using (HttpWebResponse response = Invoke(msg))
 846                                 {
 847                                         XmlReader results = msg.ResponseReader(response);
 848
 849                                         while (results.Read())
 850                                                 {
 851                                                         if (results.NodeType == XmlNodeType.Element &&
 852                                                                         results.Name == "Workspace")
 853                                                                 workspaces.Add(Workspace.FromXml(this, results));
 854                                                 }
 855                                 }
 856
 857                         workspaces.Sort();
 858                         return workspaces.ToArray();
 859                 }
 860
 861                 //              <?xml version=_T("1.0") encoding=_T("utf-8")?><soap:Envelope xmlns:xsi=_T("http://www.w3.org/2001/XMLSchema-instance") xmlns=_T("http://schemas.microsoft.com/TeamFoundation/2005/06/VersionControl/ClientServices/03") xmlns:soap=_T("http://www.w3.org/2003/05/soap-envelope")><soap:Body><UpdateWorkspace><oldWorkspaceName>neo</oldWorkspaceName><ownerName>DDI\JREED</ownerName><newWorkspace computer=_T("neo") name=_T("neo") owner=_T("DDI\JREED")><Comment /><LastAccessDate>0001-01-01T00:00:00</LastAccessDate><Folders><WorkingFolder local=_T("C:\MSOCache") item=_T("$/LSG-1.0") /></Folders></newWorkspace></UpdateWorkspace></soap:Body></soap:Envelope
 862                 public Workspace UpdateWorkspace(string oldWorkspaceName, string ownerName,
 863                                                                                                                                                  Workspace newWorkspace)
 864                 {
 865                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UpdateWorkspace");
 866                         msg.Body.WriteElementString("oldWorkspaceName", oldWorkspaceName);
 867                         msg.Body.WriteElementString("ownerName", ownerName);
 868                         newWorkspace.ToXml(msg.Body, "newWorkspace");
 869
 870                         Workspace workspace;
 871                         using (HttpWebResponse response = Invoke(msg))
 872                                 {
 873                                         XmlReader results = msg.ResponseReader(response);
 874                                         workspace = Workspace.FromXml(this, results);
 875                                 }
 876
 877                         return workspace;
 878                 }
 879
 880                 public GetOperation[] UndoPendingChanges(string workspaceName, string ownerName,
 881                                                                                                                                                                                  ItemSpec[] itemSpecs)
 882                 {
 883                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UndoPendingChanges");
 884                         msg.Body.WriteElementString("workspaceName", workspaceName);
 885                         msg.Body.WriteElementString("ownerName", ownerName);
 886
 887                         msg.Body.WriteStartElement("items");
 888                         foreach (ItemSpec item in itemSpecs)
 889                                 {
 890                                         item.ToXml(msg.Body, "ItemSpec");
 891                                 }
 892                         msg.Body.WriteEndElement();
 893
 894                         List<GetOperation> operations = new List<GetOperation>();
 895                         using (HttpWebResponse response = Invoke(msg))
 896                                 {
 897                                         XmlReader results = msg.ResponseReader(response);
 898
 899                                         while (results.Read())
 900                                                 {
 901                                                         if (results.NodeType == XmlNodeType.Element &&
 902                                                                         results.Name == "GetOperation")
 903                                                                 operations.Add(GetOperation.FromXml(ItemUrl, results));
 904                                                 }
 905                                 }
 906
 907                         return operations.ToArray();
 908                 }
 909
 910                 public void UpdateLocalVersion(UpdateLocalVersionQueue queue)
 911                 {
 912                         Message msg = new Message(GetWebRequest (new Uri(Url)), "UpdateLocalVersion");
 913                         queue.ToXml(msg.Body, "UpdateLocalVersion");
 914
 915                         HttpWebResponse response = Invoke(msg);
 916                         response.Close();
 917                 }
 918
 919                 public VersionControlServer VersionControlServer
 920                 {
 921                         get { return versionControlServer; }
 922                 }
 923
 924                 public string ItemUrl
 925                 {
 926                         get { return itemUrl; }
 927                 }
 928
 929         }
 930
 931         class TfsPath
 932         {
 933                 private static bool runningOnUnix = true;
 934                 public static StringComparison PlatformComparison = StringComparison.InvariantCulture;
 935
 936                 static TfsPath()
 937                 {
 938                         int p = (int) Environment.OSVersion.Platform;
 939                         if (!((p == 4) || (p == 128))) runningOnUnix = false;
 940
 941                         if (!runningOnUnix) PlatformComparison = StringComparison.InvariantCultureIgnoreCase;
 942                 }
 943
 944                 public static string ToPlatformPath(string path)
 945                 {
 946                         if (String.IsNullOrEmpty(path)) return path;
 947
 948                         // TFS servers corrupt *nix type paths
 949                         if (!runningOnUnix) return path;
 950                         return path.Remove(0, 2).Replace('\\', '/');
 951                 }
 952
 953                 public static string FromPlatformPath(string path)
 954                 {
 955                         if (String.IsNullOrEmpty(path)) return path;
 956
 957                         // TFS servers corrupt *nix type paths
 958                         if (!runningOnUnix) return path;
 959                         return "C:" + path.Replace('/', '\\');
 960                 }
 961         }
 962 }