oogifu

Self Quantified

2020-07-29T06:21:00.001+00:00

https://quantified-self.io/

Very good series of post on RxJava

2020-07-13T07:53:00.001+00:00

https://www.baeldung.com/rx-java

processing

2020-02-15T03:01:00.001+00:00

BIP32 and Public KCD

2019-12-19T05:13:00.000+00:00

https://github.com/tjdragon/bip32

Hedera DEX

2019-12-19T05:10:00.002+00:00

https://github.com/hammadtq/hbardelta/tree/hedera_dex

How To Launch An Unstoppable Website On IPFS In Under 3 Minutes!

2019-11-30T03:26:00.001+00:00

How To Launch An Unstoppable Website On IPFS In Under 3 Minutes!

How to stringify JSON for hashing and easy comparison in Java?

2019-11-28T05:02:00.000+00:00

Or how to implement https://github.com/substack/json-stable-stringify in Java?

    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;

    public static void stringify(final String jsonPath) throws Exception {
        final byte[] bytes = Files.readAllBytes(Paths.get(jsonPath));
        final String jsonData = new String(bytes);

        ObjectMapper om = new ObjectMapper();
        om.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);
        Map map = om.readValue(jsonData, HashMap.class);
        String json = om.writeValueAsString(map);
    }

Running the Solace VMR as an API Gateway on Ubuntu

2019-10-11T15:52:00.001+00:00

Today's post is a step by step process to run the Solace VMR as an API Gateway.
There are several options for API gateways out there, but nothing comes close to the flexibility of the VMR.
This was tested on Ubuntu 18.

Run the VMR as a docker container
Execute the following: docker run -d --net=host --shm-size=2g --security-opt apparmor:unconfined --env username_admin_globalaccesslevel=admin --env username_admin_password=admin --name=solace solace/solace-pubsub-standard

You can use docker ps -a, or docker logs -f solace to check after a couple of minutes that all is well. Note that under Ubuntu you need to configure apparmor in unconfined mode for the VMR to run properly. Finally, also on Ubuntu, --net=host helps with network configuration if you test your set-up locally using a local micro-service.
I am using DockStation, a great Linux tool to manage containers.

Solace VMR configuration
Open a browser to point to http://localhost:8080 and login using the admin / admin credentials. Follow the steps to create a simple catch-all api gateway:

Click on "Message VPNs" then "default", then "services"
In the "REST" section, select "gateway", then "apply"
Under "Queues", create a queue "CATCH_ALL_Q", apply then select
Under "Subscriptions", create two subs: "GET/>" and "POST/>", those will catch all GET and POST requests
Under "Client Connections", select "REST", create "Delivery End Point" named "CATCH_ALL_DP", click "Enabled" and apply
Then select and go to "Queue Bindings", add one, and select "CATCH_ALL_Q"
Create a REST consumer "CATCH_ALL_RC", "Enabled" and select the host of your computer with port 9505, then apply. Under "Client Connections" the Operational State should be up if you have your micro-service listening on that port

In order to test it, execute "curl http://localhost:9000/ping" assuming you have a micro-service listening on port 9505, the VMR will act as an API Gateway - and forward the request to the micro-service. Voila!

How to change folder's colors on Ubuntu 18

2019-10-06T02:06:00.003+00:00

sudo apt-get update && sudo apt-get install folder-color

Google Drive for Linux / Ubuntu

2019-05-14T10:58:00.002+00:00

https://www.howtogeek.com/196635/an-official-google-drive-for-linux-is-here-sort-of-maybe-this-is-all-well-ever-get/

A step-by-step guide for deploying a simple Solidity contract on a test network

2018-11-11T06:19:00.000+00:00

This post relates to a simple smart contract written in Solidity deployment on the Ropsten test network. It is a step-by-step deployment, giving as much detail as I could patiently gather..

METAMASK

"MetaMask is a bridge that allows you to visit the distributed web of tomorrow in your browser today. It allows you to run Ethereum dApps right in your browser without running a full Ethereum node.".
In a nutshell, it allows you to create an address and request ETH for testing. Install the extension for Chrome or Mozilla and set it up as follows. Start with the password creation (in my test I used 12345678910!)

You will now see this screenshot:

Then accept the various terms and conditions Finally, set up the secret words and back them up (spray talk duck avocado access put lens slice bench donor wise survey) - and the next screen put them back in the same order - and confirm. You will still see the following.

Now for the purpose of this exercise, select the "Ropsten Test Network" and click on "deposit" and select "Test Faucet" and click "GET ETHER" A new tab opens to https://faucet.metamask.io/ and select "reqest 1 ether from faucet" (or few times) A link like https://ropsten.etherscan.io/tx/0x2bc952af0236ef3960bdcd22b1a637f07e1369b1c0b200063c38104ab9a3611e will appear once the transaction(s) has(have) been validated and mined - you will see the number of ETH appear on your METAMASK main window for the "Ropsten Test Network"

SOLIDITY

Now on to the Solidity contract and coding/deployment/testing on the test network. Head towards https://remix.ethereum.org Under the tab 'run' select (if not already) 'environment' to be 'Injected Web' - and the test account we created should appear with the number of ETH requested by Faucet. We just need to write and deploy a contract... What about a simple contract to store the hash of a public document to validate the fact that it has not been modified?

pragma solidity ^0.4.7;

contract HashedDocsDemo {
    mapping (string => string) urlsDocHashMaps;
    
    function setHash(string url, string hash) public validStr(url) validStr(hash) {
        urlsDocHashMaps[url] = hash;
    }
    
    function checkHash(string url, string hash) public view validStr(url) validStr(hash) returns(bool) {
        string memory storedHash = urlsDocHashMaps[url];
        return keccak256(bytes(storedHash)) == keccak256(bytes(hash));
    }
    
    modifier validStr(string str) {
        bytes memory bstr = bytes(str); 
        require(bstr.length != 0, "invalid string");
        _;
    }
}

Once the contract has been pasted in the Remix IDE, go to "run" and click on deploy.

A window will popup and "click" confirm.

Another URL will be displayed (like https://ropsten.etherscan.io/tx/0xc551c6c2237c4faad697faf65bdd3d3a407914f1574b2a931871f3552154b93d) - same thing - wait for mining and effective contract deployment ("This transaction has been included into BlockNo #4400698 And will be reflected in a shortwhile")

We can finally interact with the contract - still in Remix - in the Run tab Enter any URL with any hash - then "transact" - same pop-up - confirm a new link is displayed: https://ropsten.etherscan.io/tx/0xe3c8af1e041405c53b2bf2ba300a947b3ba2a284f8f0ddce1187658f118557ce

Wait for confirmation - then you can look at the Remix ide, at the bottom, details of the transaction that went through and "decoded input" ....

Fun with Ethereum

2018-09-21T15:37:00.002+00:00

Hi, If you want to play with Ethereum, locally, I would suggest to read the following blogs: Demystifying Ethereum Private Blockchain in less than 4 minutes! and Running a “quick” Ethereum private network for experimentation and testing
I run Ubuntu 16 it was a breeze to download the code, compile it, and run a mining node locally, as well as submitting transactions using web3.

JDK 10 New Features

2018-05-08T08:36:00.002+00:00

https://www.azul.com/109-new-features-in-jdk-10/

Monitoring, Alerts, and Google Compute

2017-09-21T08:44:00.000+00:00

Have you ever looked for a simple, cheap and efficient solution to get alerts for a system that is not based on emails (as most of us get hundreds of those per day), or where you would need to look at a screen 24x7 to see a label color change from green to red?
I thought of using bots from Telegram to broadcast critical alerts to a Telegram group - and as I wanted to try Google Compute - to deploy the process on Google Compute Engine.
Code has been written in Kotlin

Kotlin/Telegram Code

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>morse</groupId>
    <artifactId>morse-tg</artifactId>
    <version>1.0</version>

    <properties>
        <kotlin.version>1.1.4-3</kotlin.version>
    </properties>

    <build>
        <sourceDirectory>src/main/kotlin</sourceDirectory>
        <testSourceDirectory>src/test/kotlin</testSourceDirectory>
        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <version>${kotlin.version}</version>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <jvmTarget>1.8</jvmTarget>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <mainClass>morse.SupportBot</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib-jre8</artifactId>
            <version>${kotlin.version}</version>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-test</artifactId>
            <version>${kotlin.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.telegram</groupId>
            <artifactId>telegrambots</artifactId>
            <version>3.3</version>
        </dependency>

    </dependencies>

</project>

kt code

package morse

import org.telegram.telegrambots.ApiContextInitializer
import org.telegram.telegrambots.TelegramBotsApi
import org.telegram.telegrambots.logging.BotLogger
import java.util.*
import java.util.logging.Level


class SupportBot : TimerTask() {
    lateinit var longPollHandler:LongPollingHandler

    override fun run() {
        longPollHandler.broadcast()
    }

    fun broadcast() {
        val timer = Timer()
        timer.schedule(this, 10_000, 60_000)
    }

    fun init() {
        BotLogger.info("SupportBot", "init()")
        ApiContextInitializer.init()

        BotLogger.setLevel(Level.ALL)

        val botAPI = TelegramBotsApi()
        BotLogger.info("SupportBot", "registering...()")

        longPollHandler = LongPollingHandler()
        botAPI.registerBot(longPollHandler)
        botAPI.registerBot(WebhookHandler())
        BotLogger.info("SupportBot", "Registered Handler")
    }

    companion object {
        @JvmStatic fun main(args: Array) {
            BotLogger.info("SupportBot", "SupportBot")

            val bot = SupportBot()
            bot.init()
            bot.broadcast()
        }
    }
}

package morse

object Cred {
    val bot = ""
    val token = ""
}

package morse

import org.telegram.telegrambots.api.methods.BotApiMethod
import org.telegram.telegrambots.api.objects.Update
import org.telegram.telegrambots.bots.TelegramWebhookBot
import java.util.*

class WebhookHandler : TelegramWebhookBot() {
    override fun getBotUsername() : String = Cred.bot

    override fun getBotToken(): String = Cred.token

    override fun getBotPath(): String = UUID.randomUUID().toString()

    override fun onWebhookUpdateReceived(update: Update?): BotApiMethod<*>? {
        return null
    }
}

package morse

import org.telegram.telegrambots.api.methods.send.SendMessage
import org.telegram.telegrambots.api.objects.Update
import org.telegram.telegrambots.bots.TelegramLongPollingBot
import org.telegram.telegrambots.logging.BotLogger
import java.util.*


class LongPollingHandler : TelegramLongPollingBot() {
    override fun getBotUsername(): String = Cred.bot

    override fun getBotToken(): String = Cred.token

    override fun onUpdateReceived(update: Update?) {
        BotLogger.info("LongPollingHandler", update.toString())
        try {
            if (update?.hasMessage()!!) {
                val message = update.message
                if (message.hasText()) {
                    val sendMessageReq = SendMessage()
                    sendMessageReq.setChatId(message.chatId)
                    sendMessageReq.text = "You just told me " + message.text
                    sendMessage(sendMessageReq)
                }
            }
        } catch (t: Throwable) {
            BotLogger.error("onUpdateReceived", t)
        }
    }

    fun broadcast() {
        BotLogger.info("LongPollingHandler", "broadcast")

        val sendMessageReq = SendMessage()
        sendMessageReq.chatId = "A negative chat it you get when added to the group"
        sendMessageReq.text = "Random message sent from Google Cloud at " + Date()
        sendMessage(sendMessageReq)
    }
}

maven was used to build, package and run this code.

Google Compute Engine

The easiest part! Nothing much to say. I went for the simple CPU/Mem option available, installed Java 8, Maven, uploaded my code, built entirely locally, and ran it via maven exec:java

Result!

Decode Your FIX has gone SSL

2016-12-15T01:34:00.002+00:00

https://www.fixdecoding.org/ is a web site developed by Paul and myself. Free of use :-)

Ethereum Wallet is amazingly slow to sync

2016-11-28T11:02:00.001+00:00

Since the last hard fork, and I must say, even before that, I am struggling with the use of ethereum mist. What a nightmare, does not sync up, very slow, 27,000 blocks behind and no sync end in view...
According to the logs, worst case, it takes 40 secs to get one block, 27,000 blocks, more than 12 days! What!

BTC to ETH

2016-11-20T02:02:00.000+00:00

From my previous post first-experience-with-ethereum, you would have read that I was waiting for my transaction to go through to buy ETH from BTC.
I submitted the transaction on 18/11/2016 at 16:39 - it finally went through more than a day later.....

First experience with Ethereum

2016-11-19T13:33:00.001+00:00

Some Saturday experiment while the kids are having fun... While drinking coffee... a thought, I want to mine!
Obviously long gone are the days where I could earn BTC while mining on a commodity laptop (about 4 millions years on mine according to the latest number of hashes needed 2^68).
So... with the promise of GPU mining (I am using OpenCL) with Ethereum - I decided to give it a try.
Please note that I am using Ubuntu 16.04

Installing the Ethereum wallet was a breeze - quite easy to set up - and interestingly - as part of the set up - I was asked if I wanted to buy some ETH from my Bicoin wallet
Of course... I did it - and issued a small transaction from my bitcoin client to the given Ethereum address
I issued a small payment of 0.005 BTC (3.74 USD) with a transaction fee of 0.00007329 BTC (0.05 USD). I sent my transaction on 18/11/2016 at 16:39 - and at the time of writing this post, i.e., more than 15 hours later, my transaction is still unconfirmed in the memory pool! If you understand the transaction fees concept and how miners can decide to do whatever they want... it is not surprising that my transaction would be at the bottom of stack. This simply proves, if any proof was needed, that Bitcoin is not ready for micro-payments, and probably will never be until this ASIC mining non-sense - must using ASIC (Application-specific integrated circuit) is sorted out
While waiting for my transaction from BTC to ETH to go through... if it ever happens.... I decided to run the mining software in GPU mode, Ethermine
I recommend to recompile from the source directly - it is the easiest and fastest way to get going

Decoding your FIX messages

2016-11-18T00:17:00.003+00:00

Looking for an easy way to decode your FIX messages, entirely local to the browser?
Use http://decodeyourfix.com/

SCALE 2.12 + JAVA 8

2016-11-10T07:50:00.000+00:00

I can confirm I can now use SCALA 2.12 with JAVA 8 libs ... :-) This piece of code, using http://sparkjava.com/ I could not do before, now can:

package demo1

import spark.Spark.get

object MicroService {
  def main(args: Array[String]): Unit = {
    get("/hello", (req, res) => "Hello World")
  }
}

Nice!

Looking for a functional test framework?

2016-10-14T10:27:00.001+00:00

Go SPOCK!

Android SDK

2016-10-13T13:26:00.000+00:00

Is it time for Google to start switching from Java to Kotlin for its Android development language? This makes sense right? First move is to use IntelliJ, second step, introduce Kotlin as an alternative language, third step, remove Java.

Ubuntu

2016-10-07T12:30:00.000+00:00

I love Ubuntu, stable, great UI, etc... but what stops me from switching 100%? The lack of a good, stable, Google Drive client...

Google Cloud SDK

2016-05-18T08:40:00.000+00:00

If you are like me, wondering what to go for when doing Google Cloud SDK work - and you are confused about what SDK to go for, go for "App Engine Flexible".
I can easily run Java 8 code in the cloud now!

Scala, Maven, jOOQ, Scalatra

2016-05-01T02:21:00.000+00:00

This post is about sharing some wonderful experience: using Scala, Scalatra, jOOQ altogether makes me a happy developer.
Now, there is nothing sexy about this post - it is not cutting edge, there is no big data involved, no AI, just simple tools that I think make a software engineer's life happier and fun.
I have embraced some parts of functional programming in Java 8 - sometimes it is quite difficult to read and debug - but it is clear and concise - less error prone - you know the usual shebang.
I still think that Scala has an edge over Java 8 - but I must say that I cannot wait for Scala 2.12 - as the binary compatibility and compilation speed are big issues.
The Scala IDE is great - but not there yet if you ask me, and I would hate to go and use IntelliJ - just not the tool for me.

This post is about using Scala with Maven, and some really cool stuff using Scalatra and jOOQ to build a simple RESTful server.

pom.xml

All you need for dependencies in one epic pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>Pento</groupId>
    <artifactId>PentoPay</artifactId>
    <version>1.0</version>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>scala-maven-plugin</artifactId>
                    <version>3.2.1</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.0.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>scala-test-compile</id>
                        <phase>process-test-resources</phase>
                        <goals>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>org.jooq</groupId>
            <artifactId>jooq</artifactId>
            <version>3.7.3</version>
        </dependency>

        <dependency>
            <groupId>org.jooq</groupId>
            <artifactId>jooq-meta</artifactId>
            <version>3.7.3</version>
        </dependency>

        <dependency>
            <groupId>org.jooq</groupId>
            <artifactId>jooq-codegen</artifactId>
            <version>3.7.3</version>
        </dependency>

        <dependency>
            <groupId>org.jooq</groupId>
            <artifactId>jooq-scala</artifactId>
            <version>3.7.3</version>
        </dependency>

        <dependency>
            <groupId>org.scalatra</groupId>
            <artifactId>scalatra_2.11</artifactId>
            <version>2.4.0</version>
        </dependency>

        <dependency>
            <groupId>com.google.inject</groupId>
            <artifactId>guice</artifactId>
            <version>4.0</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-server</artifactId>
            <version>9.3.8.v20160314</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-webapp</artifactId>
            <version>9.3.8.v20160314</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.21</version>
        </dependency>

        <dependency>
            <groupId>org.apache.derby</groupId>
            <artifactId>derby</artifactId>
            <version>10.12.1.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.derby</groupId>
            <artifactId>derbyclient</artifactId>
            <version>10.12.1.1</version>
        </dependency>

        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>2.4.5</version>
        </dependency>

    </dependencies>
    
</project>

Scalatra

Using Scalatra, the bootstrap class (with Guice Module for DI), the servlet definition and the launcher

import javax.servlet.ServletContext

import com.google.inject.Guice
import org.pento.services.{PingModule, PingService}
import org.scalatra.LifeCycle

class ScalatraBootstrap extends LifeCycle {
  private lazy val injector = Guice.createInjector(new PingModule())

  override def init(context: ServletContext): Unit = {
    context mount (injector.getInstance(classOf[PingService]), "/main-service/")
  }
}

package org.pento.services

import java.time.Clock

import com.google.inject.{AbstractModule, Provides, Singleton}

class PingModule extends AbstractModule {
  override def configure(): Unit = {
    bind(classOf[PingService]).asEagerSingleton()
  }

  @Provides @Singleton
  def provideClock() = Clock.systemUTC()
}

package org.pento.services

import java.time.Clock
import javax.inject.Inject

import org.scalatra.ScalatraServlet

class PingService @Inject() (val clock: Clock) extends ScalatraServlet {
  get ("/ping") {
    clock.millis()
  }
}

package org.pento.services

import org.eclipse.jetty.server.Server
import org.eclipse.jetty.servlet.DefaultServlet
import org.eclipse.jetty.webapp.WebAppContext
import org.scalatra.servlet.ScalatraListener

object PentoServer {
  val server = new Server(5899)
  val context = new WebAppContext()
  context.setContextPath("/")
  context.setResourceBase("src/main/scala")
  context.addEventListener(new ScalatraListener)
  context.addServlet(classOf[DefaultServlet], "/")
  server.setHandler(context)

  server.start()
  server.join()

  def main(args: Array[String]) {

  }
}

Neat. Simple.

Now to the database and jooq code generation

Who writes SQL those days? Well we have to.. but not in the code. jOOQ is probably one of the best libs I have used from Java and SCALA. Here is a simple jOOQ config that generates code from a given existing schema

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<configuration>
    <!-- Configure the database connection here -->
    <jdbc>
        <driver>org.apache.derby.jdbc.ClientDriver</driver>
        <url>jdbc:derby://localhost:1527/C:/Users/tj/Google Drive/IT-Projects/PentoPay/derby/PentoDb;create=true</url>
        <user>APP</user>
        <password>*</password>
    </jdbc>

    <generator>
        <name>org.jooq.util.DefaultGenerator</name>

        <database>
            <name>org.jooq.util.derby.DerbyDatabase</name>
            <inputSchema>APP</inputSchema>
            <includes>.*</includes>
        </database>

        <generate>
            <relations>true</relations>
            <deprecated>false</deprecated>
            <generateAnnotation>true</generateAnnotation>
            <records>true</records>
            <immutablePojos>true</immutablePojos>
            <globalObjectReferences>true</globalObjectReferences>
            <fluentSetters>false</fluentSetters>
        </generate>

        <target>
            <packageName>jooq.pento.db</packageName>
            <directory>C:/Users/tj/Google Drive/IT-Projects/PentoPay/src/main/java</directory>
        </target>
    </generator>
</configuration>

Some very nice utility classes to manage AutoCloseable and some fancy resource management (take back the jdbc connection to the pool post request). The code below allows automatically call close on an AutoCloseable

  def using[T <: AutoCloseable, R](resource: T)(block: T => R): R = {
    try {
      block(resource)
    } finally {
      if (resource != null) resource.close()
    }
  }

The one below deals specifically with jOOQ DSL Context:

  override def withSession[R](block: (DSLContext) => R): Option[R] = {
    import org.pento.utils.PentoUtils.using
    using(ds.getConnection) {connection =>
      try {
        Some(block(DSL.using(connection, sqlDialect, jooqSettings)))
      } catch  {
        case t: Throwable => None
      }
    }
  } // withSession

All in one, how to do a simple query. This is quite neat.

package org.pento.db

import com.google.inject.Inject
import com.zaxxer.hikari.HikariDataSource
import jooq.pento.db.tables.records.LastaccessRecord
import org.jooq.conf.Settings
import org.jooq.impl.DSL
import org.jooq.{DSLContext, SQLDialect}
import org.pento.utils.LastAccess

trait DataSource {
  def withSession[R](block: DSLContext => R): Option[R]
}

class DataSourceImpl @Inject() () extends DataSource {
  val ds = {
    val hds = new HikariDataSource()
    hds.setDriverClassName("")
    hds.setJdbcUrl("")
    hds.setUsername("")
    hds.setPassword("")
    hds
  }
  val sqlDialect = SQLDialect.valueOf("DERBY")
  val jooqSettings = new Settings()

  override def withSession[R](block: (DSLContext) => R): Option[R] = {
    import org.pento.utils.PentoUtils.using
    using(ds.getConnection) {connection =>
      try {
        Some(block(DSL.using(connection, sqlDialect, jooqSettings)))
      } catch  {
        case t: Throwable => None
      }
    }
  } // withSession
}

trait DB {
  def allAccesses: Option[List[LastAccess]]
}

class DBImpl @Inject() (val ds: DataSource) extends DB {
  override def allAccesses: Option[List[LastAccess]] = {
    import jooq.pento.db.tables.Lastaccess.LASTACCESS

    import scala.collection.JavaConversions._

    ds.withSession{ctx => {
      val rs = ctx.select(LASTACCESS.TS)
                  .from(LASTACCESS)
                  .fetchInto(classOf[LastaccessRecord])
      (for{r <- rs} yield LastAccess(r.value1())).toList
    }}
  }
}