En effet, si il est très simple de configurer subversion via Apache grâce à un module dédié, il n’est pas possible de faire de même avec Lighttpd.

Ce tutoriel va donc vous expliquer comment installer Apache2 sur un serveur où Lighttpd est déjà présent et surtout comment rendre votre repository SVN accessible via le port 80 grâce au mod_proxy de Lighttpd.

Les pré-requis pour ce tutoriel sont :

• Un serveur Lighttpd fonctionnel
• Un sous-domaine disponible (ici svn.example.com)

Commençons par installer Subversion :

aptitude install subversion

puis créons notre premier repository :

 svnadmin create /var/svn/testproject

Passons ensuite à Apache et son module SVN:

aptitude install apache2 libapache2-svn

Puis éditons le fichier port.conf afin qu’Apache écoute sur le port 8080

emacs /etc/apache2/port.conf

NameVirtualHost *:8080
Listen 8080

Nous allons maintenant devoir éditer le fichier httpd.conf afin de configurer le module SVN.

emacs /etc/apache2/httpd.conf

 
<VirtualHost *:8080>
    ServerName example.com
    DocumentRoot /var/www/
 
    <Location />
        DAV svn
        SVNPath /var/svn/testproject/
        AuthType Basic
        AuthName "SVN TEST"
        AuthUserFile /var/svn/testproject/conf/users
        Require valid-user
        Order allow,deny
        Allow from all
    </Location>
<VirtualHost>

Comme vous l’avez remarqué, nous allons devoir créer les différents utilisateurs qui seront autorisés à se connecter au SVN.

Pour cela :

htpasswd -c /var/svn/testproject/conf/users bobby

Enlevez le « -c » pour les utilisateurs suivant.

Nous devons maintenant appliquer les bons droits aux différents fichier :

chown -R www-data:www-data /var/svn
chmod -R 700 /var/svn

Si vous mettez à jour la configuration de votre Apache

/etc/init.d/apache2 reload

votre repository devrait être accesible via votre url : www.example.com:8080/testproject .

Il ne nous reste plus qu’a configurer le mod_proxy de Lighttpd.

Commencez par vous assurer que le mod est bien activé dans la configuration de Lighttpd, comme ici :

emacs /etc/lighttpd/lighttpd.conf

server.modules              = (
            "mod_access",
            "mod_alias",
            "mod_accesslog",
            "mod_compress",
            "mod_rewrite",
            "mod_magnet",
            "mod_redirect",
            "mod_proxy",
#           "mod_evhost",
#           "mod_usertrack",
#           "mod_rrdtool",
#           "mod_webdav",
#           "mod_expire",
#           "mod_flv_streaming",
#           "mod_evasive"
)

Ensuite, rajoutez ces quelques lignes à la fin de votre fichier de configuration (ou dans un include par soucis de propreté ) :

$HTTP["host"] == "svn.example.com" {
    server.document-root = "/var/www/"
    proxy.server = (
        "/" => (("host" => "127.0.0.1", "port" => 8080))
    )
}

Il ne nous reste plus qu’a reload notre lighttpd :

/etc/init.d/lighttpd reload

Votre SVN devrait maintenant être accessible via l’URL : http://svn.example.com/testproject

En regardant de plus prêt le fichier de configuration d’Apache2, vous verrez qu’il sera très simple de configurer de multiples repository en changeant la variable « location » dans le httpd.conf.

C’est tout pour aujourd’hui.

N.B : Par soucis de sécurité, vous souhaiterez peut être faire tourner Apache2 avec un user différent de Lighttpd, pensez alors à bien répercuter les droits sur le /var/svn.
Vous pourriez également modifier le document-root d’Apache et configurer le SSL.

Ce fichier gère toutes les autorisations d’entrée sur le serveur Postgres qui lui correspond.

Ce fichier est analysé ligne par ligne, dès qu’une ligne correspond aux critères de connexion alors la connexion est établit. Si aucune ligne ne correspond alors l’accés est refusé.

Une ligne typique ressemble à celle-ci : #TYPE     DATABASE     USER     CIDR-ADDRESS     METHOD

Chaque ligne possède 5 composantes :

• TYPE : local, autorise les connexions en local - host, autorise les connexions via internet.
• DATABASE : Spécifie la base de donées concernée par cette ligne (instruction), si cette instruction est valable pour toutes les données, « all » peut être écrit ici.
• USER : Spécifie l’utilisateur concerné par cette ligne (instruction), si cette instruction est valable pour tous les utilisateurs, « all » peut être écrit ici.
• ADDRESS : Spécifie l’adresse de la machine client ayant le droit d’accéder au serveur Postgres. Cela peut être une adresse IP ou un nom de domaine.
• METHOD : Ce champs, celui qui dans notre cas pose problème, représente la méthode d’authentification utilisée par Postgres. 12 méthodes d’authentifications existent au total. Nous allons en décrire 5 ici.

Voici les 5 méthodes :

1. md5 :  Autorise la connexion de tout utilisateur, tant qu’il possède un couple login/password valide. Le mot de passe doit être envoyé encrypté en md5.
2. ident : Autorise uniquement l’utilisateur du compte Unix courant à se connecter. Toute tentative de se connecter via un autre utilisateur se verra refuser.
3. password : Similaire à la méthode md5, sauf que le mot de passe est envoyé en clair [déconseillé]
4. trust : Accepte toutes les connexions, sans demande de mot de pase.
5. reject : Rejette systématiquement les connexions

Ca c’était pour l’explication, voici maintenant la solution.

Ouvrez le fichier /etc/postgresql/{version postgresql}/main/pg_hba.conf

Remplacer

Par

Et le tour est joué. Pour plus d’informations n’hésitez pas à vous réferrez à la doc de pg_hba.conf ici.

Ce tutorial est destiné aux débutant sous iOS. Nous prendrons l’exemple concret de la communication avec une API simple, sans authentification : http://is.gd. L’objectif est simple. Envoyer une requête à http://is.gd en fournissant en paramètre une url longue, et récupérer la version courte, le tout sans latence (requête asynchrones).

Etablissons tout d’abord notre classe URLShortenerController. Nous voulons un NSMutableData pour stocker tout retour éventuel du Web Service, et nous avons besoin d’une méthode initWithDelegate:url: qui va initialiser notre instance en stockant l’instance qui souhaite avoir le retour (delegate), et l’url a raccourcir :

@protocol URLShortenerDelegate;
 
@interface URLShortenerController : NSObject
{
	id delegate;
@private
	NSMutableData *data;
}
 
@property (nonatomic, assign) id delegate;
 
- (id)initWithDelegate:(id)aDelegate url:(NSString *)anURL;
 
@end

Nous voulons donc envoyer aussi un retour quand il est disponible. Nous allons donc créer un protocole, que toute les classes qui souhaitent utiliser notre raccourcisseur d’url doivent implémenter.

@protocol URLShortenerDelegate
@optional
- (void)shortener:(URLShortenerController *)shortener didSucceedWithShortenedURL:(NSString *)url;
- (void)shortener:(URLShortenerController *)shortener didFailWithError:(NSError *)error;
@end

Dans notre fichier d’implémentation maintenant, nous initialisons l’instance comme prévue, et nous créeons une instance de NSURLConnection. Cette classe permet d’entreprendre et récupérer de manière asynchrone des données :

- (id)initWithDelegate:(id<URLShortenerDelegate>)aDelegate url:(NSString *)anURL
{
	if ([super init])
	{
		data = [[NSMutableData alloc] init];
		self.delegate = aDelegate;
		NSURL *requestURL = [NSURL URLWithString:[NSString stringWithFormat:@"http://is.gd/api.php?longurl=%@", anURL]];
		NSURLRequest *request = [NSURLRequest requestWithURL:requestURL];
		NSURLConnection *connection = [NSURLConnection connectionWithRequest:request delegate:self];
	}
 
	return self;
}

Nous pouvons implémenter les callbacks de NSURLConnection. Je ne vous montrerais que les deux première, les autres étant utile en cas d’erreur. Tout d’abord lorsque nous recevons des données, nous les ajoutons à notre NSMutableData

- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)someData
{
	[data appendData:someData];
}

Ensuite quand nous avons reçu toute les données, nous pouvons appeller notre delegate pour lui fournir l’url raccourcie :

- (void)connectionDidFinishLoading:(NSURLConnection *)connection
{
	NSString *url = [[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] autorelease];
	[delegate shortener:self didSucceedWithShortenedURL:url];
}

Et voila ! Un peu d’imagination et vous pourrez intégrer un vrai Web Service. Les bases fournies ici seront les même.

En effet, si vous avez tenté d’installer Microsoft SQL Management Studio Express 2008, vous avez sans douté été confronté au problème suivant : lors du lancement de l’executable d’installation, après la décompression des fichiers nécessaires, une fenêtre d’installation SQL Server 2008 « classique » apparait et aucune trace de Management Studio dans les options d’installations proposées.

La solution étant dénuée de toute logique, il y a peu de chance que vous parveniez à vos fins sans un petit coup de pouce.

L’astuce est de lancer l’installation d’une nouvelle instance de SQL Server 2008, sans tenir compte d’une éventuelle installation précedante.

Une fois parvenu à la fenêtre de « selection des composants »,  cochez « Outils de gestion - de base » puis finissez l’installation normalement.

MSMSE sera alors installé et prêt à l’emploi.

> [myFoobar description]
<FoobBar:0x3e16820>
> [myNSArry description]
(
    lol,
    42
)

Nous allons développer une meilleure méthode description, qui liste les attributs de l’objet qui l’appelle (on l’appelle le « sender »), et affiche son type, son nom et sa valeur. Comme Objective C est dynamique, nous allons echanger les implémentations au runtime : les appels à description iront à notre méthode, et nous décideront dans celle-ci si nous appellons la méthode description originale (si l’objet l’implémente) ou plutôt la nôtre.

Catégories et Swizzling

Pour rajouter des méthodes à une classe, Objective C utilise les catégories. Créons donc une catégorie à NSObject afin d’y ajouter notre méthode :

@interface NSObject (DTFObject)
 
@end

Le problème c’est que si nous implementons une methode description dans notre catégorie, la méthode description du système va être écrasée. En effet, les catégories ne fonctionnent pas comme la surcharge de méthode dans ce cas. Puisque nous voulons faire appel a la méthode du systeme lorsque l’objet l’implémente, nous allons faire du swizzling de méthode : lors de l’execution, les implémentation de notre methode dtfDescription et de description seront echangées. Exemple :

[foo description];        // execute [foo dtfDescription]
[foo dtfDescription];    // execute [foo description]

Nous utiliserons JRSwizzle, une implémentation libre qui permet le swizzling de méthode dans n’importe quelle version d’Objective C. Nous faisons l’appel à jr_swizzleMethod dans la méthode + (void)load. Cette méthode est invoquée lorsqu’une classe ou une catégorie (notre cas) est ajoutée au runtime :

static void SwizzleClassMethods(Class class, SEL firstSelector, SEL secondSelector);
 
@implementation NSObject (DTFObject)
 
+ (void)load
{
	NSError	*err = [[NSError alloc] init];
 
	[self jr_swizzleMethod:@selector(description) withMethod:@selector(dtfDescription) error:&err];
	if ([[err userInfo] valueForKey:@"NSLocalizedDescriptionKey"] != nil)
		NSLog(@"%@", [[err userInfo] valueForKey:@"NSLocalizedDescriptionKey"]);
	[err release];
}
 
@end

Maintenant que les méthodes sont échangées il faut implémenter la nôtre. Nous souhaitons tout d’abord savoir si le sender (pour rappel c’est l’objet qui appelle notre méthode) implémente description. Objective C propose de savoir cela via respondsToSelector:, mais comme il retourne vrai si la méthode est implémentée dans un parent, elle retournera vrai dans tout les cas ici (NSObject est le parent de tout objet). Pas de problème, utilisons la reflexivité pour savoir cela. Nous allons récupérer la liste des méthodes du sender via class_copyMethodList() puis comparer son nom avec le selector qui nous interresse (description) via sel_isEqual() et method_getName() :

- (BOOL)implementsSelector:(SEL)aSelector
{
	Method			*methods;
	unsigned int	count;
	unsigned int	i;
 
	methods = class_copyMethodList([self class], &count);
	for (i = 0; i < count; i++)
		if (sel_isEqual(method_getName(methods[i]), aSelector))
			return YES;
	return NO;
}

Implémentons maintenant cela dans notre méthode :

- (NSString *)dtfDescription
{
	if ([self implementsSelector:@selector(description)])
		return [self dtfDescription];
}

Attention : nous ne créeons pas une boucle récursive infinie en retournant [self dtfDescription] ! Souvenez vous que les appels sont interchangés. La méthode appellée sera description. Bouclons maintenant sur les attributs de notre objet :

- (NSString *)dtfDescription
{
	unsigned int	i;
	unsigned int	count;
	Ivar			*ivars;
	NSString		*type;
	NSString		*key;
	NSMutableString	*description;
 
	if ([self implementsSelector:@selector(description)])
		return [self dtfDescription];
	ivars = class_copyIvarList([self class], &count);
	description = [NSMutableString stringWithFormat:@"<%s:0x%06x>\n(\n", class_getName([self class]), self];
	for (i = 0; i < count; i++)
	{
		type = [[NSString alloc] initWithUTF8String:ivar_getTypeEncoding(ivars[i])];
		key = [[NSString alloc] initWithUTF8String:ivar_getName(ivars[i])];
	}
	[description appendString:@")"];
	return description;
}

Nous en profitons pour commencer a remplir notre string de retour comme le faisais l’ancien description : avec le type et l’adresse de l’objet. Maintenant récuperons chaque attribut, et si c’est un attribut simple (char, char *, int…) affichons sa valeur, sinon son nom, type et adresse. Et nous avons fini. Voici la méthode finale :

 
- (NSString *)dtfDescription
{
	unsigned int	i;
	unsigned int	count;
	Ivar			*ivars;
	NSString		*type;
	NSString		*key;
	id				object;
	NSMutableString	*description;
 
	if ([self implementsSelector:@selector(description)])
		return [self dtfDescription];
	ivars = class_copyIvarList([self class], &count);
	description = [NSMutableString stringWithFormat:@"<%s:0x%06x>\n(\n", class_getName([self class]), self];
	for (i = 0; i < count; i++)
	{
		type = [[NSString alloc] initWithUTF8String:ivar_getTypeEncoding(ivars[i])];
		key = [[NSString alloc] initWithUTF8String:ivar_getName(ivars[i])];
		if ((object = object_getIvar(self, ivars[i])) != nil)
		{
			if ([type characterAtIndex:0] == _C_ID)
				[description appendString:[NSString stringWithFormat:@"\t%@ %@ = 0x%6x\n", type, key, object]];
			else
				[description appendFormat:[NSString stringWithFormat:@"\t%@ = %%%@\n", key, type], object];
		}
		else
			[description appendFormat:@"\t%@ = nil 0x%06x", key, object];
		[type release];
		[key release];
	}
	[description appendString:@")"];
	return description;
}

Le code complet est disponible sur github : http://github.com/toutankharton/DTFObject

Pour cela, rien de plus simple, commencez par lancer VmWare Workstation 7, cliquez sur « Create new virtual machine » puis suivez les quelques étapes suivantes :

Vous pouvez désormais démarrer votre VM et vous devriez avoir la bonne surprise de voir votre GRUB apparaitre.

Il ne vous reste plus qu’a installer les VmWare tools pour profiter pleinement de votre ubuntu.

Pratique, non?

N.B : N’essayez pas de démarrer votre système Windows dans votre Windows, ca ne fonctionnera évidemment pas.

• SYS et SYSTEM sont des comptes utilisateurs
• SYSDBA et SYSOPER sont des privilèges systèmes

SYS et SYSTEM

Ces comptes utilisateurs sont automatiquement crées lors de l’installation d’une base de données Oracle. Le role de « DBA » (Database Administrator) leur est initialement attribué.

• L’utilisateur SYS est l’utilisateur le plus haut-niveau d’une base de données Oracle. Toutes les tables et vues du dictionnaire de la base de données se trouvent dans le schéma de l’utilisateur SYS, autrement dit SYS est (par défaut) l’unique utilisateur qui ait accès à ces informations. Afin d’assurer l’intégrité des données se trouvant dans le dictionnaire, seulement la base de données elle même est amenée à modifer les informations s’y trouvant. Idéalement, aucun utilisateur ne doit avoir le droit de créer/modifier/supprimer des tables appartenant au schéma SYS.

• L’utilisateur SYSTEM quant à lui, est utilisé pour des tâches administratives, création de tables, de vues, etc. Toutes tâches éffectués par l’utilisateur SYSTEM doivent avoir un lien avec l’administration de la base de données, sinon il est recommandé de se connecter à la base de donnée en utilisant un autre utilisateur

SYSDBA et SYSOPER

• Le privilège SYSDBA est attribué seulement aux administrateurs de base de données ayant tous les droits sur celle-ci. Grâce à ce privilège l’utilisateur possède tous les droits sur la base de données. Lorsque un utilisateur se connecte avec le privilège SYSDBA, il ne se connectera pas sur le schéma attribué à son utilisateur, mais au schéma SYS

• Le privilège SYSOPER permet à un utilisateur d’effectuer des opérations d’administration basiques, ce privilège ne donne pas la possibilité d’avoir accès aux informations des autres utilisateurs. Lorsque un utilisateur se connecte avec le privilège SYSOPER, il ne se connectera pas sur le schéma attribué à son utilisateur, mais au schéma PUBLIC

Pour plus d’informations, voici la documentation officiel d’Oracle (en Anglais) au sujet des :

• Utilisateurs SYS et SYSTEM
• Privileges SYSDBA et SYSOPER

The application failed to initialize properly (0xc0150002). Click on OK to terminate the application.

Ceci est du au fait qu’OpenCv a été compilé sous une version précise de Visual Studio 2005. Afin de le faire fonctionner avec toute les autres versions de Visual, il suffit de télécharger un patch disponible sur le site de Microsoft

Le patch est disponible ici

Accepter les certificats SSL

Connectez-vous sur votre serveur via ssh, et authentifiez vous avec les identifiants/passe fournis a redmine. Puis, à la racine du compte, faites un checkout de votre dépot et acceptez definitivement le certificat.

$> cd
$> svn co https://svn.your-server.tld
Error validating server certificate for 'https://svn.your-server.tld:443':
 - The certificate is not issued by a trusted authority. Use the
   fingerprint to validate the certificate manually!
Certificate information:
 - Hostname: svn.your-server.tld
 - Valid: from Thu, 01 Jan 1970 00:00:00 GMT until Sun, 01 Jan 2042 00:00:00 GMT
 - Issuer: Your-Company
 - Fingerprint: 4a:db:a5:a3:b3:48:9d:d2:f4:f9:66:0f:49:c4:84:2e:cc:55:83:7c
(R)eject, accept (t)emporarily or accept (p)ermanently? p
$> /etc/init.d/mongrel_cluster restart

Testez, vous devriez normalement avoir accès à votre dépot. Si ce n’est pas le cas, c’est que Redmine ne cherche pas la configuration de votre subversion au bon endroit. La suite de cet article résoud ce problème.

Configurer Redmine pour la gestion du dépot SVN

Typiquement, votre dossier d’installation de redmine appartient à l’utilisateur redmine et au groupe www-data. Redmine cherche donc la configuration de subversion dans ~redmine/.subversion, et c’est pour cela que nous avons fait un checkout dans ce dossier (accepter le certificat l’ajoute dans le dossier .subversion de l’utilisteur). Apparement redmine ne cherche pas dans ce dossier. Ouvrer le fichier du configuration de svn dans redmine, et editez la commande utilisée pour appeller le binaire en lui passant en paramètre le bon dossier de configuration.

$> emacs dir-to-redmine/lib/redmine/scm/adapters/subversion_adapter.rb

Remplacez SVN_BIN = "svn" par SVN_BIN = "svn --config-dir /home/redmine/.subversion"


Redemarrez mongrel_cluster, et voilà !

Il s’agit de marshalling ou sérialisation binaire. On prends un tableau de byte csharp, et on le transmet comme un pointeur sur un tableau non managé. Le code est plutôt simple d’accès, quelques explication en dessous :

using System;
using System.Runtime.InteropServices;
 
namespace Test
{
    class Program
    {
        public const Int32 BUFF_SIZE = 1024;
 
        [DllImport("library.dll")]
        static extern Int32 foo([MarshalAs(UnmanagedType.LPArray)] byte[] buffer);
 
        static void Main(string[] args)
        {
            Int32   len;
            byte[]  buffer = new byte[BUFF_SIZE];
            int     i;
            string  str;
 
            len = foo(buffer);
            for (i = 0; i < len; i++)
            {
                str += Convert.ToChar(buffer[i]);
            }
        }
    }
}

Concrètement, la ligne qui nous interresse est :

        static extern Int32 foo([MarshalAs(UnmanagedType.LPArray)] byte[] buffer);

Elle signifit que vous allez sérialiser votre tableau de byte en pointeur sur un tableau non-managé. Le prototype de votre methode foo() dans la dll serait ici :

        long foo(char *buffer);