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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
package cbt;
import java.io.*;
import java.lang.reflect.*;
import java.net.*;
import java.nio.*;
import java.nio.file.*;
import java.security.*;
import java.util.*;
import javax.xml.bind.annotation.adapters.HexBinaryAdapter;
import static java.io.File.pathSeparator;
import static cbt.NailgunLauncher.*;
import java.nio.file.*;
import java.nio.file.attribute.FileTime;
public class Stage0Lib{
public static void _assert(Boolean condition, Object msg){
if(!condition){
throw new AssertionError("Assertion failed: "+msg);
}
}
public static int runMain(String cls, String[] args, ClassLoader cl) throws Throwable{
Boolean trapExitCodeBefore = NailgunLauncher.trapExitCode.get();
try{
NailgunLauncher.trapExitCode.set(true);
cl.loadClass(cls)
.getMethod("main", String[].class)
.invoke( null, (Object) args);
return 0;
}catch( InvocationTargetException exception ){
Throwable cause = exception.getCause();
if(cause instanceof TrappedExitCode){
return ((TrappedExitCode) cause).exitCode;
}
throw exception;
} finally {
NailgunLauncher.trapExitCode.set(trapExitCodeBefore);
}
}
public static Object get(Object object, String method) throws Throwable{
return object.getClass().getMethod( method ).invoke(object);
}
public static String classpath( String... files ){
Arrays.sort(files);
return join( pathSeparator, files );
}
public static File write(File file, String content, OpenOption... options) throws Throwable{
file.getParentFile().mkdirs();
Files.write(file.toPath(), content.getBytes(), options);
return file;
}
public static Boolean compile(
Boolean changed, Long start, String classpath, String target,
EarlyDependencies earlyDeps, List<File> sourceFiles
) throws Throwable{
File statusFile = new File( new File(target) + ".last-success" );
Long lastSuccessfullCompile = statusFile.lastModified();
for( File file: sourceFiles ){
if( file.lastModified() > lastSuccessfullCompile ){
changed = true;
break;
}
}
if(changed){
List<String> zincArgs = new ArrayList<String>(
Arrays.asList(
new String[]{
"-scala-compiler", earlyDeps.scalaCompiler_2_11_8_File,
"-scala-library", earlyDeps.scalaLibrary_2_11_8_File,
"-scala-extra", earlyDeps.scalaReflect_2_11_8_File,
"-sbt-interface", earlyDeps.sbtInterface_0_13_9_File,
"-compiler-interface", earlyDeps.compilerInterface_0_13_9_File,
"-cp", classpath,
"-d", target,
"-S-deprecation",
"-S-feature",
"-S-unchecked"
}
)
);
for( File f: sourceFiles ){
zincArgs.add(f.toString());
}
PrintStream oldOut = System.out;
try{
System.setOut(System.err);
int exitCode = runMain( "com.typesafe.zinc.Main", zincArgs.toArray(new String[zincArgs.size()]), earlyDeps.zinc );
if( exitCode == 0 ){
write( statusFile, "" );
Files.setLastModifiedTime( statusFile.toPath(), FileTime.fromMillis(start) );
} else {
System.exit( exitCode );
}
} finally {
System.setOut(oldOut);
}
}
return changed;
}
public static ClassLoader classLoader( String file ) throws Throwable{
return new CbtURLClassLoader(
new URL[]{ new URL("file:"+file) }
);
}
public static ClassLoader classLoader( String file, ClassLoader parent ) throws Throwable{
return new CbtURLClassLoader(
new URL[]{ new URL("file:"+file) }, parent
);
}
private static String getVarFromEnv(String envKey) {
String value = System.getenv(envKey);
if(value==null || value.isEmpty()) {
value = System.getenv(envKey.toUpperCase());
}
return value;
}
private static void setProxyfromPropOrEnv(String envKey, String propKeyH, String propKeyP) {
String proxyHost = System.getProperty(propKeyH);
String proxyPort = System.getProperty(propKeyP);
if((proxyHost==null || proxyHost.isEmpty()) && (proxyPort==null || proxyPort.isEmpty())) {
String envVar = getVarFromEnv(envKey);
if(envVar != null && !envVar.isEmpty()) {
String[] proxy = envVar.replaceFirst("^https?://", "").split(":", 2);
System.setProperty(propKeyH, proxy[0]);
System.setProperty(propKeyP, proxy[1]);
}
}
}
public static void installProxySettings() throws URISyntaxException {
setProxyfromPropOrEnv("http_proxy", "http.proxyHost", "http.proxyPort");
setProxyfromPropOrEnv("https_proxy", "https.proxyHost", "https.proxyPort");
String nonHosts = System.getProperty("http.nonProxyHosts");
if(nonHosts==null || nonHosts.isEmpty()) {
String envVar = getVarFromEnv("no_proxy");
if(envVar != null && !envVar.isEmpty()) {
System.setProperty("http.nonProxyHosts", envVar.replaceAll(",","|"));
}
}
}
private static final ProxySelector ps = ProxySelector.getDefault();
public static HttpURLConnection openConnectionConsideringProxy(URL urlString)
throws IOException, URISyntaxException {
java.net.Proxy proxy = ps.select(urlString.toURI()).get(0);
return (HttpURLConnection) urlString.openConnection(proxy);
}
public static void download(URL urlString, Path target, String sha1) throws Throwable {
final Path unverified = Paths.get(target+".unverified");
if(!Files.exists(target)) {
new File(target.toString()).getParentFile().mkdirs();
System.err.println("downloading " + urlString);
System.err.println("to " + target);
final InputStream stream = openConnectionConsideringProxy(urlString).getInputStream();
Files.copy(stream, unverified, StandardCopyOption.REPLACE_EXISTING);
stream.close();
final String checksum = sha1(Files.readAllBytes(unverified));
if(sha1 == null || sha1.toUpperCase().equals(checksum)) {
Files.move(unverified, target, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
} else {
System.err.println(target + " checksum does not match.\nExpected: |" + sha1 + "|\nFound: |" + checksum + "|");
System.exit(1);
}
}
}
public static String sha1(byte[] bytes) throws Throwable {
final MessageDigest sha1 = MessageDigest.getInstance("SHA1");
sha1.update(bytes, 0, bytes.length);
return (new HexBinaryAdapter()).marshal(sha1.digest()).toUpperCase();
}
public static String join(String separator, String[] parts){
String result = parts[0];
for(int i = 1; i < parts.length; i++){
result += separator + parts[i];
}
return result;
}
public static String[] append( String[] array, String item ){
String[] copy = Arrays.copyOf(array, array.length + 1);
copy[array.length] = item;
return copy;
}
}
|
