/// <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; } } } }