public override void execute(MetaDataServer md)
{
FileMetadata metadata = md.FileMetadata[Filename];
ServerObjectWrapper sourceDataServer = md.DataServers[SourceId];
ServerObjectWrapper receiverDataServer = md.DataServers[ReceiverId];
lock (Filename)
{
if (canRemove(md) && !metadata.IsOpen)
{
metadata.FileServers.Remove(sourceDataServer);
}
md.registerMigratingFile(Filename, SourceId, ReceiverId);
metadata.FileServers.Add(receiverDataServer);
Console.WriteLine("#MDS: migrating file: " + Filename + "from [ DS " + sourceDataServer.Id + " ] to [ DS " + receiverDataServer.Id + " ]");
string servers = "";
foreach(ServerObjectWrapper server in metadata.FileServers){
servers += server.Id + " ";
}
Console.WriteLine("#MDS: file " + Filename + " is in servers: " + servers);
}
}
public override void execute(MetaDataServer md)
{
if ((WriteQuorum > NumberOfDataServers) || (ReadQuorum > NumberOfDataServers))
{
throw new CreateFileException("Invalid quorums values in create " + Filename);
}
if (md.FileMetadata.ContainsKey(Filename))
{
throw new CreateFileException("#MDS.create - The file " + Filename + " already exists ");
}
// List<ServerObjectWrapper> newFileDataServers = getFirstServers(md, NumberOfDataServers);
List<ServerObjectWrapper> newFileDataServers = md.getSortedServers(NumberOfDataServers);
FileMetadata newFileMetadata = new FileMetadata(Filename, NumberOfDataServers, ReadQuorum, WriteQuorum, newFileDataServers);
md.FileMetadata.Add(Filename, newFileMetadata);
md.addMetadataLock(Filename, new ManualResetEvent(false));
md.getMigratingFiles().Add(Filename, new List<Tuple<string, string>>());
Console.WriteLine("#MDS: Created " + Filename);
md.makeCheckpoint();
Result = md.FileMetadata[Filename];
}
public override void execute(MetaDataServer md)
{
if (!md.FileMetadata.ContainsKey(Filename))
{
throw new OpenFileException("#MDS.open - File " + Filename + " does not exist");
}
else if (md.FileMetadata[Filename].Clients.Contains(ClientID))
{
Console.WriteLine("#MDS.open - File " + Filename + " is already open for user " + ClientID);
Result = md.FileMetadata[Filename];
return;
}
else
{
Console.WriteLine("#MDS: opening file: " + Filename);
lock (Filename)
{
md.FileMetadata[Filename].IsOpen = true;
md.FileMetadata[Filename].Clients.Add(ClientID);
md.makeCheckpoint();
Result = md.FileMetadata[Filename];
}
}
}
public override void execute(MetaDataServer md)
{
if (!md.FileMetadata.ContainsKey(Filename))
{
throw new CommonTypes.Exceptions.DeleteFileException("#MDS.delete - File " + Filename + " does not exist");
}
md.FileMetadata.Remove(Filename);
Console.WriteLine("#MDS: Deleted file: " + Filename);
md.makeCheckpoint();
}
private Boolean canRemove(MetaDataServer md)
{
FileMetadata metadata = md.FileMetadata[Filename];
int numActualServers = metadata.FileServers.Count;
int numMigratingServers = md.getMigratingFiles()[Filename].Count;
int quorumMax = Math.Max(metadata.WriteQuorum, metadata.ReadQuorum);
int maxMigrating = metadata.FileServers.Count - quorumMax - numMigratingServers;
Console.WriteLine("canMigrate [ numActualServers: " + numActualServers + ", numMigratingServers: " + numMigratingServers + ", quorumMax: " + quorumMax + ", maxMigrating: " + maxMigrating + "] - can? " + (maxMigrating > 0));
return maxMigrating > 0;
}
public override void execute(MetaDataServer md)
{
Console.WriteLine("#MDS: Registering DS " + DataServerId);
if ( md.DataServers.ContainsKey(DataServerId) )
{
md.DataServers.Remove(DataServerId);
}
ServerObjectWrapper remoteObjectWrapper = new ServerObjectWrapper(DataServerPort, DataServerId, DataServerHost);
md.DataServers.Add(DataServerId, remoteObjectWrapper);
md.addServerToUnbalancedFiles(DataServerId);
HeartbeatMessage heartbeat = new HeartbeatMessage(DataServerId, 0 , 0, 0, 0, new Dictionary<string,FileAccessCounter>());
md.receiveHeartbeat(heartbeat);
md.makeCheckpoint();
}
public override void execute(MetaDataServer md)
{
if (!md.FileMetadata.ContainsKey(Filename))
{
// throw new CloseFileException("#MDS.close - File " + Filename + " does not exist");
return;
}
if (md.FileMetadata.ContainsKey(Filename) && !md.FileMetadata[Filename].Clients.Contains(ClientID))
{
//throw new CloseFileException("#MDS.close - File " + filename + " is not open for user " + clientID);
Console.WriteLine("#MDS.close - File " + Filename + " is already closed for user " + ClientID);
return;
}
Console.WriteLine("#MDS: closing file " + Filename + "...");
md.FileMetadata[Filename].Clients.Remove(ClientID);
if (md.FileMetadata[Filename].Clients.Count == 0)
{
md.FileMetadata[Filename].IsOpen = false;
}
md.makeCheckpoint();
}
public void registerOperations(MetaDataServer md, List<MetaDataOperation> list)
{
foreach (MetaDataOperation operation in list)
{
registerOperation(md, operation);
}
}
public void registerOperation(MetaDataServer md, MetaDataOperation operation)
{
Console.WriteLine("registerOperation: " + operation + (operation == null ? "NULL" : "" + operation.OperationId));
if (md == null || operation == null)
{
throw new ArgumentNullException("RegisterOperation - Expected a MDS and an operation [ MDS:" + md + ", Operation: " + operation + " ]");
}
int operationId;
lock (typeof(MetaDataLog))
{
operationId = NextId++;
}
if (md.getReplicationHandler().IsMaster)
{
operation.OperationId = operationId;
}
if (!log.Contains(operation))
{
log.Add(operation);
}
md.getReplicationHandler().syncOperation(operation);
}
public void init(MetaDataServer md)
{
log = new List<MetaDataOperation>();
MetadataServer = md;
NextId = 0;
Status = 0;
}
private List<ServerObjectWrapper> getFirstServers(MetaDataServer md, int numDataServers)
{
List<ServerObjectWrapper> firstDataServers = new List<ServerObjectWrapper>();
foreach (ServerObjectWrapper dataserverWrapper in md.DataServers.Values)
{
if (firstDataServers.Count < numDataServers)
{
firstDataServers.Add(new ServerObjectWrapper(dataserverWrapper));
}
}
return firstDataServers;
}
static void Main(string[] args)
{
Console.SetWindowSize(80, 15);
if (args.Length < 2)
{
Console.WriteLine("Usage: <port> <metadataServerId>");
Console.ReadLine();
}
else
{
MetaDataServer metadataServer = new MetaDataServer();
metadataServer.initialize(Int32.Parse(args[0]), args[1]);
Util.createDir(CommonTypes.Properties.Resources.TEMP_DIR);
metadataServer.startConnection(metadataServer);
metadataServer.fail();
metadataServer.recover();
Console.WriteLine("#MDS: Registered " + metadataServer.Id + " at " + metadataServer.Url);
Console.ReadLine();
}
}
public void startConnection(MetaDataServer metadataServer)
{
BinaryServerFormatterSinkProvider provider = new BinaryServerFormatterSinkProvider();
provider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary props = new Hashtable();
props["port"] = Port;
TcpChannel channel = new TcpChannel(props, null, provider);
ChannelServices.RegisterChannel(channel, true);
RemotingServices.Marshal(metadataServer, Id, typeof(MetaDataServer));
}
public void getCheckpoint(String metadataServerId)
{
try
{
Console.WriteLine("#MDS: Recovering Checkpoint!");
System.Xml.Serialization.XmlSerializer reader = new System.Xml.Serialization.XmlSerializer(typeof(MetaDataServer), new Type[]{ typeof(MetaDataCloseOperation), typeof(MetaDataCreateOperation), typeof(MetaDataDeleteOperation),
typeof(MetaDataRegisterServerOperation), typeof(MetaDataMigrateOperation), typeof(MetaDataOpenOperation)});
string dirName = CommonTypes.Properties.Resources.TEMP_DIR + "\\" + metadataServerId + "\\checkpoint.xml";
System.IO.StreamReader fileReader = new System.IO.StreamReader(dirName);
MetaDataServer metadaServer = new MetaDataServer();
metadaServer = (MetaDataServer)reader.Deserialize(fileReader);
this.CheckpointCounter = metadaServer.CheckpointCounter;
this.DataServers = metadaServer.DataServers;
this.FileMetadata = metadaServer.FileMetadata;
this.Log = metadaServer.Log;
this.Port = metadaServer.Port;
foreach (String filename in FileMetadata.Keys)
{
addMetadataLock(filename, new ManualResetEvent(false));
}
fileReader.Close();
}
catch (Exception e)
{
Console.WriteLine("#MDS: GetCheckpoint Failed: " + e.Message);
}
}
public abstract void execute(MetaDataServer md);
