1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/**
* Copyright 2007 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.tonicsystems.jarjar.transform;
import com.tonicsystems.jarjar.classpath.ClassPath;
import com.tonicsystems.jarjar.classpath.ClassPathArchive;
import com.tonicsystems.jarjar.classpath.ClassPathResource;
import com.tonicsystems.jarjar.transform.jar.JarProcessor;
import com.tonicsystems.jarjar.util.IoUtil;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import javax.annotation.Nonnull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JarTransformer {
private static final Logger LOG = LoggerFactory.getLogger(JarTransformer.class);
public static enum DuplicatePolicy {
DISCARD, ERROR;
}
private final File outputFile;
private final JarProcessor processor;
private DuplicatePolicy duplicatePolicy = DuplicatePolicy.DISCARD;
private final byte[] buf = new byte[0x2000];
private final Set<String> dirs = new HashSet<String>();
private final Set<String> files = new HashSet<String>();
public JarTransformer(@Nonnull File outputFile, @Nonnull JarProcessor processor) {
this.outputFile = outputFile;
this.processor = processor;
}
@Nonnull
private Transformable newTransformable(@Nonnull ClassPathResource inputResource)
throws IOException {
Transformable struct = new Transformable();
struct.name = inputResource.getName();
struct.time = inputResource.getLastModifiedTime();
InputStream in = inputResource.openStream();
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
IoUtil.copy(in, out, buf);
struct.data = out.toByteArray();
} finally {
in.close();
}
return struct;
}
private void addDirs(JarOutputStream outputJarStream, String name) throws IOException {
int dirIdx = name.lastIndexOf('/');
if (dirIdx == -1)
return;
String dirName = name.substring(0, dirIdx + 1);
if (dirs.add(dirName)) {
JarEntry dirEntry = new JarEntry(dirName);
outputJarStream.putNextEntry(dirEntry);
}
}
public void transform(@Nonnull ClassPath inputPath) throws IOException {
SCAN:
{
for (ClassPathArchive inputArchive : inputPath) {
LOG.debug("Scanning archive {}", inputArchive);
for (ClassPathResource inputResource : inputArchive) {
Transformable struct = newTransformable(inputResource);
processor.scan(struct);
}
}
}
OUT:
{
Set<String> dirs = new HashSet<String>();
JarOutputStream outputJarStream = new JarOutputStream(new FileOutputStream(outputFile));
for (ClassPathArchive inputArchive : inputPath) {
LOG.info("Transforming archive {}", inputArchive);
for (ClassPathResource inputResource : inputArchive) {
Transformable struct = newTransformable(inputResource);
if (processor.process(struct) == JarProcessor.Result.DISCARD)
continue;
addDirs(outputJarStream, struct.name);
if (DuplicatePolicy.DISCARD.equals(duplicatePolicy)) {
if (!files.add(struct.name)) {
LOG.debug("Discarding duplicate {}", struct.name);
continue;
}
}
LOG.debug("Writing {}", struct.name);
JarEntry outputEntry = new JarEntry(struct.name);
outputEntry.setTime(struct.time);
outputEntry.setCompressedSize(-1);
outputJarStream.putNextEntry(outputEntry);
outputJarStream.write(struct.data);
}
}
outputJarStream.close();
}
}
}
|
