/// <summary>
/// Process the response from the cvs server.
/// </summary>
public override void Process() {
Manager manager = new Manager (Services.Repository.WorkingPath);
string localPath = this.ReadLine();
string reposPath = this.ReadLine();
string entry = this.ReadLine();
string flags = this.ReadLine();
string sizeStr = this.ReadLine();
PathTranslator orgPath =
new PathTranslator (Services.Repository,
reposPath);
string localPathAndFilename = orgPath.LocalPathAndFilename;
string directory = orgPath.LocalPath;
bool compress = sizeStr[0] == 'z';
if (compress) {
sizeStr = sizeStr.Substring(1);
}
int size = Int32.Parse(sizeStr);
if (!Directory.Exists(orgPath.LocalPath)) {
Directory.CreateDirectory(orgPath.LocalPath);
}
if (Services.NextFile != null && Services.NextFile.Length > 0) {
localPathAndFilename = Services.NextFile;
Services.NextFile = null;
}
Factory factory = new Factory();
Entry e = (Entry)
factory.CreateCvsObject(new DirectoryInfo(Path.GetDirectoryName(orgPath.CurrentDir.FullName)),
Entry.FILE_NAME, entry);
if (e.IsBinaryFile) {
Services.UncompressedFileHandler.ReceiveBinaryFile(Stream,
localPathAndFilename,
size);
} else {
Services.UncompressedFileHandler.ReceiveTextFile(Stream,
localPathAndFilename,
size);
}
e.Date = Services.NextFileDate;
Services.NextFileDate = null;
manager.AddEntry(e);
manager.SetFileTimeStamp (e.FullPath, e.TimeStamp, e.IsUtcTimeStamp);
UpdateMessage message = new UpdateMessage ();
message.Module = Services.Repository.WorkingDirectoryName;
message.Repository = orgPath.RelativePath;
message.Filename = e.Name;
Services.SendMessage (message.Message);
Services.ResponseMessageEvents.SendResponseMessage(message.Message, this.GetType());
}
/// <summary>
/// Process the response stream.
/// </summary>
public override void Process() {
string localPath = this.ReadLine();
string repositoryPath = this.ReadLine();
string stickyTag = this.ReadLine();
PathTranslator orgPath =
new PathTranslator (Services.Repository, repositoryPath);
string localPathAndFilename = orgPath.LocalPathAndFilename;
string directory = orgPath.LocalPath;
Manager manager =
new Manager (Services.Repository.WorkingPath);
manager.AddTag (Services.Repository, localPath, repositoryPath, stickyTag);
}
/// <summary>
/// Process a new entry response.
///
/// TODO: Copied implementation from CheckedInResponse, determine if this
/// is correct or not.
/// </summary>
public override void Process() {
string localPath = this.ReadLine();
string repositoryPath = this.ReadLine();
string entryLine = this.ReadLine();
PathTranslator orgPath =
new PathTranslator (Services.Repository,
repositoryPath);
string fileName = orgPath.LocalPathAndFilename;
Factory factory = new Factory();
Entry entry = (Entry)
factory.CreateCvsObject(orgPath.CurrentDir, Entry.FILE_NAME, entryLine);
Manager manager = new Manager (Services.Repository.WorkingPath);
manager.Add (entry);
}
/// <summary>
/// Process a clear static directory response.
/// </summary>
public override void Process() {
string localPath = this.ReadLine();
string reposPath = this.ReadLine();
Manager manager = new Manager (Services.Repository.WorkingPath);
manager.AddRepository (Services.Repository, localPath, reposPath);
manager.AddRoot (Services.Repository, localPath, reposPath);
PathTranslator pathTranslator = new PathTranslator (Services.Repository, reposPath);
Factory factory = new Factory();
Entry entry =
(Entry)factory.CreateCvsObject(pathTranslator.CurrentDir, Entry.FILE_NAME,
Entry.CreateEntry(pathTranslator.CurrentDir).FileContents);
// the root module directory does not get a cvs Entries line.
// TODO: There has to be a cleaner way to do this...
if (Services.Repository.WorkingPath.Length <= entry.Path.Length) {
manager.AddEntry(entry);
}
Services.ResponseMessageEvents.SendResponseMessage(
String.Format("Updating {0}", RemoveTrailingSlash(localPath)), this.GetType());
}
/// <summary>
/// Setup the list of files to be a folder object for the cvs
/// library to process.
/// </summary>
/// <param name="filesAdded">An array filenames that are to be added
/// to the cvs repository.</param>
private Folders GetFoldersToAdd (ICollection filesAdded) {
Folders folders = new Folders();
Manager manager = new Manager(Environment.CurrentDirectory);
LOGGER.Debug("Number of files copied=[" + filesAdded.Count + "]");
foreach (String file in filesAdded) {
Folder folder;
if (!folders.Contains(Path.GetDirectoryName(file))) {
folder = new Folder();
LOGGER.Debug("file=[" + file + "]");
LOGGER.Debug("file path=[" + Path.GetDirectoryName(file) + "]");
folder.Repository =
manager.FetchRepository(Path.GetDirectoryName(file));
folder.Root =
manager.FetchRoot(Path.GetDirectoryName(file));
folder.Tag =
manager.FetchTag(Path.GetDirectoryName(file));
folders.Add(Path.GetDirectoryName(file), folder);
} else {
folder = folders[Path.GetDirectoryName(file)];
}
if (!folder.Entries.Contains(file)) {
Entry entry = Entry.CreateEntry(new FileInfo(file));
folder.Entries.Add (file, entry);
} else {
folder.Entries[file] = Entry.CreateEntry(new FileInfo(file));
}
}
return folders;
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
ICSharpCode.SharpCvsLib.Commands.AddCommand addCommand;
this.ParseOptions(this.unparsedOptions);
try {
// Open the Repository file in the CVS directory
Manager manager = new Manager(Environment.CurrentDirectory);
Repository repository = manager.FetchRepository(Environment.CurrentDirectory);
// If this fails error out and state the user
// is not in a CVS repository directory tree.
CurrentWorkingDirectory = new WorkingDirectory( this.cvsRoot,
Environment.CurrentDirectory, repository.FileContents);
CurrentWorkingDirectory.OverrideDirectory = Environment.CurrentDirectory;
// If fileNames has a wild card (*) like '*.txt'
// Create new AddCommand object
addCommand = new ICSharpCode.SharpCvsLib.Commands.AddCommand(
this.CurrentWorkingDirectory);
String[] files = Directory.GetFiles(Environment.CurrentDirectory, fileNames);
ArrayList copiedFiles = new ArrayList ();
foreach (String file in files) {
LOGGER.Debug("file=[" + file + "]");
// Remove the .txt when everything works, giving me bugs...
String fullPath = Path.Combine(Environment.CurrentDirectory, file);
copiedFiles.Add(fullPath);
}
addCommand.Folders = GetFoldersToAdd(copiedFiles);
}
catch (Exception e) {
LOGGER.Error (e);
throw e;
}
return addCommand;
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
ICSharpCode.SharpCvsLib.Commands.RemoveCommand removeCommand;
this.ParseOptions(this.unparsedOptions);
try {
String currentDirectory = Environment.CurrentDirectory;
Entry removeEntry;
// Open the Repository file in the CVS directory
Manager manager = new Manager(currentDirectory);
Repository repository = manager.FetchRepository(currentDirectory);
removeEntry = manager.FetchEntry(currentDirectory, fileNames );
// If this fails error out and state the user
// is not in a CVS repository directory tree.
CurrentWorkingDirectory = new WorkingDirectory( this.cvsRoot,
currentDirectory, repository.FileContents);
// Create new RemoveCommand object
removeCommand = new ICSharpCode.SharpCvsLib.Commands.RemoveCommand(
this.CurrentWorkingDirectory, currentDirectory,
removeEntry);
}
catch (Exception e) {
LOGGER.Error (e);
throw e;
}
return removeCommand;
}
/// <summary>
/// Lookup the password for the given file
/// </summary>
/// <returns></returns>
private string GetPassword () {
Manager manager = new Manager(this.Repository.LocalDirectory);
return PasswordScrambler.Descramble(manager.ReadPassword(this.CvsRoot));
}
/// <summary>
/// Load the root file.
/// </summary>
/// <param name="tagFile"></param>
/// <returns></returns>
public static Tag Load (FileInfo tagFile) {
if (tagFile.Name != Tag.FILE_NAME) {
throw new ArgumentException(string.Format("Not a valid Tag file, {0}",
tagFile.FullName));
}
Manager manager = new Manager(tagFile.DirectoryName);
return manager.FetchTag(tagFile.DirectoryName);
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
ICSharpCode.SharpCvsLib.Commands.CommitCommand2 commitCommand;
try {
this.ParseOptions(this.unparsedOptions);
string cvsFolder = Path.Combine(Environment.CurrentDirectory, "CVS");
// set properties before creation of CommitCommand2
// Open the Repository file in the CVS directory
Manager manager = new Manager(cvsFolder);
Repository repository = null;
Root root = null;
try {
repository = manager.FetchRepository(cvsFolder);
} catch (CvsFileNotFoundException e) {
ConsoleMain.ExitProgram("Not a valid cvs repository.", e);
}
try {
root = manager.FetchRoot(cvsFolder);
if (null == this.cvsRoot) {
this.cvsRoot = new CvsRoot(root.FileContents);
}
} catch (CvsFileNotFoundException e) {
ConsoleMain.ExitProgram("Not a valid cvs repository.", e);
}
// If this fails error out and the user
// is not in a CVS repository directory tree.
CurrentWorkingDirectory = new WorkingDirectory( this.cvsRoot,
cvsFolder, repository.FileContents);
if (revision != null) {
this.CurrentWorkingDirectory.Revision = revision;
}
ArrayList files = new ArrayList();
if (fileNames == null || fileNames == string.Empty) {
this.GetFilesRecursive((new DirectoryInfo(cvsFolder)).Parent, files);
} else {
DirectoryInfo cvsFolderInfo = new DirectoryInfo(cvsFolder);
files = new ArrayList(cvsFolderInfo.GetFiles(fileNames));
}
CurrentWorkingDirectory.Folders = GetFoldersToCommit(files);
// Create new CommitCommand2 object
commitCommand = new ICSharpCode.SharpCvsLib.Commands.CommitCommand2(
this.CurrentWorkingDirectory );
// set public properties on the commit command
if (message != null) {
commitCommand.LogMessage = message;
}
return commitCommand;
} catch (CvsFileNotFoundException e) {
ConsoleMain.ExitProgram(string.Format("No CVS folder found in path {0}",
Environment.CurrentDirectory), e);
return null;
} catch (Exception e) {
LOGGER.Error (e);
throw e;
}
}
/// <summary>
/// Public constructor.
/// </summary>
/// <param name="cvsroot">The cvs root string, contains information
/// about the connection and path on the cvs server.</param>
/// <param name="localdirectory">The local base directory to check the
/// module out in.</param>
/// <param name="moduleName">The name of the module. This is
/// appended to the base localdirectory to check the sources out into.</param>
public WorkingDirectory( CvsRoot cvsroot,
string localdirectory,
string moduleName) {
this.repositoryname = moduleName;
this.cvsroot = cvsroot;
this.localDir = new DirectoryInfo(localdirectory);
this.manager = new Manager(this.WorkingPath);
}
/// <summary>
/// Produce the report
/// Alternate interface for when we are given a server cooection
/// This is needed for the SharpCvsLib command line client
/// </summary>
public LogReport Run(ICommandConnection connection)
{
// read Root and Repository from local directory
if (null == this.cvsRoot) {
Manager manager = new Manager(localDirectory);
Root root = (Root)manager.FetchSingle (localDirectory,
Factory.FileType.Root);
this.cvsRoot = new CvsRoot(root.FileContents);
}
if (null == workingDirectory) {
Manager manager = new Manager(localDirectory);
Repository repository = (Repository)manager.FetchSingle (localDirectory,
Factory.FileType.Repository);
this.workingDirectory = new WorkingDirectory(cvsRoot,
localDirectory,
repository.FileContents);
}
ILogCommand command;
// Recursively add all cvs folders/files under the localDirectory
System.Console.WriteLine("GNE workingDirectory.WorkingPath = {0}", workingDirectory.WorkingPath);
System.Console.WriteLine("GNE localDirectory: {0}", localDirectory);
// if (Directory.Exists(workingDirectory.WorkingPath)) {
if (Directory.Exists(localDirectory) && File.Exists(Path.Combine(localDirectory, "Repository"))) {
workingDirectory.FoldersToUpdate = FetchFiles(localDirectory);
command =
new LogCommand(workingDirectory, this.workingDirectory.ModuleName, null);
} else {
command =
// GNE - this wont compile new LogCommand(workingDirectory, this.workingDirectory.ModuleName);
new RLogCommand(workingDirectory, this.workingDirectory.ModuleName);
}
// add any date restrictions
if (hasStartDate && hasEndDate) {
command.AddInclusiveDateRange(startDate, endDate);
} else if (hasStartDate) {
command.AddInclusiveDateStart(startDate);
} else if (hasEndDate) {
command.AddInclusiveDateEnd(endDate);
}
// Initialse state machine
curLogReport = new LogReport(); // this is what we are going to return to the caller
curLogFile = new LogFile(this.cvsRoot);
curLogRevision = new LogRevision();
logState = LogState.WANT_FILE_HEADER_START;
if (connection.GetType() == typeof(CVSServerConnection)) {
CVSServerConnection cvsServerConnection = (CVSServerConnection)connection;
cvsServerConnection.MessageEvent.MessageEvent += new EncodedMessage.MessageHandler(OnMessage);
}
command.Execute(connection);
// return curLogReport but clear our reference to it
LogReport report = curLogReport;
curLogReport = null;
return report;
}
/// <summary>
/// Produce the report
/// </summary>
public LogReport Run(string password)
{
// read Root and Repository from local directory
if (null == this.cvsRoot) {
Manager manager = new Manager(localDirectory);
Root root = (Root)manager.FetchSingle (localDirectory,
Factory.FileType.Root);
cvsRoot = new CvsRoot(root.FileContents);
}
if (null == this.workingDirectory) {
workingDirectory = new WorkingDirectory(cvsRoot,
localDirectory,
module);
}
// Get a connection
CVSServerConnection connection = new CVSServerConnection();
connection.Connect(workingDirectory, password);
return Run(connection);
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
ICSharpCode.SharpCvsLib.Commands.ImportModuleCommand importCommand;
try {
this.ParseOptions(this.unparsedOptions);
CurrentWorkingDirectory = new WorkingDirectory( this.cvsRoot,
Environment.CurrentDirectory, this.repository);
Manager manager = new Manager(Environment.CurrentDirectory);
DirectoryInfo importDir = new DirectoryInfo(Environment.CurrentDirectory);
if (!importDir.Exists) {
ConsoleMain.ExitProgram("Import directory does not exist.");
}
CurrentWorkingDirectory.Folders =
manager.FetchFilesToAdd(importDir.FullName);
importCommand =
new ICSharpCode.SharpCvsLib.Commands.ImportModuleCommand(
CurrentWorkingDirectory, this.message);
importCommand.VendorString = this.vendor;
importCommand.ReleaseString = this.release;
importCommand.LogMessage = this.message;
// importCommand.Repository = this.repository;
}
catch (Exception e) {
LOGGER.Error (e);
throw e;
}
return importCommand;
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
DirectoryInfo dir =
new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "CVS"));
UpdateCommand2 updateCommand;
this.ParseOptions(this.unparsedOptions);
// note the sandbox is actually above the CVS directory
Manager manager = new Manager(dir.Parent);
Repository repository = null;
Root root = null;
try {
repository = Repository.Load(dir);
root = Root.Load(dir);
} catch (NullReferenceException) {
this.InvalidRepository();
} catch (CvsFileNotFoundException) {
this.InvalidRepository();
}
if (null == repository) {
this.InvalidRepository();
}
try {
this.cvsRootVar = new CvsRoot(root.FileContents);
} catch (ICSharpCode.SharpCvsLib.Exceptions.CvsRootParseException) {
this.InvalidRepository();
}
// If this fails error out and state the user
// is not in a CVS repository directory tree.
if (localDirectory == null) {
localDirectory = dir.Parent.FullName;
}
CurrentWorkingDirectory = new WorkingDirectory( this.CvsRootVar,
localDirectory, repository.FileContents);
if (revision != null) {
CurrentWorkingDirectory.Revision = revision;
}
if (!date.Equals(DateTime.MinValue)) {
CurrentWorkingDirectory.Date = date;
}
CurrentWorkingDirectory.FoldersToUpdate =
manager.FetchFilesToUpdate (dir.FullName);
// Create new UpdateCommand2 object
updateCommand = new UpdateCommand2(CurrentWorkingDirectory);
return updateCommand;
}
private static WorkingDirectory DeriveWorkingDirectory () {
DirectoryInfo currDir = new DirectoryInfo(Environment.CurrentDirectory);
LOGGER.Info(string.Format("Repository is null, " +
"attempting to derive from current directory: {0}.", currDir.FullName));
Manager manager = new Manager(currDir);
Repository repository =
manager.FetchRepository(currDir.FullName);
Root root =
manager.FetchRoot(currDir.FullName);
CvsRoot cvsRoot = new CvsRoot(root.FileContents);
return
new WorkingDirectory(cvsRoot, Environment.CurrentDirectory, repository.ModuleName);
}
/// <summary>
/// Execute checkout module command.
///
/// taken from: http://www.elegosoft.com/cvs/cvsclient.html
/// add \n
/// Response expected: yes. Add a file or directory. This uses any
/// previous Argument, Directory, Entry, or Modified requests, if they
/// have been sent. The last Directory sent specifies the working
/// directory at the time of the operation. To add a directory, send the
/// directory to be added using Directory and Argument requests.
///
/// </summary>
/// <example>
///
/// C: Root /u/cvsroot
/// . . .
/// C: Argument nsdir
/// C: Directory nsdir
/// C: /u/cvsroot/1dir/nsdir
/// C: Directory .
/// C: /u/cvsroot/1dir
/// C: add
/// S: M Directory /u/cvsroot/1dir/nsdir added to the repository
/// S: ok
///
/// You will notice that the server does not signal to the client in any
/// particular way that the directory has been successfully added. The client
/// is supposed to just assume that the directory has been added and update
/// its records accordingly. Note also that adding a directory is immediate;
/// it does not wait until a ci request as files do. To add a file, send the
/// file to be added using a Modified request. For example:
///
/// C: Argument nfile
/// C: Directory .
/// C: /u/cvsroot/1dir
/// C: Modified nfile
/// C: u=rw,g=r,o=r
/// C: 6
/// C: hello
/// C: add
/// S: E cvs server: scheduling file `nfile' for addition
/// S: Mode u=rw,g=r,o=r
/// S: Checked-in ./
/// S: /u/cvsroot/1dir/nfile
/// S: /nfile/0///
/// S: E cvs server: use 'cvs commit' to add this file permanently
/// S: ok
///
/// Note that the file has not been added to the repository; the only effect
/// of a successful add request, for a file, is to supply the client with a
/// new entries line containing `0' to indicate an added file. In fact, the
/// client probably could perform this operation without contacting the
/// server, although using add does cause the server to perform a few more
/// checks. The client sends a subsequent ci to actually add the file to the
/// repository. Another quirk of the add request is that with CVS 1.9 and
/// older, a pathname specified in an Argument request cannot contain `/'.
/// There is no good reason for this restriction, and in fact more recent
/// CVS servers don't have it. But the way to interoperate with the older
/// servers is to ensure that all Directory requests for add (except those
/// used to add directories, as described above), use `.' for local-directory.
/// Specifying another string for local-directory may not get an error, but
/// it will get you strange Checked-in responses from the buggy servers.
/// </example>
/// <param name="connection">Server connection</param>
public void Execute(ICommandConnection connection) {
connection.SubmitRequest(new ArgumentRequest(ArgumentRequest.Options.DASH));
int loops = 0;
foreach (DictionaryEntry folderEntry in this.Folders) {
LOGGER.Debug("loops=[" + loops++ + "]");
Folder folder = (Folder)folderEntry.Value;
this.SetDirectory (connection, folder);
// send each is-modified request
foreach (DictionaryEntry entryEntry in folder.Entries) {
Entry entry = (Entry)entryEntry.Value;
//connection.SubmitRequest(new IsModifiedRequest(entry.Name));
//String fileName = Path.Combine(entry.Path, entry.Name);
this.SendFileRequest (connection, entry);
// Add the file to the cvs entries file
Manager manager = new Manager(connection.Repository.WorkingPath);
manager.Add(entry);
if (LOGGER.IsDebugEnabled) {
LOGGER.Debug("AddCommand. Entry=[" + entry + "]");
}
}
// send each argument request
foreach (DictionaryEntry entryEntry in folder.Entries) {
Entry entry = (Entry)entryEntry.Value;
connection.SubmitRequest(new ArgumentRequest(entry.Name));
//String fileName = Path.Combine(entry.Path, entry.Name);
//this.SendFileRequest (connection, entry);
// Add the file to the cvs entries file
Manager manager = new Manager(connection.Repository.WorkingPath);
manager.Add(entry);
if (LOGGER.IsDebugEnabled) {
LOGGER.Debug("AddCommand. Entry=[" + entry + "]");
Entries entries = manager.FetchEntries(entry.FullPath);
foreach (DictionaryEntry dicEntry in entries) {
LOGGER.Debug("entry=[" + dicEntry.Value + "]");
}
}
}
}
connection.SubmitRequest(new AddRequest());
}
private void FetchFilesRecursive(ArrayList folders, string localDirectory)
{
String modulePath = localDirectory;
Manager manager = new Manager(modulePath);
Folder folder = new Folder ();
folder.Repository = (Repository)manager.FetchSingle (modulePath,
Factory.FileType.Repository);
Entries entries1= manager.FetchEntries(Path.Combine(modulePath, Entry.FILE_NAME));
foreach (DictionaryEntry dicEntry in entries1) {
Entry entry = (Entry)dicEntry.Value;
if (!entry.IsDirectory) {
if (LOGGER.IsDebugEnabled) {
LOGGER.Debug("Found file=[" + entry.FullPath + "]");
}
folder.Entries.Add (entry.FullPath, entry);
}
}
folders.Add (folder);
foreach (DictionaryEntry dicEntry in entries1) {
Entry entry = (Entry)dicEntry.Value;
if (entry.IsDirectory) {
string childDir = Path.Combine(localDirectory, entry.Name);
if (LOGGER.IsDebugEnabled) {
LOGGER.Debug("Found directory=[" + childDir + "]");
}
FetchFilesRecursive(folders, childDir);
}
}
}
/// <summary>
/// Setup the list of files to be a folder object for the cvs
/// library to process.
/// </summary>
/// <param name="filesCommitted">An array filenames that are to be committed
/// to the cvs repository.</param>
private Folders GetFoldersToCommit (ICollection filesCommitted) {
Folders folders = new Folders();
Manager manager = new Manager(Environment.CurrentDirectory);
foreach (FileInfo file in filesCommitted) {
Folder folder;
if (!folders.Contains(file.DirectoryName)) {
folder = new Folder();
DirectoryInfo cvsFolder =
new DirectoryInfo(Path.Combine(file.DirectoryName, "CVS"));
folder.Repository = Repository.Load(cvsFolder);
folder.Root = Root.Load(cvsFolder);
try {
folder.Tag = Tag.Load(cvsFolder);
} catch (CvsFileNotFoundException) {
// ignore, tag missing normal
}
folder.Entries = Entries.Load(cvsFolder);
folders.Add(file.DirectoryName, folder);
}
}
return folders;
}
/// <summary>
/// Process the login command with cvs library API calls.
/// </summary>
public void Execute () {
if (null != this.CvsRoot && this.CvsRoot.TransportProtocol !=
ICSharpCode.SharpCvsLib.Misc.CvsRoot.ProtocolType.pserver) {
LOGGER.Debug(string.Format("cvs [login aborted]: The :{0}: protocol does not support the login command",
this.CvsRoot.Protocol));
return;
}
CVSServerConnection serverConn =
new CVSServerConnection(CurrentWorkingDirectory);
try {
serverConn.Connect(CurrentWorkingDirectory, password);
} catch (ICSharpCode.SharpCvsLib.Exceptions.AuthenticationException) {
try {
this.password =
PServerProtocol.PromptForPassword(this.CvsRoot.ToString());
if (this.password == null) {
this.password = string.Empty;
}
Manager manager = new Manager(this.workingDirectory.LocalDirectory);
manager.UpdatePassFile(this.password, this.CvsRoot);
serverConn.Connect(CurrentWorkingDirectory, password);
} catch (ICSharpCode.SharpCvsLib.Exceptions.AuthenticationException e) {
ConsoleMain.ExitProgram(e.Message);
}
}
}
private static Entries LoadImpl (FileInfo cvsFile) {
Manager manager = new Manager(cvsFile.DirectoryName);
return manager.FetchEntries(cvsFile.FullName);
}
/// <summary>
/// Load the root file.
/// </summary>
/// <param name="rootFile"></param>
/// <returns></returns>
public static Root Load (FileInfo rootFile) {
if (rootFile.Name != Root.FILE_NAME) {
throw new ArgumentException(string.Format("Not a valid Root file, {0}",
rootFile.FullName));
}
Manager manager = new Manager(rootFile.DirectoryName);
return manager.FetchRoot(rootFile.DirectoryName);
}
/// <summary>
/// Execute checkout module command.
/// </summary>
/// <param name="connection">Server connection</param>
public void Execute(ICommandConnection connection) {
workingDirectory.Clear();
//connection.SubmitRequest(new CaseRequest());
connection.SubmitRequest(new ArgumentRequest(this.Module));
connection.SubmitRequest(new DirectoryRequest(".",
workingDirectory.CvsRoot.CvsRepository +
"/" + workingDirectory.ModuleName));
connection.SubmitRequest(new ExpandModulesRequest());
connection.SubmitRequest(
new ArgumentRequest(ArgumentRequest.Options.MODULE_NAME));
if (null != this.Revision) {
connection.SubmitRequest (new ArgumentRequest (ArgumentRequest.Options.REVISION));
connection.SubmitRequest(new ArgumentRequest(this.Revision));
}
if (this._hasDate) {
connection.SubmitRequest (new ArgumentRequest (ArgumentRequest.Options.DATE));
connection.SubmitRequest(new ArgumentRequest(this.DateAsString));
}
if (null != this.OverrideDirectory) {
connection.SubmitRequest (
new ArgumentRequest (ArgumentRequest.Options.OVERRIDE_DIRECTORY));
connection.SubmitRequest (
new ArgumentRequest (this.OverrideDirectory));
}
connection.SubmitRequest(new ArgumentRequest(this.Module));
connection.SubmitRequest(new DirectoryRequest(".",
workingDirectory.CvsRoot.CvsRepository +
"/" + this.Module));
connection.SubmitRequest(new CheckoutRequest());
Manager manager = new Manager (connection.Repository.WorkingPath);
}
