install grc

add match in /etc/grc.conf

add corresponding conf file in /usr/share/grc

for example log4j


#Colours are one of:
# none, default, bold, underline, blink, reverse, concealed,
# black, green, yellow, blue, magenta, cyan, white,
# on_black, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white
# beep
#
#count is one of words: once, more, stop, previous, block or unblock
#
# * once means that if the regexp is matched, its first occurrence is coloured
# and the program will continue with other regexp's.
#
# * more means that if there are multiple matches of the regexp in one line,
# all of them will be coloured.
#
# * stop means that the regexp will be coloured and program will move to the
# next line (i.e. ignoring other regexp's)
#
# * previous means the count will be the same as for the previous line
#
# * block marks a start of a multiline block of text, coloured with
# the same colour
#
# * unblock, obviously, marks the end of such a block

regexp=\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\W\d{3}
colours="\033[1;38;5;16m"
count=more
=====
regexp=INFO\s+\[.+\]
colours=blue
count=once
=====
regexp=\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\W\d{3}\s+INFO
colours=on_blue
count=once
=====
regexp=DEBUG\s+\[.+\]
colours=green
count=once
=====
regexp=\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\W\d{3}\s+DEBUG
colours=on_green
count=once
=====
regexp=WARN\s+\[.+\]
colours=yellow
count=once
=====
regexp=\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\W\d{3}\s+WARN
colours=on_yellow
count=once
=====
regexp=ERROR\s+\[.+\]
colours=red
count=once
=====
regexp=\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\W\d{3}\s+ERROR
colours=on_red
count=once


Then use grc:

grc tail -300f x.log

this will trigger the log.conf file and colourize the tail output

Use marathon ant and maven

Running marathon from an ant task is easy. To setup the classpath however is a pain. Marathon can either run in test or gui mode. Gui is used when you develop a test.

Start with installing the actual marathon application.

Create a pom with the artifact that contains the gui application. This is just so that the pom version is updated by a release.

Finally use this ant file to run marathon:
-------------------------------------------------------
<?xml version="1.0"?>

<project name="main" basedir="." xmlns:artifact="antlib:org.apache.maven.artifact.ant">


<property name="m2_loc_repo" value="${user.home}/.m2/repository"/>

<!-- has its own pom so that we the version will change with the maven releases -->
<artifact:dependencies pathId="aqva_client.classpathId">
<pom file="pom.xml"/>
<localRepository path="${m2_loc_repo}"/>
</artifact:dependencies>

<taskdef resource="net/sf/antcontrib/antlib.xml"/>

<property file="aqva_marathon.properties"/>
<fail unless="marathon.home">
You need to add a file called aqva_marathon.properties with the following properties:

marathon.home (required): path to marathon downloaded from here http://www.marathontesting.com
aqva_url (optional): url to aqva server, default: http://localhost:8080/Aqva/
aqva_user (optional): user aqva server, default: roger
aqva_pwd (optional): password aqva server, default: helly
</fail>


<path id='marathon_classpath'>
<fileset dir="${marathon.home}">
<include name="marathon.jar"/>
<include name="marathon-python.jar"/>
<include name="marathon-ruby.jar"/>
<include name="marathon-runtime.jar"/>
</fileset>
<fileset dir="${marathon.home}/Support">
<include name="forms-1.2.1/forms-1.2.1.jar"/>
<include name="jaccess-1.3/jaccess.jar"/>
<include name="jedit-textArea.jar"/>
<include name="jline-0.9.93.jar"/>
<include name="junit3.8.2/junit.jar"/>
<include name="looks-2.2.0/looks-2.2.0.jar"/>
<include name="vldocking_2.1.5C.jar"/>
</fileset>
</path>


<property name='marathon.project.dir' value='.'/>

<!-- the default test i.e. all tests -->
<property name="test" value=""/>
<property name="aqva_url" value="xxx"/>
<property name="aqva_user" value="yyy"/>
<property name="aqva_pwd" value="zzz"/>

<!-- has a value that is used for all tests in run, use this to create unique data that is used
between tests in one run -->
<tstamp>
<format property="timestamp_val" pattern="yyyyMMdd_HHmmss_SSS" />
</tstamp>


<target name="test" description="runs test(s) in batch mode (wo gui) -Dtest= to run a specific test">
<property name="app_classpath" refid="aqva_client.classpathId"/>

<java classname="net.sourceforge.marathon.Main" fork="yes">
<classpath refid="marathon_classpath"/>
<jvmarg value="-Dmarathon.application.classpath=${app_classpath}"/>
<jvmarg value="-Dpython.cachedir=${env.HOME}/.jycache"/>
<jvmarg value="-Dmarathon.project.file=marathon_test.project"/>
<!-- send in java exe -->
<jvmarg value="-Dmarathon.application.vm.command=${java.home}/bin/java"/>
<!-- send startup args -->
<jvmarg value="-Dmarathon.application.vm.arguments=-Daqva_url=${aqva_url} -Daqva_user=${aqva_user} -Daqva_pwd=${aqva_pwd} -Dtimestamp_val=${timestamp_val}"/>

<arg value="-batch"/>
<arg value="-reportdir"/>
<arg value="${marathon.project.dir}/reports"/>
<arg line="${marathon.project.dir}"/>
<arg line="${test}"/>
</java>
</target>

<target name="gui" description="run marathon gui for developing tests">
<!-- need to set the classpath in the project file-->
<property name="app_classpath" refid="aqva_client.classpathId"/>

<propertyregex property="app_classpath_fixed"
input="${app_classpath}"
regexp="\\"
replace="/"
global="true"
defaultValue="${app_classpath}"/>
<propertyregex property="JAVA_EXE_PATH_fixed"
input="${java.home}/bin/java"
regexp="\\"
replace="/"
global="true"
defaultValue="${java.home}/bin/java"/>
<copy file="resources/marathon_gui.project_TEMPLATE" tofile="temp/marathon_gui.project" overwrite="true">
<filterset>
<filter token="APP_CLASSPATH" value="${app_classpath_fixed}"/>
<filter token="JAVA_EXE_PATH" value="${JAVA_EXE_PATH_fixed}"/>
<filter token="APP_ARGS"
value="-Daqva_url=${aqva_url} -Daqva_user=${aqva_user} -Daqva_pwd=${aqva_pwd} -Dtimestamp_val=${timestamp_val}"/>
</filterset>
</copy>

<!--echo message="${app_classpath}"/-->
<java classname="net.sourceforge.marathon.Main" fork="yes">
<classpath refid="marathon_classpath"/>
<jvmarg value="-Xmx256m"/>
<jvmarg value="-Dmarathon.home=${marathon.home}"/>
<jvmarg value="-Dpython.cachedir=${env.HOME}/.jycache"/>
<jvmarg value="-Dmarathon.project.file=temp/marathon_gui.project"/>

<arg line="${marathon.project.dir}"/>
</java>
</target>

</project>
------

exclude transitive dependencies in maven built ear

set: <defaultlibbundledir>..</defaultlibbundledir>
as in

<plugin>
<groupid>org.apache.maven.plugins</groupid>
<artifactid>maven-ear-plugin</artifactid>
<version>2.4.2</version>
<configuration>
<version>5</version>
<defaultlibbundledir>..</defaultlibbundledir>
<modules>
<jarmodule>
<groupid>antlr</groupid>
<artifactid>antlr</artifactid>
<includeinapplicationxml>true</includeinapplicationxml>
<bundledir>APP-INF/lib</bundledir>
</jarmodule>
</modules>
...
</configuration>
</plugin>

android:
adb logcat - trace log
telnet localhost
gsm call 12345678

FileInputStream input = new FileInputStream("/tmp/1.xml");
FileChannel channel = input.getChannel();

// Create a read-only CharBuffer on the file
ByteBuffer bbuf = channel.map(FileChannel.MapMode.READ_ONLY, 0, (int) channel.size());
CharBuffer cbuf = Charset.forName("UTF-8").newDecoder().decode(bbuf);

vmware tools, ubuntu 9.10 minimal virtual machine

First:
sudo apt-get install build-essential linux-headers-`uname -r` gcc make

Follow: http://langui.sh/2009/10/05/ubuntu-9-10-in-vmware/

We use the virtual kernel package
cd /usr/src/
sudo dpkg -i --force-depends open-vm-modules-2.6.31-14-generic-pae_2009.07.22-179896-2+2.6.31-14.48_i386.deb

The steps above upgraded the kernel but the vmware tools is compiled for the older kernel. Follow
http://www.kunthar.com/blogs/kunthar.php/grub2-switching-boot-order

to do a default boot from the older

Using grinder and junit.

It may be convenient to use junit tests for stress tests sometimes.

junit.py

from net.grinder.script.Grinder import grinder
from net.grinder.script import Test
from java.lang import Class
from java.lang import System
from java.lang import Integer
from java.lang import Runnable
from java.lang import Thread
from java.lang import Exception
from java.lang import Throwable
from org.junit.runner import JUnitCore
from org.junit.runner import Request
from org.junit.runner import Result
from org.junit.runner.notification import RunListener

class MyRunListener(RunListener):

  def testFailure(self,failure):
    print "jUniTFailure: " + failure.toString() + failure.trace
    grinder.logger.error("jUniTFailure: " + failure.toString() + failure.trace)

  def testFinished(self,description):
    print "jUniTFinished: " + description.displayName
    grinder.logger.output("jUniTFinished: " + description.displayName)

  def testRunFinished(self,result):
    grinder.logger.output("jUniTRunFinished: ")

  def testRunStarted(self,description):
    print "jUniTRunStarted: "
    grinder.logger.output("jUniTRunStarted: ")

  def testStarted(self,description):
    print "jUniTestStarted: " + description.displayName
    grinder.logger.output("jUniTestStarted: " + description.displayName)

# recursive method to get all tests regardless of what test description is used
# The description has a tree structure that has to be traversed. The actual tests are
# the leaves with no children
def getTests(description):
 if (description.children == None or description.getChildren().size() == 0):
  return [description]
 
 childDescs = description.children
 idx=0

 children=[]
 while idx < childDescs.size():
  if (childDescs.get(idx).children == None or childDescs.get(idx).getChildren().size() == 0):
   children.append(childDescs.get(idx))
  else:
   children.extend(getTests(childDescs.get(idx)))
  
  idx=idx+1  
 return children

class TestRunner:
    def __call__(self):

 #wait with writing the reports
 grinder.statistics.delayReports = 1

 # get settings from the start script
 testClassName = System.getProperty("grinder.test")
 offsetStr = System.getProperty("grinder.offset")
 offset=0
 if offsetStr != None:
  offset=int(offsetStr)


 jUnitCore=JUnitCore()
 #jUnitCore.addListener(MyRunListener())

 mainRequest=Request.aClass(Class.forName(testClassName));

 description= mainRequest.getRunner().getDescription()
 
 testDecs=getTests(description)
 idx=0
 for testDec in testDecs:
  #print "running test "+childDescs.get(idx).toString()

  # we only have the display name for each test. The syntax is method_name(test_class_name)
  displayName=testDec.displayName
  method=displayName[:displayName.index('(')]
  testClass=displayName[displayName.index('(')+1:displayName.index(')')]
  
  #print "method: "+displayName[:displayName.index('(')]
  # lookup the junit test 
  childReq=Request.method(Class.forName(testClass), displayName[:displayName.index('(')]) 
  print "running test "+testClass+"."+method
  print "#tests "+str(childReq.getRunner().testCount())
  print "runner description "+childReq.getRunner().getDescription().displayName

  # wrap the junit test with the grinder test. This basically triggers the statitics in
  # grinder when we call any method on the wrapped object
  wrappedJunitCore = Test(offset+idx, testDec.displayName).wrap(jUnitCore)
  
  # start junit test and  collect statistics for grinder
  result=wrappedJunitCore.run(childReq)
  idx=idx+1
  if result.failureCount > 0:
   grinder.statistics.forLastTest.setSuccess(0)
   failures=result.failures
   failure=failures.get(0)
   print "failure: "+failure.toString()
   print "failure trace: "+failure.getTrace()
   grinder.logger.error("jUniTFailure: " + failure.toString() + failure.trace)
  

starting grinder using classpath from maven and ant

<?xml version="1.0"?>
<project name="main" basedir="." xmlns:artifact="antlib:org.apache.maven.artifact.ant">


    <property name="script_folder" value="."/>
    <property name="project_dir" value="."/>


    <property name="repo_server" value="x.y.z"/>
    <property name="repo_url" value="http://${repo_server}:8081"/>

    <property name="m2_repo_path" value="${user.home}/.m2/repository"/>

    <!-- handle artifacts -->
    <!--artifact:remoteRepository id="public.repository" url="http://10.71.64.68:8081/nexus/content/repositories/central-m1/"/-->
    <artifact:remoteRepository id="central" url="${repo_url}/nexus/content/groups/public"/>
    <artifact:remoteRepository id="snapshot.repository" url="${repo_url}/nexus/content/groups/public-snapshots/"/>
    <artifact:localRepository id="local.repository" path="${m2_repo_path}"/>

    <artifact:dependencies pathId="deps.classpath" filesetId="deps.fileset" useScope="test">
        <pom file="${project_dir}/pom.xml">
        </pom>
        <localRepository refid="local.repository"/>
        <remoteRepository refid="central"/>
        <remoteRepository refid="snapshot.repository"/>
    </artifact:dependencies>


    <artifact:dependencies pathId="grinder.classpath">
        <dependency groupId="junit" artifactId="junit" version="4.7"/>
        <dependency groupId="grinder" artifactId="grinder-j2se5" version="3.1"/>
        <dependency groupId="grinder" artifactId="grinder" version="3.1"/>
        <dependency groupId="grinder" artifactId="grinder-xmlbeans" version="3.1"/>
        <dependency groupId="grinder" artifactId="picocontainer" version="1.3"/>
        <dependency groupId="javax.xml.bind" artifactId="jsr173_api" version="1.0"/>
        <dependency groupId="grinder" artifactId="jython" version="2.2.1"/>
        <dependency groupId="grinder" artifactId="xmlbeans-xbean" version="2.3.0"/>
        <dependency groupId="grinder" artifactId="picocontainer" version="1.3"/>


        <localRepository refid="local.repository"/>
        <remoteRepository refid="central"/>
        <remoteRepository refid="snapshot.repository"/>
    </artifact:dependencies>


    <artifact:dependencies pathId="antcontrib.classpath">
        <dependency groupId="ant-contrib"
                    artifactId="ant-contrib"
                    version="1.0b3"/>
        <localRepository refid="local.repository"/>
        <remoteRepository refid="central"/>
        <remoteRepository refid="snapshot.repository"/>
    </artifact:dependencies>


    <taskdef resource="net/sf/antcontrib/antlib.xml">
        <classpath>
            <path refid="antcontrib.classpath"/>
        </classpath>
    </taskdef>


    <property name="testClassPattern" value="**/JUnit*IntegrationTest.class"/>
    <property name="noTestsInParallell" value="1"/>
    <target name="run-tests">
      <var name="idx" value="0"/>
       <for param="integrationtestfull" parallel="true" threadCount="${noTestsInParallell}">
            <path>
                <fileset dir="${project_dir}/target/test-classes" includes="${testClassPattern}"/>
            </path>
            <sequential>

                <propertyregex property="integrationtesttmp"
                               input="@{integrationtestfull}"
                               override="true"
                               regexp=".+[\/\\]target[\/\\]test-classes[\/\\](.+)\.class"
                               select="\1"/>
                <propertyregex property="integrationtest"
                               input="${integrationtesttmp}"
                               override="true"
                               regexp="[\/\\]"
                               replace="\."/>
                <!--var name="offset" unset="true"/-->
  <math result="offset" operand1="${idx}" operation="*" operand2="100" datatype="int"/>
                <math result="idx" operand1="${idx}" operation="+" operand2="1" datatype="int"/>
               <antcall target="run-agent">
                    <param name="grinder.test" value="${integrationtest}"/>
                    <param name="grinder.offset" value="${offset}"/>
                </antcall>
            </sequential>
        </for>
    </target>

  <!-- Default values sent to the agent process -->
  <property name="grinder.processes" value="1"/>
  <property name="grinder.threads" value="1"/>
  <property name="grinder.runs" value="1"/>
  <property name="grinder.consoleHost" value="localhost"/>
  <property name="grinder.consolePort" value="6372"/>

    <target name="run-agent">
        <echo message="grinder.test ${grinder.test} offset  ${grinder.offset}"/>
 <echo message="args to gridner agent -Dgrinder.runs=${grinder.runs} -Dgrinder.processes=${grinder.processes} -Dgrinder.threads=${grinder.threads} -Dgrinder.test=${grinder.test} -Dmts.integrationtest.enabled=true -Dmts.integrationtest.jnp.url=${mts.integrationtest.jnp.url} -Dgrinder.offset=${grinder.offset}"/>
        <echo message="property file ${script_folder}/grinder.properties"/>
 <java classname="net.grinder.Grinder"
              fork="true"
              failonerror="true"
              maxmemory="64m">
            <classpath>
                <path refid="grinder.classpath"/>
                <path refid="deps.classpath"/>
            </classpath>
     <arg value="${script_folder}/grinder.properties"/>
     <!-- Args sent to the agent worker processes -->
            <sysproperty key="grinder.jvm.arguments" value=" -Dgrinder.runs=${grinder.runs} -Dgrinder.processes=${grinder.processes} -Dgrinder.threads=${grinder.threads} -Dgrinder.test=${grinder.test} -Dmts.integrationtest.enabled=true -Dmts.integrationtest.jnp.url=${mts.integrationtest.jnp.url} -Dgrinder.offset=${grinder.offset}"/>
     <!-- Args sent to the agent process -->
            <sysproperty key="grinder.runs" value="${grinder.runs}"/>
            <sysproperty key="grinder.processes" value="${grinder.processes}"/>
            <sysproperty key="grinder.threads" value="${grinder.threads}"/>
     <sysproperty key="grinder.consoleHost" value="${grinder.consoleHost}"/>
     <sysproperty key="grinder.consolePort" value="${grinder.consolePort}"/>
        </java>
    </target>

      <target name="run-console">
        <java classname="net.grinder.Console"
              fork="true"
              failonerror="true"
              maxmemory="64m">
            <classpath>
                <path refid="grinder.classpath"/>
            </classpath>
        </java>
    </target>
    <path id="jython.classpath">
        <path refid="grinder.classpath"/>
        <!--path refid="deps.classpath"/-->
        <pathelement location="target/classes/"/>
        <pathelement location="target/test-classes/"/>
    </path>

</project>