/// <summary>
/// Populate this container with AcStream objects as per constructor parameters.
/// AcStream objects are instantiated during AcDepot and AcDepots construction.
/// This function is called internally and not by user code.
/// </summary>
/// <param name="depot">The depot for which streams will be created.</param>
/// <param name="listfile">List file <tt>\%APPDATA\%\\AcTools\\<prog_name\>\\<depot_name\>.streams</tt> for the
/// <a href="https://www.microfocus.com/documentation/accurev/72/WebHelp/wwhelp/wwhimpl/js/html/wwhelp.htm#href=AccuRev_User_CLI/cli_ref_show.html">show -l <list-file> streams</a>
/// command if found, otherwise \e null.<br>
/// Example: <tt>"C:\Users\barnyrd\AppData\Roaming\AcTools\FooApp\NEPTUNE.streams"</tt>.</param>
/// <returns>\e true if initialization succeeded, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on failure
/// to handle a range of exceptions.</exception>
/*! \sa [AcStreams constructor](@ref AcUtils#AcStreams#AcStreams) */
/*! \show_ <tt>show \<-fxig|-fxg\> -p \<depot\> [-l listfile] streams</tt> */
/*! \accunote_ The following XML attributes from <tt>show -fx -p \<depot\> streams</tt> may exist depending on the version of AccuRev in use.
* They are used internally by AccuRev and are not intended for customer usage. Micro Focus incident #3132463.
* - \e eventStream: Efficient way to determine if the server process needs to fire the event trigger processing.
* - \e eventStreamHWM: Used by GitCentric to track the high watermark for synchronization.
* - \e hasProperties: Efficient way for the GUI to determine if the property icon is displayed in the StreamBrowser. */
internal async Task <bool> initAsync(AcDepot depot, string listfile = null)
{
bool ret = false; // assume failure
try
{
AcResult result = await AcCommand.runAsync($@"show {(_includeHidden ? "-fxig" : "-fxg")} -p ""{depot}""" +
$@"{((listfile == null) ? String.Empty : "-l " + "" + listfile + "")} streams")
.ConfigureAwait(false);
if (result != null && result.RetVal == 0)
{
XElement xml = XElement.Parse(result.CmdResult);
IEnumerable <XElement> filter = null;
if (_dynamicOnly)
{
filter = from s in xml.Elements("stream")
where (bool)s.Attribute("isDynamic") == true select s;
}
else
{
filter = from s in xml.Elements("stream") select s;
}
foreach (XElement e in filter)
{
AcStream stream = new AcStream();
stream.Name = (string)e.Attribute("name");
stream.ID = (int)e.Attribute("streamNumber");
stream.BasisName = (string)e.Attribute("basis") ?? String.Empty;
stream.BasisID = (int?)e.Attribute("basisStreamNumber") ?? -1;
stream.Depot = depot;
stream.IsDynamic = (bool)e.Attribute("isDynamic");
string type = (string)e.Attribute("type");
stream.Type = (StreamType)Enum.Parse(typeof(StreamType), type);
// attribute "time" only exists for snapshot streams (creation date) or when a dynamic stream has a time basis
stream.Time = e.acxTime("time"); // time basis
stream.StartTime = (DateTime)e.acxTime("startTime");
// hidden attribute exists only if the stream is hidden
stream.Hidden = (e.Attribute("hidden") != null);
stream.HasDefaultGroup = (bool)e.Attribute("hasDefaultGroup");
lock (_locker) { Add(stream); }
}
ret = true; // operation succeeded
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcStreams.initAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcStreams.initAsync{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Use to retrieve the contents of a text file under version control.
/// </summary>
/// <remarks>
/// Puts the content of the specified file in a temporary file. The caller is responsible for deleting the file.
/// </remarks>
/// <param name="eid">The file's element ID.</param>
/// <param name="depot">The depot.</param>
/// <param name="ver_spec">The version specification in the numeric or text format, e.g. \c 32/1 or \c PG_MAINT1_barnyrd\4.</param>
/// <returns>A string initialized to the name of the temporary file with the contents from the
/// AccuRev <tt>cat -v \<ver_spec\> -p \<depot\> -e \<eid\></tt> command on success, otherwise \e null on error.
/// </returns>
/*! \cat_ <tt>cat -v \<ver_spec\> -p \<depot\> -e \<eid\></tt> */
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c cat command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \accunote_ The CLI \c cat command fails on Windows for ptext files larger than 62,733 bytes. Fixed in 6.0. AccuRev defect 28177. */
/*! \accunote_ For the \c name, \c anc and \c cat commands, the validity of the results is guaranteed only if the commands are issued outside a workspace, or in a workspace whose
* backing stream is in the same depot for both workspace and the <tt>-v \<ver_spec\></tt> option used. If issued from a workspace that has a different backing stream than
* the <tt>-v \<ver_spec\></tt>, provided both workspace and ver_spec share the same depot, the command results can be deemed valid. However, if issued from a workspace whose
* backing stream is in a different depot than the <tt>-v \<ver_spec\></tt>, the command results are invalid. Applications should set the default directory to a non-workspace
* location prior to issuing these commands. AccuRev defects 18080, 21469, 1097778. */
public static async Task <string> getCatFileAsync(int eid, AcDepot depot, string ver_spec)
{
string tmpFile = null;
try
{
AcResult r = await AcCommand.runAsync($@"cat -v ""{ver_spec}"" -p ""{depot}"" -e {eid}")
.ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
tmpFile = Path.GetTempFileName();
using (StreamWriter streamWriter = new StreamWriter(tmpFile))
{
streamWriter.Write(r.CmdResult);
}
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcQuery.getCatFileAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx) // IOException, DirectoryNotFoundException, PathTooLongException, SecurityException... others
{
AcDebug.Log($"Exception caught and logged in AcQuery.getCatFileAsync{Environment.NewLine}{ecx.Message}");
}
return(tmpFile);
}
/// <summary>
/// Get the number of active depots in the repository.
/// </summary>
/// <returns>Number of depots or <em>minus one (-1)</em> on error.</returns>
/*! \show_ <tt>show -fx depots</tt> */
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
public static async Task <int> getDepotsCountAsync()
{
int count = -1; // assume failure
try
{
AcResult r = await AcCommand.runAsync("show -fx depots").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement t = XElement.Parse(r.CmdResult);
count = t.Elements("Element").Count();
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcQuery.getDepotsCountAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcQuery.getDepotsCountAsync{Environment.NewLine}{ecx.Message}");
}
return(count);
}
/// <summary>
/// Get the number of dynamic streams in the repository that have a default group.
/// </summary>
/// <returns>Number of dynamic streams with a default group or <em>minus one (-1)</em> on error.</returns>
/*! \show_ <tt>show -fx -d streams</tt> */
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
public static async Task <int> getDynStreamsCountAsync()
{
int count = -1; // assume failure
try
{
AcResult r = await AcCommand.runAsync("show -fx -d streams").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement s = XElement.Parse(r.CmdResult);
count = (from d in s.Elements("stream") where d.Attribute("isDynamic").Value == "true" select d).Count();
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcQuery.getDynStreamsCountAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcQuery.getDynStreamsCountAsync{Environment.NewLine}{ecx.Message}");
}
return(count);
}
/// <summary>
/// When this file exists (created manually), it is used as the \e list-file to populate the depot with select streams.
/// This function is called internally and not by user code.
/// </summary>
/// <remarks>Implemented with <a href="https://www.microfocus.com/documentation/accurev/72/WebHelp/wwhelp/wwhimpl/js/html/wwhelp.htm#href=AccuRev_User_CLI/cli_ref_show.html">show -l <list-file> streams</a>
/// </remarks>
/*! > -l <list-file> Process the streams listed in the specified file. The file must be text only, containing one stream name or number per line. Extra whitespace is not allowed; make sure there are no empty lines and no leading or trailing whitespace around the filenames. There is no provision for comment lines in a list-file. This option can also be used with one of -1 ("dash-one"), -r, or -R. You cannot also specify streams using the -s option. */
/// <returns>Full path of the list file <tt>\%APPDATA\%\\AcTools\\<prog_name\>\\<depot_name\>.streams</tt> if found, otherwise \e null.<br>
/// Example: <tt>"C:\Users\barnyrd\AppData\Roaming\AcTools\FooApp\NEPTUNE.streams"</tt>
/// </returns>
/// <exception cref="Exception">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on failure to handle a range of exceptions.</exception>
/*! \code
* list-file content:
* NEPTUNE_DEV3
* NEPTUNE_MAINT2
* ...
* AcDepot depot = new AcDepot("NEPTUNE"); // two-part object construction
* if (!(await depot.initAsync())) return false; // operation failed, check log file
* foreach (AcStream stream in depot.Streams.OrderBy(n => n))
* Console.WriteLine(stream.ToString("lv") + Environment.NewLine);
* ...
* NEPTUNE_DEV3 (10) {normal}
* Basis: NEPTUNE_UAT (8)
* Depot: NEPTUNE, Hidden: False, HasDefaultGroup: True
*
* NEPTUNE_MAINT2 (6) {normal}
* Basis: NEPTUNE_MAINT (4)
* Depot: NEPTUNE, Hidden: False, HasDefaultGroup: False
* \endcode */
internal string listFile()
{
string listfile = null;
try
{
string appdata = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
string actools = Path.Combine(appdata, "AcTools");
string exeroot = String.Empty;
using (Process currentProcess = Process.GetCurrentProcess())
{
ProcessModule pm = currentProcess.MainModule;
exeroot = Path.GetFileNameWithoutExtension(pm.ModuleName);
}
string progfolder = Path.Combine(actools, exeroot);
string temp = Path.Combine(progfolder, Name);
string file = Path.ChangeExtension(temp, "streams");
if (File.Exists(file))
{
listfile = file;
}
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcDepot.listFile{Environment.NewLine}{ecx.Message}");
}
return(listfile);
}
/// <summary>
/// Get the depot-relative path for the element in \e stream with \e EID.
/// Also returns the element's parent folder EID (folder where the element resides).
/// </summary>
/// <param name="stream">Name of the stream where the element resides.</param>
/// <param name="EID">The element ID of the element on which to query.</param>
/// <returns>An tuple initialized as <em>{depot-relative path, parent EID}</em> on success, otherwise \e null.</returns>
/*! \name_ <tt>name -v \<stream\> -fx -e \<EID\></tt> */
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c name command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \code
* accurev name -v MARS_MAINT2 -fx -e 13763
* <?xml version="1.0" encoding="utf-8"?>
* <AcResponse
* Command="name"
* TaskId="51498">
* <element
* location="\.\scripts\build.xml"
* parent_id="12269"/>
* </AcResponse>
* \endcode */
/*! \accunote_ For the \c name, \c anc and \c cat commands, the validity of the results is guaranteed only if the commands are issued outside a workspace, or in a workspace whose
* backing stream is in the same depot for both workspace and the <tt>-v \<ver_spec\></tt> option used. If issued from a workspace that has a different backing stream than
* the <tt>-v \<ver_spec\></tt>, provided both workspace and ver_spec share the same depot, the command results can be deemed valid. However, if issued from a workspace whose
* backing stream is in a different depot than the <tt>-v \<ver_spec\></tt>, the command results are invalid. Applications should set the default directory to a non-workspace
* location prior to issuing these commands. AccuRev defects 18080, 21469, 1097778. */
public static async Task <Tuple <string, int> > getElementNameAsync(string stream, int EID)
{
Tuple <string, int> ret = null; // depot-relative path, parent folder EID
try
{
AcResult r = await AcCommand.runAsync($@"name -v ""{stream}"" -fx -e {EID}").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement xml = XElement.Parse(r.CmdResult);
string location = (string)xml.Element("element").Attribute("location");
int parent_id = (int)xml.Element("element").Attribute("parent_id");
ret = Tuple.Create(location, parent_id);
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcQuery.getElementNameAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcQuery.getElementNameAsync{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Convert AcResult.CmdResult XML from \e result into AcWorkspace objects and add them to our container.
/// Filters out workspace/ref trees that are not in the user's default list of depots they can view based on ACL permissions.
/// </summary>
/// <param name="result">Previously initialized AcResult object from AcWorkspaces.getWorkspacesXMLAsync and AcWorkspaces.getReferenceTreesXMLAsync.</param>
/// <param name="depot">Specify a depot to limit the query to workspaces and ref trees in \e depot only, not the users default list of depots.</param>
/// <returns>\e true if object initialization succeeded, \e false otherwise.</returns>
/// <exception cref="Exception">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on failure to handle a range of exceptions.</exception>
private bool storeWSpaces(AcResult result, AcDepot depot = null)
{
bool ret = false; // assume failure
try
{
// filter out workspace/ref trees not in the user's default list
XElement xml = XElement.Parse(result.CmdResult);
IEnumerable <XElement> filter;
if (depot != null)
{
filter = from w in xml.Elements("Element")
join AcDepot d in _depots on
(string) w.Attribute("depot") equals d.Name
where (string)w.Attribute("depot") == depot.Name
select w;
}
else
{
filter = from w in xml.Elements("Element")
join AcDepot d in _depots on
(string) w.Attribute("depot") equals d.Name
select w;
}
foreach (XElement e in filter)
{
AcWorkspace ws = new AcWorkspace();
ws.Name = (string)e.Attribute("Name");
ws.Hidden = (e.Attribute("hidden") != null); // attribute hidden exists only when true
ws.Location = (string)e.Attribute("Loc");
ws.Storage = (string)e.Attribute("Storage");
ws.Host = (string)e.Attribute("Host");
ws.ID = (int)e.Attribute("Stream");
string temp = (string)e.Attribute("depot");
ws.Depot = _depots.getDepot(temp);
ws.TargetLevel = (int)e.Attribute("Target_trans");
ws.UpdateLevel = (int)e.Attribute("Trans");
ws.FileModTime = e.acxTime("fileModTime");
int type = (int)e.Attribute("Type");
ws.Type = (WsType)type;
int eol = (int)e.Attribute("EOL");
ws.EOL = (WsEOL)eol;
ws.Principal.ID = (int)e.Attribute("user_id");
ws.Principal.Name = (string)e.Attribute("user_name");
lock (_locker) { Add(ws); }
}
ret = true; // operation succeeded
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcWorkspaces.storeWSpaces{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Populate this list with elements from the XML emitted by the
/// [stat](https://www.microfocus.com/documentation/accurev/72/WebHelp/wwhelp/wwhimpl/js/html/wwhelp.htm#href=AccuRev_User_CLI/cli_ref_stat.html) command.
/// </summary>
/// <param name="xml">XML from the AccuRev \c stat command.</param>
/// <returns>\e true if parsing was successful, \e false otherwise.</returns>
/// <exception cref="Exception">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on failure to handle a range of exceptions.</exception>
public static bool init(string xml)
{
bool ret = false; // assume failure
try
{
XElement elements = XElement.Parse(xml);
IEnumerable<XElement> query = from e in elements.Elements("element")
where !e.Attribute("status").Value.Contains("no such elem")
select e;
foreach (XElement e in query)
{
Element element = new Element();
element.Status = (string)e.Attribute("status") ?? String.Empty;
element.Location = (string)e.Attribute("location") ?? String.Empty;
string dir = (string)e.Attribute("dir") ?? String.Empty;
element.Folder = String.Equals(dir, "yes");
string exe = (string)e.Attribute("executable") ?? String.Empty;
element.Executable = String.Equals(exe, "yes");
element.EID = (int?)e.Attribute("id") ?? 0;
element.ElementType = e.acxType("elemType");
element.Size = (long?)e.Attribute("size");
element.ModTime = e.acxTime("modTime");
element.HierType = (string)e.Attribute("hierType") ?? String.Empty;
int ival;
string vir = (string)e.Attribute("Virtual") ?? String.Empty;
if (!String.IsNullOrEmpty(vir))
{
string[] arrVir = vir.Split('\\');
if (Int32.TryParse(arrVir[0], NumberStyles.Integer, null, out ival))
element.VirStreamNumber = ival;
if (Int32.TryParse(arrVir[1], NumberStyles.Integer, null, out ival))
element.VirVersionNumber = ival;
}
element.NamedVersion = (string)e.Attribute("namedVersion") ?? String.Empty;
string real = (string)e.Attribute("Real") ?? String.Empty;
if (!String.IsNullOrEmpty(real))
{
string[] arrReal = real.Split('\\');
if (Int32.TryParse(arrReal[0], NumberStyles.Integer, null, out ival))
element.RealStreamNumber = ival;
if (Int32.TryParse(arrReal[1], NumberStyles.Integer, null, out ival))
element.RealVersionNumber = ival;
}
element.LapStream = (string)e.Attribute("overlapStream") ?? String.Empty;
element.TimeBasedStream = (string)e.Attribute("timeBasisStream") ?? String.Empty;
lock (_locker) { _elements.Add(element); }
}
ret = true; // operation succeeded
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in Stat.init{Environment.NewLine}{ecx.Message}");
}
return ret;
}
/// <summary>
/// Populate this container with AcProperty objects for all streams in \e depot or just \e stream in \e depot.
/// Optionally include hidden (removed) streams.
/// </summary>
/// <param name="depot">The depot to query for properties.</param>
/// <param name="stream">The stream for a specific stream only, otherwise \e null for all streams in \e depot.</param>
/// <param name="includeHidden">\e true to include properties for hidden (removed) streams, \e false otherwise.</param>
/// <returns>\e true if initialization succeeded, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging) in
/// <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c getproperty command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \sa [AcProperties constructor](@ref AcUtils#AcProperties#AcProperties), initAsync(string, bool) */
/*! \getproperty_ <tt>getproperty \<-fx | -fix\> \<-s \<stream\> | -ks -p \<depot\>\></tt> */
public async Task <bool> initAsync(AcDepot depot, AcStream stream = null, bool includeHidden = false)
{
bool ret = false; // assume failure
try
{
string cmd = null;
if (stream != null && includeHidden)
{
cmd = $@"getproperty -fix -s ""{stream}""";
}
else if (stream != null && !includeHidden)
{
cmd = $@"getproperty -fx -s ""{stream}""";
}
else if (includeHidden) // request is for all streams in depot including those that are hidden
{
cmd = $@"getproperty -fix -ks -p ""{depot}""";
}
else // request is for all streams except those that are hidden
{
cmd = $@"getproperty -fx -ks -p ""{depot}""";
}
AcResult r = await AcCommand.runAsync(cmd).ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement xml = XElement.Parse(r.CmdResult);
foreach (XElement e in xml.Elements("property"))
{
AcProperty property = new AcProperty();
string kind = (string)e.Attribute("kind");
property.Kind = (PropKind)Enum.Parse(typeof(PropKind), kind);
property.Depot = depot;
property.ID = (int)e.Attribute("streamNumber");
property.Name = (string)e.Attribute("streamName");
property.PropName = (string)e.Attribute("propertyName");
property.PropValue = (string)e;
lock (_locker) { Add(property); }
}
ret = true; // operation succeeded
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcProperties.initAsync(AcDepot, AcStream, bool){Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcProperties.initAsync(AcDepot, AcStream, bool){Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Populate this container with AcUser objects as per [constructor parameters](@ref AcUtils#AcUsers#AcUsers).
/// </summary>
/// <param name="progress">Optionally report progress back to the caller.</param>
/// <returns>\e true if list initialization succeeded, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging) in
/// <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \show_ <tt>show \<-fx | -fix\> users</tt> */
public async Task <bool> initAsync(IProgress <int> progress = null)
{
bool ret = false; // assume failure
try
{
AcResult r = await AcCommand.runAsync($"show {(_includeDeactivated ? "-fix" : "-fx")} users")
.ConfigureAwait(false);
if (r != null && r.RetVal == 0) // if command succeeded
{
XElement xml = XElement.Parse(r.CmdResult);
IEnumerable <XElement> query = from element in xml.Elements("Element") select element;
List <Task <bool> > tasks = new List <Task <bool> >(query.Count());
Func <Task <bool>, bool> cf = t =>
{
bool res = t.Result;
if (res && progress != null)
{
progress.Report(Interlocked.Increment(ref _counter));
}
return(res);
};
foreach (XElement e in query)
{
string name = (string)e.Attribute("Name");
int id = (int)e.Attribute("Number");
// XML attribute isActive exists only if the user is inactive, otherwise it isn't there
PrinStatus status = (e.Attribute("isActive") == null) ? PrinStatus.Active : PrinStatus.Inactive;
AcUser user = new AcUser(id, name, status);
lock (_locker) { Add(user); }
Task <bool> t = initUserPropsAsync(user).ContinueWith(cf);
tasks.Add(t);
}
bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
ret = (arr != null && arr.All(n => n == true));
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcUsers.initAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcUsers.initAsync{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Determines if \e user is a member of \e group by way of direct or indirect (implicit) membership,
/// e.g. Mary is implicitly a member of groupA because she's a member of groupB which is a member of groupA.
/// </summary>
/// <param name="user">AccuRev principal name of \e user.</param>
/// <param name="group">AccuRev principal name of \e group.</param>
/// <returns>\e true if \e user is a member of \e group or \e false if not a member.</returns>
/// <exception cref="AcUtilsException">thrown on AccuRev program invocation failure for the \c ismember command.</exception>
/// <exception cref="Win32Exception">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on error spawning the AccuRev process that runs the command.</exception>
/// <exception cref="InvalidOperationException">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \sa [AcGroups.getMembers](@ref AcUtils#AcGroups#getMembers), [AcUser.getGroups](@ref AcUtils#AcUser#getGroups) */
/*! \ismember_ <tt>ismember \<user\> \<group\></tt> */
/*! \note The AccuRev program return value for \c ismember is <em>zero (0)</em> whether the user is a member of the group or not.
* It is the command's output (STDOUT) that is \"<b>1</b>\" (\e one) if the user is a member of the group or \"<b>0</b>\" (\e zero) if not a member. */
/*! \warning The server admin trigger must return <em>zero (0)</em> for \c ismember to prevent an endless recursive loop. */
public static bool isMember(string user, string group)
{
bool ret = false; // assume not a member
string command = String.Format(@"ismember ""{0}"" ""{1}""", user, group);
try
{
using (Process process = new Process())
{
process.StartInfo.FileName = "accurev";
process.StartInfo.Arguments = command;
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardInput = true; // fix for AccuRev defect 29059
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.StandardOutputEncoding = Encoding.UTF8;
process.StartInfo.StandardErrorEncoding = Encoding.UTF8;
process.ErrorDataReceived += new DataReceivedEventHandler(AcDebug.errorDataHandler);
process.Start();
process.BeginErrorReadLine();
string result = process.StandardOutput.ReadToEnd();
process.WaitForExit();
if (process.ExitCode == 0)
{
if (result.Length > 0 && result[0] == '1')
{
ret = true;
}
}
else
{
string err = String.Format("AccuRev program return: {0}{1}{2}", process.ExitCode, Environment.NewLine, "accurev " + command);
throw new AcUtilsException(err); // let calling method handle
}
}
}
catch (Win32Exception ecx)
{
string msg = String.Format("Win32Exception caught and logged in AcGroups.isMember{0}{1}{0}accurev {2}{0}errorcode: {3}{0}native errorcode: {4}{0}{5}{0}{6}{0}{7}",
Environment.NewLine, ecx.Message, command, ecx.ErrorCode.ToString(), ecx.NativeErrorCode.ToString(), ecx.StackTrace, ecx.Source, ecx.GetBaseException().Message);
AcDebug.Log(msg);
}
catch (InvalidOperationException ecx)
{
string msg = String.Format("InvalidOperationException caught and logged in AcGroups.isMember{0}{1}{0}accurev {2}",
Environment.NewLine, ecx.Message, command);
AcDebug.Log(msg);
}
return(ret);
}
/// <summary>
/// Populate this container with AcRule objects for all streams in \e streamsCol
/// as per [constructor parameter](@ref AcUtils#AcRules#AcRules) \e explicitOnly.
/// </summary>
/// <param name="streamsCol">The list of streams to query for rules.</param>
/// <param name="progress">Optionally report progress back to the caller.</param>
/// <returns>\e true if no failure occurred and list was initialized successfully, \e false otherwise.</returns>
/// <exception cref="Exception">caught and [logged](@ref AcUtils#AcDebug#initAcLogging) in
/// <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on failure to handle a range of exceptions.</exception>
public async Task <bool> initAsync(StreamsCollection streamsCol, IProgress <int> progress = null)
{
bool ret = false; // assume failure
try
{
AcDepots depots = new AcDepots();
if (!(await depots.initAsync(null, progress).ConfigureAwait(false)))
{
return(false);
}
int num = 0; // get number of streams for tasks list
foreach (AcDepot depot in depots)
{
IEnumerable <AcStream> filter = depot.Streams.Where(s =>
streamsCol.OfType <StreamElement>().Any(se => s.Name == se.Stream));
num += filter.Count();
}
List <Task <bool> > tasks = new List <Task <bool> >(num);
Func <Task <bool>, bool> cf = t =>
{
bool res = t.Result;
if (res && progress != null)
{
progress.Report(Interlocked.Increment(ref _counter));
}
return(res);
};
foreach (AcDepot depot in depots)
{
IEnumerable <AcStream> filter = depot.Streams.Where(s =>
streamsCol.OfType <StreamElement>().Any(se => s.Name == se.Stream));
foreach (AcStream stream in filter)
{
Task <bool> t = initAsync(stream).ContinueWith(cf);
tasks.Add(t);
}
}
bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
ret = (arr != null && arr.All(n => n == true)); // true if all succeeded
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcRules.initAsync(StreamsCollection){Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Initialize this AcDepot object with data from AccuRev as per constructor parameter's depot \e name or \e ID number.
/// </summary>
/// <returns>\e true if initialization succeeded, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \sa AcDepot(string, bool, bool), AcDepot(int, bool, bool), [AcDepots constructor](@ref AcUtils#AcDepots#AcDepots) */
/*! \show_ <tt>show -fx depots</tt> */
public async Task <bool> initAsync()
{
bool ret = false; // assume failure
try
{
AcResult r = await AcCommand.runAsync("show -fx depots").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement xml = XElement.Parse(r.CmdResult);
IEnumerable <XElement> filter = null;
if (_id > 0)
{
filter = from element in xml.Elements("Element")
where (int)element.Attribute("Number") == _id
select element;
}
else
{
filter = from element in xml.Elements("Element")
where (string)element.Attribute("Name") == _name
select element;
}
XElement e = filter.SingleOrDefault();
if (e != null)
{
ID = (int)e.Attribute("Number");
Name = (string)e.Attribute("Name");
Slice = (int)e.Attribute("Slice");
ExclusiveLocking = (bool)e.Attribute("exclusiveLocking");
string temp = (string)e.Attribute("case");
Case = (CaseSensitivity)Enum.Parse(typeof(CaseSensitivity), temp);
_streams = new AcStreams(_dynamicOnly, _includeHidden);
ret = await _streams.initAsync(this, listFile()).ConfigureAwait(false);
}
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcDepot.initAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcDepot.initAsync{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Centralized error handler.
/// </summary>
/// <param name="sendingProcess">The spawned process.</param>
/// <param name="errLine">The error message sent to this method by the spawned process.</param>
public static void errorDataHandler(object sendingProcess, DataReceivedEventArgs errLine)
{
if (!String.IsNullOrEmpty(errLine.Data))
{
string errline = errLine.Data.Trim();
// Report error if something other than "not in a directory associated with a workspace"
if (errline.Length > 0 &&
!String.Equals("You are not in a directory associated with a workspace", errline))
{
AcDebug.Log(errline);
}
}
}
/// <summary>
/// Determines if the current user is logged into AccuRev and, if so, retrieves their principal name.
/// </summary>
/// <remarks>Implemented by extracting the user's principal name or string <b>\"(not logged in)\"</b> from the \c info command results.</remarks>
/// <returns>A string initialized to the name of the principal logged into AccuRev or \e null if not logged in.</returns>
/*! \info_ \c info */
/*! \accunote_ To support GUIs logging into replicas, get host and port from \c info command
* (instead of from XML \<serverInfo\> results, which are not correct for replica)
* to use in titlebar, preferences.xml, and MQTT messages. 35934/17776122 (35921/17776020) */
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c info command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \note The user must have <tt>AccuRev\\bin</tt> in their \e Path environment variable to run
* AccuRev commands issued by the AcUtils library. Since this method is often the first function called
* by a client application (in this case \c info), a failure here usually means this entry is missing.*/
public static async Task <string> getPrincipalAsync()
{
string prncpl = null;
try
{
AcResult r = await AcCommand.runAsync("info").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
using (StringReader reader = new StringReader(r.CmdResult))
{
bool? login = null; // don't know yet
string line;
char[] sep = new char[] { ':' };
while ((line = reader.ReadLine()) != null && login == null)
{
string[] arr = line.Split(sep); // "Principal: barnyrd"
if (arr.Length == 2)
{
if (String.Equals(arr[0], "Principal"))
{
string temp = arr[1].Replace("\t", "");
if (String.Equals(temp, "(not logged in)"))
{
login = false;
}
else
{
prncpl = temp; // AccuRev principal name
login = true;
}
}
}
}
}
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcQuery.getPrincipalAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcQuery.getPrincipalAsync{Environment.NewLine}{ecx.Message}");
}
return(prncpl); // principal name or null if not logged in
}
/// <summary>
/// Get the depot's stream and workspace (optional) hierarchy relationship data from AccuRev.
/// This method is called internally and not by user code.
/// </summary>
/// <param name="includeWSpaces">\e true to include workspaces in the list.</param>
/// <returns>Fully initialized [MultiValueDictionary](https://www.nuget.org/packages/Microsoft.Experimental.Collections)
/// object for the depot with [parent(key),children(values)] basis/stream ID's if no exception was thrown
/// and the operation succeeded, otherwise \e null on error.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \pre Using \e includeWSpaces to include workspaces in the list requires that all stream types be specified at AcDepot
* object creation as per the \e dynamicOnly=false (default) constructor parameter. */
/*! \show_ <tt>show -p \<depot\> [-fix | -fx] -s 1 -r streams</tt> */
/*! \attention This method requires that you deploy
* <a href="https://www.nuget.org/packages/Microsoft.Experimental.Collections">Microsoft.Experimental.Collections.dll</a> with your application. */
private async Task <MultiValueDictionary <int, int> > getHierarchyAsync(bool includeWSpaces = false)
{
MultiValueDictionary <int, int> hierarchy = null;
try
{
AcResult r = await AcCommand.runAsync($@"show -p ""{this}"" {(_includeHidden ? " -fix" : " -fx")} -s 1 -r streams")
.ConfigureAwait(false);
if (r != null && r.RetVal == 0) // if command succeeded
{
XElement xml = XElement.Parse(r.CmdResult);
IEnumerable <XElement> filter;
if (includeWSpaces)
{
filter = from s in xml.Elements("stream")
select s;
}
else
{
filter = from s in xml.Elements("stream")
where (string)s.Attribute("type") != "workspace" // all except workspaces
select s;
}
int capacity = filter.Count();
hierarchy = new MultiValueDictionary <int, int>(capacity);
foreach (XElement e in filter)
{
// XML attribute basisStreamNumber does not exist in the case of root streams
int parent = (int?)e.Attribute("basisStreamNumber") ?? -1;
int child = (int)e.Attribute("streamNumber");
hierarchy.Add(parent, child);
}
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcDepot.getHierarchyAsync{Environment.NewLine}{ecx.Message}");
hierarchy = null;
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcDepot.getHierarchyAsync{Environment.NewLine}{ecx.Message}");
hierarchy = null;
}
return(hierarchy);
}
/// <summary>
/// Retrieves the AccuRev program major, minor and patch version numbers.
/// </summary>
/// <returns>An array initialized as <em>int[]={major, minor, patch}</em> on success, otherwise \e null on error.</returns>
/*! \xml_ <tt>xml -l \<xmlfile\></tt> */
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c xml command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \code
* <?xml version="1.0" encoding="utf-8"?>
* <serverInfo>
* <serverVersion
* major="5"
* minor="6"
* patch="0"/>
* <serverHostPort>machine_name_omitted:5050</serverHostPort>
* </serverInfo>
* \endcode */
public static async Task <int[]> getAccuRevVersionAsync()
{
int[] arr = null; // major, minor, patch
string tempFile = null;
try
{
tempFile = Path.GetTempFileName(); // the AccuRev xml command requires a file as its argument
using (StreamWriter streamWriter = new StreamWriter(tempFile))
{
streamWriter.Write(@"<serverInfo/>"); // set up the query
}
AcResult r = await AcCommand.runAsync($@"xml -l ""{tempFile}""").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
using (StringReader reader = new StringReader(r.CmdResult))
{
XElement doc = XElement.Load(reader);
XElement sv = doc.Element("serverVersion");
int major = (int)sv.Attribute("major");
int minor = (int)sv.Attribute("minor");
int patch = (int)sv.Attribute("patch");
arr = new int[] { major, minor, patch };
}
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcQuery.getAccuRevVersionAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcQuery.getAccuRevVersionAsync{Environment.NewLine}{ecx.Message}");
}
finally
{
if (tempFile != null)
{
File.Delete(tempFile);
}
}
return(arr);
}
/// <summary>
/// Initialize our task scheduler that allows no more than n tasks to execute simultaneously.
/// </summary>
/*! \sa [LimitedConcurrencyLevelTaskScheduler](@ref System#Threading#Tasks#Schedulers#LimitedConcurrencyLevelTaskScheduler),
* <a href="https://blogs.msdn.microsoft.com/pfxteam/2010/04/09/parallelextensionsextras-tour-7-additional-taskschedulers/">ParallelExtensionsExtras Tour - #7 - Additional TaskSchedulers</a> */
static AcCommand()
{
try
{
string maxconcurrent = Environment.GetEnvironmentVariable("ACUTILS_MAXCONCURRENT");
int max = (maxconcurrent != null) ? Int32.Parse(maxconcurrent) : MaxConcurrencyDefault;
LimitedConcurrencyLevelTaskScheduler ts = new LimitedConcurrencyLevelTaskScheduler(max);
_taskFactory = new TaskFactory(ts);
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcCommand constructor{Environment.NewLine}{ecx.Message}");
}
}
/// <summary>
/// Populate this container with AcRule objects for all streams in \e depotsCol
/// as per [constructor parameter](@ref AcUtils#AcRules#AcRules) \e explicitOnly.
/// </summary>
/// <param name="depotsCol">The list of depots to query for rules.</param>
/// <param name="progress">Optionally report progress back to the caller.</param>
/// <returns>\e true if no failure occurred and list was initialized successfully, \e false otherwise.</returns>
/// <exception cref="Exception">caught and [logged](@ref AcUtils#AcDebug#initAcLogging) in
/// <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on failure to handle a range of exceptions.</exception>
public async Task <bool> initAsync(DepotsCollection depotsCol, IProgress <int> progress = null)
{
bool ret = false; // assume failure
try
{
AcDepots depots = new AcDepots();
if (!(await depots.initAsync(depotsCol, progress).ConfigureAwait(false)))
{
return(false);
}
int num = 0; // get number of streams for tasks list
foreach (AcDepot depot in depots)
{
num += depot.Streams.Count();
}
List <Task <bool> > tasks = new List <Task <bool> >(num);
Func <Task <bool>, bool> cf = t =>
{
bool res = t.Result;
if (res && progress != null)
{
progress.Report(Interlocked.Increment(ref _counter));
}
return(res);
};
foreach (AcStream stream in depots.SelectMany(d => d.Streams))
{
Task <bool> t = initAsync(stream).ContinueWith(cf);
tasks.Add(t);
}
bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
ret = (arr != null && arr.All(n => n == true));
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcRules.initAsync(DepotsCollection){Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Populate this container with AcLock objects on streams in \e depots.
/// </summary>
/// <param name="depots">Limit the list of locks to those on streams in \e depots only. Depot names in \e depots
/// must match their respective AccuRev depot name exactly.</param>
/// <returns>\e true if initialization succeeded, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \sa [AcLocks constructor](@ref AcUtils#AcLocks#AcLocks), initAsync(AcDepot), initAsync(StreamsCollection) */
/*! \show_ <tt>show -fx locks</tt> */
public async Task <bool> initAsync(DepotsCollection depots)
{
AcDepots dlist = new AcDepots();
if (!(await dlist.initAsync(depots).ConfigureAwait(false)))
{
return(false);
}
bool ret = false; // assume failure
try
{
AcResult r = await AcCommand.runAsync("show -fx locks").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
bool result = true;
XElement xml = XElement.Parse(r.CmdResult);
for (int ii = 0; ii < dlist.Count && result; ii++)
{
AcDepot depot = dlist[ii];
IEnumerable <XElement> query = from e in xml.Elements("Element")
join AcStream s in depot.Streams on(string) e.Attribute("Name") equals s.Name
select e;
result = initList(query);
}
ret = result;
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcLocks.initAsync(DepotsCollection){Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcLocks.initAsync(DepotsCollection){Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Put a \c lock on \e stream as per lock \e kind.
/// </summary>
/// <param name="stream">Name of stream or workspace to lock.</param>
/// <param name="comment">Comment to be used for the lock.</param>
/// <param name="kind">Type of lock to apply: \e to, \e from, or \e all.</param>
/// <param name="prncpl">AccuRev principal name of user or group in the case of \e to or \e from lock.</param>
/// <param name="onlyexcept">Apply \c lock to \e prncpl only or to all except \e prncpl.</param>
/// <returns>\e true if operation succeeded, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c lock command failure.</exception>
/*! \lock_ <tt>lock -c \<comment\> [-kf [-e|-o prncpl] | -kt [-e|-o prncpl]] \<stream\></tt> */
/*! \accunote_ The CLI \c lock command can be used on a workspace stream but the same cannot be done using the AccuRev GUI client. AccuRev defect 23850. */
public async Task <bool> lockAsync(string stream, string comment, LockKind kind = LockKind.all, AcPrincipal prncpl = null, OnlyExcept onlyexcept = OnlyExcept.Except)
{
bool ret = false; // assume failure
try
{
string cmd = null;
if (kind == LockKind.from)
{
if (prncpl != null)
{
cmd = $@"lock -c ""{comment}"" -kf {((onlyexcept == OnlyExcept.Except) ? "-e" : "-o")} ""{prncpl}"" ""{stream}""";
}
else
{
cmd = $@"lock -c ""{comment}"" -kf ""{stream}"""; // lock 'from' for all
}
}
else if (kind == LockKind.to)
{
if (prncpl != null)
{
cmd = $@"lock -c ""{comment}"" -kt {((onlyexcept == OnlyExcept.Except) ? "-e" : "-o")} ""{prncpl}"" ""{stream}""";
}
else
{
cmd = $@"lock -c ""{comment}"" -kt ""{stream}"""; // lock 'to' for all
}
}
else if (kind == LockKind.all)
{
cmd = $@"lock -c ""{comment}"" ""{stream}"""; // lock 'to and from' for all
}
AcResult r = await AcCommand.runAsync(cmd).ConfigureAwait(false);
ret = (r != null && r.RetVal == 0);
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException in AcLocks.lockAsync caught and logged.{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
//@}
#endregion
/// <summary>
/// Get the list of workspaces in XML for all or the current user and optionally include
/// inactive workspaces as per [AcWorkspaces constructor](@ref AcUtils#AcWorkspaces#AcWorkspaces) \e includeHidden parameter.
/// </summary>
/// <returns>AcResult initialized with the \c show command results, otherwise \e null on error.</returns>
/*! \show_ <tt>show \<-fvx | -fvix\> \<-a | \> wspaces</tt> */
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on <tt>show wspaces</tt> command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \sa AcWorkspaces.getReferenceTreesXMLAsync */
private async Task <AcResult> getWorkspacesXMLAsync()
{
AcResult result = null;
try
{
string cmd = null;
// for all below, -v option adds the Loc (location) to output
if (_allWSpaces && _includeHidden)
{
// All workspaces, not just those that belong to the principal. Include deactivated workspaces.
cmd = "show -fvix -a wspaces"; // -a is the only option available for show wspaces
}
else if (_allWSpaces && !_includeHidden)
{
// All workspaces, not just those that belong to the principal. Do not include deactivated workspaces.
cmd = "show -fvx -a wspaces";
}
else if (!_allWSpaces && _includeHidden)
{
// Only those workspaces that belong to the principal. Include deactivated workspaces.
cmd = "show -fvix wspaces";
}
else if (!_allWSpaces && !_includeHidden)
{
// Only those workspaces that belong to the principal. Do not include deactivated workspaces.
cmd = "show -fvx wspaces";
}
result = await AcCommand.runAsync(cmd).ConfigureAwait(false);
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcWorkspaces.getWorkspacesXMLAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcWorkspaces.getWorkspacesXMLAsync{Environment.NewLine}{ecx.Message}");
}
return(result);
}
/// <summary>
/// Populate this container with AcSession objects, the currently active login sessions.
/// </summary>
/// <returns>\e true if no failure occurred and list was initialized successfully, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging) in
/// <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \show_ <tt>show -fx sessions</tt> */
public async Task <bool> initAsync()
{
bool ret = false; // assume failure
try
{
AcResult r = await AcCommand.runAsync("show -fx sessions").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement xml = XElement.Parse(r.CmdResult);
foreach (XElement e in xml.Elements("Element"))
{
AcSession session = new AcSession();
session.Name = (string)e.Attribute("Username");
session.Host = (string)e.Attribute("Host");
string temp = (string)e.Attribute("Duration");
if (!String.Equals(temp, "(timed out)"))
{
double duration = double.Parse(temp);
session.Duration = TimeSpan.FromMinutes(duration);
}
lock (_locker) { Add(session); }
}
ret = true; // operation succeeded
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcSessions.initAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcSessions.initAsync{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Convert an AccuRev date given in Unix time (\e seconds param) to a .NET DateTime in local time.
/// </summary>
/// <param name="seconds">Unix time expressed as the number of seconds since January 1, 1970 UTC.</param>
/// <returns>DateTime object with the converted value or \e null on error or \e seconds equal <em>zero (0)</em>.</returns>
/// <exception cref="ArgumentOutOfRangeException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on failure to convert \e seconds
/// to a date and time value that represents the same moment in time as the Unix time.</exception>
/*! \sa <a href="_latest_promotions_8cs-example.html">LatestPromotions.cs</a> */
public static DateTime?AcDate2DateTime(long seconds)
{
DateTime?dt = null;
try
{
if (seconds > 0)
{
DateTimeOffset dto = DateTimeOffset.FromUnixTimeSeconds(seconds);
dt = dto.DateTime.ToLocalTime();
}
}
catch (ArgumentOutOfRangeException ecx)
{
AcDebug.Log($"ArgumentOutOfRangeException caught and logged in AcDateTime.AcDate2DateTime{Environment.NewLine}{ecx.Message}");
}
return(dt);
}
/// <summary>
/// Populate this container with AcRule objects for \e stream as per
/// [constructor parameter](@ref AcUtils#AcRules#AcRules) \e explicitOnly.
/// </summary>
/// <param name="stream">The stream to query for rules.</param>
/// <returns>\e true if no failure occurred and list was initialized successfully, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging) in
/// <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c lsrules command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \lsrules_ <tt>lsrules -s \<stream\> [-d] -fx</tt> */
/*! \code
* <!-- accurev lsrules -s "PG_DEV1" -fx -->
* <AcResponse
* Command="lscomp"
* TaskId="54394">
* <element
* kind="incl"
* elemType="dir"
* dir="yes" // Not used as its redundant. We use ElementType.Dir instead.
* location="\.\Iconic"
* setInStream="PG_DEV1"
* xlinkToStream="IC_DEV1"
* options="1"/> // Obsolete. Was used for compatibility of rules in version 4.5.3 and earlier. Will always be a value of 1.
* <element
* kind="incl"
* elemType="dir"
* dir="yes"
* location="\.\"
* setInStream="PlayGround"
* options="1"/>
* </AcResponse>
* \endcode */
public async Task <bool> initAsync(AcStream stream)
{
bool ret = false; // assume failure
try
{
AcResult r = await AcCommand.runAsync($@"lsrules -s ""{stream}"" {(_explicitOnly ? "-d" : String.Empty)} -fx")
.ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement xml = XElement.Parse(r.CmdResult);
foreach (XElement e in xml.Elements("element"))
{
AcRule rule = new AcRule();
string kind = (string)e.Attribute("kind");
rule.Kind = (RuleKind)Enum.Parse(typeof(RuleKind), kind);
string type = (string)e.Attribute("elemType");
rule.Type = (ElementType)Enum.Parse(typeof(ElementType), type);
rule.Location = (string)e.Attribute("location");
rule.SetInStream = (string)e.Attribute("setInStream");
rule.XlinkToStream = (string)e.Attribute("xlinkToStream") ?? String.Empty;
lock (_locker) { Add(rule); }
}
ret = true; // operation succeeded
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcRules.initAsync(AcStream){Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcRules.initAsync(AcStream){Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Populate this container with AcPermission objects.
/// </summary>
/// <param name="name">Optional depot or stream name as per
/// [constructor parameter](@ref AcUtils#AcPermissions#AcPermissions) \e kind, otherwise all.</param>
/// <returns>\e true if no failure occurred and list was initialized successfully, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c lsacl command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \sa [AcPermissions constructor](@ref AcUtils#AcPermissions#AcPermissions) */
/*! \lsacl_ <tt>lsacl -fx {stream|depot} \<name\></tt> */
public async Task <bool> initAsync(string name = null)
{
bool ret = false; // assume failure
try
{
AcResult r = await AcCommand.runAsync($@"lsacl -fx {_kind} ""{name}""").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement xml = XElement.Parse(r.CmdResult);
foreach (XElement e in xml.Elements("Element"))
{
AcPermission perm = new AcPermission(_kind);
perm.Name = (string)e.Attribute("Name");
perm.AppliesTo = (string)e.Attribute("Group");
string type = (string)e.Attribute("Type");
perm.Type = (PermType)Enum.Parse(typeof(PermType), type);
string rights = (string)e.Attribute("Rights");
perm.Rights = (PermRights)Enum.Parse(typeof(PermRights), rights);
perm.Inheritable = (bool)e.Attribute("Inheritable");
lock (_locker) { Add(perm); }
}
ret = true; // operation succeeded
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcPermissions.initAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcPermissions.initAsync{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
//@}
#endregion
/// <summary>
/// Optionally called during [list construction](@ref AcUtils#AcGroups#AcGroups) to initialize the
/// [list of principals](@ref AcPrincipal#Members) (users and groups) that are direct (explicit) members of \e group.
/// This method is called internally and not by user code.
/// </summary>
/// <remarks>Membership lists for inactive groups are empty (not initialized). An inactive group's membership list will
/// reappear when the group is reactivated.</remarks>
/// <param name="group">Name of AccuRev group.</param>
/// <returns>\e true if no exception was thrown and operation succeeded, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \sa [AcUser.initGroupsListAsync](@ref AcUtils#AcUser#initGroupsListAsync) */
/*! \show_ <tt>show -fx -g \<group\> members</tt> */
/*! \accunote_ Unlike the \c show command used here, its <tt>show -fx -u \<user\> groups</tt> counterpart
* does include memberships resulting from indirect (implicit) membership. */
private async Task <bool> initMembersListAsync(string group)
{
bool ret = false; // assume failure
try
{
AcResult r = await AcCommand.runAsync($@"show -fx -g ""{group}"" members").ConfigureAwait(false);
if (r != null && r.RetVal == 0) // if command succeeded
{
SortedSet <string> members = new SortedSet <string>();
XElement xml = XElement.Parse(r.CmdResult);
foreach (XElement e in xml.Elements("Element"))
{
string name = (string)e.Attribute("User");
members.Add(name);
}
lock (_locker)
{
AcPrincipal prncpl = getPrincipal(group);
prncpl.Members = members;
}
ret = true; // operation succeeded
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcGroups.initMembersListAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcGroups.initMembersListAsync{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// Populate this container with AcLock objects on streams in \e depot or all AcLock objects in the repository.
/// </summary>
/// <param name="depot">Limit the list of locks to those on \e depot only, otherwise
/// \e null for all locks in the repository.</param>
/// <returns>\e true if initialization succeeded, \e false otherwise.</returns>
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c show command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
/*! \sa [AcLocks constructor](@ref AcUtils#AcLocks#AcLocks), initAsync(DepotsCollection), initAsync(StreamsCollection) */
/*! \show_ <tt>show -fx locks</tt> */
public async Task <bool> initAsync(AcDepot depot = null)
{
bool ret = false; // assume failure
try
{
AcResult r = await AcCommand.runAsync("show -fx locks").ConfigureAwait(false);
if (r != null && r.RetVal == 0)
{
XElement xml = XElement.Parse(r.CmdResult);
IEnumerable <XElement> query = null;
if (depot == null)
{
query = from e in xml.Elements("Element")
select e;
}
else
{
query = from e in xml.Elements("Element")
join AcStream s in depot.Streams on(string) e.Attribute("Name") equals s.Name
select e;
}
ret = initList(query);
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcLocks.initAsync(AcDepot){Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcLocks.initAsync(AcDepot){Environment.NewLine}{ecx.Message}");
}
return(ret);
}
/// <summary>
/// For the real version specified in the argument list, get the real stream/version
/// for the version in the specified version's workspace backing stream.
/// </summary>
/// <remarks>\c diff used here with the \c -i option, not to run a diff but to get the EID's only.</remarks>
/// <param name="realverspec">Real version specification in text format,
/// for example <tt>PG_MAINT1_barnyrd\4</tt> (numeric format won't work).</param>
/// <param name="depot">The depot.</param>
/// <param name="depotrelpath">Depot relative path, for example <tt>\\\\\.\\Bin\\foo.java</tt></param>
/// <returns>An array initialized as <em>int[]={realStreamNumber, realVersionNumber}</em> if available, otherwise \e null.</returns>
/*! \diff_ The \c diff command returns <em>zero (0)</em> for no differences found,
* <em>one (1)</em> for differences found, or <em>two (2)</em> on \c diff program error.<br>
* <tt>diff -fx -v \<realverspec\> -b -i -p \<depot\> \<depotrelpath\></tt> */
/*! > -v -b Compare the specified version (X) with the version in X's stream's backing stream. (Use -v -V instead if comparing elements of type text that are active in a time-based stream.) */
/*! > -i Information only: Report the IDs of the two versions, but don't actually compare them. This option is valid only in a command that uses a -v/-V combination or a -v/-b combination. If an element appears only in the workspace stream, not in the workspace's backing stream, this option does not list it. */
/// <exception cref="AcUtilsException">caught and [logged](@ref AcUtils#AcDebug#initAcLogging)
/// in <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on \c diff command failure.</exception>
/// <exception cref="Exception">caught and logged in same on failure to handle a range of exceptions.</exception>
public static async Task <int[]> getBackedVersionAsync(string realverspec, AcDepot depot, string depotrelpath)
{
int[] arr = null; // {realStreamNumber, realVersionNumber}
try
{
AcResult r = await AcCommand.runAsync($@"diff -fx -v ""{realverspec}"" -b -i -p ""{depot}"" ""{depotrelpath}""")
.ConfigureAwait(false);
if (r != null && r.RetVal < 2)
{
XElement xml = XElement.Parse(r.CmdResult);
XElement stream2 = xml.Descendants().Where(n => n.Name == "Stream2").SingleOrDefault();
if (stream2 != null)
{
XAttribute version = stream2.Attributes("Version").SingleOrDefault();
if (version != null)
{
string temp = (string)version;
string[] a = temp.Split('/');
int realStreamNumber = Int32.Parse(a[0], NumberStyles.Integer);
int realVersionNumber = Int32.Parse(a[1], NumberStyles.Integer);
arr = new int[] { realStreamNumber, realVersionNumber };
}
}
}
}
catch (AcUtilsException ecx)
{
AcDebug.Log($"AcUtilsException caught and logged in AcQuery.getBackedVersionAsync{Environment.NewLine}{ecx.Message}");
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcQuery.getBackedVersionAsync{Environment.NewLine}{ecx.Message}");
}
return(arr);
}
//@}
#endregion
/// <summary>
/// Helper function for initializing \e user with their Active Directory properties and group memberships
/// as per [constructor parameters](@ref AcUtils#AcUsers#AcUsers). Called internally and not by user code.
/// </summary>
/// <param name="user">The user to initialize.</param>
/// <returns>\e true if list initialization succeeded, \e false otherwise.</returns>
/// <exception cref="Exception">caught and [logged](@ref AcUtils#AcDebug#initAcLogging) in
/// <tt>\%LOCALAPPDATA\%\\AcTools\\Logs\\<prog_name\>-YYYY-MM-DD.log</tt> on failure to handle a range of exceptions.</exception>
private async Task <bool> initUserPropsAsync(AcUser user)
{
bool ret = false; // assume failure
try
{
if (_dc != null && _includeGroupsList)
{
Task <bool>[] tasks = new Task <bool> [2];
// initialize default set and other user properties from Active Directory
tasks[0] = user.initFromADAsync(_dc, _pc);
// include group membership list initialization
tasks[1] = user.initGroupsListAsync();
bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
ret = (arr != null && arr.All(n => n == true));
}
else if (_dc != null && !_includeGroupsList)
{
ret = await user.initFromADAsync(_dc, _pc).ConfigureAwait(false);
}
else if (_dc == null && _includeGroupsList)
{
ret = await user.initGroupsListAsync().ConfigureAwait(false);
}
else // _dc == null && !_includeGroupsList
{
ret = true; // nothing to do
}
}
catch (Exception ecx)
{
AcDebug.Log($"Exception caught and logged in AcUsers.initUserPropsAsync{Environment.NewLine}{ecx.Message}");
}
return(ret);
}
