Buenas, por favor alguien me puede ayudar a saber detalladamente qué es lo que hace este comando que paso a continuación, es que no lo se, me hago mucho lío. Se los agradecería
el archivo llamado fichero contiene lo que aparece a continuación ($ cat fichero): 230221-g03-entrada 230119-g03-entrada 230109-g02-salida 221115-g01-entrada <C-D>
la salida de este conjunto de comandos registrada en el fichero 'nuevoFichero' es: entrada entrada
Hola, necesito ayuda para resolver un problema de mi código. No sé donde está el fallo ya que a la hora de ejecutar (./padre /home/usuario/*) me devuelve solamente barras, cuando debe devolverme los archivos y directorios que tengo en la ruta. Por ejemplo; en mi ruta /home/usuario/* tengo 17 archivos, cuando ejecuto mi código me devuelve 17 barras (/////////////////) y lo que necesito que me devuelva es el nombre de cada archivo o directorio de esa ruta. Por favor si alguien me puede ayudar, le estaría sumamente agradecida!!!.
A continuacion paso el código del proceso padre y del proceso hijo (ambos códigos son necesarios), el modo de ejecucion debe ser de la siguiente manera: gcc hijo.c -o hijo gcc padre.c -o padre ./padre /home/usuario/*
CODIGO DE PADRE
Código:
/*fd[0] = se encarga de la lectura fd[1] = se encarga de la escritura fd[2] = hace ambas cosas, lectura/escritura*/
#define NUM_HIJOS 10//El numero de hijos debe ser tantos como numero de parametros haya #define NOMBREHIJO "./hijo" #define MAXBUFFER 256 //Tamaño del buffer lectura/escritura
void FinalizarProcesos();
void Manejador(int num);
pid_t pids[NUM_HIJOS]; int longitud_pid=0;//logitud del pid
int main(int argc, char *argv[]){ int fd[2];//Descriptores de la tuberia de comunicacion int i, j; //Para los bucles int pid; //PID de un proceso hijo
int status; //terminacion proceso hijo char buffer[MAXBUFFER];//buffer de lectura/escritura int num_caracteres;
/*Tratamiento de la linea de ordenes*/ if(argc < 2){// < 2 fprintf(stderr, "Error en el numero de argumentos\n"); exit(EXIT_FAILURE); }
/*Tratamiento de la señal*/ if(signal(SIGINT, Manejador)== SIG_ERR){ fprintf(stderr, "Error en la manipulacion de la señal\n"); exit(EXIT_FAILURE); }
/*Creacion de la tubería de comunicacion*/ if(pipe(fd) != 0){ fprintf(stderr, "Error en la creacion de la tuberia\n"); return EXIT_FAILURE; }
//CREACION DE LOS PROCESOS HIJOS for(i=1; i<argc; i++){//NUM_HIJOS switch(pids[i-1]=fork()){ //Se guarda el pid en la tabla de procesos y con pids[i-1]se salta el ./padre case -1: fprintf(stderr, "Error en la creacion del proceso hijo\n"); FinalizarProcesos(); break; case 0: //Ejecucuion por el proceso hijo
/*Redireccion de la entrada estandar al archivo*/ if ((fd[0] = open(argv[1], O_RDONLY)) == -1){ fprintf(stderr, "Error en la apertura del archivo de datos\n"); return EXIT_FAILURE; } close(1); if(dup(fd[1]) != 1){// Asignacion de salida estandar fprintf(stderr, "Error en la duplicacion del descriptor\n"); return EXIT_FAILURE; } if(execl(NOMBREHIJO, NOMBREHIJO, argv[i], NULL) == -1){ //argv[1] fprintf(stderr, "Error en la ejecucion del proceso hijo\n"); perror("execl"); exit(EXIT_FAILURE); } break; default: /*Ejecucion por el proceso padre*/ //close(fd[1]);// debe de ir fuera del for break; } longitud_pid++; //Para tener un control de cuantas cosas hay dentro del pids, por ejemplo hola (longitud=1) mundo (longitud=2) } close(fd[1]);
/*Espera a la finalizacion de los procesos hijos*/ for(i=1; i<NUM_HIJOS; i++){ pid=wait(NULL); //leer un caracter de entrada de la tuberia fd[0] (READ) if ((num_caracteres = read(fd[0], buffer, MAXBUFFER)) > 0){ printf("%.*s", num_caracteres, buffer);//leerá la tuberia y la escribirá en la salida estandar } } printf("[Proceso padre] finaliza\n"); return EXIT_SUCCESS; }
/*FinalizarProcesos: Termina todos los procesos hijos vivos*/ void FinalizarProcesos(void){ int i; for(i=0; i<longitud_pid; i++){ //Logitud_pid es porque los pids leidos van a tener valor if(kill(pids[i], SIGTERM) == -1){ fprintf(stderr, "Error al enviar una señal\n"); exit(EXIT_FAILURE); }
Hola, buenas. He realizado el siguiente código en bash, pero no sé muy bien como puedo hacer lo siguiente: - No sé hacer, que el tamaño devuelto en la ejecución se exprese en bloques de 1024bytes=1KB (Funcion computingSize())
Código:
#!/bin/bash shopt -s dotglob #recuperar ocultos
##################################muestra error y fuerza salida##################################### function mostrarError () { echo "ERROR. Modo de empleo: midu [opciones] [camino1 camino2 caminos3 ...]" exit 1 }
########################################Funcion recursiva########################################### tam_parcial=0 #variable global
function computingSize(){ #Guardamos las opciones en variables locales local opcion_d local opcion_s local opcion_exlude local ruta=$4
#si el camino es un archivo regular la unica opcion a tener en cuenta es --exclude if [ -f $ruta ]; then #se calcula el tamano (aux). Vale tambien con wc -c (tamano en bytes es valido) #stat con opciones adecuadas o en KB con ls -s tam_parcial=$aux fi
#si el camino es un directorio if [ -d $ruta ]; then local nodo #lista todo lo que tiene la ruta archivos y directorios "ls" y los va ha recorrer uno a uno por nodo for nodo in $ruta/*; do #si es directorio if [[ -d $nodo ]] ; then
#Guardar el valor de tam_parcial en variable local (e.j: temp) temp=$tam_parcial #resetear antes de la llamada a funcion recursiva tam_parcial=0
#se recupera/restaura el valor anterior de tam_parcial y se acumula con lo obtenido #en la llamada recursiva tam_parcial <- $(expr $tam_parcial + $temp)
#si es archivo regular elif [[ -f $nodo ]]; then #Calculando con wc -c tam_archivo= wc -c "$nodo"
############################Comprobacion de errores######################################### OPCION="" CONTADOR=1 #Empezamos en el argumento 1 OPCION_D=99999; OPCION_S=99999; OPCION_EXCLU=99999; for i in $@ ; do case $i in "-s" | "-d" | "--exclude") #Error si ya se ha recogido uno o mas caminos if [ $RUTAS ] ; then mostrarError fi case $i in "-d" | "--exclude") #Error si -d o --exclude es el utimo param (y no tienen ningun valor detras) if [ $CONTADOR -eq $# ]; then mostrarError fi OPCION=$i ;; "-s") #La opcion -s no tiene ningun param detras (Ruta) OPCION_S=1 ;; esac ;; *) ##Recuperamos los parametros para la opcion y/o la ruta## case $OPCION in #Deberia recoger ahora el param de -d "-d") NIVELES=`expr $i / 1` #Paso a entero #Si no hay niveles if [ ! $NIVELES ] ; then mostrarError fi #si los niveles son negativos if [ $NIVELES -lt 0 ] ; then mostrarError fi OPCION_D=$NIVELES ;;
#Param de --exclude "--exclude") OPCION_EXCLU=$i ;;
"") #Para recoger el camino. $i representa un camino dse anade al array vector RUTAS+=("$i") ;; esac #resetea al coger la opcion adecuada OPCION="" ;; esac CONTADOR=$(expr $CONTADOR + 1) done
##################################################################### # Tratar cuando no se especifica camino if [ ! $RUTAS ] ; then computingSize $OPCION_D $OPCION_S $OPCION_EXCLU "." else for i in "${RUTAS[@]}"; do # Llamar a computingSize computingSize $OPCION_D $OPCION_S $OPCION_EXCLU $i done fi
Buenas, necesito ayuda URGENTE en un código de bash que he realizado, mi duda es en la función computingSize() del código que paso a continuación ya que la función debe de calcular el tamaño en bytes o KBytes Recorriendo de forma recursiva los ficheros regulares y subdirectorios, evaluando las opciones especificadas, haciendo la función del comando du (ejemplo: du -d 0 --exclude=PATRON /RUTA).
CÓDIGO:
Código:
#!/bin/bash shopt -s dotglob #recuperar ocultos [b] function computingSize(){ #Guardamos las opciones en variables locales local opcion_d local opcion_s local opcion_exlude local ruta=$4
#si el camino es un archivo regular la unica opcion a tener en cuenta es --exclude if [ -f $ruta ]; then #se calcula el tamano (aux). Vale tambien con wc -c (tamano en bytes es valido) #stat con opciones adecuadas o en KB con ls -s tam_parcial=$aux fi
#si el camino es un directorio if [-d $ruta]; then local nodo #lista todo lo que tiene la ruta archivos y directorios "ls" y los va ha recorrer uno a uno por nodo for nodo in $ruta/*; do #si es directorio if [-d $nodo]; then
#Guardar el valor de tam_parcial en variable local (e.j: temp) temp=$tam_parcial #resetear antes de la llamada a funcion recursiva tam_parcial=0
#se recupera/restaura el valor anterior de tam_parcial y se acumula con lo obtenido #en la llamada recursiva tam_parcial <- $(expr $tam_parcial + $temp)
#si es archivo regular elif [-f $nodo]; then #Calculando con wc -c tam_archivo
Buenas, necesito ayuda URGENTE en un código de bash que he realizado, mi duda es en la función computingSize() del código que paso a continuación ya que la función debe de calcular el tamaño en bytes o KBytes Recorriendo de forma recursiva los ficheros regulares y subdirectorios, evaluando las opciones especificadas, haciendo la función del comando du (ejemplo: du -d 0 --exclude=PATRON /RUTA).
CÓDIGO:
Código:
#!/bin/bash shopt -s dotglob #recuperar ocultos
##################################muestra error y fuerza salida##################################### function mostrarError () { echo "ERROR. Modo de empleo: midu [opciones] [camino1 camino2 caminos3 ...]" exit 1 }
########################################Funcion recursiva########################################### tam_parcial=0 #variable global
function computingSize(){ #Guardamos las opciones en variables locales local opcion_d local opcion_s local opcion_exlude local ruta=$4
#si el camino es un archivo regular la unica opcion a tener en cuenta es --exclude if [ -f $ruta ]; then #se calcula el tamano (aux). Vale tambien con wc -c (tamano en bytes es valido) #stat con opciones adecuadas o en KB con ls -s tam_parcial=$aux fi
#si el camino es un directorio if [-d $ruta]; then local nodo #lista todo lo que tiene la ruta archivos y directorios "ls" y los va ha recorrer uno a uno por nodo for nodo in $ruta/*; do #si es directorio if [-d $nodo]; then
#Guardar el valor de tam_parcial en variable local (e.j: temp) temp=$tam_parcial #resetear antes de la llamada a funcion recursiva tam_parcial=0
#se recupera/restaura el valor anterior de tam_parcial y se acumula con lo obtenido #en la llamada recursiva tam_parcial <- $(expr $tam_parcial + $temp)
#si es archivo regular elif [-f $nodo]; then #Calculando con wc -c tam_archivo
############################Comprobacion de errores######################################### OPCION="" CONTADOR=1 #Empezamos en el argumento 1 OPCION_D=99999; OPCION_S=99999; OPCION_EXCLU=99999; for i in $@ ; do case $i in "-s" | "-d" | "--exclude") #Error si ya se ha recogido uno o mas caminos if [ $RUTAS ] ; then mostrarError fi case $i in "-d" | "--exclude") #Error si -d o --exclude es el utimo param (y no tienen ningun valor detras) if[$CONTADOR -eq $#]; then mostrarError fi OPCION=$i ;; "-s") #La opcion -s no tiene ningun param detras (Ruta) OPCION_S=1 ;; esac ;; *) ##Recuperamos los parametros para la opcion y/o la ruta## case $OPCION in #Deberia recoger ahora el param de -d "-d") NIVELES=`expr $i / 1` #Paso a entero #Si no hay niveles if [ ! $NIVELES ] ; then mostrarError fi #si los niveles son negativos if [ $NIVELES -lt 0 ] ; then mostrarError fi OPCION_D=$NIVELES ;;
#Param de --exclude "--exclude") OPCION_EXCLU=$i ;;
"") #Para recoger el camino. $i representa un camino dse anade al array vector RUTAS+=("$i") ;; esac #resetea al coger la opcion adecuada OPCION="" ;; esac CONTADOR=$(expr $CONTADOR + 1) done
##################################################################### # Tratar cuando no se especifica camino if [ ! $RUTAS ] ; then computingSize $OPCION_D $OPCION_S $OPCION_EXCLU "." else for i in "${RUTAS[@]}"; do # Llamar a computingSize computingSize $OPCION_D $OPCION_S $OPCION_EXCLU $i done fi
Buenas tardes!, tengo ciertas dudas a la hora de generar el código en java de unas clases UML y es que no sé muy bien los métodos que tienen que llevar tampoco sé si las relaciones entre clases hay que ponerlas y cómo se pueden poner.
Si me pueden ayudar a saber como puedo generar los métodos de la clase entities->Profesor y entities->CursoPropio
Agradecería mucho si me ayudan a resolver estas lagunas que tengo. Soy nueva programando y no se muy bien como se hace.
Dejo un enlace a un video donde aparecen las clases UML que tengo que generar su código y sobre las que tengo duda:
El código que he hecho de la clase CursoPropio es el siguiente, pero no sé si me faltan o no métodos:
public class CursoPropio { private String _id; private String _nombre; private int _eCTS; private Date _fechaInicio; private Date _fechaFin; private double _tasaMatricula; private int _edicion; public Vector<Matricula> _matriculas = new Vector<Matricula>(); public Centro _centro; public ProfesorUCLM _director; public ProfesorUCLM _secretario; public Vector<Materia> _materias = new Vector<Materia>(); public EstadoCurso _estado; public TipoCurso _tipo; public CursoPropioDAO _cursoPropioDao; }
Buenas, estoy haciendo un programa en java Cliente y Servidor con sockets UDP. El cliente y el servidor se deben de enviar mutuamente ( intercambiando mensajes ) la hora actual en el momento de ejecucion, y tambien deben de imprimir el número segundos transcurridos en el intercambio de mensajes(ESTO ULTIMO NO TENGO NI IDEA DE COMO LO PUEDO HACER). He hecho el codigo del intercambio de hora pero me da error. Si alguien porfavor me pudiese ayudar a saber donde esta el fallo y tambien si me puede ayudar a saber como puedo hallar los segundos transcurridos, estaría muy agradecida.
try { DatagramSocket socketUDP = new DatagramSocket(); byte[] mensaje = args[0].getBytes(); InetAddress hostServidor = InetAddress.getByName(args[1]); int puertoServidor = 5000;
//Construimos un datagrama para enviar el mensaje al Servidor DatagramPacket peticion = new DatagramPacket(mensaje, args[0].length(), hostServidor, puertoServidor); //Enviamos el datagrama SimpleDateFormat dateFormat=new SimpleDateFormat("[yyyy-MM-dd HH:mm:ss]");// Establecer el formato de fecha System.out.println("Fecha y hora enviadas al servidor: "+dateFormat.format(new Date()));
socketUDP.send(peticion);
//Construimos el datagrama que contendra la respuesta byte[] buffer = new byte[1000]; DatagramPacket respuesta = new DatagramPacket(buffer, buffer.length);
socketUDP.receive(respuesta);
//Enviamos la respuesta del servidor a la salida estandar System.out.println("Respuesta: "+ new String(respuesta.getData()));
try { @SuppressWarnings("resource") DatagramSocket socketUDP = new DatagramSocket(5000); byte[] buffer = new byte[1000];
while(true) { //Construimos el DatagramPacket para recibir peticiones DatagramPacket peticion = new DatagramPacket(buffer, buffer.length);
//Leemos una peticion del DatagramSocket socketUDP.receive(peticion);
System.out.println("Datagrama recibido del host: "+ peticion.getAddress()); System.out.println(" desde el puerto remoto: "+ peticion.getPort());
//Construimos el DatagramPacket para enviar la respuesta DatagramPacket respuesta = new DatagramPacket(peticion.getData(), peticion.getLength(), peticion.getAddress(), peticion.getPort());
SimpleDateFormat dateFormat=new SimpleDateFormat("[yyyy-MM-dd HH:mm:ss]");// Establecer el formato de fecha System.out.println("Fecha y hora enviadas al cliente: "+dateFormat.format(new Date()));
//Enviamos la respuesta, que es un eco socketUDP.send(respuesta); }
Es una especificacion diferente, además si que me ayudaron y respondieron, lo agradezco mucho la verdad! . Si alguien me pudiese ayudar con este dilema porfavor!
Mostrar Mensajes
, voy a probar lo que dices, para ver si me funciona