/// <summary>
/// Creates a new cache manager for the serverGuid passed in.
/// </summary>
/// <param name="serverGuid"></param>
public LocationCacheManager(Guid serverGuid, Guid serviceOwner, Uri connectionBaseUrl)
{
m_cacheAvailable = (serverGuid.Equals(Guid.Empty)) ? false : true;
m_lastChangeId = -1;
m_cacheExpirationDate = DateTime.MinValue;
if (serviceOwner == Guid.Empty)
{
// For a legacy server (which didn't return serviceOwner in the connectionData), let's not try to break anything
// just use the old path.
// We should be able to remove this case eventually.
m_cacheFilePath = Path.Combine(Path.Combine(VssClientSettings.ClientCacheDirectory, serverGuid.ToString()),
s_cacheFileName);
}
else
{
m_cacheFilePath = Path.Combine(Path.Combine(Path.Combine(VssClientSettings.ClientCacheDirectory, serverGuid.ToString()), serviceOwner.ToString()),
s_cacheFileName);
}
m_cacheLocallyFresh = false;
m_accessMappings = new Dictionary <String, AccessMapping>(VssStringComparer.AccessMappingMoniker);
m_services = new Dictionary <String, Dictionary <Guid, ServiceDefinition> >(VssStringComparer.ServiceType);
m_cachedMisses = new HashSet <String>(VssStringComparer.ServiceType);
m_connectionBaseUrl = connectionBaseUrl;
m_locationXmlOperator = new LocationXmlOperator(true);
}
/// <summary>
/// Reads the service definitions from the provided document.
/// For a specification of what the xml should look like, see the
/// corresponding Write method.
/// </summary>
/// <param name="document">The document to read from.</param>
/// <returns>A list of service definitions.</returns>
public List <ServiceDefinition> ReadServices(XmlDocument document, Dictionary <String, AccessMapping> accessMappings)
{
List <ServiceDefinition> definitions = new List <ServiceDefinition>();
XmlNodeList servicesNodeList = document.SelectNodes("//" + s_services);
if (servicesNodeList == null)
{
return(definitions);
}
foreach (XmlNode servicesNode in servicesNodeList)
{
// Get all of the service definition nodes
foreach (XmlNode definitionNode in servicesNode.SelectNodes("./" + s_serviceDefinition))
{
ServiceDefinition definition = new ServiceDefinition();
// Get the service type - it must exist
XmlNode serviceTypeNode = definitionNode.SelectSingleNode("./" + s_serviceType);
LocationXmlOperator.CheckXmlNodeNullOrEmpty(serviceTypeNode, s_serviceType, definitionNode);
definition.ServiceType = serviceTypeNode.InnerText;
// Get the identifier if it exists - it must exist if this is the client cache
XmlNode identifierNode = definitionNode.SelectSingleNode("./" + s_identifier);
if (m_isClientCache)
{
LocationXmlOperator.CheckXmlNodeNullOrEmpty(identifierNode, s_identifier, definitionNode);
}
definition.Identifier = (identifierNode != null) ? XmlConvert.ToGuid(identifierNode.InnerText) : Guid.Empty;
// Get the display name - it must exist
XmlNode displayNameNode = definitionNode.SelectSingleNode("./" + s_displayName);
LocationXmlOperator.CheckXmlNodeNullOrEmpty(displayNameNode, s_displayName, definitionNode);
definition.DisplayName = displayNameNode.InnerText;
// Get the description if it exists
XmlNode descriptionNode = definitionNode.SelectSingleNode("./" + s_description);
definition.Description = (descriptionNode != null) ? descriptionNode.InnerText : String.Empty;
// Get the relativePath and the relativeTo setting
XmlNode relativePathNode = definitionNode.SelectSingleNode("./" + s_relativePath);
LocationXmlOperator.CheckXmlNodeNull(relativePathNode, s_relativePath, definitionNode);
definition.RelativePath = relativePathNode.InnerText;
// Get the relativeTo setting
XmlAttribute relativeToAttribute = relativePathNode.Attributes[s_relativeTo];
CheckXmlAttributeNullOrEmpty(relativeToAttribute, s_relativeTo, relativePathNode);
RelativeToSetting setting;
if (!RelativeToEnumCache.GetRelativeToEnums().TryGetValue(relativeToAttribute.InnerText, out setting))
{
throw new ConfigFileException(relativeToAttribute.InnerText);
}
definition.RelativeToSetting = setting;
// If the relativeToSetting is FullyQualified and the path is empty, set it to null
// to make the framework happy.
if (definition.RelativeToSetting == RelativeToSetting.FullyQualified && definition.RelativePath == String.Empty)
{
definition.RelativePath = null;
}
XmlNode parentServiceTypeNode = definitionNode.SelectSingleNode("./" + s_parentServiceType);
definition.ParentServiceType = (parentServiceTypeNode != null) ? parentServiceTypeNode.InnerText : null;
XmlNode parentIdentifierNode = definitionNode.SelectSingleNode("./" + s_parentIdentifier);
definition.ParentIdentifier = (parentIdentifierNode != null) ? XmlConvert.ToGuid(parentIdentifierNode.InnerText) : Guid.Empty;
// Get all of the location mappings
definition.LocationMappings = new List <LocationMapping>();
if (definition.RelativeToSetting == RelativeToSetting.FullyQualified)
{
XmlNodeList mappings = definitionNode.SelectNodes(".//" + s_locationMapping);
foreach (XmlNode mappingNode in mappings)
{
LocationMapping locationMapping = new LocationMapping();
// Get the accessMapping
XmlNode accessMappingNode = mappingNode.SelectSingleNode("./" + s_accessMapping);
LocationXmlOperator.CheckXmlNodeNullOrEmpty(accessMappingNode, s_accessMapping, mappingNode);
locationMapping.AccessMappingMoniker = accessMappingNode.InnerText;
// Only process the location code if this is the client cache and there better
// not be a location node if this isn't a client cache.
XmlNode locationNode = mappingNode.SelectSingleNode("./" + s_location);
if (m_isClientCache)
{
CheckXmlNodeNullOrEmpty(locationNode, s_location, mappingNode);
}
locationMapping.Location = (locationNode != null) ? locationNode.InnerText : null;
// We will let the caller build the proper location from the proper service definitions
// instead of doing it here.
definition.LocationMappings.Add(locationMapping);
}
}
// Get the resourceVersion
XmlNode resourceVersionNode = definitionNode.SelectSingleNode("./" + s_resourceVersion);
definition.ResourceVersion = (resourceVersionNode != null) ? XmlConvert.ToInt32(resourceVersionNode.InnerText) : 0;
// Get the minVersion
XmlNode minVersionNode = definitionNode.SelectSingleNode("./" + s_minVersion);
definition.MinVersionString = (minVersionNode != null) ? minVersionNode.InnerText : null;
// Get the maxVersion
XmlNode maxVersionNode = definitionNode.SelectSingleNode("./" + s_maxVersion);
definition.MaxVersionString = (maxVersionNode != null) ? maxVersionNode.InnerText : null;
// Get the releasedVersion
XmlNode releasedVersionNode = definitionNode.SelectSingleNode("./" + s_releasedVersion);
definition.ReleasedVersionString = (releasedVersionNode != null) ? releasedVersionNode.InnerText : null;
definitions.Add(definition);
}
}
return(definitions);
}