Example 1

int main()
{
	g_type_init();

	GError *error = NULL;
	DBusGConnection *conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);

	if (error != NULL) {
		g_error("D-BUS Connection error: %s", error->message);
		g_error_free(error);
	}

	if (!conn) {
		g_error("D-BUS connection cannot be created");
		return EXIT_FAILURE;
	}

	DBusGProxy *proxy = dbus_g_proxy_new_for_name(conn,
			"org.freedesktop.NetworkManager",
			"/org/freedesktop/NetworkManager",
			"org.freedesktop.NetworkManager");

	if (!proxy) {
		g_error("Cannot create proxy");
		return EXIT_FAILURE;
	}

	g_message("Calling NetworkManager.sate synchronously");
	guint state;
	GError *error = NULL;
	if (!dbus_g_proxy_call(proxy, "state", &error, G_TYPE_INVALID,
			G_TYPE_UINT, &state, G_TYPE_INVALID)) {
		if (error->domain == DBUS_GERROR && error->code
					== DBUS_GERROR_REMOTE_EXCEPTION) {
			g_error("Caught remote method exception %s: %s",
					dbus_g_error_get_name(error),
					error->message);
		} else {
			g_error("D-BUS: %s", error->message);
		}
	}
	print_network_manager_state(state);

	g_object_unref(proxy);
	dbus_g_connection_unref(conn);
	return EXIT_SUCCESS;
}

The code is self explaining. Be careful to use the right type parameters, otherwise the call will not work, at D-Bus tutorial page you can find GLib – DBus type mapping. If you want to use more complex types outside this mapping, GLib may show you the message “No marshaller for signature of …” and you will need to register a custom marshaller to this type, but this is a subject for future posts.

Example 2

A faster way to call a remote method is to generate client stub. First you need to get XML API of object interface, you can use d-feet tool to call DBus Introspectable interface and get that.

Then execute the following command passing network-manager-api.xml file:

dbus-binding-tool --mode=glib-client network-manager-api.xml >  network-manager-client-stub.h

And you will simply get the code ready to execute D-BUS calls and they are properly typed according to method signatures. The example show you an asynchronous call using the stub:

#include "network-manager-client-stub.h"

void network_state_callback(DBusGProxy *proxy, guint state, GError *error, gpointer userdata)
{
	print_network_manager_state(state);
	g_main_loop_quit(loop);
}

static GMainLoop *loop;
int main()
{
	loop = g_main_loop_new(NULL, FALSE);
	g_type_init();

	GError *error = NULL;
	DBusGConnection *conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);

	if (error != NULL) {
		g_error("D-BUS Connection error: %s", error->message);
		g_error_free(error);
	}

	if (!conn) {
		g_error("D-BUS connection cannot be created");
		return EXIT_FAILURE;
	}

	DBusGProxy *proxy = dbus_g_proxy_new_for_name(conn,
			"org.freedesktop.NetworkManager",
			"/org/freedesktop/NetworkManager",
			"org.freedesktop.NetworkManager");

	if (!proxy) {
		g_error("Cannot create proxy");
		return EXIT_FAILURE;
	}

	g_message("Calling NetworkManager.sate asynchronously");
	org_freedesktop_NetworkManager_state_async(proxy, network_state_callback , NULL);

	g_message("Waiting D-BUS callback");
	g_main_loop_run(loop);

	g_message("Exiting glib mainloop");

	g_main_loop_unref(loop);
	g_object_unref(proxy);
	dbus_g_connection_unref(conn);
	return EXIT_SUCCESS;
}

See full code example in method-invocation.c at dbus-glib-sample project.

First, let us choose the signal we want to listen. To see current active D-BUS services on system (I am using Ubuntu 10.04), you can open a debugger tool like d-feet and see something like that:

Let us catch ‘StateChange’ signal from NetworkManager Interface (API definition link), in our test case to dispatch this signal, you should connect or disconnect your active network connection after run the code sample.

#include <glib.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>

DBusHandlerResult signal_filter(DBusConnection *connection, DBusMessage *msg,
		void *user_data)
{
	if (dbus_message_is_signal(msg, "org.freedesktop.NetworkManager",
			"StateChange")) {
		read_network_manager_state_change(msg);
	}
	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

int main()
{
	GMainLoop *loop = g_main_loop_new(NULL, FALSE);
	DBusError error;

	dbus_error_init(&error);
	DBusConnection *conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error);

	if (dbus_error_is_set(&error)) {
		g_error("Cannot get System BUS connection: %s", error.message);
		dbus_error_free(&error);
		return EXIT_FAILURE;
	}
	dbus_connection_setup_with_g_main(conn, NULL);

	char *rule = "type='signal',interface='org.freedesktop.NetworkManager'";
	g_message("Signal match rule: %s", rule);
	dbus_bus_add_match(conn, rule, &error);

	if (dbus_error_is_set(&error)) {
		g_error("Cannot add D-BUS match rule, cause: %s", error.message);
		dbus_error_free(&error);
		return EXIT_FAILURE;
	}

	g_message("Listening to D-BUS signals using a connection filter");
	dbus_connection_add_filter(conn, signal_filter, NULL, NULL);

	g_main_loop_run(loop);

	return EXIT_SUCCESS;
}

The filter function return DBUS_HANDLER_RESULT_HANDLED, other handlers will not receive this message, but in example code we want the other BUS listeners catch the network connection signal.

Do not forget to call dbus_connection_setup_with_g_main function since the connection was created from dbus_bus_get function, otherwise the GLib mainloop and D-BUS callbacks will not work properly and will you be very sad, belive me.

To read the message you can use D-BUS Message API, it is part of D-Bus low-level public API.

void read_network_manager_state_change(DBusMessage *msg)
{
	DBusError error;
	dbus_error_init(&error);

	guint32 state = 0;

	if (!dbus_message_get_args(msg, &error, DBUS_TYPE_UINT32, &state,
			DBUS_TYPE_INVALID)) {
		g_error("Cannot read NetworkManager state change message, cause: %s", error.message);
		dbus_error_free(&error);
		return;
	}
	print_network_manager_state(state);
}

The second example show how to receive the same signal, but using a proxy from remote object.

#include <glib.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>

void state_changed_callback(DBusGProxy *proxy, guint32 state,
		gpointer user_data)
{
	print_network_manager_state(state);
}

int main()
{
	GMainLoop *loop = g_main_loop_new(NULL, FALSE);

	g_type_init();

	GError *error = NULL;
	DBusGConnection *conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);

	if (error != NULL) {
		g_error("D-BUS Connection error: %s", error->message);
		g_error_free(error);
	}

	if (!conn) {
		g_error("D-BUS connection cannot be created");
		return EXIT_FAILURE;
	}

	DBusGProxy *proxy = dbus_g_proxy_new_for_name(conn,
			"org.freedesktop.NetworkManager",
			"/org/freedesktop/NetworkManager",
			"org.freedesktop.NetworkManager");

	if (!proxy) {
		g_error("Cannot create proxy");
		return EXIT_FAILURE;
	}

	dbus_g_proxy_add_signal(proxy, "StateChange", G_TYPE_UINT,
			G_TYPE_INVALID);

	dbus_g_proxy_connect_signal(proxy, "StateChange",
			G_CALLBACK(state_changed_callback), NULL, NULL);

	g_message("Waiting D-BUS proxy callback for signal");
	g_main_loop_run(loop);

	return EXIT_SUCCESS;
}

Next post I will talk about asynchronous/synchronous calls.

Download full example code at gitorious dbus-glib-sample project.

D-Bus is a system for interprocess communication (IPC), and it is a good way to integrate operating system/desktop applications on linux, the windows port is under development. You can find details about “what is D-BUS?” at tutorial page.

Next post will describe how to listen to application signals.

Esta tecnologia é uma alternativa de formato de serialização de dados frente aos que comumente usamos em aplicações (XML, JSON, CSV), ou outros formatos binários que seguem padrões estritos como ASN1, etc…

Consiste um uma maneira simples de especificar a estrutura de sua informação (IDL), e gerar automaticamente os objetos para encapsular as informações e métodos para serialização/deserialização.

Longe de se tornar um padrão internacional e inter-corporativo como XML, a proposta do PB é otimização da troca de dados, tamanho da informação, e compatibilidade com versões anteriores de mensagens, permitindo upgrades de serviço on-the-fly.

Por isso, desde que você tenha domínio/influência entre os serviços que irão conversar usando este protocolo sejam internos ou externos a sua corporação, pode ser uma boa alternativa de otimização.

Download (.pdf)

Vejam as duas linhas do produto e os screenshots disponíveis em:

ESbox - IDE para aplicações C/C++ e Python, requer instalação de SDK para executar cross-compilation para o dispositivo.

PluThon-  IDE leve para aplicações  python utilizando diretamente o dispositivo como plataforma de desenvolvimento, não requer SDK.

Existem muitas features novas legais além de um novo sistema de ajuda sensível  para o desenvolvedor que é dinamicamente atualizado pelos mantenedores ! =]

Para criação destes dois produtos eclipse,  foi desenvolvido um o novo framework base: Mica (Maemo IDE Common Architecture -  http://mica.garage.maemo.org/2nd_edition/), matendo a aquitetura de cada produto bastante simplificada e fácil para quem desejar colaborar ou estender os mesmos ou ainda criar o seu….  hein? Sim o código é inteiramente open-source e tem licensa EPL .

O link oficial do anúncio: http://maemo.org/news/announcements/maemo_eclipse_integration_2nd_edition_prefinal_released/

Registre sua dúvida ou opinião sobre o mini-workshop http://fabricioepa.googlepages.com/jeequickstart-webtier

JBean File Storage

O componente ainda apesar de implementado ainda não está disponibilizado publicamente pois ainda necessita de revisão, documentação e algumas possíveis melhorias embora esta versão esteja presente em 2 projetos já em produção.

A idéia chave foi associar um caminho a um tipo java, eu mentiria se dissesse que a idéia foi completamente minha pois me baseei numa solução proposta por Luciano Logrado ao trabalharmos juntos em um outro projeto, digamos que eu incrementei a idéia para suportar polimorfismo e com isto será possível:

• Associar um caminho a uma tipo (classe ou interface) e seus subtipos também estarão associados
• Usar uma Expression Language (semelhante a do JSP 2.0) mínima para usar caminhos dinâmicos
• Herdar um caminho dum outro POJO
• Manter na hierarquia de diretórios a hierarquia nas associações dos POJOS

Estes dois últimos são importantes caso por exemplo existam dois POJO’s com relacionamento de pai/filho e ao excluir o pai os filhos devem ser excluídos:

Cliente ->* Conta

Desta forma o caminho de arquivos do cliente poderia ser:

$/Cliente_99

/Conta_33

MeuExtrato1.txt

/Conta_34

Extrato2008.txt

Com uma operação de exclusão do diretório do cliente haverá propagação no sistema de arquivo para os subdiretórios, ou seja, as contas. Além de manter a organização dos arquivos numa hierarquia de pastas de fácil entendimento visual e manipulação.

Veja detalhes do uso:

Configuração

Consiste em definir num arquivo xml os caminhos (paths) e as formas de amazenamento de arquivos utilizada (Stores).

Arquivo: test-file-storage.xml

<jbfs-conf>
    <stores>
        <local-system-file-store
          name="MySampleFileStorage"
          rootDir="C:/temp" />
    </stores>
<paths>
<path name="root" >/MyRootDir</path>
<path name="fatherDir" type="jbfs.test.FatherBean">
          ${root}/Father/${_bean.name}
       </path>
<path name="childSubdir">
            ${fatherDir}/ChildSubdir
       </path>
<path name="childFileName" type="jbfs.test.ChildBean" >
             ${_bean.father}/ChildDir/${_bean.childName}.txt
       </path>
    </paths>
</jbfs-conf>

Uso

Basta recuperar a instância do JBFS e utlizar os dois objetos principais:

• PathResolver (Resolvedor de Caminhos) -> Resolve qual caminho associado ao objeto ou um nome utilizando os paths configurados.
• FileStorage (O armazenamento de arquivos) -> Representa uma Store configurada e executa as operações sobre o sistema de arquivo escolhido.
  • Podem existir várias implementações de FileStorage conforme o sistema de arquivo utilizado: FTP, sistema de arquivos remoto, etc. Por enquanto só existe a implementação de armazenamento em disco local: <local-system-file-store />

Segue abaixo um teste unitário que exemplifica o uso duma possível classe cliente do nosso componente:

package jbfs.test;

public class TestPathResolver {

    protected JBeanFileStorage jbfs;

   //CONFIGURANDO
    @Before
    public void setUp() {
        jbfs = new JBeanFileStorage("test-storage.xml"); //File must be on classpath
    }

    //Resolvendo um diretório baseado em um nome
    @Test
    public void testResolveSimplePathFromName() {

        String path = jbfs.getPathResolver().resolveName("root", null);

        assertEquals("/MyRootDir", path);

    }

    //Resolvendo um diretório baseado em um Bean
    @Test
    public void testResolvePathFromBean() {

        FatherBean bean = new FatherBean("fatherName");

        String path= jbfs.getPathResolver().resolveBean(bean);

        assertEquals("/MyRootDir/Father/fatherName", path);
    }

    @Test
    public void testResolveComplexPathFromBean() {

        ChildBean bean = new ChildBean("childFile", new FatherBean("fatherName"));

        String filePath = jbfs.getPathResolver().resolveBean(bean);

        assertEquals("/MyRootDir/Father/fatherName/ChildDir/childFile.txt", filePath);
    }

//TESTANDO MANIPULAÇÃO DOS ARQUIVOS
@Test
    public void testFileCRUD() {

        ChildBean bean = new ChildBean("childFile", new FatherBean("fatherName"));

        String filePath= jbfs.getPathResolver().resolveBean(bean);

       FileStorage storage = jbfs.getStore("MySampleFileStorage");

        try {
            storage.createNewFile(filePath, "hellow".getBytes());

            assertTrue(storage.exists(filePath));

            assertEquals("hellow", new String(storage.getBytes(filePath)));

            storage.delete(filePath);

            assertFalse(storage.exists(filePath));

        } catch (IOException e) {
            e.printStackTrace();
            fail("Test fail");
        }
   }
}

Integração com outros Componentes

Quando trabalhando com um framework ORM como Hibernate, pode ser interessante apagar os arquivos associados de uma entidade automaticamente quando for removida do Banco de Dados. Seguindo o exemplo Cliente -> * Conta, quando a transação que remove a entidade Cliente for confirmada os arquivos do cliente e suas contas serão excluídos. Para isto interceptador como o implementado abaixo pode ser utilizado em conjunto com o JBFS:

/**
 * File Garbage Collector tries to remove file paths associated with deleted
 * Hibernate Entities.
 *
 * @author Fabrí­cio Silva
 *
 */
public class FileGarbageCollector extends EmptyInterceptor {

	private FileStorage repository;
	private PathResolver pathResolver;
	private JBeanFileStorage jbfs;
	private static SessionFactory hibernateSessionFactory;

	private Map trash = new HashMap();

       public FileGarbageCollector (SessionFactory hibernateSessionFactory){
            this.hibernateSessionFactory = hibernateSessionFactory;
        } 

	@Override
	public void onDelete(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {

		if (jbfs.getConfiguration().hasPolimorficPath(entity)) {
			putPathInGarbageForDeletion(pathResolver.resolveBean(entity));
		}
	}

	@Override
	public void afterTransactionCompletion(Transaction tx) {
		performGarbageDeletion(tx);
	}

	private void performGarbageDeletion(Transaction tx) {
		Garbage g = trash.remove(tx);
		if (g != null && tx.wasCommitted() && !tx.wasRolledBack()) {
			for (String path : g.paths) {
				try {
					repository.deleteQuietly(path);
				} catch (Exception e) {
					logger.debug(
							"Error when file garbage collector try to delete path:"
									+ path, e);
				}
			}
		}
	}

       private void putPathInGarbageForDeletion(String path) {
		Transaction tx = hibernateSessionFactory.getCurrentSession()
				.getTransaction();

		Garbage g = trash.get(tx);
		if (g == null) {
			g = new Garbage();
			trash.put(tx, g);
		}
		g.addPath(path);
	}

       class Garbage {
		protected List paths = new LinkedList();

		void addPath(String path) {
			paths.add(path);
		}

		List getPaths() {
			return paths;
		}

		void setPaths(List paths) {
			this.paths = paths;
		}

	}

     //O código que inicializa as variáveis de instância foi omitido...
}

Por o JFBS ser um POJO ele pode facilmente se integrar com qualquer framework ou componente de sua aplicação, em especial no framework Spring sua configuração é tão simples como de qualquer outro bean:

<!-- File Storage -->
<bean id="jbfs"
	class="easyaccept.util.file.jbfs.JBeanFileStorage" scope="singleton" >
<property name="confLocation">
		<value>file-storage.xml</value>
	</property>
</bean>

Espero que tenham gostado, quando o componente estiver com o mínimo aceitável de documentação será publicado aqui. Futuramente outras implementações de armazenamento estarão disponíveis:

• FTP
• SVN
• CVS
• Remote System File

Abraço.

Em suporte a este propósito utilizei os recursos do Subversion (SVN), por ser open-source e de livre distribuição, além de integrar novos recursos em relação ao famoso sistema de controle de versão CVS.

O foco do estudo foi relacionado aos usuários de um repositório, como também o recurso de integração com Java/Eclipse IDE.

Enjoy it =) !

Fundamentos do Controle de Versão e SVN

Illegal attempt to associate a collection with two open sessions

Causa:

O erro é provocado quando um hiberObject associado a uma sessão tenta ser alterado por outra sessão do hibernate.

Solução:

Esqueça os métodos session.get/load/update você pode conseguir o mesmo efeito com session.refresh/merge.

Contexto do Problema:

Isso acontece devido a associação de um objeto gerenciado pelo hibernate (hiberOjbect) com a sessão que o carrega. Tecnicamente se um objeto foi carregado por uma sessão, até que o objeto seja desconectado (passando para o estado Detached) ele permanece associado a ela. O que pode ser feito invocando os métodos:

//Apenas se os relacionamentos do hiberOject
//que possuem cascade="evict" eles serão também desconectados
session.evict(hiberObject);
session.clear();
session.close();
 

Se outra sessão tentar alterá-lo sem ele estar destacado da última sessão, o erro será lançado.

Problemas Típicos:

1. 0 Quando se deseja usar um objeto em outra sessão sem fechar a primeira use o evict, lembrando que se os relacionamentos não possuirem cascade=”evict” o efeito do método não servirá para eles e provavelmente o mesmo erro ocorrerá para o “proxy” dos relcionamentos (que podem ser coleções causando Illegal attempt to associate a collection with two open sessions) .

2.0 Em Aplicações WEB Java tipicamente carregamos um hiberObject e o setamos em alguma variável do contexto web (request, session, sevletContext), após algum uso pela camada de apresentação fazemos outra chamada a camada do hibernate usando esse mesmo hiberObject onde ocorre falha com o dito erro. Neste caso temos dois pontos:

• Se a sessão que o carregou anterior ainda estava aberta você recai no erro 1.0

• Caso a velha sessão já tenha morrido, o seu hiberObject não está mais conectado a mesma, porém os seus relacionamentos ainda podem ter algum “proxy” para a velha sessão. Nesse caso é mais simples usar um dos metódos:

//Caso queira reconectar e recarregar
//no seu objeto os dados do banco
session.refresh(detachedHiberObject);

//Caso queira reconectar o objeto fazer um update no banco
//de dados com as novas informações setadas no objeto
connectedHiberObject = session.merge(detachedHiberObject);

O merge/refresh tem funções diferentes, mas ambos reconectam o objeto a uma sessão, seja a mesma ou não, sem provocar erro.

• Use somente quando houver “descasamento” entre tipos primitivos e objetos empacotadores
• Não abuse: um Integer não substitui um int (a performance é pior)
• Cuidado, unboxing com objetos null lança exceção

Probolema:

• Generics não trabalha com tipos primitivos

Após executar o seguinte teste de performance, constatou-se uma diferênça em média de 25% com uso do autobox. O algoritimo de teste baseou-se em comparar as duas execuções:

1. faça 1000 vezes
   • varra um ArrayList<Integer>, capturando o valor sem fazer autobox
2. faça 1000 vezes
   • varra um ArrayList<Integer> usando enhanced-loop fazendo automaticamente unbox para int, capturando o valor e fazendo autbox novamente para um objeto Integer.

Resultado da execução:

___________________________________

autoBoxUnBox()…java.lang.NullPointerException
Sem autoboxing = 6531ms
Com autobox/unbox= 8734ms
Diferença de 26%

___________________________________

Conclusão:

Se sua aplicação é “Performance Driven”, estruturas como o IntHashMap visto no blog anterior entre outras coleções da API que não trabalhem com Generics podem ser a melhor saída para escovar milisegundos de processamento.

Abaixo segue a classe usada no teste:

package update5.boxing;

import java.util.*;

/**
 *
 * @author Fabrício Silva Epaminondas
 */
public class AutoboxingUnboxing {

    static void autoBoxUnBox() {
        // Antes
        int prim = 10;// primitivo
        Integer obj = new Integer(20);// objeto
        Integer nullObj = null;

        // Java 5
        Integer c = 30;// autobox Integer c = new Integer(30)
        prim = obj;// unbox prim = obj.intValue();
        obj = prim;// autobox obj = new Integer(prim);

        try{
            prim = nullObj;// throw NullPointerException
        }catch (NullPointerException e) {
            System.out.println("autoBoxUnBox()..." + e);
        }
    }

    @SuppressWarnings("unchecked")
    static void autoboxComGenerics() {

        // Antes
        Map products = new HashMap();
        products.put(new Integer(2779), new Float(20.45f));
        products.put(Integer.valueOf(922), Float.valueOf(99.99f));
        float price = new Float((Float) products.get(new Integer(922)
                .intValue())).floatValue();

        // AutoBoxing com Generics
        Map<Integer, Float> products2 = new HashMap<Integer, Float>();
        products2.put(10, 20.45f);
        products2.put(20, 99.99f);
        float price2 = products2.get(10);

        // Problema: Performance
        // Generics só aceita Tipos de Objetos e não primitivos

        // Ex: ArrayList de Integers..
        Collection<Integer> values = new ArrayList<Integer>();
        for (int i = 0; i < 100000; i++) {
            values.add(i);
        }

        Integer intObj = null;

        // Teste de Performance 1 (Sem Autobox)
        long time = System.currentTimeMillis();

        // repete 1000 vezes
        for (int i = 0; i < 1000; i++) {
            // for em coleção de objetos Integer
            for (Integer val : values) {
                intObj = val;// sem autobox
            }
        }
        long performance1 = System.currentTimeMillis() - time;
        System.out.println("Sem autoboxing = " + performance1 + "ms");

        // Teste de Performance 2 (Com Autobox/Unbox)
        time = System.currentTimeMillis();

        // repete 1000 vezes
        for (int i = 0; i < 1000; i++) {
            // for em coleção de objetos Integer
            for (int val : values) {// executando unboxing para int
                intObj = val;// autobox para Integer
            }
        }
        long performance2 = System.currentTimeMillis() - time;
        System.out.println("Com autobox/unbox= " + performance2 + "ms");

        System.out.println("Diferença de " + percentGain(performance1,performance2) + "%");
    }

    static long percentGain(long num, long div) {
        return (100 - num*100/div);
    }

    public static void main(String[] args) {

        autoBoxUnBox();

        autoboxComGenerics();
    }
}