/// <summary>
/// send_frame procesa todos los datos necesarios
/// para armar el contenido de un frame yenviarlos
/// por el puerto.
/// </summary>
/// <param name="mac">Este parametro es la data de la
/// direccion mac en formato hexadecimal. Es la direccion
/// mac de la computadora a la que se le va a enviar la data</param>
/// <param name="data">Este parametro es la data que se va a
/// enviar en el frame, en formato hexadecimal </param>
public void send_frame(string mac, string data)
{
var packagetosend = new List <Bit>();
var dirmaxin = string.IsNullOrEmpty(mac) ? "FFFF" : mac;
var dirmacout = string.IsNullOrEmpty(this.direccionMax) ? "FFFF" : this.direccionMax;
var lenghtdata = (data.Length / 2).ToString("X");
while (lenghtdata.Length < 2)
{
lenghtdata = "0" + lenghtdata;
}
packagetosend = AuxiliaryFunctions.ConvertToListOfBitHexadecimalSequence(dirmaxin, dirmacout, lenghtdata, "00", data);
//packagetosend.AddRange(packagetosend);
foreach (var item in puertos)
{
item.SendData(packagetosend);
}
Console.WriteLine($"Enviado por la computadora '{this.name}' el " +
$"paquete {AuxiliaryFunctions.FromByteDataToHexadecimal(packagetosend)}");
}
private void WriteDataReceivedInOutput(DataFramePackage package)
{
uint time_received = package.TimeReceived;
string pcout = AuxiliaryFunctions.FromByteDataToHexadecimal(package.MacOut);
string data = AuxiliaryFunctions.FromByteDataToHexadecimal(package.Data);
string dataFrame = package.ToString();
this.EscribirEnLaSalida(dataFrame, this.name + "_data.txt");
}
private async void inicializa_app()
{
Movies movies = await DbFunctions.obtem_movies();
if (AuxiliaryFunctions.checks_connection() || movies != null)
{
gera_movies(movies);
}
else
{
//Transfere para tela informada
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => Frame.Navigate(typeof(ConnectionErro)));
}
}
public override void ProcessDataReceived()
{
base.ProcessDataReceived();
if (currentBuildInFrame.FullData)
{
_history.Add(currentBuildInFrame);
string port = BytesReceives[BytesReceives.Count - 1].portreceived;
Port ptReceived = this.puertos[int.Parse(port.Split('_')[1])];
string dirMacFromDataReceived = AuxiliaryFunctions.FromByteDataToHexadecimal(currentBuildInFrame.MacOut);
ptReceived.PutMacDirection(dirMacFromDataReceived);
string dirMacHostIn = AuxiliaryFunctions.FromByteDataToHexadecimal(currentBuildInFrame.MacIn);
Port ptToSend = GimePortWithDirMac(dirMacHostIn);
if (ptToSend == null || dirMacHostIn == "FFFF")
{
List <Bit> datatosend = currentBuildInFrame.GetAllDataFrame();
foreach (var item in this.puertos)
{
if (item.Equals(ptReceived))
{
continue;
}
item.SendData(datatosend);
}
}
else
{
ptToSend.SendData(currentBuildInFrame.GetAllDataFrame());
}
currentBuildInFrame = null;
}
}
private void HandlePhoto <T>(T @object, IFormFile photo, int thumbWidth)
{
if (photo != null)
{
if (!AuxiliaryFunctions.ValidImageTypes.Contains(photo.ContentType))
{
ModelState.AddModelError("Photo", "Izberite fotografijo v eni izmed naslednjih oblik: BMP, GIF, JPG, or PNG.");
}
else
{
using (var reader = new BinaryReader(photo.OpenReadStream()))
{
if (@object is Photo)
{
(@object as Photo).ArtistPhoto = reader.ReadBytes((int)photo.Length);
(@object as Photo).ArtistThumb = AuxiliaryFunctions.CreateThumbnail((@object as Photo).ArtistPhoto, thumbWidth);
}
}
}
}
}
public void TestSVM()
{
AuxiliaryFunctions.WritePercentage(tuple.ToArray(), @"Output\percentage.txt");
}
/// <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);
}
}
