Heuristic Services

Plugin architecture with Symfony

2023-03-31T00:00:00+00:00

Symfony no longer recommends organising your application using bundles, however bundles are still recommended when you want to share features and functions between multiple applications.

This post examines how bundles are also useful to allow the concept of plugins, or extensions, to be registered dynamically with your core application. It uses the scenario of a BankingApp wanting to support many banking backends, or services.

The idea is that we want to be able to register multiple backends dynamically, using composer in the BankingApp, in a BankingService.

At the end, we want to be able to call these services using a simple key, which in this case is a string acme_bank:

$bankService->getBank('acme_bank')->deposit(100);

One of our backends is called “Acme Bank” and is provided by the Symfony bundle acme-bank-bundle.

It provides the AcmeBankService:

class AcmeBankService implements Bank
{
    public function deposit(int $amount): string
    {
        return sprintf("Deposited %d into AcmeBank", $amount);
    }
....

This is registered as a Symfony services in services.php:

$services->set(AcmeBankService::class)
    ->public()
    ->autowire()
    ->autoconfigure()
    ->tag('banking_app.bank', []);

Importantly the service is tagged with the key banking_app.bank.

We can add the acme-bank-bundle to the BankApp in the usual way, by installing the bundle using composer.

Please be aware, that as these composer packages are not part of a public registry, I have added them as local repositories, you will need to update the path if you want to use them:

"repositories": [
    {
        "type": "path",
        "url": "/home/hs/git/banking-app-api"
    },
    {
        "type": "path",
        "url": "/home/hs/git/acme-bank-bundle"
    }
]

You can register the bundle in the usual way in BankingApp:

BankingApp\AcmeBankBundle\BankingAppAcmeBankBundle::class => ['all' => true],

Given the service in acme-banking-bundle tagged with banking_app.bank, we can add a compiler pass to the BankingApp application to detect these services and add it to a registry within our BankingService:

$bankServiceDefinition = $containerBuilder->findDefinition(BankService::class);

foreach ($containerBuilder->findTaggedServiceIds('banking_app.bank') as $id => $tags) {
    $bankServiceDefinition->addMethodCall('addBank', [new Reference($id)]);
}

Firstly, this finds our BankingService, then when it detects that our bundle has tagged a service with banking_app.bank, it will add it to our registry by calling addBank on our BankService:

class BankService
{
    private array $bankRegistry = [];
    public function addBank(Bank $bank): void 
    {
        $this->bankRegistry[$bank->getName()] = $bank;
    }
}

If you noticed, in our composer file, I also included a package called banking-app-api, which has the interface Bank:

interface Bank
{
    public function deposit(int $amount): string;
    public function getName(): string;
}

The BankingApp and the banking-app-bundle both have a dependency on this interface, so that we can use PHP types. This means that the BankingApp will never end up calling a method that does not exist on our bank service at runtime.

The API has to exist outside of both projects, as if it were defined in the BankingApp, this would introduce a circular dependency, as the acme-bank-bundle becomes dependent on the BankingApp and the BankingApp has a dependency on the acme-bank-bundle.

Finally, we can use our BankService in the HomeController in BankingApp:

#[Route('/')]
public function home(BankService $bankService) {
    return new Response($bankService->getBank('acme_bank')->deposit(100));
}

This returns:

 Deposited 100 into AcmeBank

In this case, the acme_bank could be a key that is stored in a database, associated with that user. The bank’s name comes from a further method we have defined in our API:

 public function getName(): string;

This is a simple example, however all the infrastructure is there to build out more complex systems, for example, you could initiate an OAuth flow using another method in the API:

 public function getOAuthLink(string $userId): string;

You could iterate over your bank registry and display this link for each of the banking_app.bank services that have been registered.

MQTT and SSL

2022-04-11T00:00:00+00:00

Using a directly-trusted server certificate

Moquette is a broker that supports SSL. In the Moquette documentation, it mentions you can generate a keypair as a Java keystore:

~$ keytool -keystore serverkeystore.pkcs12 -alias testserver -genkey -keyalg RSA

Make sure that the path to the keystore is the filesystem path, not the file:/// URL.

final String keystorePath = Objects.requireNonNull(Broker.class.getResource("serverkeystore.pkcs12")).getPath();
properties.put(SSL_PORT_PROPERTY_NAME, "8883");
properties.put(JKS_PATH_PROPERTY_NAME, keystorePath);
properties.put(KEY_STORE_PASSWORD_PROPERTY_NAME, "password");
properties.put(KEY_MANAGER_PASSWORD_PROPERTY_NAME, "password");

If you use a client such as the hivemq-mqtt-client, then you will find that it fails, as it fails to validate the Subject Alternative Name (SAN).

Exception in thread "main" com.hivemq.client.mqtt.exceptions.ConnectionFailedException: javax.net.ssl.SSLHandshakeException: No subject alternative names present

A certificate can be generated using a SAN, in this case for localhost:

keytool -keystore serverkeystore.pkcs12 -alias testserver -genkey -keyalg RSA -dname "CN=127.0.0.1" -ext "SAN=IP:127.0.0.1"

You can list the certificate in the keystore with:

keytool -list -keystore serverkeystore.pkcs12

We’ll need to add this certificate to the client’s (in this case HiveMQTT) trust store, so export the certificate using:

keytool -export -alias testserver -keystore serverkeystore.pkcs12 -file testserver.crt

You can inspect the certificate by using openssql and specifying it needs to read the DER binary format:

openssl x509 -inform der -in testserver.crt -text

Continue to follow the Moquette documentation to create a keystore that trusts this certificate for the client:

keytool -keystore clientkeystore.pkcs12 -genkey -keyalg RSA
keytool -keystore clientkeystore.pkcs12 -import -alias testserver -file testserver.crt -trustcacerts

Configure the HiveMQTT client to use this directly trusted certificate and subscribe to a test message:

public static void main(String[] args) throws CertificateException, KeyStoreException, IOException, NoSuchAlgorithmException, URISyntaxException, InterruptedException {
    final Mqtt3BlockingClient client = com.hivemq.client.mqtt.MqttClient.builder()
            .useMqttVersion3()
            .serverHost("127.0.0.1")
            .serverPort(8883)
            .identifier("testClient")
            .sslConfig().trustManagerFactory(getTrustManagerFactory()).applySslConfig()
            .buildBlocking();
    client.connect();

    client.toAsync()
            .subscribeWith()
            .topicFilter("+/topic/hello")
            .callback(e -> System.out.printf("%s %s", e.getTopic(), new String(e.getPayloadAsBytes())))
            .send();

    client.publishWith()
            .topic("test/topic/hello")
            .payload("Test message".getBytes(StandardCharsets.UTF_8))
            .send();
}

private static TrustManagerFactory getTrustManagerFactory() throws KeyStoreException, IOException, CertificateException, NoSuchAlgorithmException, URISyntaxException {
    final KeyStore keystore = KeyStore.getInstance("pkcs12");
    final InputStream in = new FileInputStream(Objects.requireNonNull(Client.class.getResource("clientkeystore.pkcs12")).getFile());
    keystore.load(in, "password".toCharArray());

    final TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
    trustManagerFactory.init(keystore);

    return trustManagerFactory;
}

Implementing Postgres UUID primary keys with Spring Boot and Hibernate

2019-09-14T00:00:00+00:00

An alternative to auto-increment sequential primary keys, is using a Universally Unique Identifier. Spring Boot and Hibernate support them and you can use them using Spring Data’s autogenerated SQL, JPQL and native queries.

As a demonstration project, you can clone spring-boot-hibernate-postgres-uuids.

To run the examples, you’ll need docker and docker-compose installed. You can setup the project by running docker-compose up in the docker directory. Doing this will create a new database, and automatically install the uuid-ossp extension.

Creating the Entity model

The project uses a User model as an example. You can setup Hibernate to use a UUID for its entity ID by using the annotations below.

@Entity
@Table(name = "users", schema = "spring_boot_uuids", uniqueConstraints = {
        @UniqueConstraint(columnNames = "email", name = "UNIQUE_EMAIL")
})
public class User
{
    @Id
    @Column
    @Type(type="pg-uuid")
    @GenericGenerator(name = "uuid-gen", strategy = "uuid2")
    @GeneratedValue(generator = "uuid-gen")
    private UUID id;

    [snip]
}

Creating the Spring Data Repository

You can create a CrudRepository using a UUID as the identifier.

@Repository
public interface UserRepository extends CrudRepository<User, UUID>
{
    [snip]
}

Now you can use the CrudRepository autogenerated retrieve functions.

    @Test
    public void savesUserWithId()
    {
        User user = new User();
        user.setEmail(TEST_EMAIL_ADDRESS);
        User persistedUser = userRepository.save(user);
        assertThat(persistedUser.getId(), is(not(nullValue())));
    }

If you create a projection, it will work with that too.

public interface UserDisplay
{
    UUID getId();

    String getEmail();

    @Value("#{T(java.time.Period).between(target.dateOfBirth, T(java.time.LocalDate).now()).getYears()}")
    Integer getAge();
}

You can use the projection in combination with a JPQL query,

    @Query("SELECT u.id AS id, " +
           "u.email AS email, " +
           "u.dateOfBirth AS dateOfBirth " +
           "FROM User u WHERE u.id = :userId")
    Optional<UserDisplay> getDisplayById(@Param("userId") UUID userId);

and a native query:

    @Query(value = "SELECT CAST(u.id AS VARCHAR) AS id, " +
            "u.email AS email," +
            "u.date_of_birth AS dateOfBirth " +
            "FROM spring_boot_uuids.users u " +
            "WHERE u.id = :userId", nativeQuery = true)
    Optional<UserDisplay> getNativeDisplayById(@Param("userId") UUID userId);

You’ll notice that the native query requires that the UUID be cast to a VARCHAR datatype. This is because currently Hibernate does not correctly recognise the raw UUID type.

First post

2019-08-11T00:00:00+00:00

public class HelloWorld
{
    public static void main(String[] args)
    {
        System.out.println("Hello world...");
    }
}