Using the executorservice to create new Threads on google appengine

Appengine actually allows you to spawn new threads, as long as you follow the rules defined in the docs. Here is how I did it,

	package no.nilsapp.someapp.cronjobs;
	import com.google.appengine.api.ThreadManager;
	import java.io.IOException;
	import java.util.List;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;
	import java.util.concurrent.ThreadFactory;
	import java.util.concurrent.TimeUnit;
	public class AppengineExecutor {
	public void run() throws IOException {
	ThreadFactory factory = ThreadManager.currentRequestThreadFactory();
	ExecutorService executor = Executors.newCachedThreadPool(factory);
	List<Shipment> shipmentsToCheck = dataStorage.getShipmentsNotDelivered();
	System.out.println("Checking shipments " + shipmentsToCheck.size());
	for (Shipment shipment : shipmentsToCheck) {
	// please note that "MyRunnable" implements Runnable and cannot directly extend Thread.
	Runnable checkShipmentTask = ThreadManager.createThreadForCurrentRequest(new MyRunnable(shipment));
	executor.execute(checkShipmentTask);
	}
	System.out.println("Sent all jobs to execution.");
	executor.shutdown();
	try {
	executor.awaitTermination(10, TimeUnit.SECONDS);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}
	}

view raw AppengineExecutor.java hosted with ❤ by GitHub

copy, paste and use it as you wish.

Using gae plugin with gradle (gradle + appengine)

Looking for an example project using gradle and appengine? I have used the gae plugin for gradle in this simple webapp and made the sourcecode available for you. Follow this link and build with gradle 1.6 .

git store password

To make git store your password, simply type

"git config credential.helper store"

to store it locally (for just the current repo), type

"git config --local credential.helper store"

Next time you push to the repo, git will store your password permanently.

Speeding up my build with gradle and some paralell magic

Just posting the results here, will get back to the details and some explanation in a later post.

Multi-module java project, 10 sub-modules, about 10k(?) unit-tests.

mvn clean install:  Total time: 3:52.082s ~ 232 secs
gradle clean build: Total time: 3 mins 20.987 secs
gradle clean build: Total time: 2 mins 17.648 secs (module parallel)
gradle clean build: Total time: 2 mins 0.58 secs ~ 120 secs ( module parallell, 2 threads)
gradle clean build: Total time: 2 mins 26.935 secs ( module parallell, 3 threads)

Raspberry pi WiFi : dongle and config

• Buy this dongle from dealextreme. This dongle works out of the box with Raspbian “wheezy” and needs no additional drivers. The chip is the realtek 8188 chip and works perfectly with linux.
• Edit /etc/networking/interfaces according to the gist below. Replace network name and password with your own:

	auto lo
	iface lo inet loopback
	iface eth0 inet dhcp
	allow-hotplug wlan0
	#iface wlan0 inet manual
	iface wlan0 inet dhcp
	wpa-ssid "my_network_name"
	wpa-psk "my_password"
	#wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
	#iface default inet dhcp

view raw interfaces hosted with ❤ by GitHub

Halt yor pi, remove any networking cables and restart. Congrats, your pi is wireless online!

Generate java from Wsdl with gradle

UPDATE: I have made a plugin to do this, just follow the guide on https://github.com/nilsmagnus/wsdl2java .

 The plain simple way to generate java from wsdl is this: add a javaexec task to your wsdl and run. The following code snippet will help you out:

	project.ext{
	cxfVersion = '2.5.1'
	generatedWsdlDir = file("build/generated-sources")
	wsdlDir = file("wsdl")
	wsdlsToGenerate =[
	['-xjc', '-b', "$wsdlDir/serializable_binding.xml", "$wsdlDir/mywsdl1.wsdl.xml"],
	['-xjc', '-b', "$wsdlDir/some_binding.xml", "$wsdlDir/mywsdl2.xml"],
	['-xjc', '-b', "$wsdlDir/joda_binding.xml", "$wsdlDir/mywsdl3.wsdl.xml"],
	// 55 more wsdls
	]
	}
	dependencies {
	compile "joda-time:joda-time:$jodatimeVersion"
	compile "org.apache.cxf:cxf-tools:$cxfVersion",
	"org.apache.cxf:cxf-tools-wsdlto-databinding-jaxb:$cxfVersion",
	"org.apache.cxf:cxf-tools-wsdlto-frontend-jaxws:$cxfVersion",
	"log4j:log4j:$log4jVersion"
	}
	task wsdl2Java() {
	inputs.files wsdlDir.listFiles()
	outputs.files generatedWsdlDir
	doLast {
	wsdlsToGenerate.each { wsdlFile ->
	createJavaFromWsdl(wsdlFile, generatedWsdlDir)
	}
	}
	}
	def createJavaFromWsdl(arguments, destinationDir) {
	arguments.add(arguments.size - 1, '-d')
	arguments.add(arguments.size - 1, generatedWsdlDir)
	println "Processing " + arguments[arguments.size - 1]
	javaexec {
	main = 'org.apache.cxf.tools.wsdlto.WSDLToJava'
	classpath = configurations.runtime
	args arguments
	}
	}

view raw simpleWsdlToJava.groovy hosted with ❤ by GitHub

The "wsdlsToGenerate" contains all the arguments for the org.apache.cxf.tools.wsdlto.WsdlToJava class, in the right order.

However, if you have a project like I have with 58 different wsdls, this approach is very time consuming. This is because every time createJavaFromWsdl() is called, a new java process will be started, executed and stopped. Now you have 58 sequential java processes running in your build script(!). 

Instead, why not run everything in the same java process? This can be done with code snippet 2: 

	buildscript {
	repositories {
	mavenCentral()
	}
	}
	project.ext {
	wsdlDir = file("wsdl")
	generatedWsdlDir = file("build/generated-sources")
	wsdlsToGenerate = [
	['-xjc', '-b', "$wsdlDir/serializable_binding.xml", "$wsdlDir/mywsdl2.wsdl.xml"],
	['-xjc', '-b', "$wsdlDir/some_binding.xml", "$wsdlDir/mywsdl3.wsdl.xml"],
	['-xjc', '-b', "$wsdlDir/other_binding.xml", "$wsdlDir/mywsdl4.wsdl.xml"],
	// 54 more wsdls
	['-xjc', '-b', "$wsdlDir/joda_binding.xml", "$wsdlDir/mywsdl55.wsdl.xml"],
	]
	}
	configurations{
	ws
	}
	dependencies{
	ws "org.apache.cxf:cxf-tools:2.5.1",
	"org.apache.cxf:cxf-tools-wsdlto-databinding-jaxb:2.5.1",
	"org.apache.cxf:cxf-tools-wsdlto-frontend-jaxws:2.5.1",
	"log4j:log4j:1.2.17"
	}
	task wsdl2Java() {
	if (!wsdlDir.listFiles()) {
	// do nothing
	} else {
	inputs.files wsdlDir.listFiles()
	outputs.files generatedWsdlDir
	doLast {
	wsdlsToGenerate.each { argsin ->
	argsin.add(argsin.size - 1, '-d')
	argsin.add(argsin.size - 1, generatedWsdlDir)
	javaexec {
	classpath configurations.ws
	main = 'org.apache.cxf.tools.wsdlto.WSDLToJava'
	args = argsin
	systemProperties = ['exitOnFinish':'TRUE']
	}
	}
	}
	}
	}

view raw fasterWsdlToJava.groovy hosted with ❤ by GitHub

Now, this adds some dependencies to the build-script, but I can live with that.

The runtime from snippet1 with 58 wsdls is 2min 58secons on my laptop. The runtime of snippet2 is 24seconds!