import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.ReadableByteChannel;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
public class Test {
// server path
from where the files will download
static String serverSHFilesPath = "http://localhost:8080/examples/server/serverSH.zip";
// the file which
you want to download after checking checksum
static String serverDownloadFilesPath = "http://localhost:8080/examples/server/";
// location on
local machine where the files will get download after
// checksum or by
default
// on first time
static String destPath = "C:/Users/UserName/AppData/Roaming/download/";
// path where
server checksum files will get download
static String destPathServerSH = "C:/Users/UserName/AppData/Roaming/download/serverSH/";
static String destPathLocalSH = "C:/Users/UserName/AppData/Roaming/download/localSH/";
static String serverSHName = "serverSH.zip";
// name of the
file which will be downloading
static String downloadFile = "Config.properties";
public static void main(String[] args) throws
MalformedURLException,
NoSuchAlgorithmException,
IOException {
createFilesFolderPath(destPathServerSH);
downloadServerSHFiles(serverSHFilesPath,
Paths.get(destPathServerSH, serverSHName).toString());
downloadingFiles(serverDownloadFilesPath, destPath, downloadFile,
destPathServerSH);
}
private static void
downloadServerSHFiles(String serverPropsPath2,
String
destPathServerSH2) throws
MalformedURLException, IOException {
InputStream openStream = new URL(serverPropsPath2).openStream();
try
(ReadableByteChannel in = Channels.newChannel(openStream);
FileChannel
out = new FileOutputStream(destPathServerSH2)
.getChannel())
{
out.transferFrom(in, 0, Long.MAX_VALUE);
}
//unzip checksum folder on local
unzip(destPathServerSH2, destPath);
//delete after unzipping
deleteZipFolders(destPathServerSH2);
}
public static void
downloadingFiles(String serverDownloadFilesPath,
String
destPath, String downloadFile, String destPathServerSH)
throws
MalformedURLException, IOException, NoSuchAlgorithmException {
//
copyFile(createFilesFolderPath, serverPropsPath);
MessageDigest
md5 = null;
md5 = MessageDigest.getInstance("MD5");
InputStream openStream = new URL(serverDownloadFilesPath + downloadFile)
.openStream();
// careate
path on local where you have intend to download the files
createFilesFolderPath(destPath);
StringBuilder
sb = null;
// logic to check
the file you are going to download are already
// downloaded
and are not changed
File fLocal = new File(Paths.get(destPathLocalSH,
downloadFile + ".sh.txt").toString());
File fServer = new File(Paths.get(destPathServerSH,
downloadFile + ".sh.txt").toString());
// if the
checksum file exist on local machine then enter in if
// condition
if (fLocal.exists()) {
// sb =
calculateHash(destPath, downloadFile, md5);
String
localFileSH = new String(Files.readAllBytes(Paths.get(fLocal
.getAbsolutePath())));
String
serverFileSH = new String(Files.readAllBytes(Paths
.get(fServer.getAbsolutePath())));
System.out.println("Hash value
of file : " + downloadFile + " : "
+
localFileSH);
//same hashcode
then don’t download
if (serverFileSH.equals(localFileSH)) {
System.out
.println(" hash code
is same !!! no need to download the file ");
} else {
//different checksum, update local copy of checksum file and
download file as well
BufferedWriter
writer = new BufferedWriter(new FileWriter(fLocal));
writer.write(serverFileSH.toString());
writer.close();
try
(ReadableByteChannel in = Channels.newChannel(openStream);
FileChannel
out = new FileOutputStream(destPath
+
downloadFile).getChannel()) {
out.transferFrom(in, 0, Long.MAX_VALUE);
}
System.out
.println("Successfully
re-downloaded and verified
checksum!"
+
localFileSH);
}
} else {
// unzip
code
try
(ReadableByteChannel in = Channels.newChannel(openStream);
FileChannel
out = new FileOutputStream(destPath
+
downloadFile).getChannel()) {
out.transferFrom(in, 0, Long.MAX_VALUE);
}
sb = calculateHash(destPath, downloadFile, md5);
BufferedWriter
writer = new BufferedWriter(new FileWriter(fLocal));
writer.write(sb.toString());
writer.close();
String
contents = new String(Files.readAllBytes(Paths.get(fLocal
.getAbsolutePath())));
System.out
.println("Successfully
downloaded and verified
checksum!"
+
contents);
}
}
public static String
createFilesFolderPath(String zaraOpsLocalPath) {
File file = new File(zaraOpsLocalPath);
if (!file.exists()) {
if (file.mkdirs()) {
return zaraOpsLocalPath;
} else {
System.out.println("Failed to
create directory!");
}
}
return zaraOpsLocalPath;
}
private static void copyFiles(File source, File dest, String downloadFile,
String
destPath) throws IOException {
if (downloadFile.contains("ConfigProp.zip")) {
File propDel = new File(destPath + "Config.properties");
propDel.delete();
}
if (downloadFile.contains(".zip")) {
String
replace = downloadFile.replace(".zip", "");
File propDel = new File(destPath + replace);
boolean deleteDirectory = deleteDirectory(propDel);
if (deleteDirectory)
System.out.println(" file :
"
+ deleteDirectory + "
deleted.");
}
if (dest.exists())
dest.delete();
Files.copy(source.toPath(), dest.toPath());
}
public static boolean
deleteDirectory(File directory) {
if (directory.exists()) {
File[]
files = directory.listFiles();
if (null != files) {
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) {
deleteDirectory(files[i]);
}
else {
files[i].delete();
}
}
}
}
return (directory.delete());
}
private static StringBuilder
calculateHash(String destPath,
String
downloadFile, MessageDigest md5)
throws
FileNotFoundException, IOException {
StringBuilder
sb = new StringBuilder();
byte[] dataBytes = new byte[1024];
int nread = 0;
FileInputStream
fis = new FileInputStream(destPath + downloadFile);
while ((nread = fis.read(dataBytes)) != -1)
md5.update(dataBytes, 0, nread);
fis.close();
byte[] mdbytes = md5.digest();
for (int i = 0; i < mdbytes.length; i++)
sb.append(Integer.toString((mdbytes[i] & 0xff) +
0x100, 16)
.substring(1));
return sb;
}
private static void unzip(String zipFilePath, String destDir) {
if (zipFilePath.contains(".zip")) {
try {
File
dir = new File(destDir);
// create output
directory if it doesn't exist
if (!dir.exists())
dir.mkdirs();
// Open the zip
file
ZipFile
zipFile = new ZipFile(zipFilePath);
Enumeration<?>
enu = zipFile.entries();
while (enu.hasMoreElements())
{
ZipEntry
zipEntry = (ZipEntry) enu.nextElement();
String
fileName = zipEntry.getName();
// Do we need to
create a directory ?
File
file = new File(destDir + File.separator + fileName);
System.out.println("Unzipping
to : "
+
file.getAbsolutePath());
if (fileName.endsWith("/")) {
file.mkdirs();
continue;
}
File
parent = file.getParentFile();
if (parent != null) {
parent.mkdirs();
}
// Extract the
file
InputStream
is = zipFile.getInputStream(zipEntry);
FileOutputStream
fos = new FileOutputStream(file);
byte[] bytes = new byte[1024];
int length;
while ((length = is.read(bytes)) >= 0) {
fos.write(bytes, 0, length);
}
is.close();
fos.close();
}
zipFile.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void
deleteZipFolders(String zipFilePath) {
// TODO Auto-generated
method stub
File file = new File(zipFilePath);
if (zipFilePath.contains(".zip")) {
file.delete();
System.out.println("deleted :
"
+ file.getName());
}
}
}
|
