buildSrc/src/main/java/cc/squirreljme/plugin/util/FossilExe.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the Mozilla Public License Version 2.0.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package cc.squirreljme.plugin.util;
  11
  12 import java.io.BufferedReader;
  13 import java.io.ByteArrayInputStream;
  14 import java.io.ByteArrayOutputStream;
  15 import java.io.IOException;
  16 import java.io.InputStream;
  17 import java.io.InputStreamReader;
  18 import java.nio.charset.StandardCharsets;
  19 import java.nio.file.Files;
  20 import java.nio.file.Path;
  21 import java.nio.file.Paths;
  22 import java.nio.file.StandardOpenOption;
  23 import java.util.ArrayList;
  24 import java.util.Arrays;
  25 import java.util.Collection;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.regex.Pattern;
  29 import org.gradle.internal.os.OperatingSystem;
  30
  31 /**
  32  * This class provides support for the Fossil executable, to do some tasks
  33  * and otherwise from within Gradle.
  34  *
  35  * @since 2020/06/24
  36  */
  37 public final class FossilExe
  38 {
  39         /** Cached executable. */
  40         @SuppressWarnings({"StaticVariableMayNotBeInitialized", "unused"})
  41         private static FossilExe _cached;
  42
  43         /** The executable path. */
  44         private final Path exe;
  45
  46         /**
  47          * Initializes the executable reference with the given path.
  48          *
  49          * @param __exe The executable path.
  50          * @throws NullPointerException On null arguments.
  51          * @since 2020/06/24
  52          */
  53         public FossilExe(Path __exe)
  54                 throws NullPointerException
  55         {
  56                 if (__exe == null)
  57                         throw new NullPointerException("NARG");
  58
  59                 this.exe = __exe;
  60         }
  61
  62         /**
  63          * Cats the given file name.
  64          *
  65          * @param __fileName The file name.
  66          * @return The file data.
  67          * @throws NullPointerException On null arguments.
  68          * @since 2020/06/27
  69          */
  70         public final byte[] cat(String __fileName)
  71                 throws NullPointerException
  72         {
  73                 if (__fileName == null)
  74                         throw new NullPointerException("NARG");
  75
  76                 return this.runRawOutput("cat", __fileName);
  77         }
  78
  79         /**
  80          * Returns the current fossil user.
  81          *
  82          * @return The current fossil user.
  83          * @throws InvalidFossilExeException If the user is not valid.
  84          * @since 2020/06/27
  85          */
  86         public final String currentUser()
  87                 throws InvalidFossilExeException
  88         {
  89                 // Use first line found for the user
  90                 for (String line : this.runLineOutput("user", "default"))
  91                         if (!line.isEmpty())
  92                                 return line.trim();
  93
  94                 // Fail
  95                 throw new InvalidFossilExeException("No default user set in Fossil, " +
  96                         "please set `fossil user default user.name`");
  97         }
  98
  99         /**
 100          * Returns the executable path.
 101          *
 102          * @return The executable path.
 103          * @since 2020/06/25
 104          */
 105         public final Path exePath()
 106         {
 107                 return this.exe;
 108         }
 109
 110         /**
 111          * Runs the specified command and returns the process for it.
 112          *
 113          * @param __args Arguments to the command.
 114          * @return The process of the command.
 115          * @since 2020/06/24
 116          */
 117         @SuppressWarnings("UseOfProcessBuilder")
 118         public final Process runCommand(String... __args)
 119         {
 120                 ProcessBuilder builder = new ProcessBuilder();
 121
 122                 // The first argument is always the command
 123                 List<String> command = new ArrayList<>();
 124                 command.add(this.exe.toAbsolutePath().toString());
 125
 126                 // Add all subsequent arguments
 127                 if (__args != null)
 128                         command.addAll(Arrays.<String>asList(__args));
 129
 130                 // Use this command
 131                 builder.command(command);
 132
 133                 // Standard output is always printed to the console, for debugging
 134                 builder.redirectError(ProcessBuilder.Redirect.INHERIT);
 135
 136                 // Force specific locales and otherwise
 137                 Map<String, String> env = builder.environment();
 138                 env.put("LC_ALL", "C");
 139
 140                 // Start the command but wrap IOException as it is annoying
 141                 try
 142                 {
 143                         return builder.start();
 144                 }
 145                 catch (IOException e)
 146                 {
 147                         throw new RuntimeException("Could not execute command.", e);
 148                 }
 149         }
 150
 151         /**
 152          * Executes the command and returns the lines used.
 153          *
 154          * @param __args The arguments to call.
 155          * @return The lines used in the command.
 156          * @since 2020/06/25
 157          */
 158         public final Collection<String> runLineOutput(String... __args)
 159         {
 160                 // Get the raw command bytes
 161                 Collection<String> rv = new ArrayList<>();
 162                 try (BufferedReader in = new BufferedReader(new InputStreamReader(
 163                         new ByteArrayInputStream(this.runRawOutput(__args)),
 164                         StandardCharsets.UTF_8)))
 165                 {
 166                         for (;;)
 167                         {
 168                                 String ln = in.readLine();
 169
 170                                 if (ln == null)
 171                                         break;
 172
 173                                 rv.add(ln);
 174                         }
 175                 }
 176
 177                 // Could no read the command result
 178                 catch (IOException e)
 179                 {
 180                         throw new RuntimeException("Line read/write error.", e);
 181                 }
 182
 183                 return rv;
 184         }
 185
 186         /**
 187          * Runs the command and returns the raw output.
 188          *
 189          * @param __args The commands to run.
 190          * @return The raw output of the command.
 191          * @since 2020/06/25
 192          */
 193         public final byte[] runRawOutput(String... __args)
 194         {
 195                 // Start the Fossil process
 196                 Process process = this.runCommand(__args);
 197
 198                 // Read in the command data
 199                 try (InputStream in = process.getInputStream();
 200                         ByteArrayOutputStream out = new ByteArrayOutputStream())
 201                 {
 202                         // Copy data
 203                         byte[] buf = new byte[4096];
 204                         for (;;)
 205                         {
 206                                 int rc = in.read(buf);
 207
 208                                 if (rc < 0)
 209                                         break;
 210
 211                                 out.write(buf, 0, rc);
 212                         }
 213
 214                         // Wait for it to complete
 215                         for (;;)
 216                                 try
 217                                 {
 218                                         int exitCode = process.waitFor();
 219                                         if (0 != exitCode)
 220                                                 throw new RuntimeException(String.format(
 221                                                         "Exited %s with failure %d: %d bytes",
 222                                                         Arrays.asList(__args), exitCode,
 223                                                         out.toByteArray().length));
 224                                         break;
 225                                 }
 226                                 catch (InterruptedException ignored)
 227                                 {
 228                                 }
 229
 230                         // Use the result
 231                         return out.toByteArray();
 232                 }
 233
 234                 // Could not read the command result
 235                 catch (IOException e)
 236                 {
 237                         throw new RuntimeException("Raw read/write error.", e);
 238                 }
 239
 240                 // Make sure the process stops
 241                 finally
 242                 {
 243                         // Make sure the process is destroyed
 244                         process.destroy();
 245                 }
 246         }
 247
 248         /**
 249          * Gets the content of the specified file.
 250          *
 251          * @param __fileName The file name.
 252          * @return The stream for the file data or {@code null} if no such file
 253          * exists or it has no content.
 254          * @throws NullPointerException On null arguments.
 255          * @since 2020/06/25
 256          */
 257         public final InputStream unversionCat(String __fileName)
 258                 throws NullPointerException
 259         {
 260                 if (__fileName == null)
 261                         throw new NullPointerException("NARG");
 262
 263                 byte[] data = this.unversionCatBytes(__fileName);
 264                 if (data == null)
 265                         return null;
 266
 267                 return new ByteArrayInputStream(data);
 268         }
 269
 270         /**
 271          * Gets the content of the specified file.
 272          *
 273          * @param __fileName The file name.
 274          * @return The stream for the file data or {@code null} if no such file
 275          * exists or it has no content.
 276          * @throws NullPointerException On null arguments.
 277          * @since 2020/06/25
 278          */
 279         public final byte[] unversionCatBytes(String __fileName)
 280                 throws NullPointerException
 281         {
 282                 // If no data is available, return nothing
 283                 byte[] data = this.runRawOutput("unversion", "cat", __fileName);
 284                 if (data.length == 0)
 285                         return null;
 286
 287                 return data;
 288         }
 289
 290         /**
 291          * Deletes the specified file.
 292          *
 293          * @param __path The path to delete.
 294          * @throws NullPointerException On null arguments.
 295          * @since 2022/08/29
 296          */
 297         public void unversionDelete(String __path)
 298                 throws NullPointerException
 299         {
 300                 if (__path == null)
 301                         throw new NullPointerException("NARG");
 302
 303                 this.runLineOutput("unversion", "rm", __path);
 304         }
 305
 306         /**
 307          * Returns the list of unversioned files.
 308          *
 309          * @return The list of unversioned files.
 310          * @since 2020/06/25
 311          */
 312         public final Collection<String> unversionList()
 313         {
 314                 return this.runLineOutput("unversion", "ls");
 315         }
 316
 317         /**
 318          * Stores unversion bytes.
 319          *
 320          * @param __fileName The file name.
 321          * @param __data The data to store.
 322          * @throws NullPointerException On null arguments.
 323          * @since 2020/06/27
 324          */
 325         public final void unversionStoreBytes(String __fileName, byte[] __data)
 326                 throws NullPointerException
 327         {
 328                 if (__fileName == null || __data == null)
 329                         throw new NullPointerException("NARG");
 330
 331                 // Fossil accepts files as unversioned input
 332                 Path tempFile = null;
 333                 try
 334                 {
 335                         // Setup temporary file
 336                         tempFile = Files.createTempFile("squirreljme-uvfile",
 337                                 ".bin");
 338
 339                         // Write data to file
 340                         Files.write(tempFile, __data, StandardOpenOption.WRITE,
 341                                 StandardOpenOption.TRUNCATE_EXISTING,
 342                                 StandardOpenOption.CREATE);
 343
 344                         // Store the file data
 345                         this.runRawOutput("unversion", "add",
 346                                 tempFile.toAbsolutePath().toString(),
 347                                 "--as", __fileName);
 348                 }
 349
 350                 // Could not write data
 351                 catch (IOException e)
 352                 {
 353                         throw new RuntimeException(
 354                                 "Could not store file: " + __fileName, e);
 355                 }
 356
 357                 // Clean out file, if it exists
 358                 finally
 359                 {
 360                         if (tempFile != null)
 361                                 try
 362                                 {
 363                                         Files.delete(tempFile);
 364                                 }
 365                                 catch (IOException ignored)
 366                                 {
 367                                 }
 368                 }
 369         }
 370
 371         /**
 372          * Stores unversion bytes.
 373          *
 374          * @param __fileName The file name.
 375          * @param __data The data to store.
 376          * @throws IOException On read errors.
 377          * @throws NullPointerException On null arguments.
 378          * @since 2022/08/29
 379          */
 380         public final void unversionStoreBytes(String __fileName,
 381                 InputStream __data)
 382                 throws IOException, NullPointerException
 383         {
 384                 if (__fileName == null || __data == null)
 385                         throw new NullPointerException("NARG");
 386
 387                 byte[] bytes;
 388                 try (ByteArrayOutputStream baos = new ByteArrayOutputStream())
 389                 {
 390                         // Copy over
 391                         byte[] buf = new byte[16384];
 392                         for (;;)
 393                         {
 394                                 int rc = __data.read(buf);
 395
 396                                 // EOF?
 397                                 if (rc < 0)
 398                                         break;
 399
 400                                 baos.write(buf, 0, rc);
 401                         }
 402
 403                         // Get all the bytes
 404                         bytes = baos.toByteArray();
 405                 }
 406
 407                 // Forward to store call
 408                 this.unversionStoreBytes(__fileName, bytes);
 409         }
 410
 411         /**
 412          * Returns the fossil version.
 413          *
 414          * @return The fossil version.
 415          * @since 2020/06/25
 416          */
 417         public final FossilVersion version()
 418         {
 419                 Collection<String> lines = this.runLineOutput("version");
 420
 421                 // Try to find the fossil version
 422                 for (String line : lines)
 423                 {
 424                         // Ignore lines not containing this text
 425                         if (!line.toLowerCase().contains("this is fossil version"))
 426                                 continue;
 427
 428                         // Try to find the version number
 429                         for (String split : line.split("[ \t]"))
 430                         {
 431                                 // Ignore blank sequences
 432                                 if (split.isEmpty())
 433                                         continue;
 434
 435                                 // Use the split that starts with a number
 436                                 char first = split.charAt(0);
 437                                 if (first >= '1' && first <= '9')
 438                                         try
 439                                         {
 440                                                 return new FossilVersion(split);
 441                                         }
 442                                         catch (IllegalArgumentException e)
 443                                         {
 444                                                 throw new InvalidFossilExeException("Invalid Exe", e);
 445                                         }
 446                         }
 447                 }
 448
 449                 // This is not a good thing
 450                 throw new InvalidFossilExeException("Could not find fossil version.");
 451         }
 452
 453         /**
 454          * Attempts to locate the fossil executable.
 455          *
 456          * @return The executable instance.
 457          * @throws InvalidFossilExeException If an executable could not be found.
 458          * @since 2020/06/24
 459          */
 460         @SuppressWarnings({"CallToSystemGetenv",
 461                 "StaticVariableUsedBeforeInitialization"})
 462         public static FossilExe instance()
 463                 throws InvalidFossilExeException
 464         {
 465                 // Pre-cached already?
 466                 FossilExe rv = FossilExe._cached;
 467                 if (rv != null)
 468                         return rv;
 469
 470                 // Try to find it
 471                 Path maybe = PathUtils.findPathExecutable("fossil");
 472                 if (maybe == null)
 473                         throw new InvalidFossilExeException(
 474                                 "Could not find Fossil executable.");
 475
 476                 // Cache for later
 477                 rv = new FossilExe(maybe);
 478                 FossilExe._cached = rv;
 479                 return rv;
 480         }
 481
 482         /**
 483          * Check to see if Fossil is available.
 484          *
 485          * @param __withUser Also check that the user is set?
 486          * @return If Fossil is available.
 487          * @since 2020/06/25
 488          */
 489         public static boolean isAvailable(boolean __withUser)
 490         {
 491                 try
 492                 {
 493                         FossilExe exe = FossilExe.instance();
 494
 495                         // These will throw exceptions if not valid
 496                         exe.version();
 497
 498                         // Check user as well?
 499                         if (__withUser)
 500                                 exe.currentUser();
 501
 502                         return true;
 503                 }
 504
 505                 // Not available
 506                 catch (InvalidFossilExeException ignored)
 507                 {
 508                         return false;
 509                 }
 510         }
 511 }