Analyzing Your Maven POM Files with POM Analyzer

 

When working with Maven projects, managing dependencies effectively is crucial to ensuring the stability, security, and up-to-dateness of your applications. POM files (Project Object Model) are at the heart of Maven builds, defining the dependencies, plugins, and other configurations. However, keeping track of dependency versions and identifying vulnerabilities manually can be a daunting task.

This is where POM Analyzer comes into play. POM Analyzer automates the process of analyzing your Maven build file, POM, to find the current versions of dependencies versus the latest versions available. Additionally, it scans for known vulnerabilities, providing a comprehensive HTML report that is both easy to read and insightful.

What Does POM Analyzer Do?

POM Analyzer performs the following tasks:

1. Version Comparison: It compares the current version of each dependency listed in the POM file with the latest version available from search.maven.org/solrsearch.
2. Vulnerability Check: It scans each dependency against ossindex.sonatype.org to detect known vulnerabilities.
3. HTML Report Generation: Using Apache FreeMarker, it generates a well-structured HTML report. This report includes the following sections:
• Project Name and Description
• Total Libraries
• Vulnerable Libraries (with direct vulnerabilities)
• Unique Vulnerabilities (listed based on their CVSS scores)
4. Direct Links for Verification: Each vulnerability reported includes links to credible sites for further investigation.

How Does It Work?

The POM Analyzer follows these steps:

1. Pre-check: It first ensures that Maven is installed on your machine.
2. POM File Validation: It checks whether the provided POM file is valid.
3. Dependency Tree Generation: The tool generates a dependency tree, parsing each artifact for version analysis and vulnerability checks.
4. Report Generation: After collecting the necessary data, it utilizes Apache FreeMarker to craft a detailed HTML report.

Why Choose POM Analyzer?

One of the biggest challenges in maintaining a Maven project is keeping dependencies updated while also monitoring for security issues. POM Analyzer addresses this by automating the entire process, saving time and reducing the risk of missing critical updates or vulnerabilities.

A Word of Caution

Since the tool continuously queries the OSS Index API to check for vulnerabilities, generating the report may take a little time. Additionally, repeated requests may temporarily block the machine from accessing data. Therefore, patience is key while using the tool.

Final Thoughts

The POM Analyzer is an invaluable tool for Maven project maintainers. It not only streamlines the process of dependency management but also integrates vulnerability analysis to enhance project security. Whether you are looking to keep your dependencies up to date or proactively secure your project from known vulnerabilities, POM Analyzer has got you covered.

For more details and to explore the project, visit the GitHub repository (https://github.com/adchowdhury/pomAnalyzer).

Solution to Reverse Words

This is one solution to "Reverse Words" problem in google codejam hosted at https://code.google.com/codejam/contest/351101/dashboard#s=p1

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * @author: Aniruddha Dutta Chowdhury (adchowdhury@gmail.com)
 * @since: May 8, 2015
 */

public class ReverseWords {

    public static void main(String[] args) {
        String filePath = "input.txt";
       
        try {
            BufferedReader br = new BufferedReader(new FileReader(filePath));
            String sCurrentLine;
            StringBuffer sb = new StringBuffer();
            int insertIndex = 0;
            char currentChar = '\b';
            while ((sCurrentLine = br.readLine()) != null) {
                //System.out.println(sCurrentLine);
                for(int iCharCounter = 0; iCharCounter < sCurrentLine.length(); iCharCounter++) {
                    currentChar = sCurrentLine.charAt(iCharCounter);
                    if(currentChar == ' ') {
                        insertIndex = 0;
                        sb.insert(insertIndex, currentChar);
                    }else {
                        sb.insert(insertIndex++, currentChar);
                    }
                }
                System.out.println(sb);
                sb = new StringBuffer();
                insertIndex = 0;
            }
        } catch (Throwable a_th) {
            a_th.printStackTrace();
        }
    }
}

Hack to KUKU-KUBE

Hi

Its long since my last blog. Was caught up into many things and also was looking for something interesting to post.

This is hack to the game available in below link as of the date of publishing this blog. The idea is borrowed from "Imitation Game" & "Independence Day" movie.

http://www.kuku-kube.com/


Steps to make the game simpler are as follows:
1) Open the link in browser
2) Use firebug or other javascript debug tool. That can be invoked by pressing F12 on windows machines.
3) Copy the below whole code
4) Paste in the console area and execute
5) Now play the game. All tiles should be black & white. Which gives probability of scoring around 70 per minute.

function getScript(url, success) { 
 var script = document.createElement('script');
 script.src = url;
  
 var head = document.getElementsByTagName('head')[0],
 done = false;
  
 // Attach handlers for all browsers
 script.onload = script.onreadystatechange = function() {
  
   if (!this.readyState || this.readyState == 'loaded' || this.readyState == 'complete'){    
    // callback function provided as param
    success();    
    script.onload = script.onreadystatechange = null;
    head.removeChild(script);    
   };  
  };
}

getScript('http://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js',function(){
console.log(jQuery("span").size())
});
setInterval(changeColor, 100);
function changeColor(){
var previousColor = null;
jQuery("#box").find("span").each(function(index, element){
  if(index == 0){
    previousColor = null;
  }
 // console.log(index + " : " + previousColor + " : " + jQuery(this).css("background-color"))
  if(previousColor == null){
    previousColor = jQuery(this).css("background-color");
    jQuery(this).css("background-color", 'black')    
  }else  if(jQuery(this).css("background-color") == previousColor){
    jQuery(this).css("background-color", 'black')
  }else{
    jQuery(this).css("background-color", 'white')
  }
})
}

Recursively get all fields for a hierarchical class tree

Hi friends, it took quite a long time to again post something worthy. Normally when we play with reflection, we get metadata only about the targeted class, not anything inherited. This will try to resolve that part. We will get targeted class & it's inherited fields as well.

Any feedback is always welcome. Please do not hesitate in case you have any.


public class testReflection {
    public static void main(String[] args) {
        try {
            C c = new C();
            Class klass = c.getClass();
            Field[] fields = getAllFields(klass);
            for (Field field : fields) {
                System.out.println(field.getName());
            }
        } catch (Throwable a_th) {
            a_th.printStackTrace();
        }
    }

    public static Field[] getAllFields(Class klass) {
        List fields = new ArrayList();
        fields.addAll(Arrays.asList(klass.getDeclaredFields()));
        if (klass.getSuperclass() != null) {
            fields.addAll(Arrays.asList(getAllFields(klass.getSuperclass())));
        }
        return fields.toArray(new Field[] {});
    }
}

class A {
    public String    nameA    = "";
}

class B extends A {
    public String    nameB    = "";
    public String    nameB1    = "";
    public String    nameB2    = "";
}

class C extends B {
    public String    nameC    = "";
}

Solution to Store Credit

This is a probable solution to CODE JAM's Store Credit.

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;


public class StoreCredit {
   
    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(ReverseWords.class.getClassLoader().getResourceAsStream("A-large-practice.in"));
            int problemCount = Integer.parseInt(scanner.nextLine());
            int caseCounter = 1;
            for(int iProblemCounter = 0; iProblemCounter < problemCount; iProblemCounter++) {
                Set completedIndexes = new HashSet();
               
                int creditAmount = Integer.parseInt(scanner.nextLine());
                int numberOfItems = Integer.parseInt(scanner.nextLine());
                String itemsLine = scanner.nextLine();
                String[] intArray = itemsLine.split(" ");
                String output = "";
                itemLoop:{
                    for (int iArrayCounter = 0; iArrayCounter < numberOfItems; iArrayCounter++) {
                        completedIndexes.add(iArrayCounter);
                        for (int iArrayInnerCounter = 0; iArrayInnerCounter < numberOfItems; iArrayInnerCounter++) {
                            if(completedIndexes.contains(iArrayInnerCounter)) {
                                continue;
                            }
                            int sum = (Integer.parseInt(intArray[iArrayCounter]) + Integer.parseInt(intArray[iArrayInnerCounter]));
                            output = (iArrayCounter + 1) + " " + (iArrayInnerCounter + 1);
                            if(sum == creditAmount) {
                                break itemLoop;
                            }
                        }
                    }
                }
                System.out.println("Case #" + (caseCounter++) + ": " + output);
            }
        } catch (Throwable a_th) {
            a_th.printStackTrace();
        }
    }
}

See you later friends.

Windows Service Monitor and starting

Hi friends,

It's been long since my last post. Again I am here with some solution. Specifically for windows. The problem statement was, few windows service was getting stopped all of a sudden due to some error. What we needed is one small utility which monitors the specific service and start that if that is stopped.

There was many suggestion and solution, many monitoring softwares. But I liked the solution mentioned below. Took quite some time to collect all the information and build it.

First copy paste the below code in a file named as "serviceMonitor.vbs" or you can choose any other name as well.

Set sh = CreateObject("Shell.Application")
set shellLogger = CreateObject("WScript.Shell")

If sh.IsServiceRunning("SERVICE_TO_MONITOR") Then
    shellLogger.LogEvent 4, "SERVICE_TO_MONITOR is running"
Else
    shellLogger.LogEvent 4, "SERVICE_TO_MONITOR is not running"
    if sh.ServiceStart("SERVICE_TO_MONITOR", true) Then
        shellLogger.LogEvent 4, "SERVICE_TO_MONITOR automatically started"
    Else
        shellLogger.LogEvent 4, "SERVICE_TO_MONITOR could not be started"
    End If
End If   

Replace the word SERVICE_TO_MONITOR with name of your service.
Then open scheduler and create a task. Choose the trigger you want, I kept it at every 1 min.

wolla...  your windows service will never be down. If it is down, It will be up within next one min. :)

DiamondPattern

Hi friends,

This is a simple program which generates a diamond kind of pattern with the passed character which is 'e' in this case.

public class DiamondPattern {
    public static void main(String[] args) {
        printPattern('e');
    }
   
    private static final int BASE_CHAR = (int)'a';
   
    private static void printPattern(char a_endChar) {
        int charCounter = BASE_CHAR;
        boolean isIncreasing = true;
        do {
            System.out.print(getPadding(a_endChar - charCounter + 1));
           
            for(int iHCounter = BASE_CHAR; iHCounter < charCounter; iHCounter++) {
                System.out.print((char)iHCounter);
            }
           
            for(int iHCounter = charCounter - 2; iHCounter >= BASE_CHAR; iHCounter--) {
                System.out.print((char)iHCounter);
            }
           
            if(isIncreasing) {
                charCounter++;
            }else {
                charCounter--;
            }
           
            if(charCounter > a_endChar) {
                isIncreasing = false;
            }
            System.out.println();
        }while(charCounter >= BASE_CHAR);
    }
   
    public static String getPadding(int a_padCount) {
        StringBuffer strPadding = new StringBuffer();
        for (int iCounter = 0; iCounter < a_padCount; iCounter++) {
            strPadding.append(' ');
        }
        return strPadding.toString();
    }
}