Windows Scripting Host

[BeRSeRKeR]

                                Hola a todos.

Me preguntaba si alguien tiene conocimiento de algún script (Windows Scripting Host) que me permita copiar una serie de archivos; que yo especifique, a cualquier ordenador de la red (especificando su ip o nombre).

O si sabéis de alguna página que me pueda orientar sobre ése tema en concreto....

¡Gracias in avance! :ojo:

Saludos                                

[HgH]

                                ¿Has mirado en la MSDN?                                

[Zaelsius]

                                Aquí hay un tutorial:

http://www.borncity.com/WSHBazaar/WSHBooks.htm#L5

Yo en su día me miré algunas cosas de WSH, aunque ya no me acuerdo de nada  :( . De todas formas es muy fácil. Otra alternativa sería utilizar scripts ".vbs", si ya sabes VB pues prácticamente lo tienes hecho en 5 minutos.                                

[BeRSeRKeR]

                                Pues si, estoy mirando en las MSDN  y en inet pero he puesto el post éste por si por casualidad alguno conocía algún script por el estilo...

gracias a los dos.                                

[BeRSeRKeR]

                                Hola.

He encontrado una forma para hacer el script que quiero. Lo que hace es mapear la ruta donde quiero enviar los archivos en una unidad de red. La verdad es que no sé si habrá alguna forma mejor. Por ahora es lo que he encontrado y hace lo que quiero pero si alguien conoce alguna otra forma mejor pues que lo diga, please.

Saludos!                                

[mICrO]

                                Yo hize un .js para el curro que hace algo parecido a lo que tu
necesitas, esta echo con el windows scripting host

Un saludo

mICrO

nota : guardar como actualiza.js

Código [Seleccionar] Expand



// ********************************************************************

// **  actualiza.js                                                  **

// **   Programa de copia de actualizacion de ficheros en maquinas.  **

// **                                                                **

// ** Autor:                                                         **

// **                                                                **

// **  Juan Antonio Medina Iglesias ^ Ibermatica                     **

// **                                                                **

// ** Descripcion :                                                  **

// ** Este programa "replica" una estructura de directorios, con sus **

// **  archivos en una lista de maquinas.                            **

// **                                                                **

// ** Funcionamiento :                                               **

// ** Crear una estructura de directorios que se desea replicar en   **

// **  la carpeta datos, esta carpeta contendra primero una carpeta  **

// **  que sera considerada la unidad por ejemplo "C" o "D", etc.    **

// **  Dentro de esas carpetas de unidades crear la carpetas y       **

// **  subcarpetas necesarias para la estructura dada.               **

// **                                                                **

// ** Ejemplo :                                                      **

// **                                                                **

// **  Datos                                                         **

// **   - C <dir>                                                    **

// **      - SAT <dir>                                               **

// **         - Bases <dir>                                          **

// **           - clientes.new <fichero>                             **

// **           - tabla20.txt<fichero>                               **

// **                                                                **

// ** Crear una fichero llamado maquinas.txt que este en la carpeta  **

// **  datos y que contenga una lista de maquinas , una maquina por  **

// **  por linea.                                                    **

// **                                                                **

// ** Ejemplo :                                                      **

// **                                                                **

// **  AUTOMATA1_A                                                   **

// **  AUTOMATA5_B                                                   **

// **                                                                **

// ** Tras estar todo listo lanzar el fichero bat run.bat, despues de**

// **  la ejecucion recoger el fichero log.txt                       **

// ********************************************************************









////// MAIN **************** INICIO //////



//  Llama a la funcion de actualizar los ficheros

actualizaFicheros("datosmaquinas.txt","datos");



////// FIN **************** MAIN //////









// ********************************************************************

// **  compruebaCarpetaDestino  (fileSystemObject,rutaFichero)       **

// **                                                                **

// **  Comprueba si el directorio de destiuno de un fichero existe y **

// **  sino lo crea adecuadamente.                                   **

// **  de crearlo.                                                   **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// **  fileSystemObject = una referencia a un objeto fylesystem      **

// **  rutaFichero = ruta completa al fichero que luego copiaremos   **

// ********************************************************************

function compruebaCarpetaDestino(fileSystemObject,rutaFichero){



//el path de la carpeta que buscamos

var pathCarpetaRaiz = new String();



//en un principio cogemos la ruta del fichero

pathCarpetaRaiz = rutaFichero;



//creamos un array segun la cadena separando por

// por ejemplo la cadena servidor_orssacsatbasesclientes.new

// arrayElementos[0] = vacio = ""

// arrayElementos[1]= vacio = ""

// arrayElementos[2] = nombre maquina = "servidor_orssa"

// arrayElementos[3] = unidad = "c"

// arrayElementos[4] = carpeta = "sat"

// arrayElementos[5] = carpeta = "bases"

// arrayElementos[6] = fichero = "clientes.new"

var arrayElementos = rutaFichero.split("");



//el path de la carpeta raiz es maquinaunidad

pathCarpetaRaiz = "" + arrayElementos[2] + "" + arrayElementos[3];



//switch para saber si se llego a entrar en la carpeta raiz (maquina)

var llegoAMaquina = false;

try{

 //el path hasta la carpeta en la que estoy

 var carpetaActual = pathCarpetaRaiz;

 

 //el folder object de la raiz, exception si no existe

 var carpetaRaiz = fileSystemObject.GetFolder(pathCarpetaRaiz);  

 

 //al menos llegue a la maquina

 llegoAMaquina = true;

 

 //recorremos el array de supcarpetas hasta llegar a la que viene antes del nombre del fichero

 for(contador = 4; contador < arrayElementos.length-1;contador++){

 

  // en que subcarpeta estoy

  carpetaActual+=""+arrayElementos[contador];

 

  //sino existe esta carpeta

  if (!fileSystemObject.FolderExists(carpetaActual)){    

   

   //se crea la carpeta y se saca en el log

   fileSystemObject.CreateFolder(carpetaActual)    

   logOk("creando carpeta " + carpetaActual);

  }

 }

}

//exception producida

catch(e){

 //si al menos llegamos a la maquina

 if (llegoAMaquina){

  //hubo un error creado una carpeta

  logError("creando carpeta " + carpetaActual);

 }else{//sino fue al acceder a la maquina

  logError("acceder a unidad de red " + carpetaActual);

 }

 //levantamos para que la recoga la copia de ficheros

 throw e;

}

}



// ********************************************************************

// **  borraLog  ()                                                  **

// **                                                                **

// **  Si existe el fichero de log, lo borra.                        **

// ********************************************************************

function borraLog(){

//creacion del objeto filesystem

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");

//si existe el fichero de log

if (fileSystemObject.FileExists("log.txt")){

 //lo borramos

 fileSystemObject.DeleteFile("log.txt");

}

}



// ********************************************************************

// **  log  (texto)                                                  **

// **                                                                **

// ** inserta una linea en el log y escribe por la salida standard   **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** texto = una linea de texto                                     **

// ********************************************************************

function log(texto){

//modos para ficheros

var ForAppending = 8;

var TristateUseDefault = -2;



//el objeto de filesystem

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");



//abriemos el log para añadir sino existe se crea.

var textStream = fileSystemObject.OpenTextFile("log.txt", ForAppending, true);



//la fecha actual

var fechaActual = new Date();



//la fecha en formato [dd/mm/aaaa][hh:mm:ss.lll]

var fechaStr = new String();



//construimos la fecha

fechaStr += "["



if (fechaActual.getDate()<10) fechaStr += "0";

fechaStr += fechaActual.getDate();

fechaStr += "/";

if (fechaActual.getMonth()<10) fechaStr += "0";

fechaStr += fechaActual.getMonth();

fechaStr += "/";

fechaStr += fechaActual.getYear();



fechaStr += "][";



if (fechaActual.getHours()<10) fechaStr += "0";

fechaStr += fechaActual.getHours();

fechaStr += ":"

if (fechaActual.getMinutes()<10) fechaStr += "0";

fechaStr += fechaActual.getMinutes();

fechaStr += ":";

if (fechaActual.getSeconds()<10) fechaStr += "0";

fechaStr += fechaActual.getSeconds();

fechaStr += ".";

if (fechaActual.getMilliseconds()<100) fechaStr += "0";

if (fechaActual.getMilliseconds()<10) fechaStr += "0";

fechaStr += fechaActual.getMilliseconds();



fechaStr += "]"



//escribimos en el fichero de log

textStream.WriteLine(fechaStr + " " + texto);



//ceramos el fichero

textStream.close();



//enviamos a la salida standard

WScript.echo(texto);

}



// ********************************************************************

// **  logConFinal(texto,final,maximo)                               **

// **                                                                **

// ** inserta una linea en el log y escribe por la salida standard,  **

// **  con una terminacino dada y un maximo de longitud              **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** texto = una linea de texto                                     **

// ** final = una cadena final                                       **

// ** maximo = maximo numero de caracteres para la linea, sin final  **

// ********************************************************************

function logConFinal(texto,final,maximo){



//si la linea es mas pequeña que el maximo

if (texto.length<maximo){

 

 //añadir espacios hasta que sea del tamaño pedido

 var contador;

 for(contador = texto.length; contador < maximo; contador++){

  texto += ' ';

 }  

//sino

}else{

 //la corrtamos a 3 caracteres de a longitud y añadimos al final "..."

 texto = texto.substring(0,maximo-3);

 texto = texto + "..."

}



//logeamos añadiendo el final

log (texto+final);

}

// ********************************************************************

// **  logOk  (texto)                                                **

// **                                                                **

// ** inserta una linea en el log y escribe por la salida standard   **

// **  añade al final "[Ok]" y limita la linea a 72 caracteres.      **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** texto = una linea de texto                                     **

// ********************************************************************

function logOk(texto){

logConFinal(texto,"[Ok]",72);

}



// ********************************************************************

// **  logError  (texto)                                             **

// **                                                                **

// ** inserta una linea en el log y escribe por la salida standard   **

// **  añade al final "[Error]" y limita la linea a 72 caracteres.   **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** texto = una linea de texto                                     **

// ********************************************************************

function logError(texto){

logConFinal(texto,"[Error]",72);

}



// ********************************************************************

// **  insertaFicherosDeDirectorio (fileSystemObject,directorio,     **

// **                               directorio_raiz)                 **

// **                                                                **

// ** devuelve un diccionario con los ficheros de un directorio, la  **

// ** ruta es relativa a un directorio raiz.                         **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** fileSystemObject = una objecto FileSystem                      **

// ** directorio = una ruta de directorio                            **

// ** directorio_raiz = la ruta al directorio raiz                   **

// ********************************************************************

function insertaFicherosDeDirectorio(fileSystemObject,directorio,directorio_raiz){



//crea el diccionario

var diccionario = WScript.CreateObject("Scripting.Dictionary");



var counter = 0;



//obtiene la carpeta y enumera los ficheros

var carpeta = fileSystemObject.GetFolder(directorio);

var enumeratorFichero = new Enumerator(carpeta.Files);



//ruta del fichero

var ficheroStr = new String();



//recorre la lista

for (; !enumeratorFichero.atEnd(); enumeratorFichero.moveNext()){

 

 counter ++;

 

 //coge el path y le quita la ruta del directorio raiz

 ficheroStr = enumeratorFichero.item().Path;

 ficheroStr  = ficheroStr.replace(directorio_raiz,"");

 

 //añade el fichero al diccionario

 diccionario.add (directorio + counter,ficheroStr);

}



//devuelve el diccionario

return diccionario;

}



// ********************************************************************

// ** insertaDirectorio(fileSystemObject,directorio,directorio_raiz) **

// **                                                                **

// ** devuelve un diccionario con los ficheros de un directorio,  y  **

// ** subdirectorio ruta es relativa a un directorio raiz.           **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** fileSystemObject = una objecto FileSystem                      **

// ** directorio = una ruta de directorio                            **

// ** directorio_raiz = la ruta al directorio raiz                   **

// ********************************************************************

function insertaDirectorio(fileSystemObject,directorio,directorio_raiz){



//el diccionario que sera devuelto

var diccionarioFinal =  WScript.CreateObject("Scripting.Dictionary");



//diccionario temporal

var diccionarioTemporal;

var arrayElementos;

var contador;



//obtiene la carpeta

var carpeta = fileSystemObject.GetFolder(directorio);



//enumera las subcarpetas

var enumeratorCarpetas = new Enumerator(carpeta.SubFolders);

 

//recorre las subcarpetas

var carpetaStr = new String();

for (; !enumeratorCarpetas.atEnd(); enumeratorCarpetas.moveNext()){

 

 //obtiene la ruta relativa

 carpetaStr = enumeratorCarpetas.item().Path;

 carpetaStr  = carpetaStr.replace(directorio_raiz,"");

 

 //obtiene los ficheros de esta carpeta

 diccionarioTemporal = insertaFicherosDeDirectorio(fileSystemObject,enumeratorCarpetas.item().Path,directorio_raiz);

 arrayElementos = (new VBArray(diccionarioTemporal.Items())).toArray();    

 for(contador = 0;contador <diccionarioTemporal.count;contador++){

  //copia los elementos al diccionario final        

  diccionarioFinal.Add (arrayElementos[contador],arrayElementos[contador]);

 }

 

 //obtien los ficheros de las subcarpetas (recursividad)

 diccionarioTemporal = insertaDirectorio(fileSystemObject,enumeratorCarpetas.item().Path,directorio_raiz);

 arrayElementos = (new VBArray(diccionarioTemporal.Items())).toArray();    

 for(contador = 0;contador <diccionarioTemporal.count;contador++){  

  //copia los elementos al diccionario final            

  diccionarioFinal.Add (arrayElementos[contador],arrayElementos[contador]);

 }  

}



//devuelve el diccionario

return diccionarioFinal;

}



// ********************************************************************

// ** dameDiccionarioDesdeDirectorio(directorio)                     **

// **                                                                **

// ** devuelve un diccionario con los ficheros de un directorio,  y  **

// **  sus subdirectorio la ruta es relativa al directorio dado      **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** directorio = una ruta de directorio                            **

// ********************************************************************

function dameDiccionarioDesdeDirectorio(directorio){



//objeto filesystem

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");  



//obtiene la carpeta

var carpeta = fileSystemObject.GetFolder(directorio);



//obtiene los ficheros

var elements = insertaDirectorio(fileSystemObject,carpeta.Path,carpeta.Path+"");



return elements;

}



// ********************************************************************

// ** cargaFicheroDiccionario(fichero_diccioanario)                  **

// **                                                                **

// ** Carga un diccionario con el contenido de un fichero de texto   **

// **  el fichero contendra un item por linea                        **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** fichero_diccioanario = una ruta hacia un fichero               **

// ********************************************************************

function cargaFicheroDiccionario(fichero_diccioanario){

var counter = 0;



//crea un diccionario

var elements = WScript.CreateObject("Scripting.Dictionary");



var ForReading = 1;

var TristateUseDefault = -2;



//objeto filesystem

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");



  //abre el fichero

textStream = fileSystemObject.OpenTextFile(fichero_diccioanario, ForReading, false);



//mientras no llegemos al final

while (!textStream.AtEndOfLine)

{

 //añadimos al diccionario la linea y seguimos hacia adelante

 counter ++;

 elements.add ("elemento" + counter ,textStream.ReadLine());

}

textStream.Close( );  



return elements;

}





// ********************************************************************

// ** copiaFicheros(maquina_destino,diccionarioFicheros)             **

// **                                                                **

// ** Copia una lista de ficheros a una maquina                      **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** maquina_destino = la maquina de destino                        **

// ** diccionarioFicheros = un diccionario con rutas de ficheros     **

// ********************************************************************

function copiaFicheros(maquina_destino,diccionarioFicheros){



//creamos el filesystem object

var fileSystemObject = WScript.CreateObject("Scripting.FilesystemObject");



//añadimos al log

log("Actualizando ficheros en la maquina : " + maquina_destino);



var contador;



//enumeramos los elementos del diccionario

var arrayFicheros = (new VBArray(diccionarioFicheros.Items())).toArray();  



//origen y destino

var origen = new String();

var destino = new String();



//cuenta los ficheros buenos y malos

var ficherosBuenos = 0;

var ficherosMalos = 0;



//recorremos el diccionario

for(contador = 0;contador < diccionarioFicheros.count;contador++){



 //origen y destino del fichero

 origen = "datos" + arrayFicheros[contador];

 destino = "" + maquina_destino + "" + origen.replace("datos","");

 

 //capturamos errores

 try{  

  //comprueba si la carpeta de destino existe y sino la crea

  compruebaCarpetaDestino(fileSystemObject,destino);

 

  //copiamos el fichero

  fileSystemObject.CopyFile(origen,destino);

 

  //sacamos una linea en el log

  logOk("de "+ origen + " a " + destino);

 

  //un fichero bueno

  ficherosBuenos++;

 }  

 //error

 catch(e){  

 

  //sacamos el error

  logError("de "+ origen + " a " + destino);

 

  //un fichero malo

  ficherosMalos++;

 }

 

 

 

 

}

//sacamos el log final

log(ficherosBuenos+" fichero(s) correcto(s), "+ficherosMalos+" fichero(s) incorrecto(s)");

log("");



}



// ********************************************************************

// ** actualizaFicheros(lista_maquinas,directorio_datos)             **

// **                                                                **

// ** Actualiza unas maquinas con unos ficheros                      **

// **                                                                **

// ** Parametros :                                                   **

// **                                                                **

// ** lista_maquinas = fichero que contiene la lista de maquinas     **

// ** directorio_datos = El directorio con los datos a copiar        **

// ********************************************************************

function actualizaFicheros(lista_maquinas,directorio_datos){

try{

 //boramos el log

 borraLog();

 

 //sacamos informacion en el log

 log("ACTUALIZADOR DE FICHEROS:");

 log("");

 log("inicializando...");



 var contador;



 //cargamos el fichero de maquinas

 log("cargando fichero de maquinas");

 var listaMaquinas = cargaFicheroDiccionario(lista_maquinas);

 var arrayMaquinas = (new VBArray(listaMaquinas.Items())).toArray();  



 log("cargando lista de ficheros");

 

 //creamos la lista de ficheros

 var listaFicheros = dameDiccionarioDesdeDirectorio(directorio_datos);

 

 //copiamos a cada maquina

 log(" ");

 for(contador = 0;contador <listaMaquinas.count;contador++){

  copiaFicheros(arrayMaquinas[contador],listaFicheros);

 }

}

//algun error

catch(e){

 log("Se ha producido un error");

}

}









run.bat

Código [Seleccionar] Expand



@CScript.exe actualiza.js

pause

                               

[BeRSeRKeR]

                                Muchas gracias mICrO, le echaré dos ojos :o

Saludos