/// <summary>
/// Esto es para darle una dirección Mac a la computadora
/// El parámetro es un string hexadecimal de 4 dígitos
/// </summary>
/// <param name="dirMac"></param>
public void PutMacDirection(string dirMac)
{
if (direccionMax == null && CheckMetods.CheckIsOkDirMac(dirMac))
{
this.direccionMax = dirMac;
}
else
{
throw new InvalidCastException($"No se pudo asignar la dirección Mac {dirMac} a la computadora {this.name}");
}
}
/// <summary>
/// Este método ejecuta una instrucción en especifico y chequea
/// que tenga la sintaxis correcta , ante cualquier error esta da una excepción
/// identificando que pudo haber sucedido
/// </summary>
/// <param name="instruccion"></param>
public static void EjecutarInstruccion(Instruccion instruccion)
{
string _instruccion = instruccion.instruccion;
string [] instruccionpartida = _instruccion.Split(" ");
if (instruccionpartida.Length < 1)
{
EnviromentActions.LanzarExepciondeCasteo(instruccion);
}
if (instruccionpartida[0][0] == '#')
{
return;
}
uint tiempodelainstruccion;
if (!UInt32.TryParse(instruccionpartida[0], out tiempodelainstruccion))
{
throw new FormatException($"no tiene un formato válido '{instruccionpartida[0]}' para ser el tiempo de una instruccion ");
}
if (instruccionpartida.Length < 2)
{
EnviromentActions.LanzarExepciondeCasteo(instruccion);
}
TipodeInstruccion tipoinstruccion = AuxiliaryFunctions.GiveMeTheInstruction(instruccionpartida[1]);
if (tipoinstruccion == TipodeInstruccion.create)
{
if (instruccionpartida.Length < 4)
{
EnviromentActions.LanzarExepciondeCasteo(instruccion);
}
string name = instruccionpartida[3];
uint cantidaddepuertos = 1;
if (instruccionpartida[2] == "hub")
{
if (instruccionpartida.Length < 5)
{
EnviromentActions.LanzarExepciondeCasteo(instruccion);
}
if (!UInt32.TryParse(instruccionpartida[4], out cantidaddepuertos))
{
throw new FormatException($"La cantidad de puertos '{instruccionpartida[4]}' de la instrucción no tiene un formato válido");
}
if (cantidaddepuertos < 4 || cantidaddepuertos > 8)
{
throw new IndexOutOfRangeException("la cantidad de puertos para un hub no son validos");
}
Hub hub = new Hub(name, (int)cantidaddepuertos, Program.dispositivos.Count);
Program.dispositivos.Add(hub);
}
else if (instruccionpartida[2] == "host")
{
cantidaddepuertos = 1;
Computadora computadora = new Computadora(name, Program.dispositivos.Count);
Program.dispositivos.Add(computadora);
}
else if (instruccionpartida[2] == "switch")
{
if (instruccionpartida.Length < 5)
{
EnviromentActions.LanzarExepciondeCasteo(instruccion);
}
if (!UInt32.TryParse(instruccionpartida[4], out cantidaddepuertos))
{
throw new FormatException($"La cantidad de puertos '{instruccionpartida[4]}' de la instrucción no tiene un formato válido");
}
if (cantidaddepuertos < Program.cantidadminimadepuertosdeunhub || cantidaddepuertos > Program.cantidadmaximadepuertosdeunhub)
{
throw new IndexOutOfRangeException("la cantidad de puertos para un hub no son validos");
}
Switch _switch = new Switch(name, (int)cantidaddepuertos, Program.dispositivos.Count);
Program.dispositivos.Add(_switch);
}
}
else if (tipoinstruccion == TipodeInstruccion.connect)
{
if (instruccionpartida.Length < 4)
{
EnviromentActions.LanzarExepciondeCasteo(instruccion);
}
string port1 = instruccionpartida[2];
string port2 = instruccionpartida[3];
Dispositivo disp1;
Dispositivo disp2;
disp1 = dispositivos.Where(disp => disp.Name.Contains(port1.Split('_').FirstOrDefault())).FirstOrDefault();
if (disp1 == null)
{
throw new KeyNotFoundException($"No hay ningún dispositivo cuyo nombre sea {port1.Split('_')}");
}
disp2 = dispositivos.Where(disp => disp.Name.Contains(port2.Split('_').FirstOrDefault())).FirstOrDefault();
if (disp2 == null)
{
throw new KeyNotFoundException($"No hay ningún dispositivo cuyo nombre sea {port2.Split('_')}");
}
int numeroport1 = int.Parse(port1.Split('_')[1]) - 1;
int numeroport2 = int.Parse(port2.Split('_')[1]) - 1;
Port p1 = disp1.DameElPuerto(numeroport1);
Port p2 = disp2.DameElPuerto(numeroport2);
Cable cable = new Cable();
EnviromentActions.ConnectPortsByCable(cable,
puerto1: p1,
puerto2: p2);
}
else if (tipoinstruccion == TipodeInstruccion.send)
{
if (instruccionpartida.Length < 4)
{
EnviromentActions.LanzarExepciondeCasteo(instruccion);
}
string host = instruccionpartida[2];
string data = instruccionpartida[3];
if (!CheckMetods.esBinariaLaCadena(data))
{
throw new InvalidCastException($"La información '{data}' que se quiere enviar no tiene un formato correcto ");
}
var disp = from dispositivo in dispositivos
where dispositivo.Name == host.Split('_')[0]
select dispositivo;
Dispositivo[] comp = disp.ToArray();
if (comp.Length != 1)
{
throw new Exception("no se encontró el dispositivo");
}
Computadora computadora = comp[0] as Computadora;
List <Bit> paquetedebits = new List <Bit>();
foreach (var item in data)
{
paquetedebits.Add((Bit)int.Parse(item.ToString()));
}
computadora.send(paquetedebits);
}
else if (tipoinstruccion == TipodeInstruccion.disconnect)
{
if (instruccionpartida.Length < 4)
{
EnviromentActions.LanzarExepciondeCasteo(instruccion);
}
string port1 = instruccionpartida[2];
string port2 = instruccionpartida[3];
Dispositivo dispositivo1 = dispositivos.Where(x => x.Name == instruccionpartida[2].Split('_')[0]).FirstOrDefault();
Dispositivo dispositivo2 = dispositivos.Where(x => x.Name == instruccionpartida[3].Split('_')[0]).FirstOrDefault();
if (dispositivo1 == null)
{
throw new InvalidCastException($"El puerto {port1} al que se esta tratando de acceder no existe ");
}
if (dispositivo2 == null)
{
throw new InvalidCastException($"El puerto {port2} al que se esta tratando de acceder no existe ");
}
int numeropuerto1 = int.Parse(port1.Split('_')[1]) - 1;
int numeropuerto2 = int.Parse(port2.Split('_')[1]) - 1;
Port p1 = dispositivo1.DameElPuerto(numeropuerto1);
Port p2 = dispositivo2.DameElPuerto(numeropuerto2);
p1.Cable = null;
p2.Cable = null;
}
else if (tipoinstruccion == TipodeInstruccion.mac)
{
if (instruccionpartida.Length < 4)
{
throw new InvalidCastException($"La instruccion mac '{_instruccion}' no tiene un formato valido");
}
Dispositivo disp = dispositivos.Where(x => x.Name == instruccionpartida[2]).FirstOrDefault();
Computadora comp = null;
if (disp is Computadora)
{
comp = disp as Computadora;
}
if (comp is null)
{
throw new NullReferenceException($"No se puede encontrar el Host '{instruccionpartida[2]}' en los dispositivos actuales");
}
string dirMac = instruccionpartida[3];
if (!CheckMetods.CheckIsOkDirMac(dirMac))
{
throw new InvalidCastException($"La instruccion Mac '{dirMac}' no tiene la sintaxis correcta ");
}
comp.PutMacDirection(dirMac);
}
else if (tipoinstruccion == TipodeInstruccion.send_frame)
{
if (instruccionpartida.Length < 5)
{
throw new InvalidCastException($"La instruccion mac '{_instruccion}' no tiene un formato valido");
}
Dispositivo disp = dispositivos.Where(x => x.Name == instruccionpartida[2]).FirstOrDefault();
Computadora comp = null;
if (disp is Computadora)
{
comp = disp as Computadora;
}
if (comp is null)
{
throw new NullReferenceException($"No se puede encontrar el Host '{instruccionpartida[2]}' en los dispositivos actuales");
}
string dirMacToSend = instruccionpartida[3];
string dataToSend = instruccionpartida[4];
if (!CheckMetods.CheckIsOkDirMac(dirMacToSend))
{
throw new InvalidCastException($"La instruccion send_frame '{dirMacToSend}' no tiene la sintaxis correcta ");
}
if (!CheckMetods.CheckStrContainOnlyHexadecimalCharacters(dataToSend))
{
throw new InvalidCastException($"La instruccion send_frame '{dataToSend}' no contiene los datos a enviar en formato hexadecimal");
}
comp.send_frame(dirMacToSend, dataToSend);
}
}
/// <summary>
/// esto es para leer del fichero config.txt que se
/// encuentra en este mismo directorio en que esta este proyecto
/// este pone todos los parametros establecido que se encuentran en
/// el fichero
/// </summary>
public static void Configurar()
{
var CurrentDirectory = Environment.CurrentDirectory;
var parent = Directory.GetParent(Directory.GetParent(Directory.GetParent(CurrentDirectory).FullName).FullName);
string rutaCompleta = Path.Join(parent.FullName, "config.txt");
if (!File.Exists(rutaCompleta))
{
PonerConfiguracionPorDefecto();
Console.WriteLine($"Advertencia: El fichero 'config.txt' no existe\n las configuraciones que se van a poner son las que hay por defecto");
return;
}
var variable = File.ReadLines(rutaCompleta);
foreach (var item in variable)
{
if (item.Length < 1)
{
continue;
}
string[] configuracionpartida = item.Split(':');
if (configuracionpartida.Length < 2)
{
throw new InvalidCastException($"la configuración {item} no tiene el formato correcto");
}
switch (configuracionpartida[0])
{
case "max_cantidad_milisegundos":
UInt32 _tiempo_maximo;
if (UInt32.TryParse(configuracionpartida[1], out _tiempo_maximo))
{
Program.tiempo_maximo = _tiempo_maximo;
}
else
{
throw new InvalidCastException($"el numero para asignarle al tiempo_maximo: '{configuracionpartida[1]} no es valido '");
}
break;
case "signal_time":
int _signal_time;
if (Int32.TryParse(configuracionpartida[1], out _signal_time))
{
Program.signal_time = (uint)_signal_time;
}
else
{
throw new InvalidCastException($"el numero para asignarle el _signal_time '{configuracionpartida[1]}' no tiene el formato correcto");
}
break;
case "numero_puertos_hub":
string[] extremosdelintervalo = configuracionpartida[1].Split('-');
if (extremosdelintervalo.Length < 2)
{
throw new InvalidCastException($"No tiene el formato correcto los intervalos '{extremosdelintervalo}'");
}
int min, max;
if (!int.TryParse(extremosdelintervalo[0], out min))
{
throw new InvalidCastException($"El extremo {extremosdelintervalo[0]} no es un numero valido ");
}
if (!int.TryParse(extremosdelintervalo[1], out max))
{
throw new InvalidCastException($"El extremo {extremosdelintervalo[1]} no es un numero valido ");
}
if (CheckMetods.sonvalidoslacantidaddepuertosdeunhub(min, max))
{
Program.cantidadminimadepuertosdeunhub = min;
Program.cantidadmaximadepuertosdeunhub = max;
}
break;
}
}
}
