Test SyntaxHighlighter

SyntaxHighlighter

PHP

<?php
$example = range(0, 9);
foreach ($example as $value)
{
 echo $value;
}

JAVA

public class TestJava {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub

 }

}

SQL

SELECT *
FROM DUAL;

Shell Script

#!/bin/bash
clear
which bash
echo "Good morning, world."

Tested in following browsers:

• Chrome Version 41.0.2272.89 m 
• Firefox 36.0.1 
• IE 10.0.23

Reference links:

• SyntaxHighlighter
• awesome-syntax-highlighting-made-easy
• how-do-i-add-syntax-highlighting-to-my.html

Create Deployment Jar with Maven

Create a single jar with all dependencies type "mvn assembly:assembly" from the command line.
Include following plugin in pom.xml

    
        
            
                maven-assembly-plugin
                
                    
                        src/assemble/distribution.xml
                    
                    
                        jar-with-dependencies
                    
                
            
        
    

Configuration details in descriptor file distribution.xml

    distribution
    
        jar
    
    
        
            
                README
                README.txt
                NOTICE
                NOTICE.txt
                LICENSE
                LICENSE.txt
                log4j.properties
            
        
    

Apache Maven Assembly Plugin

UI Design

Some resource need to check

http://www.wix.com/website/templates
http://fortawesome.github.io/Font-Awesome/

Check locked Objects in Oracle database

LOCKED DATABASE OBJECTS

SELECT l.session_id || ',' || v.serial# sid_serial,       
       l.ORACLE_USERNAME ora_user,       
       o.object_name,       
       o.object_type,       
       DECODE(l.locked_mode,              
              0,
              'None',              
              1,
              'Null',              
              2,
              'Row-S (SS)',              
              3,
              'Row-X (SX)',              
              4,
              'Share',              
              5,
              'S/Row-X (SSX)',              
              6,
              'Exclusive',              
              TO_CHAR(l.locked_mode)              
              ) lock_mode,       
       o.status,       
       to_char(o.last_ddl_time, 'dd.mm.yy') last_ddl
  FROM dba_objects o, gv$locked_object l, v$session v
 WHERE o.object_id = l.object_id      
   and l.SESSION_ID = v.sid;

select a.sid, a.serial#, OBJECT_NAME , a.*
  from v$session a, v$locked_object b, dba_objects c
 where b.object_id = c.object_id
   and a.sid = b.session_id;
 
ALTER SYSTEM KILL SESSION 'sid,serial#';

SELECT T.*, sa.SQL_TEXT, sa.SQL_FULLTEXT, sa.BIND_DATA
  FROM (select c.owner,
               c.object_name,
               c.object_type,
               b.sid,
               b.serial#,
               b.status,
               a.ORACLE_USERNAME,
               b.osuser,
               b.machine,
               DECODE(a.locked_mode,
                      0,
                      'None',
                      1,
                      'Null',
                      2,
                      'Row-S (SS)',
                      3,
                      'Row-X (SX)',
                      4,
                      'Share',
                      5,
                      'S/Row-X (SSX)',
                      6,
                      'Exclusive',
                      TO_CHAR(a.locked_mode)) alock_mode,
               b.STATUS SESSION_STATUS,
               b.LOGON_TIME,
               b.SQL_HASH_VALUE
          from v$locked_object a, v$session b, dba_objects c
         where b.sid = a.session_id
           and a.object_id = c.object_id) T
  left join v$sqlarea sa
    ON sa.HASH_VALUE = t.SQL_HASH_VALUE;
 

select a.sid, a.serial#, OBJECT_NAME, a.LOGON_TIME
  from v$session a, v$locked_object b, dba_objects c
 where b.object_id = c.object_id
   and a.sid = b.session_id;
    
    
SELECT SID, SQL_ID, USERNAME, BLOCKING_SESSION
  FROM v$session
 WHERE BLOCKING_SESSION IS NOT NULL;
  
  
 SELECT l1.sid || ' is blocking ' || l2.sid blocking_sessions
  FROM v$lock l1, v$lock l2
 WHERE l1.block = 1
   AND l2.request > 0
   AND l1.id1 = l2.id1
   AND l1.id2 = l2.id2;

SELECT s1.username || '@' || s1.machine || ' ( SID=' || s1.sid ||
       ' )  is blocking ' || s2.username || '@' || s2.machine || ' ( SID=' ||
       s2.sid || ' ) ' AS blocking_status
  FROM v$lock l1, v$session s1, v$lock l2, v$session s2
 WHERE s1.sid = l1.sid
   AND s2.sid = l2.sid
   AND l1.BLOCK = 1
   AND l2.request > 0
   AND l1.id1 = l2.id1
   AND l1.id2 = l2.id2;
    

select * from v$lock where type='TX' and request>0;
select * from v$lock where type='TX' and lmode>0;

Reference:

• Finding oracle locked objects

Java Socket Example: Proxy server

This tool can be used for intercept services request and redirect or return error message for specified sources. Basically, reading and writing in same socket in java.

import org.apache.log4j.Logger;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ProxyServerTest extends Thread {

    final static Logger logger = Logger.getLogger(ProxyServerTest.class);

    private ServerSocket serverSocket;
    private String wsServer;
    private int wsServerPort;
    private List ipList = new ArrayList();


    public ProxyServerTest(String hostName, int port, int timeout, String wsServer, int wsServerPort, List ipList) throws IOException {
        InetAddress ia = InetAddress.getByName(hostName);
        serverSocket = new ServerSocket(port, 50, ia);
        serverSocket.setSoTimeout(timeout);
        this.wsServer = wsServer;
        this.wsServerPort = wsServerPort;
        this.ipList = ipList;
    }

    public void run() {
        logger.info("Filter source ips: " + ipList);
        while (true) {
            try {
                logger.info("Waiting for client " + " LocalSocketAddress: " + serverSocket.getLocalSocketAddress()
                        + ", HostAddress: " + serverSocket.getInetAddress().getHostAddress() +
                        ", HostName: " + serverSocket.getInetAddress().getHostName() + " on port " + serverSocket.getLocalPort() + "...");
                Socket clientSocket = serverSocket.accept();

                logger.info("Just connected to " + clientSocket.getRemoteSocketAddress());

                String hostName = clientSocket.getInetAddress().getHostName();
                String hostAddress = clientSocket.getInetAddress().getHostAddress();

                logger.info("Filer IPs" + ipList + ", hostName:" + hostName + ", hostAddress:" + hostAddress);

                if (ipList.contains(hostAddress) || ipList.contains(hostName)) {
                    /** Return error message to client */
                    logger.info("Return error message to client");
                    ClientReadMessageThread cht = new ClientReadMessageThread(clientSocket);
                    Thread t = new Thread(cht);
                    t.start();
                    ClientSendMessageThread csmt = new ClientSendMessageThread(clientSocket);
                    Thread t2 = new Thread(csmt);
                    t2.start();
                    try {
                        t.join(1000);
                        t2.join(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        logger.error(e);
                    }

                } else {
                    /** Redirect to sighting WebService */
                    logger.info("Forwarding request to sighting web service :" + wsServer + ":" + wsServerPort);
                    Socket wsSocket = new Socket(wsServer, wsServerPort);

                    wsSocket.setKeepAlive(true);
                    clientSocket.setKeepAlive(true);
                    logger.info("isConnected wsSocket:" + wsSocket.isConnected());

                    OutputStream os = wsSocket.getOutputStream();
                    InputStream is = clientSocket.getInputStream();

                    Thread clientToWS = new Thread(new ClientReader(is, os, "ID1:" + clientSocket.getInetAddress().getHostName() + " to " + wsSocket.getInetAddress().getHostName()));
                    clientToWS.start();

                    InputStream wsIS = wsSocket.getInputStream();
                    OutputStream csOS = clientSocket.getOutputStream();

                    Thread wsToClient = new Thread(new ClientReader(wsIS, csOS, "ID2:" + wsSocket.getInetAddress().getHostName() + " to " + clientSocket.getInetAddress().getHostName()));
                    wsToClient.start();

                    try {
                        clientToWS.join(1000);
                        wsToClient.join(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        logger.error(e);
                    }
                }

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    logger.error(e);
                }
                logger.info("Close socket: " + clientSocket.getInetAddress());
                clientSocket.close();
            } catch (SocketTimeoutException s) {
                logger.error("Socket timed out!");
                logger.error(s);
                break;
            } catch (IOException e) {
                e.printStackTrace();
                logger.error(e);
                break;
            }
        }
    }

    public static class ClientReader implements Runnable {
        private InputStream is;
        private OutputStream os;
        private String id;

        public ClientReader(InputStream i, OutputStream o, String id) {
            this.is = i;
            this.os = o;
            this.id = id;
        }

        public void run() {
            try {
                logger.info(id + " start copying.");
                int x;
                x = is.read();
                while (x != -1) {
                    //    System.out.println(id);
                    os.write(x);
                    os.flush();
                    x = is.read();
                }
                logger.info(id + " data copied. x:" + x);
            } catch (IOException e) {
                e.printStackTrace();
                logger.error(e);
            }
        }
    }

    public static void main(String[] args) {
        try {
            System.out.println("Usage: HOST_NAME PORT_NO TIME_OUT WS_HOST_NAME WS_PORT_NO COMMA_SEPARATED_IP_ADDRESS_TO_SEND_ERROR");

            String hostName = String.valueOf(args[0]);
            int port = Integer.parseInt(args[1]);
            int timeout = Integer.parseInt(args[2]);
            String wsHostName = String.valueOf(args[3]);
            int wsPort = Integer.parseInt(args[4]);
            String ipAddressToIgnore = String.valueOf(args[5]);
            logger.info("hostName:" + hostName);
            logger.info("port:" + port);
            logger.info("timeout:" + timeout);
            logger.info("wsHostName:" + wsHostName);
            logger.info("wsPort:" + wsPort);
            logger.info("ipAddressToIgnore:" + ipAddressToIgnore);
            List ipList = Arrays.asList(ipAddressToIgnore.split(","));
            Thread t = new ProxyServerTest(hostName, port, timeout, wsHostName, wsPort, ipList);
            t.start();

        } catch (Exception e) {
            e.printStackTrace();
            logger.error(e);
            System.out.println("Usage: HOST_NAME PORT_NO TIME_OUT WS_HOST_NAME WS_PORT_NO COMMA_SEPERATED_IP_ADDRESS_TO_SEND_ERROR");
        }
    }
}

import org.apache.log4j.Logger;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;

public class ClientSendMessageThread implements Runnable {

    final static Logger logger = Logger.getLogger(ClientSendMessageThread.class);
    private Socket clientSocket;

    public ClientSendMessageThread(Socket clientSocket) {
        this.clientSocket = clientSocket;
    }

    public void run() {
        try {
            String errorResponse = "soap:ServerObject \"org.mule.transport.NullPayload\" not of correct type. It must be of type \"java.util.List\"";
            logger.info("Sending error response:" + clientSocket.getLocalSocketAddress());
            logger.info("Error response:" + '\n' + errorResponse);

            PrintWriter pw = new PrintWriter(clientSocket.getOutputStream());
            /** Set header details */
            pw.println("HTTP/1.1 500 Internal Server Error");
            pw.println("Content-Type: text/xml");
            pw.println("http.status: 500");
            pw.println("http.method: POST");
            pw.println("Content-Length: " + errorResponse.length());
            pw.print("\r\n");
            pw.println(errorResponse);
            pw.flush();
            // pw.close();
            logger.info("Response send to client:" + clientSocket.getLocalSocketAddress());
        } catch (IOException e) {
            e.printStackTrace();
            logger.error(e);
        }

    }
}

import org.apache.log4j.Logger;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.SocketException;

public class ClientReadMessageThread implements Runnable {

    final static Logger logger = Logger.getLogger(ClientReadMessageThread.class);
    private Socket clientSocket;

    public ClientReadMessageThread(Socket clientSocket) {
        this.clientSocket = clientSocket;
    }

    public void run() {
        try {
            logger.info("Reading data :" + clientSocket.getLocalSocketAddress());
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            String tmp;
            StringBuffer inputLine = new StringBuffer();
            while ((tmp = in.readLine()) != null) {
                inputLine.append(tmp);
                logger.info(tmp);
            }
            logger.info("Finished reading data :" + clientSocket.getLocalSocketAddress());
        } catch (SocketException se) {
            // se.printStackTrace();
            logger.warn(se);
        } catch (IOException e) {
            e.printStackTrace();
            logger.error(e);
        }
    }
}