Automatizacion: Diario de Lecherito

#33 Puede ser que la este reinventando muchisimo pero no he visto ningun proyecto que haga lo que yo quiero y como yo lo quiero, asi que estoy haciendo lo que yo necesito. Por ejemplo con el templater existen cosas como gradle init y mvn archetypes pero las dos cosas me parecen basura ademas de que no me parecen demasiado portables, luego go tiene su propio sistema etc etc, no he visto que haya algo mas universal.

Respecto a mis utilidades ni puta idea, ni siquiera he buscado si hay algo parecido o no, es lo que necesito y lo he hecho. No pienso si vale o no, si hay alternativas o no, la mayoria de cosas que estoy haciendo son por aprender ya que me lo paso bastante bien cacharreando.

La ultima vez que hice algo open source porque yo lo necesitaba y no lo deje super abandonado es un proyecto de configuracion que tiene stars en github y gente usandolo en produccion y todo, las necesidades que tenga yo tambien las puede tener mucha otra gente!

Al final he hecho un peque;o script para hacer release y subir automaticamente los ficheros a minio asi que tardo poco en hacer release y tenerlo en brew de linux y mac.

Lo siguiente es separarlo de lo hardcoded que tengo en el proyecto para poder usarlo en diferentes sitios y por diferentes personas.

Una vez que haga eso, estuve mirando como manejar las claves ssh que esta empezando a ser un co;azo increible.

#46 Bueno, lo prometido es deuda y ya tengo la base de datos!

Base de datos

La bbdd es una postgres normal, nada del otro mundo a la que le he creado una que se llama banker.

Librerias

1. Ktor se usa para REST.
2. Exposed con con el driver pgjdbc-ng para interactuar con la base de datos.

Codigo

Para interactuar con la base de datos, he creado una tabla de exposed en la que describo los tipos

object Transactions: Table() {
    val id = long("id").autoIncrement()
    val amount = long("amount")
    val bank = myEnum<Bank>("bank")
    val type = myEnum<TransactionType>("type")

    override val primaryKey = PrimaryKey(id)
    override val tableName = "transactions"
}

Lo de myEnum esta todavia en pruebas ya que es algo relacionado con guardar enums usando su ordinal (aunque quiza lo cambie en el futuro)

Con eso y la database:

val database by lazy {
    Database.connect(
            url = "jdbc:pgsql://localhost:6581/monitoring",
            driver = "com.impossibl.postgres.jdbc.PGDriver",
            user = "monitoring",
            password = "xddddd"
    ).also {
        transaction(it) {
            SchemaUtils.setSchema(Schema("banker"))
            SchemaUtils.createMissingTablesAndColumns(Transactions)
        }
    }
}

Tenemos ya la conextion a la base de datos, con el schema y las tablas/columnas necesarias.

Respecto a las rutas de get y post (que estan en el post de mas arriba), podemos ver como ha cambiado para simplemente insertarlo en la base de datos en vez de hardcoded:

private fun Routing.getAllTransactions() = get("/transactions") {
    val response = bankerTransaction {
        Transactions.selectAll().map { it.asTransaction() }
    }
    call.respond(response)
}

private fun Routing.postTransaction() = post("/transactions") {
    bankerTransaction {
        val transaction = runBlocking { call.receive<Transaction>() }
        Transactions.insert { table ->
            table[amount] = transaction.amount
            table[bank] = transaction.bank
            table[type] = transaction.type
        }
    }
    call.respondOk()
}

Parte cliente

Me hice un playground para poder hacer mis tonterias y descrubri los worksheets de intellij, que son basicamente scripts de kotlin con el contexto del proyecto, asi que me mola porque puedo tener snippets que ejecuto al instante!

Por ejemplo, el cliente seria este:

val transactionsClient = HttpClient(CIO) {
    install(JsonFeature) {
        serializer = GsonSerializer()
    }

    defaultRequest {
        url {
            host = "localhost"
            port = 8080
            path("transactions")
        }
        header(HttpHeaders.ContentType, ContentType.Application.Json)
    }
}

Y luego se usa easy peasy:

runBlocking {
    transactionsClient.post<Unit> {
        body = Transaction(1 /* Aunque esto es inutil, pero bueno */, Random.nextLong(50000), Bank.Caixa, TransactionType.In)
    }
}

Deploy

Ya tengo el Dockerfile preparado, me faltaria hacer que cuando haga push, se haga build del nuevo contenedor y se actualice.

Asi que por ahora bastante chulo (y funcional :D), he de mirar a ver si funciona con una base de datos nueva y poco mas. Luego lo pondre ya en "production", mirare las transacciones que tengo todas y usar el cliente para insertarlas todas.

#49 Si, tendra una descripcion y eso, por ahora solo queria saber como se hacian las cosas etc. La cosa es que cada banco tiene sus propios campos y me gustaria unificarlo de alguna manera. Los campos de la clase Transaction van a cambiar casi seguro, no se todavia si ponerle un UUID o un autoincrement como primary key y estas cosas, son cosas que estoy averiguando conforme estoy investigando.

Estos serian los datos que tengo ahora mismo de cada transaccion en cada banco:

Caixa: Número de cuenta;Oficina;Divisa;F. Operación;F. Valor;Ingreso (+);Gasto (-);Saldo (+);Saldo (-);Concepto común;Concepto propio;Referencia 1;Referencia 2;Concepto complementario 1;Concepto complementario 2
Revolut: Completed Date ; Description ; Paid Out (EUR) ; Paid In (EUR) ; Exchange Out; Exchange In; Balance (EUR); Category; Notes
BOI: Date;Transaction Details;Payments - out;Payments - In

PD: REEEEEEEeeeeeee

Pues se me ha ido otra vez el dia con cosas que no tenian nada que ver, solamente van a hacer mas rapido el desarrollo en el futuro xDDDD. Es increible con la rapidez que me invento algo "nuevo".

Cuando estaba usando el Playground y haciendo cosas manual, perdi literalmente 30 minutos porque la clase que estaba usando no era la adecuada (no habia hecho copypasta) y decidi que esas cosas mejor pillarlas a tiempo y arreglarlas de una vez por todas.

Gradle al rescate!

Me he montado un repo de artefactos para guardar mis librerias ahi (por ahora JVM solo) y cree un repositorio nuevo con el modelo del Banker:

create_project BankerModel: Crea el repositorio en el gitlab que esta en el NAS
laguna kotlin-ocean-jvm-lib -n BankerModel: Crea el proyecto con el templater
associate_project: Asocia el proyecto recien creado con el repositorio (remote add, commit, push -u)

Con esto ya tenia el modelo casi listo, lo unico que habia que hacer era copiar y pegar los modelos.

Publishing

Ahora viene lo bueno, para poder usar ese modelo hay que publicarlo en algun lado, y me ha costado lo mio pero al final lo he dejado de una manera casi ideal, lo unico que me falla es que el grupo es el mismo que el nombre asi que la dependencia queda del tipo: BankModel:BankModel:1.0).

Me he creado un plugin para gradle (con los mismos 3 comandos de ahi arriba), en el que configuro el s3 privado y un extension method del proyecto para configurar el plugin con el grupo y la version:

fun Project.configure(libName: String, version: String) {
    apply<OceanLibPlugin>()
    this.group = libName
    this.version = version
}

Y el s3

fun RepositoryHandler.privateS3(bucket: String = "maven", endpoint: String = "http://s3.domain") {
    maven("s3://$bucket") {
        System.setProperty("org.gradle.s3.endpoint", endpoint)
        name = "PrivateS3"
        credentials(AwsCredentials::class.java) {
            accessKey = "access"
            secretKey = "secret"
        }
    }
}

Como el proyecto lo bautice Ocean (las utilities), el metodo para a;adir una dependencia privada desde S3 es un barco!

fun DependencyHandler.ship(lib: String, version: String) {
    add("implementation", "$lib:$lib:$version")
}

Bastante sencillo. Pero no me gustaba como quedaba, mezclaba las librerias privadas y las publicas y eso no me gusta, no se ven las cosas claras y como que las dependencias estan en el sitio que no deberian.

Como ultimo paso, le a;adi el poder para que el plugin lea un fichero Libraries que es basciamente un Json con las dependencias privadas (y estoy pensando en meter ahi tambien las publicas aunque todavia lo estoy pensando). Y no solo eso si no crear un repositorio de aliases donde Gson se transformaria a com.google.code.gson:gson y asi me seria muy sencillo a;adir nuevas librerias, privadas o pulicas con tan solo una palabra.

El formato del fichero Libraries, como dije es un simple Json con por ahora 2 propiedades, implementation y testImplementation que a;adirian las dependencias a su equivalente en gradle

{
    "implementation": {
        "BankerModel": "1.0"
    }
}

Esto en el plugin es bastante trivial una vez que entiendes como funciona lo interno de Gradle:

val libraries = Gson().fromJson(file.readText(), Libraries::class.java)
libraries.implementation.forEach {
    project.dependencies.ship(it.key, it.value)
}
libraries.implementation.forEach {
    project.dependencies.testShip(it.key, it.value)
}

Asi que por ahora bastante contento conforme han quedado las cosas!

No se con que seguire ma;ana, pero bueno, como minimo diria que empezare a ver como hacer deploy del servicio Banker y como hacer build y publish de las librerias automaticamente. Pero eso es algo que esta todavia por ver.