ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/utils/BluePrintArchiveUtils.kt

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2019 Bell Canada.
   4  * Modifications Copyright © 2019 Nordix Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 package org.onap.ccsdk.cds.controllerblueprints.core.utils
  20
  21 import com.google.common.base.Predicates
  22 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
  23 import org.slf4j.LoggerFactory
  24 import java.io.BufferedInputStream
  25 import java.io.ByteArrayOutputStream
  26 import java.io.File
  27 import java.io.FileOutputStream
  28 import java.io.IOException
  29 import java.io.OutputStream
  30 import java.nio.charset.Charset
  31 import java.nio.file.FileVisitResult
  32 import java.nio.file.Files
  33 import java.nio.file.Path
  34 import java.nio.file.SimpleFileVisitor
  35 import java.nio.file.attribute.BasicFileAttributes
  36 import java.util.function.Predicate
  37 import java.util.zip.Deflater
  38 import java.util.zip.ZipEntry
  39 import java.util.zip.ZipFile
  40 import java.util.zip.ZipOutputStream
  41
  42 class BluePrintArchiveUtils {
  43
  44     companion object {
  45         private val log = LoggerFactory.getLogger(BluePrintArchiveUtils::class.java)
  46
  47         /**
  48          * Create a new Zip from a root directory
  49          *
  50          * @param source the base directory
  51          * @param destination the output filename
  52          * @return True if OK
  53          */
  54         fun compress(source: File, destination: File): Boolean {
  55             try {
  56                 if(!destination.parentFile.exists()) {
  57                     destination.parentFile.mkdirs()
  58                 }
  59                 destination.createNewFile()
  60                 val ignoreZipFiles = Predicate<Path> { path -> !path.endsWith(".zip") && !path.endsWith(".ZIP") }
  61                 FileOutputStream(destination).use { out ->
  62                     compressFolder(source.toPath(), out, pathFilter = ignoreZipFiles)
  63                 }
  64             } catch (e: Exception) {
  65                 log.error("Fail to compress folder($source) to path(${destination.path})", e)
  66                 return false
  67             }
  68             return true
  69         }
  70
  71         /**
  72          * In-memory compress an entire folder.
  73          */
  74         fun compressToBytes(baseDir: Path, compressionLevel: Int = Deflater.NO_COMPRESSION): ByteArray {
  75             return compressFolder(baseDir, ByteArrayOutputStream(), compressionLevel = compressionLevel)
  76                     .toByteArray()
  77         }
  78
  79         /**
  80          * Compress an entire folder.
  81          *
  82          * @param baseDir path of base folder to be packaged.
  83          * @param output the output stream
  84          * @param pathFilter filter to ignore files based on its path.
  85          * @param compressionLevel the wanted compression level.
  86          * @param fixedModificationTime to force every entry to have this modification time.
  87          * Useful for reproducible operations, like tests, for example.
  88          */
  89         private fun <T> compressFolder(baseDir: Path, output: T,
  90                                        pathFilter: Predicate<Path> = Predicates.alwaysTrue(),
  91                                        compressionLevel: Int = Deflater.DEFAULT_COMPRESSION,
  92                                        fixedModificationTime: Long? = null): T
  93                 where T : OutputStream {
  94             ZipOutputStream(output)
  95                     .apply { setLevel(compressionLevel) }
  96                     .use { zos ->
  97                         Files.walkFileTree(baseDir, object : SimpleFileVisitor<Path>() {
  98                             @Throws(IOException::class)
  99                             override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
 100                                 if (pathFilter.test(file)) {
 101                                     val zipEntry = ZipEntry(baseDir.relativize(file).toString())
 102                                     fixedModificationTime?.let {
 103                                         zipEntry.time = it
 104                                     }
 105                                     zipEntry.time = 0;
 106                                     zos.putNextEntry(zipEntry)
 107                                     Files.copy(file, zos)
 108                                     zos.closeEntry()
 109                                 }
 110                                 return FileVisitResult.CONTINUE
 111                             }
 112
 113                             @Throws(IOException::class)
 114                             override fun preVisitDirectory(dir: Path, attrs: BasicFileAttributes): FileVisitResult {
 115                                 val zipEntry = ZipEntry(baseDir.relativize(dir).toString() + "/")
 116                                 fixedModificationTime?.let {
 117                                     zipEntry.time = it
 118                                 }
 119                                 zos.putNextEntry(zipEntry)
 120                                 zos.closeEntry()
 121                                 return FileVisitResult.CONTINUE
 122                             }
 123                         })
 124                     }
 125             return output
 126         }
 127
 128         fun deCompress(zipFile: File, targetPath: String): File {
 129             val zip = ZipFile(zipFile, Charset.defaultCharset())
 130             val enumeration = zip.entries()
 131             while (enumeration.hasMoreElements()) {
 132                 val entry = enumeration.nextElement()
 133                 val destFilePath = File(targetPath, entry.name)
 134                 destFilePath.parentFile.mkdirs()
 135
 136                 if (entry.isDirectory)
 137                     continue
 138
 139                 val bufferedIs = BufferedInputStream(zip.getInputStream(entry))
 140                 bufferedIs.use {
 141                     destFilePath.outputStream().buffered(1024).use { bos ->
 142                         bufferedIs.copyTo(bos)
 143                     }
 144                 }
 145             }
 146
 147             val destinationDir = File(targetPath)
 148             check(destinationDir.isDirectory && destinationDir.exists()) {
 149                 throw BluePrintProcessorException("failed to decompress blueprint(${zipFile.absolutePath}) to ($targetPath) ")
 150             }
 151
 152             return destinationDir
 153         }
 154     }
 155
 156 }