/// <summary>
/// Load the content of a Metadata item into the object model
/// </summary>
/// <param name="contentReader"></param>
/// <remarks></remarks>
private void LoadContentFromTextReader(TextReader contentReader)
{
if (contentReader == null)
{
throw new ArgumentNullException("contentReader");
}
// reset...
ErrorInLoading = null;
m_CachedMetadata = null;
using (XmlTextReader xmlReader = new XmlTextReader(contentReader))
{
if (m_MetadataType == MetadataType.Unknown)
{
// If we don't know the metedata type, we try to sniff it...
MetadataType fileType = DetermineFileType(xmlReader);
// try
m_CachedMetadata = LoadMetadataContent(fileType, xmlReader);
if (m_CachedMetadata.MetadataFormatError == null)
{
m_MetadataType = fileType;
}
}
}
}
/// <summary>
/// the function is called when the metadata is removed, and we need clean up the content
/// </summary>
/// <remarks></remarks>
internal void CleanUpContent()
{
ErrorInLoading = null;
m_BinaryContent = new byte[] { };
m_CachedMetadata = null;
}
void SendMetadataDto(string fileName, MetadataDTO metadataDTO, MetadataQuorumDto dataservers)
{
int timestamp = dataservers.timestamps[metadataPort - base_port];
MetadataContent metadata = new MetadataContent(metadataDTO, __OPEN__, timestamp);
metadataDB.Add(fileName, metadata);
Console.WriteLine("File \"" + fileName + "\" created by client and replicated to this metadata server.");
}
public MetadataDTO Open(string fileName)
{
freezer.WaitOne();
MetadataContent metadata = metadataDB[fileName];
//metadata.metadataDTO.ticket++;
metadata.access += __OPEN__;
Console.WriteLine("File \"" + fileName + "\" opened by client.");
return(metadata.metadataDTO);
}
/** Delete metadata
* more simple than create because it didn't do the creation of the quorum
**/
public void Delete(string fileName)
{
freezer.WaitOne();
MetadataContent metadata = metadataDB[fileName];
deleteFromALLdataServers(metadata.metadataDTO);
metadata.access -= __DELETE__; //What you're doing here is exactly the same you're doing in open... Doesn't make much sense...
/* DELETE equals -1, so doing access -= DELETE is the same as += OPEN
* if this is for checking how many clients have the file open, just erase this access thing...
* using an integer to check how many clients have the file open is not going to work, no matter what you do */
Console.WriteLine("File \"" + fileName + "\" deleted by client.");
}
// old version not used now
protected MetadataDTO Create(string fileName, int nbDataServers, int readQuorum, int writeQuorum)
{
freezer.WaitOne();
int ticket = getTicket();
int timestamp = getTimestamp();
Dictionary <string, string> dataServers = CreateFileOnServers(fileName, nbDataServers);
MetadataDTO metadataDTO = new MetadataDTO(nbDataServers, readQuorum, writeQuorum, dataServers, ticket);
MetadataContent metadata = new MetadataContent(metadataDTO, __OPEN__, timestamp);
metadataDB.Add(fileName, metadata);
Console.WriteLine("File \"" + fileName + "\" created by client.");
return(metadataDTO);
}
public void Close(string fileName)
{
freezer.WaitOne();
MetadataContent metadata = metadataDB[fileName];
Console.WriteLine("File \"" + fileName + "\" closed by client."); //move this line to end of operation when this code gets fixed
if (metadata.access > 0)
{
metadata.access -= __OPEN__; //sam please remove this, the server shouldnt crash just because the client does something stupid
}
else
{
throw new System.InvalidOperationException("MetadataServer Close: file not open (access=" + metadata.access + ")");
}
}
/**
* Consensus Client-Metadata Servers for active replication: send response to client and save metadata of created file
**/
public MetadataDTO createCommit(MetadataQuorumDto dataservers, string fileName, int nbDataServers, int readQuorum, int writeQuorum)
{
MetadataDTO metadataDTO;
freezer.WaitOne();
//next if-else is for load balancing the file creation task for selected metadata server from client
if (dataservers.runCreate(metadataPort))
{
int ticket = getTicket();
int timestamp = dataservers.timestamps[metadataPort - base_port];
Dictionary <string, string> dataServers = CreateFileOnServers(dataservers.Dataservers, fileName, nbDataServers);
metadataDTO = new MetadataDTO(nbDataServers, readQuorum, writeQuorum, dataServers, ticket);
MetadataContent metadata = new MetadataContent(metadataDTO, __OPEN__, timestamp);
metadataDB.Add(fileName, metadata);
for (int i = 0; i < msi.GetLength(0); i++)
{
MetadataServerInfo mi = msi[i];
if (mi != null)
{
//indirect hearbeat for metadata being up or down
try
{
((MetadataMessageService)Activator.GetObject(typeof(MetadataMessageService), "tcp://localhost:" + mi.port + "/DataMessageService")).SendMetadataDto(fileName, metadataDTO, dataservers);
int msID = mi.getID(base_port);
Console.WriteLine("Metadata successfully tranfered from metadata server number " + msID + ".");
}
catch (Exception e)
{
onlineMS[mi.getID(base_port)] = false;
msi[i] = null;
}
}
}
Console.WriteLine("File \"" + fileName + "\" created by client in elected metadata server.");
return(metadataDTO);
}
else
{
throw new System.ApplicationException("createCommit: unexpected run in non elected metadata server");
}
}
/// <summary>
/// Load schema/wsdl model from text reader. -- it will parse the metadata content.
/// </summary>
/// <return></return>
/// <remarks></remarks>
private MetadataContent LoadMetadataContent(MetadataType fileType, XmlTextReader xmlReader)
{
MetadataContent cachedMetadata = new MetadataContent();
try
{
switch (fileType)
{
case MetadataType.Disco:
cachedMetadata = new MetadataContent(Discovery.DiscoveryDocument.Read(xmlReader));
break;
case MetadataType.Wsdl:
cachedMetadata = new MetadataContent(Description.ServiceDescription.Read(xmlReader));
cachedMetadata.MetadataServiceDescription.RetrievalUrl = GetMetadataSourceUrl();
break;
case MetadataType.Schema:
cachedMetadata = new MetadataContent(XmlSchema.Read(xmlReader, null));
cachedMetadata.MetadataXmlSchema.SourceUri = GetMetadataSourceUrl();
break;
case MetadataType.Unknown:
// For unknown types, we don't do nothing...
break;
default:
Debug.Assert(fileType == MetadataType.Xml || fileType == MetadataType.Policy || fileType == MetadataType.Edmx);
XmlDocument tempDoc = new XmlDocument();
tempDoc.Load(xmlReader);
cachedMetadata = new MetadataContent(tempDoc);
break;
}
}
catch (Exception ex)
{
cachedMetadata = new MetadataContent(ex);
}
return(cachedMetadata);
}
/// <summary>
/// convert metadata file to MetadataSection (to feed code/proxy generator)
/// We don't reuse the buffered object model, because the generator could modify & corrupt them.
/// </summary>
/// <remarks></remarks>
internal MetadataSection CreateMetadataSection()
{
MetadataContent metadata = LoadMetadataContent(m_MetadataType);
if (metadata.MetadataFormatError != null)
{
throw metadata.MetadataFormatError;
}
MetadataSection metadataSection = null;
switch (FileType)
{
case MetadataType.Unknown:
break;
case MetadataType.Disco:
if (metadata.MetadataServiceDescription != null)
{
metadataSection = MetadataSection.CreateFromServiceDescription(metadata.MetadataServiceDescription);
}
break;
case MetadataType.Wsdl:
// We need to make a copy of the WSDL object model since the act of importing it actuall
// modifies it, and we don't want the cached instance to be polluted...
System.Web.Services.Description.ServiceDescription description = metadata.MetadataServiceDescription;
if (description != null)
{
metadataSection = MetadataSection.CreateFromServiceDescription(description);
}
break;
case MetadataType.Schema:
if (metadata.MetadataXmlSchema != null)
{
metadataSection = MetadataSection.CreateFromSchema(metadata.MetadataXmlSchema);
}
break;
case MetadataFile.MetadataType.Policy:
if (metadata.MetadataXmlDocument != null)
{
metadataSection = MetadataSection.CreateFromPolicy(metadata.MetadataXmlDocument.DocumentElement, null);
}
break;
case MetadataFile.MetadataType.Xml:
case MetadataFile.MetadataType.Edmx:
if (metadata.MetadataXmlDocument != null)
{
metadataSection = new MetadataSection(null, null, metadata.MetadataXmlDocument.DocumentElement);
}
break;
default:
System.Diagnostics.Debug.Fail("Unknown Type?");
break;
}
return(metadataSection);
}
/// <summary>
/// Load schema/wsdl model from text reader. -- it will parse the metadata content.
/// </summary>
/// <return></return>
/// <remarks></remarks>
private MetadataContent LoadMetadataContent(MetadataType fileType, XmlTextReader xmlReader)
{
MetadataContent cachedMetadata = new MetadataContent();
try
{
switch (fileType)
{
case MetadataType.Disco:
cachedMetadata = new MetadataContent(Discovery.DiscoveryDocument.Read(xmlReader));
break;
case MetadataType.Wsdl:
cachedMetadata = new MetadataContent(Description.ServiceDescription.Read(xmlReader));
cachedMetadata.MetadataServiceDescription.RetrievalUrl = GetMetadataSourceUrl();
break;
case MetadataType.Schema:
cachedMetadata = new MetadataContent(XmlSchema.Read(xmlReader, null));
cachedMetadata.MetadataXmlSchema.SourceUri = GetMetadataSourceUrl();
break;
case MetadataType.Unknown:
// For unknown types, we don't do nothing...
break;
default:
Debug.Assert(fileType == MetadataType.Xml || fileType == MetadataType.Policy || fileType == MetadataType.Edmx);
XmlDocument tempDoc = new XmlDocument();
tempDoc.Load(xmlReader);
cachedMetadata = new MetadataContent(tempDoc);
break;
}
}
catch (Exception ex)
{
cachedMetadata = new MetadataContent(ex);
}
return cachedMetadata;
}
/// <summary>
/// the function is called when the metadata is removed, and we need clean up the content
/// </summary>
/// <remarks></remarks>
internal void CleanUpContent()
{
ErrorInLoading = null;
m_BinaryContent = new byte[] { };
m_CachedMetadata = null;
}
/// <summary>
/// Load the content of a Metadata item into the object model
/// </summary>
/// <param name="contentReader"></param>
/// <remarks></remarks>
private void LoadContentFromTextReader(TextReader contentReader)
{
if (contentReader == null)
{
throw new ArgumentNullException("contentReader");
}
// reset...
ErrorInLoading = null;
m_CachedMetadata = null;
using (XmlTextReader xmlReader = new XmlTextReader(contentReader))
{
if (m_MetadataType == MetadataType.Unknown)
{
// If we don't know the metedata type, we try to sniff it...
MetadataType fileType = DetermineFileType(xmlReader);
// try
m_CachedMetadata = LoadMetadataContent(fileType, xmlReader);
if (m_CachedMetadata.MetadataFormatError == null)
{
m_MetadataType = fileType;
}
}
}
}
