Welcome to my blog site on pnkv - Nick's blog

Using C++ library From Rust - DepthAI RGB Camera Example

Sat, 19 Nov 2022 18:39:15 GMT

There has been a long time since the my last post, and many things happend. I have been persuaded by Alex to join AdVentura Works SA to a very exiting adventure, touching one of my passions in embedded software, robotics, AI/CV/ML. I have left Zest Labs GmbH and joined the new startup, where we are making the warehouse operations more safe and efficient. We have lots of opportunities in the area of tele-operations, AI assited operations, tasks and operation optimisations. Our new project requires top performance on the edge, and we cannot afford a single *ms* lost in compute. As long time fan of GoLang - I have been challenged to squize even more performance. Our first POCs were written in Go and it performed really well for consumer grade hardware, but when we touch the edge, there is much more to ask. Go is excellent language, producing blazingly fast binaries, but there is still a garbage collector, and much more importantly - memory copy when using C bindings. In our area, there are a lot of modules and libraries written in C and C++. We have to be able to wrap those functionallities and squize the best performance out of them. All this drove me to Rust - well - not so surprizing. Rust is very close to the hardware, often creates faster binaries than the once written in low level languages like C and C++, and at the same time it is safe and pleasurable to write in. Our goal is to be able to use existing libraries written in C and C++ in our new applications, without compromizing on performance and safety. All this made me to experiment, so that I can showcase the interface between already written libraries and our software. Calling external (static or dynamic libraries) is not a trivial problem. C is quite streamlined - in Rust you can use `extern "C"` and be quite sure that the things will work. As for C++ - Rust compiler cannot have a good picture what to interface. Majory of the basic aproaches are to wrap C++ code in C libraries and then to call them from Rust. As you can understand - this is not trivial and requires lots of time and effort. So let's see what are the options: - [bindgen](https://lib.rs/crates/bindgen) - Bindgen parses header files and generates Rust bindings. Works well for C but for C++ is not perfect - [cbindgen](https://lib.rs/crates/cbindgen) - Works in the other direction - parses Rust code and generates C or C++ headers - [cxx crate](https://lib.rs/crates/cxx) - Works both ways - can generate c++ bindings and vise versa. - [cpp crate](https://lib.rs/crates/cpp) - Can embed C++ code in your rust code Kudos to [Tobias Hunger](https://twitter.com/t_hunger?lang=en) for his [post/presentation](https://slint-ui.com/blog/rust-and-cpp.html). So lets get our hands durty and write some Rust to call C++ ready library. I have chosen something that will work for me in my projects. We have bought a [OpenCV AI Kit: OAK—D](https://store.opencv.ai/products/oak-d) to utilise in our project. So the task is to be able to integrate the existing [DepthAI Core Library](https://github.com/luxonis/depthai-core), written in C++, in our Rust core project. I have taken the short path at the beginning, so that I have less complexity, and just to make the showcase, how to make the things done in the future, so I have chosen to write the existing example app from `depthai-core` in rust - [rgb_encoding.cpp](https://github.com/luxonis/depthai-core/blob/main/examples/VideoEncoder/rgb_encoding.cpp). The ultimate goal will be to have the same functionallity as in the C++ example, but written in Rust. For the onces, who don't want to read more of my rumbles - just check the repository that I have published [Using DepthAI Core from Rust](https://github.com/npenkov/depthai-rgb-encoding-example-rs) ## For the rest - lets explore the code First we will define a c++ header and implementation, where we will define a class that instantiates the DepthAI Device, and creates a pipeline. Further we will use the same class to fetch the H264/5 frames and write them to a file. Here I have chosen the aproach to control the thread and fetching the frames from Rust - as the call is synchonios - I have the luxory to handle it in Rust. Some of you will criticize me for using a call back function, instead of diretctly fetching the frame data. This has been done intentionally, so that in the future I can change the code to push the frames in a WebRTC pipeline asynchroniously. [include/depthai_wrapper.h](https://github.com/npenkov/depthai-rgb-encoding-example-rs/blob/main/include/depthai_wrapper.h) ```h pragma once #include "rust/cxx.h" #include namespace dev { namespace pnkv { struct DepthAISource; class DepthAIClient { public: DepthAIClient(); ::std::int32_t next_frame(DepthAISource &src) const; // [1] private: class impl; std::shared_ptr impl; void push_frame(DepthAISource &src) const; }; std::unique_ptr new_depthai_client(); // [2] } } ``` - [1] `next_frame` function will be called from Rust code to obtain the next Video frame from the camera, which will trigger call back to `post_frame`, which will be Rust bound function - [2] Method to use for constructing the C++ object - called from Rust code. [src/deothai_wrapper.cc](https://github.com/npenkov/depthai-rgb-encoding-example-rs/blob/main/src/depthai_wrapper.cc) ```cpp #include "include/depthai_wrapper.h" #include "depthai-rust/src/main.rs.h" // [3] #include #include #include #include #include #include #include #include #include #include #include "depthai/depthai.hpp" namespace dev { namespace pnkv { // Implement simple RawData wrapper for Rust class DepthAIClient::impl { friend DepthAIClient; private: std::shared_ptr outputQueue; std::shared_ptr device; }; DepthAIClient::DepthAIClient() : impl(new class DepthAIClient::impl) // [4] { // Create pipeline auto pipeline = std::make_shared(); // Define sources and outputs auto camRgb = pipeline->create(); auto videoEnc = pipeline->create(); auto xout = pipeline->create(); xout->setStreamName("camRgb"); // Properties camRgb->setBoardSocket(dai::CameraBoardSocket::RGB); camRgb->setResolution(dai::ColorCameraProperties::SensorResolution::THE_720_P); videoEnc->setDefaultProfilePreset(30, dai::VideoEncoderProperties::Profile::H264_BASELINE); // Linking camRgb->video.link(videoEnc->input); videoEnc->bitstream.link(xout->input); auto deviceInfoVec = dai::Device::getAllAvailableDevices(); const auto usbSpeed = dai::UsbSpeed::SUPER; auto openVinoVersion = dai::OpenVINO::Version::VERSION_2021_4; std::map> qRgbMap; std::vector> devices; // Get the first device for (auto &deviceInfo : deviceInfoVec) { auto device = std::make_shared(openVinoVersion, deviceInfo, usbSpeed); device->startPipeline(*pipeline); impl->device = device; auto outputQueue = impl->device->getOutputQueue("camRgb", 30, true); impl->outputQueue = outputQueue; break; } } // Start fetching encoded frames and pushing them to DepthAISource ::std::int32_t DepthAIClient::next_frame(DepthAISource &src) const // [5] { push_frame(src); return 0; } void DepthAIClient::push_frame(DepthAISource &src) const { // Output queue will be used to get the encoded data from the output defined above auto h265Packet = impl->outputQueue->get(); ::rust::Slice data = ::rust::Slice(h265Packet->getData().data(), h265Packet->getData().size()); post_frame(src, data, h265Packet->getData().size()); // [6] return; } std::unique_ptr new_depthai_client() { return std::make_unique(); } } } ``` - [3] This header will be generated by `cxx` - [4] Constuct the object and obtain the instance to `Dai::device` and `Dai::outputQueue` - [5] Method called from rust to fetch the next frame - [6] `post_frame` is method defined in Rust, that will receive the call when the data is ready from the Camera queue Now comes the time to use the [cxx](https://crates.io/crates/cxx). [src/main.rs](https://github.com/npenkov/depthai-rgb-encoding-example-rs/blob/main/src/main.rs) ```rs #[cxx::bridge(namespace = "dev::pnkv")] // [7] mod ffi { // Rust types and signatures exposed to C++. extern "Rust" { type DepthAISource; // [8] fn post_frame(src: &mut DepthAISource, data: &[u8], size: u32); // [9] } // C++ types and signatures exposed to Rust. unsafe extern "C++" { include!("include/depthai_wrapper.h"); // [10] type DepthAIClient; // [11] fn new_depthai_client() -> UniquePtr; // [12] fn next_frame(&self, src: &mut DepthAISource) -> i32; // [13] } } pub struct DepthAISource { file: std::fs::File, } impl DepthAISource { pub fn new() -> Self { Self { file: std::fs::File::create("video.h264").unwrap(), } } pub fn close(&mut self) { self.file.flush().unwrap(); } } pub fn post_frame(src: &mut DepthAISource, data: &[u8], size: u32) { debug("post_frame: {} {}", data.len(), size); src.file.write_all(data).unwrap(); } ``` - [7] - cxx macro to define the bridge - [8] - definition of rust structure, that will be passed by reference to C++ methods - [9] - rust external function call back, that is called from c++ code __The rest is syntactic sugar, so that we have the code assistance and verification in rust__ - [10] - include the c header - [11] - define the type that will be implemented in c++ - [12] - the constructor called from rust to instantiate the object - [13] - function defined in c++ that we will call from rust How do we build/generate the bridge - at the end `cxx` needs to generate C++ bindings. This is done using the [Rust build scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html) In the project file [build.rs](https://github.com/npenkov/depthai-rgb-encoding-example-rs/blob/main/build.rs) we will use `cxx_build` macro, that needs to be added as development crate. ```rs cxx_build::bridge("src/main.rs") // [13] .file("src/depthai_wrapper.cc") // [14] .includes(&[ // [15] ".", "/usr/include/opencv4", "./deps/depthai-core/build/install/include", "./deps/depthai-core/build/install/include/depthai-shared/3rdparty", "./deps/depthai-core/build/install/lib/cmake/depthai/dependencies/include", ]) .flag_if_supported("-std=c++14") .compile("depthai-rust"); println!("cargo:rerun-if-changed=src/main.rs"); // [16] println!("cargo:rerun-if-changed=src/depthai.cc"); println!("cargo:rerun-if-changed=include/depthai.h"); println!( "cargo:rustc-link-search={}", "./deps/depthai-core/build/install/lib" ); // [17] println!("cargo:rustc-link-lib=dylib=depthai-core"); // [18] println!("cargo:rustc-link-lib=dylib=depthai-opencv"); // [19] ``` - [13] - define the main source to compile with bridge definition - [14] - add C++ compilation source - [15] - add the includes needed for the compilation - [16] - instruct `rustc` to rebuild the sources in case files change - [17] - add shared libraries location (this is where depthai-core has built the dynamic libraries) - [18]/[19] - add shared libraries to be linked with > __Note:__ that before building the project, we have to build the DepthAI core share libraries. (see the [README.md](https://github.com/npenkov/depthai-rgb-encoding-example-rs/blob/main/README.md) and [Makefile](https://github.com/npenkov/depthai-rgb-encoding-example-rs/blob/main/Makefile) in the project) The project can be built using `cargo build` or you can directly run it using `cargo run` - in both cases, if you have not installed `depthai-core` in the standard location - make sure to adjust the Library path - `LD_LIBRARY_PATH=$(CURRENT_DIR)/deps/depthai-core/build/install/lib`. The project has been tested only on Linux amd64 system. ~Enjoy

Maintaining uniqueness using golang and cassandra light weight transactions (LWT)

Wed, 11 Nov 2020 15:41:00 GMT

CCommon case when running a backend system is to require some kind of uniqueness of the records, based on their content. Wheneven having a transactional system, that is pumped with events from other systems/services, every transaction is with generated UUID, but this does not guarantee that the source is unique. There are many cases, where there is backend service that sends data, and if the call fails, the data sending is retried. There are plenty of ways to handle this case with SQL databases, but I would like to explain how we approach the problem in highly scalable system, relying on NoSQL database in AP segment of CAP Theorem - Cassandra. ## The Problem We would like to store our posts (postID, postText), but we want to guarantee that two requests for creating one and the same post does not result in 2 but just 1 record. (we assume that the ID is generated by our system, and there is no way to recognize if it is the same post, but only checking the content). ## The solution The functionality is covered by OSS library [CUS](https://github.com/npenkov/cus) The solution will be relying on Cassandra as DB store, and the service will be implemented in Golang. Our service will implement the following steps: * Receives a post with content `postContent` * Based on `postContent` we generate SHA-256 checksum. * We try to insert the record in cassandra table, where Checksum is the Key in the table with LWT * If the previous call succeeds, we are OK to insert it in the main table and to return `Success` to the caller * If the call is not successful - we return the already inserted before record with error indicating that the content is duplicate. ## Database schema ```cql CREATE TABLE IF NOT EXISTS cus_data( obj_id TEXT PRIMARY KEY, checksum TEXT, data BLOB); CREATE TABLE IF NOT EXISTS cus_checksum( checksum TEXT PRIMARY KEY, obj_id TEXT); ``` In `cus_data` we will store the `obj_id` the `checksum` and the real data - `data`, where as in table `cus_checksum` we are going to store the reverse index of `checksum` against `obj_id`. The crucial part is that we are going to use Lightweight Transactions (LWT), provided by Cassandra, Scylla and AWS Keyspaces, to make sure that we are consistent in inserting records, that are unique. Usually in SQL like database we would use serialized transaction isolation for this, but since we are operating in AP database like cassandra - we can do that only with LWT. ## CQL Statements Insert checksum and check with LWT if the operation succeded ```cql INSERT INTO cus_checksum (checksum, obj_id) VALUES (?,?) IF NOT EXISTS ``` Insert the real data record ```cql INSERT INTO cus_data (obj_id, checksum, data) VALUES (?,?,?) ``` ## Go implementation If you follow the code, the most importat thing is how to use LWT with gocql driver. It can be seen in [Create method of the library](https://github.com/npenkov/cus/blob/main/create.go) ```go row := make(map[string]interface{}) if applied, err = qry.MapScanCAS(row); err != nil { return nil, fmt.Errorf("failed no data available from LWT : %v", err) } if !applied { var ok bool var duplicateObjId string if duplicateObjId, ok = row["obj_id"].(string); !ok { return nil, fmt.Errorf("Failed to cast obj_id arg to string : %v", row) } return &duplicateObjId, ErrDuplicateObject } if err := s.session.Query(insertDataCQL, id, checksum, data).Exec(); err != nil { return nil, fmt.Errorf("failed to insert data : %v", err) } ``` > **NOTE**: Here is used `MapScanCAS` instead of `MapScan` or `Scan` method in the gocql driver. This is important if you are doing LWT ## Source code [Cassandra Unique Store library](https://github.com/npenkov/cus) ~Enjoy

Managing your IdP with terraform

Sat, 31 Oct 2020 19:55:15 GMT

Often when you want to implement authenticaiton/identity provider in your system, you turn to a well tested solution that is already on the market. Writting a good full OAuth2/OIDC/Federation IdP Provider is not a simple task, and if you start from scratch - you can consider it 3-6 months with good size pizza team, that is experienced in the technologies - to go through the whole implementation cycle. There are plenty of solutions out there, and quite a good ones - Auth0, Google OAuth, Github OAuth, AWS Cognito. Those are all external indentity providers that you can hook into your product, and rely on them. The problem usually is that mojority of Enterprises would like to keep the solution inhouse. They are even not ready to do federation through the public internet. Here comes one of the solutions for such enterprises - RedHat Keycloak is for quite some while on the market and offers a very decent set of features that one can expect from IdP. I am not going to go into detail and explain what Keycloak is - feel free to check it out at the [official site](https://www.keycloak.org/). Well from Operations point of view, especially if you are running on Kubernetes, intallation of Keycloak is traight forward using this [Helm Chart](https://github.com/codecentric/helm-charts/tree/master/charts/keycloak) When we do that for our customers, we even wrap the helm installation in [terraform](https://www.terraform.io/) code, so that we can automate all the infrastructure and component deployment, and to keep them as code (Infrastructure as code is a main principle of [ZestLabs](https://zestlabs.io)) All said, what we need left is a way to configure our Keycloak Installation, once it is up and running. This can include: * Creating new Realm with custom login theme * Client configurations for our OAuth2 clients used in the applications * Configuring Authentication behaviour * Configuring federation to other OIDC, LDAP, SAML Providers * Creating users Luckyly keycloak is entirely API Driven, and basicly everything that you have in the nice UI Console, you can achieve using API Calls. There is an open source provider for keycloak, that can be found on [Github](https://github.com/mrparkers/terraform-provider-keycloak), capable of handling all those configurations, that utilizes the API interface. ## Using the provider in your project Start by introducing the provider in your project. All the follow up snippets are done and tested on Terraform 0.13+. ```tf terraform { required_providers { keycloak = { source = "mrparkers/keycloak" version = ">= 2.0.0" } } } ``` > One important note here is - if you are creating a module that will do the job of configuring Keycloak, and then you will use this module in your infrastructure terraform scripts, make sure to include the same snippet to the module itself - this is something introduced since terraform 0.13 and without it, you will start seeing messages like: ```log Cannot initialize keycloak provider at: hashicorp/keycloak ``` ## Configuring your provider agains your Keycloak installation If your keycloak is freshly installed, most probably you will need to use the admin account that was initially created using password grant: ```tf provider "keycloak" { client_id = "admin-cli" username = "keycloak" password = "password" url = "http://localhost:8080" } ``` Replace in the snippet the `url`, `username` and `password` with the once specified in your helm installation. If you need some more flexibility, e.g. providing those credentials from secure provider on execution, then a solution with [Terragrunt](https://github.com/gruntwork-io/terragrunt) can be considered. Anyway this will be a topic for another article. ## Creating your Realm If you are wandering what Realm is - feel free to visit the [Getting started guide](https://www.keycloak.org/docs/latest/getting_started/#creating-a-realm-and-a-user) ```tf resource "keycloak_realm" "my_realm" { realm = "my-realm" enabled = true display_name_html = "

My Org Realm

" login_with_email_allowed = true } ``` for more details on the realm config - refer to the provider realm doc [resource "keycloak_realm"](https://registry.terraform.io/providers/mrparkers/keycloak/latest/docs/resources/realm) ### Supply a default root user for the realm ```tf // Create default user root with the same password as the admin one in master realm resource "keycloak_user" "root" { realm_id = keycloak_realm.my_realm.id username = var.root_username enabled = true email = var.root_email first_name = var.root_firstname last_name = var.root_lastname email_verified = true attributes = { } initial_password { value = var.keycloak_password temporary = true } } ``` ## Create OIDC Clients Mobile realm with clientId: `mobile`, clientSecret: `${var.oidc_secret_mobile}` and mobile oauth schema: `my-mobile-app-schema` ```tf resource "keycloak_openid_client" "mobile" { realm_id = keycloak_realm.my_realm.id client_id = "mobile" enabled = true access_type = "CONFIDENTIAL" standard_flow_enabled = true valid_redirect_uris = [ "my-mobile-app-schema:/callback" ] root_url = "$${authBaseUrl}" admin_url = "$${authBaseUrl}" web_origins = ["+"] client_secret = var.oidc_secret_mobile } ``` ## Applying the configuration What was left is just executing the infrastructure/configuration scripts using terraform: ```sh terraform init terraform apply ``` After the second step, terraform will present the plan of execution and ask for confirmation. ~Enjoy

Playing with kaniko and kubernetes internal docker registry

Sun, 01 Jul 2018 17:44:45 GMT

General idea here is to deploy a docker resgistry inside kubernetes and to use it just for putting the images that we build in the cluster, and to serve them to the same cluster. Few considerations * We are not going to secure the registry, the presumtions will be that your k8s cluster nodes run in a private network. If you want to secure pulling images in a secure way, you have to consider few more steps. * Docker resgirstry will be deployed in stateful set. Make sure that your PVC with persistence class are working in your cluster. * For building the images we will use [Kaniko](https://github.com/GoogleContainerTools/kaniko) * For deploying the docker registry, I would prefer to use my own config, rather than using Helm chart for this. ## Setting up private docker registry in kubernetes Lets first create a new namespace, to keep docker registry separated: __000-namespace.yaml__ ```yaml --- apiVersion: v1 kind: Namespace metadata: name: registry ``` ```sh kubectl apply -f 000-namespace.yaml ``` Then we can setup the configurations and the secret we are going to use for the registry __001-config.yaml__ ```yaml --- apiVersion: v1 data: config.yml: |- health: storagedriver: enabled: true interval: 10s threshold: 3 http: addr: :5000 headers: X-Content-Type-Options: - nosniff log: fields: service: registry storage: cache: blobdescriptor: inmemory version: 0.1 kind: ConfigMap metadata: labels: app: docker-registry name: docker-registry-config namespace: registry --- apiVersion: v1 data: haSharedSecret: U29tZVZlcnlTdHJpbmdTZWNyZXQK kind: Secret metadata: labels: app: docker-registry chart: docker-registry-1.4.3 name: docker-registry-secret namespace: registry type: Opaque ``` ```sh kubectl apply -f 001-config.yaml ``` Now it is time to deploy docker registry in stateful set: __002-registry-statefulset.yaml__ ```yaml apiVersion: apps/v1beta1 kind: StatefulSet metadata: name: docker-registry namespace: registry spec: selector: matchLabels: app: docker-registry serviceName: "registry" replicas: 1 template: metadata: labels: app: docker-registry annotations: spec: terminationGracePeriodSeconds: 30 containers: - command: - /bin/registry - serve - /etc/docker/registry/config.yml env: - name: REGISTRY_HTTP_SECRET valueFrom: secretKeyRef: key: haSharedSecret name: docker-registry-secret - name: REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY value: /var/lib/registry image: registry:2.6.2 imagePullPolicy: IfNotPresent livenessProbe: failureThreshold: 3 httpGet: path: / port: 5000 scheme: HTTP periodSeconds: 10 successThreshold: 1 timeoutSeconds: 1 name: docker-registry ports: - containerPort: 5000 protocol: TCP readinessProbe: failureThreshold: 3 httpGet: path: / port: 5000 scheme: HTTP periodSeconds: 10 successThreshold: 1 timeoutSeconds: 1 resources: {} terminationMessagePath: /dev/termination-log terminationMessagePolicy: File volumeMounts: - mountPath: /var/lib/registry/ name: data - mountPath: /etc/docker/registry name: docker-registry-config volumes: - name: data persistentVolumeClaim: claimName: docker-registry - configMap: name: docker-registry-config name: docker-registry-config volumeClaimTemplates: - metadata: name: data annotations: volume.beta.kubernetes.io/storage-class: fast spec: accessModes: [ "ReadWriteOnce" ] storageClassName: generic resources: requests: storage: 20Gi ``` Make sure you have defined storage class `fast` or replace `volume.beta.kubernetes.io/storage-class: fast` in the stateful set descriptor. ```sh kubectl apply -f 002-registry-statefulset.yaml ``` One last step for the registry will be to define the service and expose it to a node port, so that node dockre can pull the images on `localhost:NODE_PORT` __003-registry-svc.yaml__ ```yaml --- apiVersion: v1 kind: Service metadata: labels: app: docker-registry name: docker-registry namespace: registry spec: externalTrafficPolicy: Cluster ports: - name: registry nodePort: 31500 port: 5000 protocol: TCP targetPort: 5000 selector: app: docker-registry sessionAffinity: None type: NodePort ``` ```sh kubectl apply -f 003-registry-svc.yaml ``` Here we have exposed the registry on nodeport `31500` ## Configuring kaniko build Lets now build an image without exposing docker socket. For this we will use Project [Kaniko](https://github.com/GoogleContainerTools/kaniko).We will use preconfigured namespace `playground` to run the build. First we will define few config maps that we will use for the build. We will play with small application written in Go. So we will use a base `golang` image, and we will execute docker multistage build, where we first compile the application, and then use `alpine` image to run it. __000-Dockerfile-configmap.yaml__ ```yaml --- apiVersion: v1 data: Dockerfile: |- FROM golang:latest WORKDIR /go/src RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app . FROM alpine:latest RUN apk --no-cache add ca-certificates WORKDIR /root/ COPY --from=0 /go/src/app . EXPOSE 8080 CMD ["./app"] kind: ConfigMap metadata: name: dockerfile namespace: playground ``` ```sh kubectl apply -f 000-Dockerfile-configmap.yaml ``` The real source we will also define in config map, that we will mount in the builder pod: __001-maingo-configmap.yaml__ ```yaml --- apiVersion: v1 data: main.go: |- package main import ( "net/http" "strings" ) func sayHello(w http.ResponseWriter, r *http.Request) { message := r.URL.Path message = strings.TrimPrefix(message, "/") message = "Hello " + message w.Write([]byte(message)) } func main() { http.HandleFunc("/", sayHello) if err := http.ListenAndServe(":8080", nil); err != nil { panic(err) } } kind: ConfigMap metadata: name: maingo namespace: playground ``` ```sh kubectl apply -f 001-maingo-configmap.yaml ``` Now lets run the build: __002-kaniko-pod.yaml__ ```yaml apiVersion: v1 kind: Pod metadata: name: kaniko namespace: playground spec: containers: - args: - --dockerfile=/go/src/Dockerfile - --context=/go/src - --destination=docker-registry.registry.svc.cluster.local:5000/test/app:1.0 image: gcr.io/kaniko-project/executor:latest imagePullPolicy: Always name: kaniko volumeMounts: - mountPath: /go/src/Dockerfile name: dockerfile subPath: Dockerfile - mountPath: /go/src/main.go name: maingo subPath: main.go dnsPolicy: ClusterFirst restartPolicy: Never volumes: - configMap: name: dockerfile name: dockerfile - configMap: name: maingo name: maingo ``` ```sh kubectl apply -f 002-kaniko-pod.yaml ``` This will deploy the pod and run the build. You can monitor the build process by running: ```sh kubectl logs -n playground -f kaniko ``` After everything is executed successfuly, the builder pod will push the image to the local registry: `docker-registry.registry.svc.cluster.local:5000/test/app:1.0` The way afterwards to use the same image, when deploying the pod is: ```yaml ... image: localhost:31500/test/app:1.0 ... ``` ~Enjoy

Gcqlsh

Sun, 30 Oct 2016 21:14:45 GMT

It has been a long time since the last post. It is time to show my new open source project - [gcqlsh](https://github.com/npenkov/gcqlsh). The idea came when I was preparing some Cassandra docker images and I wanted to stay minimalistic with our CI infrastructure. So I have based my Cassandra docker image on Alpine. Unfortunatly came the frustration with installing python and all the dependencies. On the other hand, I needed an utility for automating the schema creation withing the docker container on first start. There it came Golang with its beautiful architecture and performance. Write you code. Build it for any architecture - and you have one single performant binary without need of any dependencies. If you are interested - make sure to visit the project's github page. Ideas and contributions are also welcome. Click on the [image](gcqlsh_rec.gif) to see the animation ~Enjoy

Caching Prepared Sqlite Statements in iOS Application

Fri, 02 Aug 2013 23:08:00 GMT

Many applications use Core data for iOS devices, others utilize frameworks like fmdb. But there are also people that write SQLite access from scratch. The comes the answer - how do you cache prepared statements (I will not discuss here why we cache prepared statements)? Well - I have implemented 2 methods: * 1) Using C syntax to maintain array of **sqlite_stmt*** * 2) Using **NSPointerArray*** to store **sqlite_stmt*** that are prepared First approach has it's advantages in regards of using older SDKs (NSPointerArray is available from iOS 6.0+) Second approach is more elegant, but as mentioned - only for newer versions. Lets have some code: _**Using C syntax**_ ```objc // Declare instance variables to store statements - good place is in you Database manager instance sqlite3_stmt **stmtCached; int stmtCachedCount; NSMutableDictionary *stmtSQLPool; ... @property (atomic, retain) NSMutableDictionary *stmtSQLPool; ... // in implementation @synthesize stmtSQLPool; ... // in constructor initialize the array stmtCached = (sqlite3_stmt**) malloc(sizeof(sqlite3_stmt*)*MAX_NUM_CACHED_STATEMENT); ``` Code to prepare and cache statements: ```objc - (sqlite3_stmt*) prepareAndCacheStatementWithSQL: (NSString*) sql andDatabase: (sqlite3*) db { @synchronized(self){ // Try to find if we have cached the statement NSNumber *index = [self.stmtSQLPool objectForKey:sql]; if (index != nil && stmtCachedCount > index.intValue) { // we have already cached statement sqlite3_stmt* stmt = stmtCached[index.intValue]; return stmt; } // Not prepared yet - prepare it and put it in the pool sqlite3_stmt *stmt = [DAO prepareStatementWithNSString:sql andDB: db]; if (!stmt) @throw [NSException exceptionWithName:@"Error preparing statement" reason:[NSString stringWithFormat:@"Something went wrong - cannot prepare statement for sql: '%@' - %s", sql, sqlite3_errmsg(db)] userInfo:nil]; if (stmtCachedCount >= MAX_NUM_CACHED_STATEMENT) { NSLog(@"Maximum number of cached statements reached. Stmt for sql %@ will not be cached.", sql); } else { stmtCached[stmtCachedCount++] = stmt; // store the index NSNumber *indexNumber = [NSNumber numberWithInt:(stmtCachedCount-1)]; [stmtSQLPool setObject:indexNumber forKey:sql]; } return stmt; } } ``` This is pretty much everything. Of course don't forget to release and finalize statements on db close. _**In second approach**_ - just instead of using (_sqlite**_) - replace with (_NSPointerArray*_): ```objc NSPointerFunctionsOptions options = (NSPointerFunctionsStrongMemory | NSPointerFunctionsStructPersonality); self.stmtCached = [NSPointerArray pointerArrayWithOptions:options]; ``` Fetch and store statements: ```objc sqlite3_stmt * stmt = [stmtCached pointerAtIndex:i]; ... [stmtCached addPointer:stmt]; ``` ~Enjoy

Migrating From Svn to Git

Sun, 21 Apr 2013 13:05:48 GMT

Suppose you have a SVN repository and you would like to move to GIT - there might be many arguments around this. Well - here are some steps that I have tried to synthesise after many attempts and reading in internet. I am sure there are many approaches, but this one works for me straight forward. The whole procedure consists of several steps: * Extracting users from SVN and creating a mapping file SVN_USER <-> GIT_USER * Cloning SVN repository into GIT repository * Migrating branches * Migrating tags * Creating new GIT detached repository and pushing all changes to it Here are some assumptions: You will work in one directory, where you will create `Suppose you have a SVN repository and you would like to move to GIT - there might be many arguments around this. Well - here are some steps that I have tried to synthesise after many attempts and reading in internet. I am sure there are many approaches, but this one works for me straight forward. The whole procedure consists of several steps: * Extracting users from SVN and creating a mapping file SVN_USER <-> GIT_USER * Cloning SVN repository into GIT repository * Migrating branches * Migrating tags * Creating new GIT detached repository and pushing all changes to it Here are some assumptions: You will work in one directory, where you will create `YOUR_SVN_REPOSITORY_URL` - is the URL that you use to checkout from SVN. Lets start _**Extracting users from SVN and creating a mapping file SVN_USER <-> GIT_USER**_ GIT needs to know how to map users from SVN to it's format. Usually users in SVN are just usernames, where in GIT they are in format `John Smith ;` So at the end we should produce a mapping file that looks like: ``` jsmith = John Smith ; ltorvalds = Linus ; ``` So execute the following command in your checkout svn repository, in order to create a file with the mapping `svn-git-users-mapping.txt` ```sh svn log -q | awk -F '|' '/^r/ {sub("^ ", "", $2); sub(" $", "", $2); print $2" = "$2" <"$2">"}' | sort -u > svn-git-users-mapping.txt ``` Edit the produced file with correct User names and emails on the right side. _**Cloning SVN repository into GIT repository**_ The following code executed in terminal will first create a directory, and clone svn into git repository in this directory, using `svn-git-users-mapping.txt` file for transforming users. ```sh mkdir YOUR_GIT_REPO_DIR git svn clone YOUR_SVN_REPOSITORY_URL -A svn-git-users-mapping.txt --stdlayout YOUR_GIT_REPO_DIR ``` This script uses the standard SVN layout (trunk, branches, tags) - if you have a different structure - you can explicitly specify it, using parameters (-T trunk -b branches -t tags) _**Migrating branches**_ Now is time to migrate branches - enter the created directory (YOUR\_GIT\_REPO_DIR) and execute the following script (this is a bash script, so if you use another shell, maybe you have to adjust it): ```sh for branch in `git branch -r | grep -v -e 'tags\/$.*$' | sed 's/ $.*$/\1/g'` do remote_branch="remotes/$branch" echo "About to checkout branch $remote_branch into $branch" echo "=============================================" git checkout -b "$branch" "$remote_branch" done ``` Similar process is used for the next point too: _**Migrating tags**_ ```sh for branch in `git branch -r | grep -e '$tags\/$$.*$' | sed 's/$tags\/$$.*$/\2/g'` do remote_branch="remotes/tags/$branch" new_tag="tag_$branch" echo "About to checkout tag $remote_branch into $new_tag" echo "=============================================" git checkout -b "$new_tag" "$remote_branch" git checkout master git tag $branch "$new_tag" git branch -D "$new_tag" done ``` Now that we have fully migrated repository, if we want a detached one from SVN (currently the created repo is connected to svn and can be used that way, with commends `git svn rebase --all` - to fetch and rebase all changes from SVN, and `git svn dcommit --interactive` - to push changes from git local commits to remote SVN repo). Next step: _**Creating new GIT detached repository and pushing all changes to it**_ ```sh git init --bare NEW_GIT_REPO cd NEW_GIT_REPO git symbolic-ref HEAD refs/heads/trunk cd YOUR_GIT_REPO_DIR git remote add NEW_GIT_REPO ../NEW_GIT_REPO git config remote.NEW_GIT_REPO.push 'refs/remotes/*:refs/heads/*' git push NEW_GIT_REPO ``` Now you are ready to use the newly created GIT repository, having all your history, branches and tags. In next article I will try to share my experience of using SVN as central repository, and GIT as local versioning and client. Here are some links that I used, while researching the best way to do the migration: - [Converting a Subversion repository to Git](http://john.albin.net/git/convert-subversion-to-git) - [Stackoverflow: How to migrate SVN with history to a new Git repository?](http://stackoverflow.com/questions/79165/how-to-migrate-svn-with-history-to-a-new-git-repository) - [Experimenting with Git at Slide Part 1/3](http://unethicalblogger.com/2008/07/27/experimenting-with-git-at-slide-part-1-3.html) - [Tool to manage svn-externals with git](https://github.com/andrep/git-svn-clone-externals) ~Enjoy

How to Speed Up Android Emulator on UX System

Sun, 05 Aug 2012 11:29:01 GMT

If you are developing for Android, you probably have already abandoned the emulator that comes with Android SDK, and are testing and debugging on a real device. I cannot blame you - the emulator is awfully slow. Well I have good news for you - you can speed it up, if you are using uX system (Unix like - Linux, Mac OS X, BSD). The trick is very simple - and I suppose some of you have already activated it - **mount /tmp folder into memory**. The reason why the emulator is much more faster - is that when the emulator is started, the image is expanded into **/tmp** folder - and all the communication goes through there. Normally it goes through DiskIO, and the trick is to do it through much faster channel - memory. Here is the way to do it in Linux: ```sh sudo gedit /etc/fstab ``` add the following line at the bottom: ```sh tmpfs /tmp tmpfs defaults,noatime,mode=1777 0 0 ``` This will mount your /tmp folder into memory. Now you can type: ```sh sudo mount /tmp ``` or restart the system. Enjoy the difference. And here how it is done under Mac OS X (you can visit one article here - http://laclefyoshi.blogspot.de/2011/05/tmpfs-on-linux-and-mac.html): ```sh sudo hdid -nomount ram://256000 ``` this will give you something like /dev/rdisk2 - then use "2" in the following command instead of "X": ```sh sudo newfs_hfs /dev/diskX sudo mount -t hfs /dev/diskX /tmp ``` This is something you should do every time you restart the system. ~Enjoy

Setting Environment Variables in Mac Os X

Sat, 17 Mar 2012 21:32:49 GMT

Once you have experience (or not) with some uX system, at some point you have to deal with environment variables, especially if you intend to do some development. I used to come from Open Source uX systems, and some old ones like HPUX, AIX, Solaris. When I switched to OS X, which is to some extent BSD - I had to find the best way to deal with env. variables. So - here are the ones that I use _**Variables set in your terminal access**_ Say you are using some variables usually in terminal access. Then you can use the same way of setting them, as on any other uX System - in your shell profile scripts (the one that is executed at the beginning, when you start terminal). In my case I use `bash` - so the file that I use to set env variables is `$HOME/.bash_profile` You can simple add lines to this file (or create it, if it does not exist): ```sh export TOMCAT_HOME=/opt/apache-tomcat ``` Setting environment variables that should be available also in programs outside terminal - say you want to have them in Eclipse IDE, or in some other program - then we do it in `/etc/launchd.conf` the syntax there is different: ```sh setenv ANDROID_HOME /opt/android-sdks ``` this will require root access and restarting the launchd or system, in order to have them active. ~Enjoy

First steps in creating Web service JSON enabled iOS application

Sat, 28 Jan 2012 13:07:35 GMT

This article continues the series for creating a web service consuming program on your mobile device. In the [previous article](/2012/01/25/first-steps-in-creating-your-web-service-enabled-mobile-application-using-json-geronimo-android-and-resteasy/) I have showed you how to create Server part (web service) on Geronimo and how to access it from Android app. Now we shall do the same with iOS application. So what do you need. * Mac with OSX * XCode IDE with iOS SDK * [Code and applications (server, IDE, code) from previous article in order to run the server](/2012/01/25/first-steps-in-creating-your-web-service-enabled-mobile-application-using-json-geronimo-android-and-resteasy/) So lets start. First create iOS Project - I prefer here to use "Single View Controller" template: ![](demo-createNewProject.png) Then put you properties for the new project: ![](demo-setProjectProps.png) Now we shall define UI variables that we shall use. Open `ViewController.h` and modify it like shown bellow ```objc #import <UIKit/UIKit.h> @interface ViewController : UIViewController { IBOutlet UITextField *txtIPAddress; IBOutlet UITextView *txtDisplayArea; IBOutlet UIButton *btnRunWebService; } @property (nonatomic, retain) UITextField *txtIPAddress; @property (nonatomic, retain) UITextView *txtDisplayArea; @property (nonatomic, retain) UIButton *btnRunWebService; - (IBAction)runWebServiceAction:(id)sender; @end ``` Here we define the same controls that we used in Android demo - one TextField for entering IPAddress of the server, one TextView where we should display the response from server and a button, that will trigger web service call. I will not describe why and how Objective-C is used to define these - there are plenty of books and demos on the net to find this out. Next we shall create the UI in out `ViewController.xib`. Open it and draw the controls shown on screenshots, using drag and drop from your right-bottom panel with Library controls: ![](demo-composeUI.png) The next step is to create the binding UI <-> Class implementation. Open the tree with controls, right click on "Placeholders" -> "File's Owner" and drag to TextField (IPAddress). Xcode will offer to connect it to attribute `txtIPAddress`. Repeat this for TextView (area) and for the button. Now do the reverse operation - drag from Button to "File's Owner" in order to connect the Push button operation to method that we defined in `ViewController.h`. Now we shall define the value class `MsgObj` with 2 attributes - id and message text. `MsgObj.h` ```objc #import <Foundation/Foundation.h> @interface MsgObj : NSObject { NSNumber *msgId; NSString *msgTxt; } @property (nonatomic, retain) NSNumber *msgId; @property (nonatomic, retain) NSString *msgTxt; - (id)initWithJSON:(NSDictionary*)dataDict; @end ``` `MsgObj.m` ```objc #import "MsgObj.h" @implementation MsgObj @synthesize msgId; @synthesize msgTxt; - (id)initWithJSON:(NSDictionary*)dataDict{ if (self = [super init]) { self.msgId = [dataDict objectForKey:@"id"]; self.msgTxt = [dataDict objectForKey:@"msgText"]; } return self; } - (void)dealloc{ [msgId release]; [msgTxt release]; [super dealloc]; } @end ``` What we do here is to define constructor `initWithJSON` that we will use to create with objects, when we receive data from web service call. We are ready to program the call know. First put the following line on the top of `ViewController.m`. This will define macro for async call queue: ```objc #define kBackGroudQueue dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)``` Then we should "synthesize" the attributes just after the class implementation definition: ```objc @implementation ViewController @synthesize txtDisplayArea; @synthesize txtIPAddress; @synthesize btnRunWebService; ``` We should not forget to manage the memory - define the `dealloc` method ```objc -(void)dealloc { [txtIPAddress release]; [txtDisplayArea release]; [btnRunWebService release]; [super dealloc]; } ``` At the end - we will put the call to web service. There we use the TextField to obtain the server IP address, and to execute the call in Async call, using the macro we defined before: ```objc - (IBAction)runWebServiceAction:(id)sender { NSString *ipAddress = [txtIPAddress text];; NSString *urlString = [NSString stringWithFormat:@"http://%@:8080/testweb/re/first/tellMe", ipAddress]; NSLog(@"Call URL: %@", urlString); //3 NSURL *url = [NSURL URLWithString:urlString]; dispatch_async(kBackGroudQueue, ^{ NSData* data = [NSData dataWithContentsOfURL: url]; [self performSelectorOnMainThread:@selector(receiveData:) withObject:data waitUntilDone:YES]; }); } ``` Here we also have set that when response is received - it will be received in method `receiveData:` ```objc - (void)receiveData:(NSData *)responseData { //parse out the json data NSError* error; NSDictionary* json = [NSJSONSerialization JSONObjectWithData:responseData options:kNilOptions error:&error]; MsgObj *msg = [[MsgObj alloc] initWithJSON:json]; [txtDisplayArea setText:[msg msgTxt]]; } ``` When we receive data - we parse it to JSON and construct our MsgObj. At the end we show the result by setting TextView with text contained in the message. When you run this it will look like: ![](demo-runSimulator.png) Obtain your IP address by typing `ifconfig` into Terminal. Put it in the TextField for IP Address and push the button. (Don't forget to start the web server and web application before - this you should know from [previous article](/post/2012/01/25/first-steps-in-creating-your-web-service-enabled-mobile-application-using-json-geronimo-android-and-resteasy/)). ![](demo-runWebService.png) You can download source code for this project [here](/uploads/2012/01/testIOS.tar.gz "iOS Demo application source code"). ~Enjoys

First steps in creating your web service enabled mobile application using JSON, Geronimo, Android and RESTEasy

Wed, 25 Jan 2012 17:23:20 GMT

This articles will reveal the first steps in setting up your development environment for building WebService/Enterprise Java applications and consuming their services from Android device. What I am using in this example: * Geronimo with Jetty7 javaee5 - 2.2.1 - as application/web server * Eclipse Indigo EE (with WTP plugin) * Android SDK 4.0.3 * Google Gson 2.1 * Resteasy - jaxrs - 2.3.1.GA Please don't be bored from so many screenshots. If you know the basics you just can skip them. Please also don't try to rewrite any code from them - source code is available for download at the end of the article. So first step is to download and setup all these packages. If you are new to Java - then you should start by downloading Java 6 or Java 7 from Oracle Download site. The proceed with Eclipse EE - download site. Get Android and follow the instructions to install it and add ADT plugin to your Eclipse IDE. Download and unpack Google GSon, Reaseasy and Geronimo. And now is where the fun starts.

The Web ServiceFirst we will create a web application with one simple webservice that will serve JSON data. I suppose at this step that you have setup your Eclipse and integrated it with Geronimo. (if you have troubles with finding information, please consult with the link to Geronimo 2.2 documentation). Start Eclipse EE and create your Geronimo server - goto server tab in the bottom panel, righ-click and select New -> Server: ![](03-CreateGeronimoServer.png) Select the location that you have extracted Geronimo server in: ![](04-SelectGeronimoLocation.png) Create a new Web -> Dynamic Web Project. ![](01-CreateWebProject.png) Set the web project name and make sure to select target server to **Apache Geronimo server** that you have created ![](02-WebProject-SetTheName.png) Now we should import Resteasy libraries into our Web Project - just get the libs from the location that you have extracted resteasy package and drop them into `WebContent\WEB-INF\lib` folder in package explorer. When asked - select "Copy" files. ![](05-AddResteasyLibsToProject1.png) Here comes the fun part. Let's code the classes. We shall begin with the data container object for our data exchange. We shall create a simple bean (MsgObj) that will contain 2 attributes - id and msgText. ![](06-CreateMsgClass.png) ```java package com.npenkov.testweb; import javax.xml.bind.annotation.XmlAttribute; import javax.xml.bind.annotation.XmlRootElement; @XmlRootElement(name = "msg") public class MsgObj { private int id; private String msgText; @XmlAttribute public int getId() { return id; } public void setId(int id) { this.id = id; } @XmlAttribute public String getMsgText() { return msgText; } public void setMsgText(String msgText) { this.msgText = msgText; } } ``` As we have out container, now we shall create the Service class. It will contain just one simple method that will return a new instance of our `MsgObj` with some data in it. ```java package com.npenkov.testweb; import javax.ws.rs.Consumes; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; @Path("/first") @Consumes({"application/json"}) @Produces({"application/json"}) public class FirstService { @GET @Path("/tellMe") public MsgObj tellMe() { MsgObj m = new MsgObj(); m.setId(1); m.setMsgText("Hello, friend!"); return m; } } ``` Important for web service (resteasy) is to create the so called`` class, that will know what services we should expose. It is mandatory that it extends `javax.ws.rs.core.Application`. You should mention here in the constructor that we add our service class to list of web service classes that Application will provide. ```java package com.npenkov.testweb; import java.util.HashSet; import java.util.Set; import javax.ws.rs.core.Application; public class WebServicesApp extends Application { HashSet singletons = new HashSet(); public WebServicesApp() { singletons.add(new FirstService()); } @Override public Set> getClasses() { HashSet> set = new HashSet>(); return set; } @Override public Set getSingletons() { return singletons; } } ``` Time for setting the `web.xml` descriptor. There we should register Resteasy servlet that will get the requests and execute our web services. If you take a look at the code fragment - we register our Application in parameter `javax.ws.rs.core.Application`. ```xml javax.ws.rs.core.Application com.npenkov.testweb.WebServicesApp resteasy.servlet.mapping.prefix /re org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap Resteasy org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher Resteasy /re/* ``` Ready to start the server and deploy out web application. Right click on testweb``` in Package Explorer and right-click there. Then select "Run as" -> "Run on server". Finish the process. ![](10-RunOnServer.png) Wait for Geronimo to boot - you will see lots of messages in "Console" view in the bottom. When it is ready - we can test our small web service. Open your browser and type the following url: http://localhost:8080/testweb/re/first/tellMe


    
      Usually default port for Jetty (web server) is set to 8080.
    
    
      In the URL first we have our server and port.
    
    
      Then is the webApplication name.
    
    
      Then the mapping context that we specified in web.xml
    
    
      the last two tokens are our service ("first") and method ("tellMe") - these are the words that we put as @Path``` in FirstService```class.

      

![](11-TestViaBrowser.png)

So we are ready now to start consuming web service from our web device. But first we have to write the client code in Android Application.


The Android Application

Start by creating new "Android Project".

![](12-AndroidProject.png)

Make sure to select the runtime for the project. It might be that you have to consult here with Android Development documentation on how to create Virtual Device.

![](13-SelectRuntime.png)

Continue with defining the main UI elements. We are not going to do something with lots of screens or functionallities - just one screen, with one input box for your WebService server IP address, one area that we will present responses there and finally - a button that will trigger WebService call. So starting with res/layout/main.xml```

```xml



Running ABAP queries with dynamic WHERE clause - UPDATED 2
Thu, 24 Nov 2011 16:26:57 GMT
Here comes a short and simple example for ABAP Programming. Suppose you want to make some more flexible function module for searching data in database table, that depending on parameters that are passed (can be optional), forms the WHERE clause of select statement. In ABAP this is pretty straight forward:

```abap
FUNCTION zsfli_sflight_getlist.
*"----------------------------------------------------------------------
*"*"Local Interface:
*" IMPORTING
*" VALUE(P_CARRID) TYPE ZSFLIGHT-CARRID OPTIONAL
*" VALUE(P_CONNID) TYPE ZSFLIGHT-CONNID OPTIONAL
*" VALUE(P_FLDATE) TYPE ZSFLIGHT-FLDATE OPTIONAL
*" TABLES
*" FLIGHT_DATA STRUCTURE ZSFLIGHT
*" RETURN STRUCTURE BAPIRET2
*"----------------------------------------------------------------------
  DATA l_where(100) OCCURS 0 WITH HEADER LINE.

  IF p_carrid IS NOT INITIAL.
    APPEND 'carrid = p_carrid' TO l_where.
  ENDIF.
  IF p_connid IS NOT INITIAL.
    IF l_where IS INITIAL.
      APPEND ' and ' TO l_where.
    ENDIF.
    APPEND 'connid = p_connid' TO l_where.
  ENDIF.
  IF p_fldate IS NOT INITIAL.
    IF l_where IS INITIAL.
      APPEND ' and ' TO l_where.
    ENDIF.
    APPEND 'fldate = p_fldate' TO l_where.
  ENDIF.

  SELECT * FROM sflight INTO CORRESPONDING FIELDS OF TABLE flight_data
  WHERE (l_where).

ENDFUNCTION.
```

In this way you can call function **`zsfli_sflight_getlist`** only with parameter **`p_fldate`** set, the select will filter and return all records for desired date.
  
~Enjoy

UPDATE2: I have added additional check for checking if there are already added `WHERE` conditions, so that we can combine several conditions at once:

```abap
IF l_where IS NOT INITIAL.
    APPEND ' and ' TO l_where.
ENDIF.
```


Get Ruby on Rails working on Ubuntu 11.10
Tue, 08 Nov 2011 10:54:25 GMT
A long time I have not been using Ruby On Rails. I have decided to give it a try again, so started by installing on Ubuntu 11.10 in VirtualBox. From what I remember - I have never happened before having issue with RoR working out of the box. Unfortunately this was not the case this time. Everything started with something really new to me:

```
    Invalid gemspec in [/var/lib/gems/1.8/specifications/json-1.6.1.gemspec]: invalid date format in specification: "2011-09-18 00:00:00.000000000Z"
    Invalid gemspec in [/var/lib/gems/1.8/specifications/tilt-1.3.3.gemspec]: invalid date format in specification: "2011-08-25 00:00:00.000000000Z"
```

At the beginning I have tried to solve it in several ways - by installing ruby from APT sources via

`sudo apt-get install rails`

or just by installing rails from gems:

`sudo gem install rails`

Both re-installation and methods did not worked.
  
So I have to dig deeper.
  
After a lot of searching in google I found a simple solution. Obviously gemspecs have some different date formats that don't validate. **So if you have such a message, just run the following command:**
  

`sudo sed -i 's/ 00:00:00.000000000Z//' /var/lib/gems/1.8/specifications/*`

This will fix the message. As soon as you install some new gem and you have this message - just run the script again.

Next it came the problem with **SQLIte3**:

```
    Building native extensions.  This could take a while...
    ERROR: Error installing sqlite3-ruby:
    ERROR: Failed to build gem native extension.
    /usr/bin/ruby1.8 extconf.rb
    checking for sqlite3.h... no
    sqlite3.h is missing. Try 'port install sqlite3 +universal'
    or 'yum install sqlite3-devel' and check your shared library search path (the
    location where your sqlite3 shared library is located).
    *** extconf.rb failed ***
    Could not create Makefile due to some reason, probably lack of
    necessary libraries and/or headers.  Check the mkmf.log file for more
    details.  You may need configuration options.

```

**This is solved by installing the development package of SQLite Ruby:**

```sh
sudo apt-get install libsqlite3-dev
```

And at the end it came the problem with **missing ExecJS engine**:

_``_ 

This I solved by downloading JavaScript engine from the URL mentioned (in my case Google V8) and putting on require in _config/boot.rb_

```
sudo gem install execjs
sudo gem install therubyracer
```

And adjust your applicaiton's **config/boot.rb**:

```ruby
require 'rubygems'
require 'execjs'
require 'v8'

# Set up gems listed in the Gemfile.
ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)

require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
```

After all these fixes, everything ran smooth.
  
I am sure there could be more elegant way to fix all these issues, so feel free to propose solutions.
  
~Enjoy


'Preview' crashes under Mac OSX Lion - FIX
Fri, 12 Aug 2011 22:10:28 GMT
It happened, that when I upgraded to Lion, for some reason Preview stopped working. This was new to me - usually I don't expect such behavior under Mac OS. Seems that lots of people had this, especially the ones that have upgraded MBP with SDD and having HDD at the place of Optical Drive. In this case you make SymLinks in your home directory pointing to HHD for Downloads (for Photos, Music, Movies or anything that you can afford to play from slow media and takes more space, which is expensive on SSD).

The FIX: Remove the symlink for Downloads, start Preview, create symlink, start preview again:

```bash
killall -9 Preview
cd ~/
rm Downloads
open -a Preview
killall -9 Preview
ln -s YOUR_LINK_DIRECTORY_FOR_DOWNLOAD Downloads
open -a Preview
```

~Enjoy

UPDATE: The same happened with TextEdit - I suppose it will be for all programs that use one and the same IO with Downloads. So in case it happens, just replace `Preview` with


Solving Issues Like Warning Attempting to Create Use_block_in_frame Variable With Block That Isnt in the Frame
Mon, 01 Aug 2011 22:42:59 GMT
I used to fight for a while with strange issue. I am using Singleton in my iOS application to hold Session information. Unfortunately when using NSMutableArrayList to hold stack of current objects - the references become empty at some point and there is a warning like:

`warning: Attempting to create USE_BLOCK_IN_FRAME variable with block that isn't in the frame.`

While searching on the net - I have mentioned one comment about using singletons - well - this was my lead.
  
I am using common singleton macro that defines most of the memory management methods. Exactly in session manager I used the macro, before `@synthesize` - this was the problem, static definitions should not appear before synthesized methods. So if you have something like this, just replace it with:

```objc
@synthesize loggedUserId, ...
SYNTHESIZE_SINGLETON_FOR_CLASS(SessionManager)
```