My current example is rails active resource. This is a great framework if you are planning to use it to talk to another rails app. If your url does not end in .json then you have to override / reimplement many high level methods because of one or two private methods.

I know they teach you this in school. I know it makes you feel smart. Stop it. Private methods makes your frameworks less usable and less extensible.

Snapshots
Streams (Callbacks in particular)
Secrets

I have put an SRPM out at [1] and a compiled jar at [2]. You can always clone the repo at [3] and build it from there.

Thanks!

[1] http://bkearney.fedorapeople.org/libvirt-java-0.4.5-ALPHA.fc12.src.rpm
[2] http://bkearney.fedorapeople.org/libvirt-0.4.5.ALPHA.jar
[3] http://www.libvirt.org/git/?p=libvirt-java.git;a=summary

So.. I hear that Rest is a panacea, but mostly because it is “Rest not SOAP”. I actually understand many of the benefits that REST is gives you:

1) I can use a simple http client to access resources, therefore it is easier to adopt.
2) I inherit alot of the WS-* enhancements from the underlieing http transport, so the frameworks are lighter weight.
3) The ability to use the service both by a client and a browser.. mashups become easy.

What I keep getting hung up on is the absence of a formal description of the interface. I see WADL, but whenever I dig into this it seems to get brushed aside as a nuisance. If i want to write typed clients, then I need to have some formal contract of what can be passed in and what is returned. This contract seems to be what alot of the cruft around SOAP is for. Is there something I am missing with this? The answer the books/articles seem to give is “who needs a formal spec, it is all URI’s”. This tends to be a load of hooey, since some clients (rails in particular) do not handle nicely objects of the same type with heterogeneous data sets.

So.. it seems like Rest (which is not SOAP) makes it easy for the easy clients by skimping on the tools for the more complex clients. I can easily do jersey -> jersey, and I presume Resteasy -> Resteasy. But w/o that neutral definition.. cross implementation clients (robust ones) are actually harder.

Am I missing something?

I figure it is best to get the first cut out there though. So here it is.

(*
	Parse the /etc/cobbler/settings file  which is in
	YAML 1.0 format.

	The lens can handle the following contructs
	* key: value
	* key: "value"
	* key: 'value'
	* key: [value1, value2]
	* key:
	   - value1
	   - value2
	* key:
	   key2: value1
	   key3: value2 

	Author: Bryan Kearney

	About: License
	  This file is licensed under the LGPLv2+, like the rest of Augeas.
*)
module CobblerSettings =
	autoload xfm

	let kw = /[a-zA-Z0-9_]+/
	(* TODO Would be better if this stripped off the " and ' chracters *)
	let kv = /([^]['", \t\n#:@-]+|"[^"\n]*"|'[^'\n]*')/ 

	let lbr = del /\[/ "["
	let rbr = del /\]/ "]"
	let colon = del /:[ \t]*/ ": "
	let dash = del /-[ \t]*/ "- "
	(* let comma = del /,[ \t]*(\n[ \t]+)?/ ", " *)
	let comma = del /[ \t]*,[ \t]*/ ", "

	let eol_only = del /\n/ "\n"

	(* TODO Would be better to make items a child of a document *)
	let docmarker = /-{3}/

	let eol   = Util.eol
	let comment = Util.comment
	let empty   = Util.empty
	let indent = del /[ \t]+/ "\t"
	let ws = del /[ \t]*/ " "

	let value_list = Build.opt_list [label "item" . store kv] comma
	let setting = [key kw . colon . store kv] . eol
	let simple_setting_suffix = store kv . eol
	let setting_list_suffix =  [label "sequence" . lbr . ws . (value_list . ws)? . rbr ] . eol
	let indendented_setting_list_suffix =  eol_only . (indent . setting)+
    let indented_list_suffix =  [label "list" . eol_only . ([ label "value" . indent . dash  . store kv] . eol)+]

    (* Break out setting because of a current bug in augeas *)
	let nested_setting = [key kw . colon . (
											(* simple_setting_suffix | *)
											setting_list_suffix |
											indendented_setting_list_suffix |
											indented_list_suffix
											)
						]

	let document = [label "---" . store docmarker] . eol    

	let lns = (document | comment | empty | setting | nested_setting )*
    (* let lns = (setting)* *)

	let xfm = transform lns (incl "/etc/cobbler/settings") 

	(*
	test lns  get "" = ?
	test lns  get "Simple_Setting: Value \n" = ?
	test lns  get "Simple_Setting2: 'Value2@acme.com' \n" = ?
	test lns  get "Simple_Setting3: ''\n" = ?
	test lns  get "Simple_Setting4: \"\"\n" = ?
	test lns  get "Setting_List:[Value1, Value2, Value3]\n" = ?
	test lns  get "Empty_Setting_List: []\n" = ?
	test lns  get "# Commented_Out_Setting: 'some value'\n" = ?
	test lns  get "---\n" = ?
	test lns  get "Nested_Setting:\n Test: Value\n" = ?
	test lns  get "Nested_Setting:\n - Test \n" = ?
	let  cset = Sys.read_file "/etc/cobbler/settings"
	test lns  get cset = ?
    *)
(* Local Variables: *)
(* mode: caml *)
(* End: *)

My next steps will be to clean this up, and to submit it along with some tests.