1 /*
2 * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.jpackager.internal.windows;
27
28 import jdk.jpackager.internal.AbstractImageBundler;
29 import jdk.jpackager.internal.BundlerParamInfo;
30 import jdk.jpackager.internal.ConfigException;
31 import jdk.jpackager.internal.IOUtils;
32 import jdk.jpackager.internal.Log;
33 import jdk.jpackager.internal.Platform;
34 import jdk.jpackager.internal.StandardBundlerParam;
35 import jdk.jpackager.internal.UnsupportedPlatformException;
36 import jdk.jpackager.internal.builders.windows.WindowsAppImageBuilder;
37 import jdk.jpackager.internal.resources.windows.WinResources;
38 import jdk.jpackager.internal.JLinkBundlerHelper;
39 import jdk.jpackager.internal.Arguments;
40 import jdk.jpackager.internal.builders.AbstractAppImageBuilder;
41
42 import java.io.ByteArrayOutputStream;
43 import java.io.File;
44 import java.io.IOException;
45 import java.io.PrintStream;
46 import java.text.MessageFormat;
47 import java.util.Arrays;
48 import java.util.Collection;
49 import java.util.Map;
50 import java.util.ResourceBundle;
51
52 import static jdk.jpackager.internal.windows.WindowsBundlerParam.*;
53 import static jdk.jpackager.internal.windows.WinMsiBundler.WIN_APP_IMAGE;
54
55 public class WinAppBundler extends AbstractImageBundler {
56
57 private static final ResourceBundle I18N =
58 ResourceBundle.getBundle(
59 "jdk.jpackager.internal.resources.windows.WinAppBundler");
60
61 public static final BundlerParamInfo<File> ICON_ICO =
62 new StandardBundlerParam<>(
63 I18N.getString("param.icon-ico.name"),
64 I18N.getString("param.icon-ico.description"),
65 "icon.ico",
66 File.class,
67 params -> {
68 File f = ICON.fetchFrom(params);
69 if (f != null && !f.getName().toLowerCase().endsWith(".ico")) {
70 Log.error(MessageFormat.format(
71 I18N.getString("message.icon-not-ico"), f));
72 return null;
73 }
74 return f;
75 },
76 (s, p) -> new File(s));
77
78 public WinAppBundler() {
79 super();
80 baseResourceLoader = WinResources.class;
81 }
82
83 public final static String WIN_BUNDLER_PREFIX =
84 BUNDLER_PREFIX + "windows/";
85
86 @Override
87 public boolean validate(Map<String, ? super Object> params)
88 throws UnsupportedPlatformException, ConfigException {
89 try {
90 if (params == null) throw new ConfigException(
91 I18N.getString("error.parameters-null"),
92 I18N.getString("error.parameters-null.advice"));
93
94 return doValidate(params);
95 } catch (RuntimeException re) {
96 if (re.getCause() instanceof ConfigException) {
97 throw (ConfigException) re.getCause();
98 } else {
99 throw new ConfigException(re);
100 }
101 }
102 }
103
104 // to be used by chained bundlers, e.g. by EXE bundler to avoid
105 // skipping validation if p.type does not include "image"
106 boolean doValidate(Map<String, ? super Object> p)
107 throws UnsupportedPlatformException, ConfigException {
108 if (Platform.getPlatform() != Platform.WINDOWS) {
109 throw new UnsupportedPlatformException();
110 }
111
112 imageBundleValidation(p);
113
114 if (StandardBundlerParam.getPredefinedAppImage(p) != null) {
115 return true;
116 }
117
118 // Make sure that jpackager.exe exists.
119 File tool = new File(
120 System.getProperty("java.home") + "\\bin\\jpackager.exe");
121
122 if (!tool.exists()) {
123 throw new ConfigException(
124 I18N.getString("error.no-windows-resources"),
125 I18N.getString("error.no-windows-resources.advice"));
126 }
127
128 // validate runtime bit-architectire
129 testRuntimeBitArchitecture(p);
130
131 return true;
132 }
133
134 private static void testRuntimeBitArchitecture(
135 Map<String, ? super Object> params) throws ConfigException {
136 if ("true".equalsIgnoreCase(System.getProperty(
137 "fxpackager.disableBitArchitectureMismatchCheck"))) {
138 Log.debug(I18N.getString("message.disable-bit-architecture-check"));
139 return;
140 }
141
142 if ((BIT_ARCH_64.fetchFrom(params) !=
143 BIT_ARCH_64_RUNTIME.fetchFrom(params))) {
144 throw new ConfigException(
145 I18N.getString("error.bit-architecture-mismatch"),
146 I18N.getString("error.bit-architecture-mismatch.advice"));
147 }
148 }
149
150 private static boolean usePredefineAppName(Map<String, ? super Object> p) {
151 return (PREDEFINED_APP_IMAGE.fetchFrom(p) != null);
152 }
153
154 private static String appName;
155 synchronized static String getAppName(
156 Map<String, ? super Object> p) {
157 // If we building from predefined app image, then we should use names
158 // from image and not from CLI.
159 if (usePredefineAppName(p)) {
160 if (appName == null) {
161 // Use WIN_APP_IMAGE here, since we already copy pre-defined
162 // image to WIN_APP_IMAGE
163 File appImageDir = new File(
164 WIN_APP_IMAGE.fetchFrom(p).toString() + "\\app");
165 File [] files = appImageDir.listFiles(
166 (File dir, String name) -> name.endsWith(".cfg"));
167 if (files == null || files.length == 0) {
168 throw new RuntimeException(MessageFormat.format(
169 I18N.getString("error.cannot-find-launcher"),
170 appImageDir));
171 } else {
172 appName = files[0].getName();
173 int index = appName.indexOf(".");
174 if (index != -1) {
175 appName = appName.substring(0, index);
176 }
177 if (files.length > 1) {
178 Log.error(MessageFormat.format(I18N.getString(
179 "message.multiple-launchers"), appName));
180 }
181 }
182 return appName;
183 } else {
184 return appName;
185 }
186 }
187
188 return APP_NAME.fetchFrom(p);
189 }
190
191 public static String getLauncherName(Map<String, ? super Object> p) {
192 return getAppName(p) + ".exe";
193 }
194
195 public static String getLauncherCfgName(Map<String, ? super Object> p) {
196 return "app\\" + getAppName(p) +".cfg";
197 }
198
199 public boolean bundle(Map<String, ? super Object> p, File outputDirectory) {
200 return doBundle(p, outputDirectory, false) != null;
201 }
202
203 File doBundle(Map<String, ? super Object> p,
204 File outputDirectory, boolean dependentTask) {
205 if (Arguments.CREATE_JRE_INSTALLER.fetchFrom(p)) {
206 return doJreBundle(p, outputDirectory, dependentTask);
207 } else {
208 return doAppBundle(p, outputDirectory, dependentTask);
209 }
210 }
211
212 File doJreBundle(Map<String, ? super Object> p,
213 File outputDirectory, boolean dependentTask) {
214 try {
215 File rootDirectory = createRoot(p, outputDirectory, dependentTask,
216 APP_NAME.fetchFrom(p), "windowsapp-image-builder");
217 AbstractAppImageBuilder appBuilder = new WindowsAppImageBuilder(
218 APP_NAME.fetchFrom(p),
219 outputDirectory.toPath());
220 File predefined = PREDEFINED_RUNTIME_IMAGE.fetchFrom(p);
221 if (predefined == null ) {
222 JLinkBundlerHelper.generateServerJre(p, appBuilder);
223 } else {
224 return predefined;
225 }
226 return rootDirectory;
227 } catch (Exception ex) {
228 Log.error("Exception: "+ex);
229 Log.verbose(ex);
230 return null;
231 }
232 }
233
234 File doAppBundle(Map<String, ? super Object> p,
235 File outputDirectory, boolean dependentTask) {
236 try {
237 File rootDirectory = createRoot(p, outputDirectory, dependentTask,
238 APP_NAME.fetchFrom(p), "windowsapp-image-builder");
239 AbstractAppImageBuilder appBuilder =
240 new WindowsAppImageBuilder(p, outputDirectory.toPath());
241 if (PREDEFINED_RUNTIME_IMAGE.fetchFrom(p) == null ) {
242 JLinkBundlerHelper.execute(p, appBuilder);
243 } else {
244 StandardBundlerParam.copyPredefinedRuntimeImage(p, appBuilder);
245 }
246 if (!dependentTask) {
247 Log.verbose(MessageFormat.format(
248 I18N.getString("message.result-dir"),
249 outputDirectory.getAbsolutePath()));
250 }
251 return rootDirectory;
252 } catch (Exception ex) {
253 Log.error("Exception: "+ex);
254 Log.verbose(ex);
255 return null;
256 }
257 }
258
259 private static final String RUNTIME_AUTO_DETECT = ".runtime.autodetect";
260
261 public static void extractFlagsFromRuntime(
262 Map<String, ? super Object> params) {
263 if (params.containsKey(".runtime.autodetect")) return;
264
265 params.put(RUNTIME_AUTO_DETECT, "attempted");
266
267 String commandline;
268 File runtimePath = JLinkBundlerHelper.getJDKHome(params).toFile();
269 File launcherPath = new File(runtimePath, "bin\\java.exe");
270
271 ProcessBuilder pb =
272 new ProcessBuilder(launcherPath.getAbsolutePath(), "-version");
273 try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
274 try (PrintStream pout = new PrintStream(baos)) {
275 IOUtils.exec(pb, Log.isDebug(), true, pout);
276 }
277
278 commandline = baos.toString();
279 } catch (IOException e) {
280 e.printStackTrace();
281 params.put(RUNTIME_AUTO_DETECT, "failed");
282 return;
283 }
284
285 AbstractImageBundler.extractFlagsFromVersion(params, commandline);
286 params.put(RUNTIME_AUTO_DETECT, "succeeded");
287 }
288
289 @Override
290 public String getName() {
291 return I18N.getString("bundler.name");
292 }
293
294 @Override
295 public String getDescription() {
296 return I18N.getString("bundler.description");
297 }
298
299 @Override
300 public String getID() {
301 return "windows.app";
302 }
303
304 @Override
305 public String getBundleType() {
306 return "IMAGE";
307 }
308
309 @Override
310 public Collection<BundlerParamInfo<?>> getBundleParameters() {
311 return getAppBundleParameters();
312 }
313
314 public static Collection<BundlerParamInfo<?>> getAppBundleParameters() {
315 return Arrays.asList(
316 APP_NAME,
317 APP_RESOURCES,
318 ARGUMENTS,
319 CLASSPATH,
320 ICON_ICO,
321 JVM_OPTIONS,
322 JVM_PROPERTIES,
323 MAIN_CLASS,
324 MAIN_JAR,
325 PREFERENCES_ID,
326 VERSION,
327 VERBOSE
328 );
329 }
330
331 @Override
332 public File execute(
333 Map<String, ? super Object> params, File outputParentDir) {
334 return doBundle(params, outputParentDir, false);
335 }
336
337 @Override
338 public boolean supported() {
339 return (Platform.getPlatform() == Platform.WINDOWS);
340 }
341
342 }