Migrating from a database to static blog

{
  "date": "2021-03-22T05:45:56.317",
  "categories": [ (2)
    {
      "id": 51,
      "name": "Java/EE/Microprofile",
      "slug": "javaee",
      "color": "#fe005e"
    },
    ...
  ],
  "posts": [ (1)
    {
      "id": 151,
      "title": "Bye bye wordpress.com, Hello RBlog!",
      "author": "rmannibucau",
      "slug": "bye-bye-wordpress",
      "type": "POST",
      "content": "<p>Blogging is probably the easiest way to share some tips and experiences. ...",
      "summary": "I started blogging in 2012 on wordpress.com ...",
      "published": "2016-05-26 23:49:00",
      "created": "2016-05-26 23:49:00",
      "updated": "2016-05-26 23:49:00",
      "categories": { (2)
        "id": 53,
        "name": "Other"
      }
    },
    ...
  ],
  ...
}

<dependency>
  <groupId>commons-net</groupId>
  <artifactId>commons-net</artifactId>
  <version>3.8.0</version>
  <scope>provided</scope>
</dependency>
<dependency>
  <groupId>org.talend.sdk.component</groupId>
  <artifactId>component-runtime-junit</artifactId>
  <version>1.31.0</version>
  <scope>provided</scope>
  <exclusions>
    <exclusion> <!-- no need of transitive deps -->
      <groupId>*</groupId>
      <artifactId>*</artifactId>
    </exclusion>
  </exclusions>
</dependency>

import org.apache.commons.net.ftp.FTPClient;
import org.talend.sdk.component.maven.Server;

import java.io.IOException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.function.Function;

public class FTPClientPool implements AutoCloseable {
    private final BlockingQueue<FTPClient> clients;

    public FTPClientPool(final int count, final Server credentials, final String host, final int port) throws IOException {
        try {
            clients = new ArrayBlockingQueue<>(count);
            for (int i = 0; i < count; i++) {
                final var client = new FTPClient();
                client.connect(host, port);
                if (!client.login(credentials.getUsername(), credentials.getPassword())) {
                    throw new IllegalArgumentException("Can't log in");
                }
                clients.add(client);
            }
        } catch (final RuntimeException | IOException re) {
            close();
            throw re;
        }
    }

    public <T> T withClient(final Function<FTPClient, T> fn) throws InterruptedException {
        final var client = clients.take();
        try {
            return fn.apply(client);
        } finally {
            clients.add(client);
        }
    }

    @Override
    public void close() {
        clients.forEach(it -> {
            try {
                it.disconnect();
            } catch (final IOException e) {
                // no-op
            }
        });
        clients.clear();
    }
}

record FileSpec(String name, long size) {}

public final class SynchronizeFTP {
    public static void main(final String... args) throws Exception {
        final var credentials = new MavenDecrypter().find("blog-ftp"); (1)
        final var pool = Executors.newWorkStealingPool(); (2)
        try (var ftp = new FTPClientPool(Integer.get("ftp.concurrency", 1), credentials, "xxxx.net", 21)) { (3)
            (4)
            final var remoteFiles = listFiles(pool, ftp, "/webapps/ROOT")
                    .toCompletableFuture()
                    .get();

            (5)
            final var sourceFolder = Paths.get("target/rmannibucau-blog");
            final var localFiles = listFiles(sourceFolder);

            (6)
            final var diff = new ArrayList<>(localFiles);
            diff.removeAll(remoteFiles);

            if (!diff.isEmpty()) {
                ftp.withClient(client -> {
                    diff.forEach(file -> { (7)
                        final var from = sourceFolder.resolve(file.name());
                        try (final var stream = Files.newInputStream(from)) {
                            client.storeFile("/webapps/ROOT/" + file.name(), stream);
                        } catch (final IOException e) {
                            throw new IllegalStateException(e);
                        }
                    });
                    return null;
                });
            }
        } finally {
            pool.shutdownNow();
        }
    }
}

private static List<FileSpec> listFiles(final Path path) throws IOException {
    final var files = new ArrayList<FileSpec>(256);
    Files.walkFileTree(path, new SimpleFileVisitor<>() {
        @Override
        public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
            final var filename = file.getFileName().toString();
            (1)
            if (("war-tracker".equals(filename) || "MANIFEST.MF".equals(filename)) &&
                    file.getParent() != null && "META-INF".equals(file.getParent().getFileName().toString())) {
                return FileVisitResult.SKIP_SUBTREE;
            }
            files.add(new FileSpec(path.relativize(file).toString().replace(File.separatorChar, '/'), Files.size(file)));
            return super.visitFile(file, attrs);
        }

        @Override
        public FileVisitResult preVisitDirectory(final Path dir, final BasicFileAttributes attrs) throws IOException {
            (1)
            if ("maven".equals(dir.getFileName().toString()) &&
                    dir.getParent() != null && "META-INF".equals(dir.getParent().getFileName().toString())) {
                return FileVisitResult.SKIP_SUBTREE;
            }
            return super.preVisitDirectory(dir, attrs);
        }
    });
    return files;
}

private static CompletionStage<Collection<FileSpec>> listFiles(final ExecutorService pool, final FTPClientPool ftp,
                                                               final String dir) throws IOException {
    final var files = new ArrayList<FileSpec>(256);
    final FTPFile[] listFiles;
    try {
        listFiles = ftp.withClient(client -> { (1)
            try {
                return client.listFiles(dir);
            } catch (final IOException e) {
                throw new IllegalStateException(e);
            }
        });
    } catch (final InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new IllegalStateException(e);
    }
    final var promise = new CompletableFuture<Collection<FileSpec>>();
    try {
        pool.submit(() -> { (2)
            var facade = CompletableFuture.<Void>completedFuture(null); (3)
            try {
                for (final FTPFile ftpFile : listFiles) {
                    (4)
                    if (("maven".equals(ftpFile.getName()) || "war-tracker".equals(ftpFile.getName()) || "MANIFEST.MF".equals(ftpFile.getName())) &&
                            dir.endsWith("META-INF")) { // ignore these ones
                        continue;
                    }
                    (5)
                    if (ftpFile.isFile()) {
                        final var remoteFile = new FileSpec(ftpFile.getName(), ftpFile.getSize());
                        synchronized (files) {
                            files.add(remoteFile);
                        }
                    } else if (ftpFile.isDirectory()) {
                        facade = facade (6)
                                .thenCompose(ignored -> {
                                    try {
                                        return listFiles(pool, ftp, dir + '/' + ftpFile.getName());
                                    } catch (final IOException e) {
                                        throw new IllegalStateException(e);
                                    }
                                })
                                .thenApply(list -> list.stream()
                                        .map(f -> new FileSpec(ftpFile.getName() + '/' + f.name(), f.size()))
                                        .collect(toList()))
                                .thenAccept(list -> {
                                    synchronized (files) {
                                        files.addAll(list);
                                    }
                                });
                    }
                }
                facade.whenComplete((r, e) -> { (7)
                    if (e != null) {
                        promise.completeExceptionally(e);
                    } else {
                        promise.complete(files);
                    }
                });
            } catch (final RuntimeException re) {
                promise.completeExceptionally(re);
            }
        });
    } catch (final RuntimeException re) { (8)
        promise.completeExceptionally(re);
    }
    return promise;
}

<plugins>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.1</version>
    <configuration>
      <source>16</source>
      <target>16</target>
      <release>16</release>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.3.1</version>
    <configuration>
      <failOnMissingWebXml>false</failOnMissingWebXml>
      <!-- ignore classes since it is a fully static website -->
      <classesDirectory>${project.build.directory}/skip-classes</classesDirectory>
    </configuration>
  </plugin>
  <plugin> <!-- to test or prepare an instance (version upgrade) -->
    <groupId>org.apache.tomee.maven</groupId>
    <artifactId>tomee-maven-plugin</artifactId>
    <version>8.0.5</version>
    <configuration>
      <context>ROOT</context>
      <removeDefaultWebapps>true</removeDefaultWebapps>

      <tomeeGroupId>org.apache.tomcat</tomeeGroupId>
      <tomeeArtifactId>tomcat</tomeeArtifactId>
      <tomeeVersion>10.0.4</tomeeVersion>
      <tomeeClassifier>ignore</tomeeClassifier>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>3.0.0</version>
    <executions>
      <execution>
        <id>sync</id>
        <phase>none</phase>
        <goals>
          <goal>java</goal>
        </goals>
        <configuration>
          <mainClass>com.github.rmannibucau.blog.migration.ftp.SynchronizeFTP</mainClass>
          <classpathScope>compile</classpathScope>
          <includeProjectDependencies>true</includeProjectDependencies>
          <stopUnresponsiveDaemonThreads>true</stopUnresponsiveDaemonThreads>
        </configuration>
      </execution>
    </executions>
  </plugin>
  <plugin>
    <groupId>io.yupiik.maven</groupId>
    <artifactId>yupiik-tools-maven-plugin</artifactId>
    <version>1.0.9-SNAPSHOT</version>
    <executions>
      <execution>
        <id>generate-site</id>
        <phase>process-classes</phase>
        <goals>
          <goal>minisite</goal>
        </goals>
      </execution>
    </executions>
    <configuration>
      <!-- same as before -->
    </configuration>
  </plugin>
</plugins>