Programmer Works

Wednesday, March 29, 2017

Hibernate Samples

All hibernate sample can be cloned from github. Git repository location: https://github.com/raviteja548/hiberante_examples

References Javabrains.io

Sunday, October 23, 2016

Trigger Jenkins Build Using SVN PostCommit hook

This post explains about triggering jenkins build as soon as you commit files/changes to svn repository.

There are two ways to achieve this.

1. Poll repository to find if any changes done in your project location. But with this approach there is a chance of build skips since polling is done in a particular interval. This is ideally not preferable as it increases load on server, building jobs even when there are no changes detected.

2. Configure SVN repository to trigger post-commit hook which can trigger jenkins build.

This post covers 2nd way in detail.

Location of hooks folder: SVN hooks can be found right in the place where repository is created which contains directory name hooks. You can find all the type of hooks which are supported by svn.

By default all the extensions of hooks are .tmpl, in order to make them executable the extension should be changed to .bat/.exe in a windows environment.

3. Post Commit hook by default receives two arguments. They are received in an order REPOS and REV

REPOS: is the location when svn repository is created. EX: "file:///E:/WORK/svn" (on windows)

REV : is the revision value generated for every commit. EX: 18928

4. It is necessary to get an idea about utility svnlook which is a command-line utility for examining different aspects of a Subversion repository. It does not make any changes to the repository—it's just used for “peeking.” svnlook is typically used by the repository hooks explore much about "svnlook --help"

3. Triggering jenkins build on post commit will involve a series of steps i.e

a) Initially a property has to be set on the project location as a keyvalue pair. Make sure you commit property name and value changes to svn ex: name:ci:buildurl value:jenkins-job-build-url

b) Finding out which directories were updated on commit.

"svnlook" with option "dirs-changed" has the ability to find out directory changes on postcommit using revision number EX: >svnlook dirs-changed E:\WORK\svn -r 392 ( 392 is revision number, command execution would result below)
>testproj/trunk/src/main/java/testproj/

c) Extraction svn-properties on the directory that resulted in change.

"svnlook" with option "propget" and valid arguments can result in property name that was set to project.

EX:> "svnlook propget E:\WORK\svn ci:buildurl testproj/trunk/src/main/java/testproj/"

> http://localhost:8080/job/testproject/build?delay=0sec

("testproj/trunk/src/main/java/testproj/" is the folder that was updated during a commit in step b and ci:buildurl is the property name, E:\WORK\svn is the repository location)

4. Using the value obtained from step C execute curl command to run jenkins build

EX: curl -X POST http://localhost:8080/job/testproject/build?delay=0sec

5. After all the subsequent steps you can find jenkins building the job.

6. This is a sample post-commit hook attached below.

   
setlocal  
set REPOS=%1  
set REV=%2

FOR /F %%i in ('svnlook dirs-changed E:\WORK\svn -r %REV%') do SET dirloc=%%i 
 
FOR /F %%i in ('svnlook propget E:\WORK\svn ci:buildurl %dirloc%') do SET PROP=%%i

if defined %PROP%
curl -X POST %PROP%

Tuesday, June 14, 2016

Quick start to heroku applications

Nexus Repository Manager

Nexus is a repository manager & stating repository in which files can be uploaded using maven. Alternatively files can be also uploaded via curl commands.
This tutorial outlines to install Nexus also covers artifacts upload using maven & files upload using curl commands.
1. Download latest nexus war file from http://www.sonatype.org/downloads/nexus- latest.war
2. Deploy the war file in any webserver.
3. Launch nexus home page http://localhost:8081/nexus-2.13.0-01/#welcome
4. Default username and password to login are admin & admin123
5. You can create your own Repository from views/Repositories section
6. Add a hosted repository using the sample configuration shown in image.

7. Have curl in classpath to upload files into repository. Example: curl --upload-file upload.zip -u admin:admin123 -v http://localhost:8081/nexus-2.13.0-01/content/repositories/targus/upload.zip Repository url can be found navigating to corresponding repository and in summary section

8. Files uploaded can be found in the browse storage section of the respective repository.

Sunday, October 11, 2015

FindBugs Jenkins Integration

Jenkins installation & integration with firebugs documentation available in the link. Download here Maven plugin for findbugs report generation.

<reporting>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>findbugs-maven-plugin</artifactId>
            <version>2.5.2</version>
            <configuration>
                <!--
                    Enables analysis which takes more memory but finds more bugs.
                    If you run out of memory, changes the value of the effort element
                    to 'low'.
                -->
                <effort>Max</effort>
                <!-- Reports all bugs (other values are medium and max) -->
                <threshold>Low</threshold>
                <!-- Produces XML report -->
                <xmlOutput>true</xmlOutput>
            </configuration>
        </plugin>
    </plugins>
</reporting>

Command to generate find bugs report : mvn clean compile site

Wednesday, July 15, 2015

PEM File Creation

PEM:Privacy Enhanced Mail is a Base64 encoded DER certificate
PEM files are used to represent Certificate/PrivateKey in an understandable format. They have a distinct header and footer for every key, where the body is composed of Base64 encoded Key.
They are represented as shown below for (Certificate/PrivateKey/Certificate Signing Request/PublicKey)

Java Program to generate PEM files.

package bc;

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.cert.X509Certificate;
import java.util.Date;

import javax.security.auth.x500.X500Principal;

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.openssl.PEMWriter;
import org.bouncycastle.x509.X509V1CertificateGenerator;

public class PEMWrite {
    public static void main(String[] args) throws Exception {
        generateSelfSignedX509Certificate();
    }

    static {
        // adds the Bouncy castle provider to java security
        Security.addProvider(new BouncyCastleProvider());
    }

    /**
     * Generate a self signed X509 certificate with Bouncy Castle.
     */
    static void generateSelfSignedX509Certificate() throws Exception {

        // yesterday
        Date validityBeginDate = new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000);
        // in 2 years
        Date validityEndDate = new Date(System.currentTimeMillis() + 2 * 365 * 24 * 60 * 60 * 1000);

        // GENERATE THE PUBLIC/PRIVATE RSA KEY PAIR
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", "BC");
        keyPairGenerator.initialize(1024, new SecureRandom());

        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        // GENERATE THE X509 CERTIFICATE
        X509V1CertificateGenerator certGen = new X509V1CertificateGenerator();
        X500Principal dnName = new X500Principal("CN=RaviTeja");
        certGen.setSerialNumber(BigInteger.valueOf(System.currentTimeMillis()));
        certGen.setSubjectDN(dnName);
        certGen.setIssuerDN(dnName); // use the same
        certGen.setNotBefore(validityBeginDate);
        certGen.setNotAfter(validityEndDate);
        certGen.setPublicKey(keyPair.getPublic());
        certGen.setSignatureAlgorithm("SHA256WithRSAEncryption");
        X509Certificate cert = certGen.generate(keyPair.getPrivate(), "BC");
        System.out.println(cert);

        // PEM format representing Certificate
        PEMWriter pemWriter = new PEMWriter(new PrintWriter(System.out));
        pemWriter.writeObject(cert);
        pemWriter.flush();

        //Loads Private Key as PEM format into private_key.pem file
        File file = new File("private_key.pem");
        PEMWriter pw1 = new PEMWriter(new FileWriter(file));
        pw1.writeObject(keyPair.getPrivate());
        pw1.flush();
        pw1.close();

        //PEM format representing PrivateKey
        pemWriter.writeObject(keyPair.getPrivate());
        pemWriter.flush();

        //PEM format representing PublicKey
        pemWriter.writeObject(keyPair.getPublic());
        pemWriter.flush();
        pemWriter.close();

    }
}

Tuesday, April 28, 2015

JSON & XML Online Conversion tool

http://jsonxmlutil.appspot.com/
This tutorial is for converting JSON to XML or XML to JSON. The conversion happens using APIGEE tool, which is used to develop APIs. For the conversion of JSON/XML we use the target endpoint's that are developed on APIGEE tool. We create an API for the conversion which will have two resources inorder to handle JSONtoXML and XMLtoJSON requests.

Step1:Create a resource jsontoxml or any name..

Step2: In develope section , you can arrange all the policies to be applied on the requests. The request gets route on the basis of matching pattern Ex: ../convert/jsontoxml,.../convert/xmltojson (For this you should have good understanding on APIGEE )

Step3: Deploy to environment available

Step4: Go to trace section and Start the Trace Session and hit the url's, you find the live traffic logging.

Finally

How does the conversion happen

APIGEE tool has the ability to do service chaining, sampling data, make XML/JSON conversions, extract variables from request or response e.t.c
APIGEE record the request sent by user into request variable, we now form a list of policies in a sequence to be executed.
Ex: for xml to json conversion, in the response flow

1) Create an assign message policy and assign all the xml request that is sent into an variable response.
2)Send this response xml to an XML to JSON policy using the request as source & assign it to an output variable.
3)Finally assign the json response in an Assign-Message-Policy which can be consumed by any one who ever sends the request.

Source code has been bundled, any one needs this proxy can download it from the url and import in their APIGEE account. Download Here