linux command to get urls response from email json file

# insert new line after '},'
sed -i $'s/},/\\\n/g' file

# extract email value from json
grep -o '"email":"[^,]*' file

# do GET on urls and print response code
cat urls.txt | xargs curl -sL -w " %{http_code} %{url_effective}\\n" -o

Comparaison librairies sérialisation XML JSON

Introduction

Les critères de comparaison sont :

• l'extensibilité
• le mode de mapping, interne (annotation), externe (schéma)
• la simplicité d'utilisation
• la performance
• le mapping de type (Date, Collection, Map, Locale...)

Le test consiste à dé-sérialiser puis re-sérialiser un flux de données :

XML

<?xml version="1.0" encoding="UTF-8" ?>
<document locale="fr">
    <int-p>5</int-p>
    <integer>10</integer>
    <string>string</string>
    <myList>
        <element id="1">
            <text>me</text>
        </element>
        <element id="2">
            <text>you</text>
        </element>
    </myList>
    <myMap>
        <entry key="key1" value="value1" />
        <entry key="key2" value="value2" />
    </myMap>
</document>

JSON

{
    "locale":"fr",
    "int-p":5,
    "integer":10,
    "string":"string",
    "myList":[
        {"id":"1","text":"me"},
        {"id":"2","text":"you"}
    ],
    "myMap": {
        "key1":"value1",
        "key2":"value2"
    }
}

Librairies

	Jibx	Simple	XStream	JaxB	Jackson	Gson
Type	XML	XML	XML	XML	JSON	JSON
Interface	+++	+++	+++	-	:-D	+++
Perf	+++	+	++	++	+++	++
Extend	-	+++	+	++	+	+++
List	+++	+++	+++	+++	+++	+++
Map	+	+++	-	-	+++	+++
Winner	10	13	9	7	10	14

Interface : prise en charge du mapping au travers une interface Java.

Perf : la performance de serialisation/déserialisation

Extend : La lib gère-t-elle facilement le changement de schéma entre version du document

List : Facilité et différent moyen de faire le mapping des List

Map : Facilité et différent moyen de faire le mapping des Map

XML

Jibx

Type de mapping : fichier de configuration et compilation par injection de bytecode.

Les plus :

• Le plus performant
• Configuration externe aux objets
• Plusieurs mappings possibles

Les moins :

• Nécessite une pré-compilation
• Pas aussi simple que des annotations
• !! Pas de support d'extension simple

XStream

Type de mapping : annotations

Les plus :

• Le plus performant après jibx
• Très simple

Les moins :

• Nécessite l'usage d'annotations dans les objets
• !! Pas vraiment de support d'extension simple http://jira.codehaus.org/browse/XSTR-30 ??
  http://stackoverflow.com/questions/5377380/how-to-make-xstream-skip-unmapped-tags-when-parsing-xml
  http://rafaelsteil.com/omit-unexpected-xml-elements-with-xstream/

new XStream() {
    @Override
    protected MapperWrapper wrapMapper(MapperWrapper next) {
        return new MapperWrapper(next) {
            @Override
            public boolean shouldSerializeMember(Class definedIn, String fieldName) {
                if (definedIn == Object.class) { return false; }
                return super.shouldSerializeMember(definedIn, fieldName);
            }
        };
    }
};

Simple

Type de mapping : annotations

Les plus :

• Très simple
• !! Support d'extension

Les moins :

• Nécessite l'usage d'annotations dans les objets

Extensibilité

• @Version(revision=1.0) private double version;

Jaxb

Type de mapping : annotations

Les plus :

• C'est un standard 8-)
• !! Support d'extension (par défaut)

Les moins :

• Ne marche jamais du premier coup
• Fonctionne très mal ou pas quand les properties des objets implémentent des interfaces ou héritent d'objets. m(
• Nécessite l'usage d'annotations dans les objets

JSON

Jackson

Type de mapping : annotations ou configuration par code

Les plus :

• Le plus performant
• Accepte le mapping d'objets tiers
• !! Support d'extension

Les moins :

• Documentation un peu confuse

Extensibilité

• @JsonIgnoreProperties(ignoreUnknown = true)
• this.mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Gson

Type de mapping : annotations ou configuration par code

Les plus :

• Le plus performant après Jackson
• Très simple
• !! Support d'extension (par défaut)
• Accepte le mapping d'objets tiers
• Gestion du versionning du modèle
• Utilisé et réalisé par Google :-p

Les moins :

• J'en connais pas

Autres Librairies

• XML
• protostuff : orienté server-server et pas facilement customisable
• Extensibilité : support natif ;-)
• xmlbeans : requière un schéma XML, 100% XSD
• Extensibilité : XSD any
• castor : battu par jibx car plus simple et beaucoup plus performant (mais castor implemente aussi JDO). Pas vraiment testé, si certains connaissent ?
• Extensibilité : Unmarshaller.setIgnoreExtraElements(true);
• JSON
• protostuff : orienté server-server et pas facilement customisable
• Extensibilité : support natif ;-)
• json-flexjson : performances déplorables
• json-simple : low level api
• jettison : low level api

Mode de sérialisation

	Avantages	Inconvénients
Interne (annotation)	facile à mettre en place	difficulté à maintenir la compatibilité de la sérialisation en cas de changement du modèle interne
Externe (schéma)	facile de maintenir la compatibilité de la sérialisation en cas de changement du modèle interne	il faut définir le schéma et rendre accessible l'API de message aux applications

Extensibilité

L'extensibilité doit permettre l'évolution des données en fournissant une rétro-compatibilité transparent.

Concrètement, si on ajoute un attribut ou un élément au XML généré par le serveur, on ne doit pas avoir à changer la partie cliente.

Performances

Temps moyen de dé-sérialisation et sérialisation sur 1000 et 100 000 itérations avec données aléatoires

Conclusion

Pour la sérialisation XML, le gagnant en terme de performances est Jibx mais il n'est pas simple d'écrire le mapping et il n'offre aucun support pour l'extensibilité. Simple est comme son nom l'indique le plus simple et offre un bon mapping ainsi qu'un support pour l'extensibilité. XStream est un peu plus performant mais à besoin d'être tweaké pour faire aussi bien que Simple.

Pour la sérialisation JSON, le gagnant est Jackson avec Gson qui le colle de très près. Ils supportent aussi bien le mapping de différents objets que l'extensibilité. Jackson est un peu plus performant mais Gson est vraiment très simple et la doc est très claire.

Si la communication est exclusivement de serveur à serveur, l'utilisation de la sérialisation Java ou mieux de protobuf est fortement recommandée pour des raisons de performances et d'extensibilité.

Si la communication est à destination de clients web, une sérialisation XML JSON est recommandée car simple et accessible.

References

Code : http://code.google.com/p/caffeine/source/browse/#git%2Fserializer-comparison

https://github.com/eishay/jvm-serializers/wiki/

http://blog.xebia.fr/2010/08/18/comparatif-des-librairies-json/

http://code.google.com/p/json-smart/wiki/Benchmark

http://www.igvita.com/2011/08/01/protocol-buffers-avro-thrift-messagepack/

Bash command to insert some property on second line

sed -i '2iconnector=value' `grep -L "connector=" client-*.properties`

2i means insert on line 2 what follows




the command with grep is to retrieve files that do not have the property

bootstrap css arrow class

.arrow {
    display: inline-block;
    width: 0;
    height: 0;
    vertical-align: top;
    content: "";
    opacity: 0.3;
    filter: alpha(opacity=30);
}

.btn .arrow {
    margin-left: 0;
}
.btn .arrow.arrow-up {
    margin-top: 6px;
}
.btn .arrow.arrow-down {
    margin-top: 7px;
}
.btn .arrow.arrow-left {
    margin-top: 5px;
}
.btn .arrow.arrow-right {
    margin-top: 6px;
}

.btn:hover .arrow {
  opacity: 1;
  filter: alpha(opacity=100);
}

.arrow.arrow-up {
    border-left: 4px solid transparent;
    border-right: 4px solid transparent;
    border-bottom: 4px solid #000000;
}

.arrow.arrow-down {
    border-left: 4px solid transparent;
    border-right: 4px solid transparent;
    border-top: 4px solid #000000;
}

.arrow.arrow-right {
    border-top: 4px solid transparent;
    border-bottom: 4px solid transparent;
    border-left: 4px solid #000000;
}

.arrow.arrow-left {
    border-top: 5px solid transparent;
    border-bottom: 5px solid transparent;
    border-right: 5px solid #000000;
}

reference : http://css-tricks.com/snippets/css/css-triangle/

Only use password hash BCrypt

The real problem with password hash is not how secure is the algorithm but how long before it can be broken by brut force using cheap hardware.

Now that you can buy computer CPU grid on the cloud for nothing, it is a matter of time that all our SHA-256 hash be broken.

So, try BCrypt : http://en.wikipedia.org/wiki/Bcrypt

I am not very good at math but I understand that, you can choose the strength of the amount of computation to hash your password, which amount means time !

If today CPU can generate millions of MD5 hash per second, with BCrypt and a strength of 12 (2 at the power of 12), it takes 1 seconde on my Intel i7 quad core. With strength 13 it takes 2, with strength 14 it takes 4 and so on.

You have understood well. To generate a hash it takes at least 1 seconde. So if your passwords database were stolen, it will take 1 million more time than MD5 to bruteforce your password.

Set this strength as a configuration value and when the tomorrow computer will compute strength 14 in less than 10 milliseconds just upgrade the strength.

spring-data document mongodb does not recreate your indexes after a mongoTemplate.getDb().dropDatabase()

I'm using spring-data mongodb and I wanted to do well so I've made some unit tests to verify my queries their performances against indexes. Instead of doing a removeAll form each collections, I though it will be quicker to do a mongoTemplate.getDb().dropDatabase(). Big mistakes !! Dropping the database remove everything and indexes of courses. I though they were recreate by spring-data, and it is not. So, removeAll on collection repository will do it.

Linux Mint 13, enabled stamina on your sony vaio : how to deactivate one of the hybrid video card !

On my new computer, which is a Sony VAIO VPC-SE1A9E on Linux Mint 13 64 bits, I wanted to use the stamina feature and discovered that it deactivate/switch the video card used in an hybrid system. This works easily on Windows. Not in the mood to use windows so I browsed the web and found this to disable one of the video card.
Copy this in your '/etc/rc.local' before 'exit 0'

# deactivate ATI video card on startup in order to save battery life

# change right and owner of vgaswitcheroo
# http://ubuntuforums.org/showthread.php?p=11696293#post11696293
sudo chmod -R 705 /sys/kernel/debug
sudo chown -R USERNAME:USERNAME /sys/kernel/debug/vgaswitcheroo

# remove radeon module from kernel 
modprobe radeon

# http://doc.ubuntu-fr.org/vga_switcheroo
# http://asusm51ta-with-linux.blogspot.fr/
echo OFF > /sys/kernel/debug/vgaswitcheroo/switch

DO NOT 'blacklist radeon' at the end of /etc/modprobe.d/blacklist.conf because vga_switcheroo requires it to be enabled

To control if the device is disable type the command :

lspci -vnnn | grep VGA

The controller which is active should end with : [VGA controller] !! EDIT : laptops featuring hybrid graphics show a huge raise in power drain after a suspend/resume cycle
This is because the X server doesn't currently support GPU hot-pluggin.
A workaround is to move the code from '/etc/rc.local' to your '~/.profile' and first force to switch ON then to switch OFF.
references :
ubuntu-gnulinux-1204-precise-on-sony
radeon-module-boot-problems
vga_switcheroo
vgaswitcheroo -- permission denied
ASUSM51Ta & Linux: Enjoy Hybrid Graphics with switcheroo
Thanks you guys !