Utilities.java
4.84 KB
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/*
* Decompiled with CFR 0_118.
*
* Could not load the following classes:
* com.adobe.aemds.bedrock.OS
* org.slf4j.Logger
* org.slf4j.LoggerFactory
*/
package com.adobe.aemds.bedrock.installer.internal;
import com.adobe.aemds.bedrock.OS;
import com.adobe.aemds.bedrock.installer.internal.AdobeJarSupport;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
class Utilities {
private static Logger logger = LoggerFactory.getLogger(Utilities.class);
Utilities() {
}
public static boolean deleteRecursive(File target) {
String[] cmd;
try {
String targetPath = target.getCanonicalPath();
cmd = OS.isWindows() ? (!target.isDirectory() ? new String[]{"cmd.exe", "/c", "del", "/s", "/f", "/q", targetPath} : new String[]{"cmd.exe", "/c", "rmdir", "/s", "/q", targetPath}) : new String[]{"rm", "-r", "-f", targetPath};
}
catch (IOException ex) {
logger.warn("Error getting canonical path for file " + target, (Throwable)ex);
return false;
}
int retVal = Utilities.runCmd(cmd);
return retVal == 0;
}
private static int runCmd(String[] cmd) {
int retVal;
Process proc;
try {
proc = Runtime.getRuntime().exec(cmd);
}
catch (IOException e) {
logger.warn("Error running system command", (Throwable)e);
return -1;
}
try {
proc.getOutputStream().close();
}
catch (IOException e) {
logger.warn("Error closing process output stream", (Throwable)e);
}
String cmdLine = Utilities.unsplit(cmd);
StreamGobbler errorGobbler = new StreamGobbler("error stream consumer for cmd: " + cmdLine, proc.getErrorStream(), System.err);
errorGobbler.start();
StreamGobbler outputGobbler = new StreamGobbler("output stream consumer for cmd: " + cmdLine, proc.getInputStream(), null);
outputGobbler.start();
do {
try {
retVal = proc.waitFor();
break;
}
catch (InterruptedException e) {
logger.warn("Interrupted while waiting for process to terminate, retrying...", (Throwable)e);
continue;
}
break;
} while (true);
errorGobbler.collectThread();
outputGobbler.collectThread();
return retVal;
}
private static String unsplit(String[] strs) {
StringBuilder buf = new StringBuilder();
for (int i = 0; i < strs.length; ++i) {
if (i != 0) {
buf.append(' ');
}
buf.append(strs[i]);
}
return buf.toString();
}
/*
* WARNING - Removed try catching itself - possible behaviour change.
*/
static void unpackResources(InputStream src, File dest, boolean setSharedXbit) throws IOException {
AdobeJarSupport inputJar = null;
try {
inputJar = new AdobeJarSupport(src);
inputJar.extractAll(dest, setSharedXbit);
inputJar.close();
}
finally {
if (inputJar != null) {
inputJar.close();
}
}
}
private static class StreamGobbler
extends Thread {
private final int BUFLEN = 512;
private byte[] buffer = new byte[512];
final InputStream is;
final OutputStream copyTo;
StreamGobbler(String name, InputStream is, OutputStream copyTo) {
super(name);
this.setDaemon(true);
this.is = is;
this.copyTo = copyTo;
}
public void run() {
try {
int bytesRead;
while (!StreamGobbler.interrupted() && (bytesRead = this.is.read(this.buffer)) != -1) {
if (this.copyTo == null) continue;
this.copyTo.write(this.buffer, 0, bytesRead);
}
}
catch (IOException e) {
logger.warn("Error reading from process input/error stream", (Throwable)e);
}
try {
this.is.close();
}
catch (IOException e) {
logger.warn("Error closing process input/error stream", (Throwable)e);
}
}
void collectThread() {
this.interrupt();
try {
this.join(1000);
}
catch (InterruptedException e) {
logger.warn("Interrupted waiting for thread to die", (Throwable)e);
}
if (this.isAlive()) {
logger.warn("Thread {0} is apparently hung.", (Object)this);
this.interrupt();
}
}
}
}