Monitorar diretório, excluindo arquivos com extensões não permitidase gravando LOG

Prezados,

É minha primeira publicação neste fórum e gostaria de compartilhar uma solução que desenvolvi para monitorar um diretório da empresa que trabalho que vira e mexe os usuários colocam arquivos não pertinentes e estouram a capacidade de armazenamento (vídeos, músicas, fotos, etc.) e depois esses arquivos precisavam ser procurados e excluídos manualmente. Essa situação de procurar e excluir foi automatizada e a solução abaixo em Java roda diariamente.

A solução consiste em [color=red]Seis Passos: [/color]
5 classes;
1 arquivo properties (para poder incluir/excluir uma extensão de arquivo, e setar o valor de variáveis sem a necessidade de recompilação da solução).

Bom, vamos ao que interessa:

[color=red]Passo 1: [/color]
Início do arquivo conf.properties diretorioMonitorado = c:\\Public\\ diretorioLog = c:\\LOG\\ numExt = 4 ext1 = .avi ext2 = .mp4 ext3 = .mp3 ext4 = .mpeg tempoCicloEmSegundos = 5 Fim do arquivo conf.properties

Se for necessária a inclusão ou exclusão de mais uma extensão de arquivo, deve-se alterar no conf.properties o valor numExt = (número de extensões que serão tratadas) no nosso exemplo = 4, e acrescentar ou excluir uma linha extX = (extensão) sendo que o valor de X deve ser igual à quantidade de extensões tratadas.

Exemplo: se utilizarmos 5 extensões para a busca teremos que ter a variavel numExt = 5 e necessáriamente um ext5 também, conforme segue: ext5 = (extensão)

Vale lembrar que todas as variáveis devem ser/estar/existir válidas no arquivo conf.properties para que a aplicação inicie corretamente.

Passamos agora para a nossa classe principal

[color=red]Passo 2: [/color]
Início do arquivo executaLimpeza.java

[code]
import java.io.IOException;

/**

  • @author emmanuelrizzo
  • Apaga arquivos indesejáveis
    */

public class executaLimpeza {

public static void main(String[] args) throws InterruptedException,
		IOException {

	System.out.println("###############################################");
	System.out.println("## Iniciando a monitoração - Monitora Backup ##");
	System.out.println("###############################################");

	// condição para loop infinito
	int x = 1;
	int y = 0;

	while (x != y) {
		new verificaDiretorio().run();
		// System.out.println("Olá, estou iniciando um novo ciclo de execução!");

	}
}

}[/code] Fim do arquivo executaLimpeza.java

[color=red]Passo 3: [/color]
Aqui montamos a nossa classe para ler o arquivo conf.properties
Inicio do arquivo CarregaProperties.java

[code]import java.io.BufferedInputStream;
import java.io.IOException;
import java.net.URL;
import java.util.Properties;

public class CarregaProperties {

public static final Properties properties;

static {
	properties = new Properties();
	try {
		loadConfiguracao();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

public static void loadConfiguracao() throws IOException {

	URL resource = CarregaProperties.class.getResource("conf.properties");

	properties.load(new BufferedInputStream(resource.openStream()));
	properties.getProperty("diretorioMonitorado");

}

}[/code]Fim do arquivo CarregaProperties.java

[color=red]Passo 4: [/color]
Inicio do arquivo verificaDiretorio.java

[code]import java.io.IOException;

public class verificaDiretorio {

public verificaDiretorio() {

}

public void run() throws InterruptedException, IOException {

	new CarregaProperties();
	String tempoCicloEmSegundos = CarregaProperties.properties
			.getProperty("tempoCicloEmSegundos");
	int tempoCicloEmSegundosInt = Integer.parseInt(tempoCicloEmSegundos);
	
	int repeticao = (tempoCicloEmSegundosInt * 1000);
	
	new validaArquivos();
	Thread.sleep(repeticao); // tempo em milisegundos
	// Thread.interrupted();

}

}[/code]Fim do arquivo verificaDiretorio.java
Nesta classe são lidos os valores do arquivo conf.properties setados para o tempo de execução e é realizada chamada para o método validaArquivos();

[color=red]Passo 5: [/color]
Inicio do arquivo validaArquivos.java

[code]import java.io.File;
import java.io.IOException;

public class validaArquivos {

public validaArquivos() throws InterruptedException, IOException {

	new CarregaProperties();
	String diretorioMonitorado = CarregaProperties.properties
			.getProperty("diretorioMonitorado");
	// System.out.println(diretorioMonitorado);

	limpaTudo apagando = new limpaTudo();

	File file = new File(diretorioMonitorado);
	apagando.limpa(file, 0);

}

}[/code]Fim do arquivo validaArquivos.java
Nesta classe são lidos os valores do arquivo conf.properties setados para o diretório monitorado, e é realizada chamada para o método limpaTudo();

[color=red]Passo 6: [/color]
Esse é o passo principal, pois vai efetuar a leitura das extensões no arquivo conf.properties, vai gerar a saida da LOG do que for apagado, faz a varredura no diretorio monitorado e a exclusão dos arquivos que forem localizados com as extensões procuradas

Inicio do arquivo limpaTudo.java

[code]import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class limpaTudo {

public void limpa(File file, int nivel) throws IOException {

	new CarregaProperties();
	String diretorioLog = CarregaProperties.properties
			.getProperty("diretorioLog");
	// System.out.println(diretorioLog);

	BufferedWriter ListaArquivos = new BufferedWriter(new FileWriter(
			diretorioLog + "LogProibidos.txt", true));

	if (file.isDirectory()) {

		File[] lista = file.listFiles();

		// Faz uma chamada recursiva para listar arquivos e subdiretórios
		for (int i = 0; i < lista.length; i++)
			limpa(lista[i], nivel + 1);

	}

	new CarregaProperties();
	String numExt1 = CarregaProperties.properties.getProperty("numExt");
	int numeroExt = Integer.parseInt(numExt1);

	for (int aux = 1; aux < (numeroExt + 1); aux++) {

		String ext = CarregaProperties.properties.getProperty("ext" + aux);

		boolean arquivoAcc = ((file.getName().endsWith(ext) && file
				.canWrite()));

		if (arquivoAcc) {
			System.out.println("Arquivo removido: " + file.getPath());
			file.delete();
			ListaArquivos.write("Arquivo removido: " + file.getPath());
			ListaArquivos.newLine();
		}

	}

	// Fecha arquivo de LOG
	ListaArquivos.close();

}

}[/code]

[size=18][color=blue] Para schedular (iniciar e parar) a execução no Windows[/color] [/size]

Compile o projeto no Eclipse e extraia um arquivo executável .JAR

Para schedular a execução no windows de forma automática no agendador de tarefas eu fiz dois arquivos BAT, um para iniciar pela manhã e outro para encerrar a execução no final do dia:

Arquivo [color=green]iniciarMonitoracao.BAT [/color]

start "monitoraAmbiente" java -jar monitoraAmbiente.jar sendo que o nome monitoraAmbiente.jar deve corresponder ao nome do JAR criado
[/quote]
Arquivo [color=green]pararMonitoracao.BAT [/color]

TASKKILL /FI "WINDOWTITLE eq monitoraAmbiente 

[size=18]Espero que essa aplicação seja útil para alguém como foi pra mim
e peço desculpas antecipadamente pelos erros de padronização, conceitos e implementação que porventura existirem.
De qualquer forma a aplicação funciona e é muito útil para o que se propõe a fazer.

Um grande abraço para todos.[/size]

Solução bem interessante, porém, alguns pontos (dos quais você se desculpou):
Conceitualmente, entendo que “validaArquivos” deveria validar (ou seja, comparar se o arquivo arq.ext deve ou não ser apagado. E não é isto que ocorre, a classe simplesmente pega o arquivo e o envia para o limpaTudo que, necessariamente, não limpa tudo, apenas os arquivos que possuem extensão mapeada no conf.properties.

Tirando isso, tá susse.