# To checkout in repository_name dir
svn co https://svn.domain.com/repository_name repository_name
 # To checkout in the current dir
svn co https://svn.domain.com/repository_name .

svn ci -m "your message"

svn switch --relocate http://old.repository.url.domain.tld https://new.repository.url.domain.tld

svn copy http://repository.url.domain.tld/trunk https://repository.url.domain.tld/tags/0.1.1 -m "comment"

$this->widgetSchema['date_demarage'] = new sfWidgetFormSelect(array('label' => 'Date de démarrage',
                                                                    'choices' => array_combine($dateArray, $dateArray)
                                                                    ));

protected function processForm(sfWebRequest $request, sfForm $form)
{
  $form->bind($request->getParameter($form->getName()), $request->getFiles($form->getName()));
  if($form->isValid())
  {
    $register = $form->save();
    $register->addGroupByName('member');
    $register->addPermissionByName('member');
    $register->profile->setSfGuardUserId($register->id);
    $register->save();
    $this->getUser()->signIn($this->form->getObject());
    $this->redirect('@feeds');
  }
  $this->getUser()->setFlash('error','formular is not correctly filled.');
}

$this->widgetSchema['cat_id'] = new sfWidgetFormDoctrineChoice(array('label' => 'Category',
                                                                      'model' => 'hosts_categories',
                                                                      'add_empty' => true));

$this->widgetSchema['password'] = new sfWidgetFormInputPassword();

$this->validatorSchema['intervalle'] = new sfValidatorRegex(array('pattern' => '/^[0-9]{1}[i,m,d]{1}$/'));

$this->validatorSchema['intervalle'] = new sfValidatorOr(array(new sfValidatorRegex(array('pattern' => '/^[0-9]{1}[i,m,d]{1}$/')),
                                                                new sfValidatorRegex(array('pattern' => '/^[0-9]{1}[i,m,d]{1};[0-9]{2}h[0-9]{2}$/'))));

$this->validatorSchema->setPostValidator(new sfValidatorAnd(array(new sfValidatorSchemaCompare('repassword',  sfValidatorSchemaCompare::EQUAL, 'password'),
                                                                  new sfValidatorDoctrineUnique(array('model' => 'sfGuardUser',
                                                                                                      'column' => 'username'), array('invalid' => 'This username already taken.')),
                                                                  new sfValidatorDoctrineUnique(array('model' => 'sfGuardUser',
                                                                                                      'column' => 'email_address'), array('invalid' => 'This email address already taken.'))
                                                                  )));

$this->validatorSchema['password'] = new sfValidatorString(array('min_length' => 5, 'max_length' => 15));
$this->validatorSchema['repassword'] = new sfValidatorString(array('required' => true));
$this->validatorSchema->setPostValidator(new sfValidatorSchemaCompare('repassword',  sfValidatorSchemaCompare::EQUAL, 'password'));

sfContext::getInstance()->getRouting()->getCurrentRouteName()

homepage:
  url: /
  param: { module: product, action: index }

import os
import mimetypes
import string
import sys
 
def red(string):
    return '\x1b\x5b1;31;40m%s\x1b\x5b0;37;40m'%(string)
 
def green(string):
    return '\x1b\x5b1;32;40m%s\x1b\x5b0;37;40m'%(string)
 
def count(list):
    line_count = 0
    for line in list:
        line_count += 1
    return line_count
 
mimeArray = ['application/x-httpd-php']
errors_count = 0
files_count = 0
lines_count = 0
bytes_count = 0
 
if '-e' in sys.argv:
    showonlyerror = 1
else:
    showonlyerror = 0
 
for path, dirs, files in os.walk('.'):
    for file in files:
        f_mime = mimetypes.guess_type(file)
        if f_mime[0] in mimeArray:
            f_path = os.path.join(path, file)
            a = os.popen('php -l %s'%(f_path)).readlines()
            b = open(f_path)
            counta = count(a)
            sizea = os.path.getsize(f_path)
            line_count = count(b)
            files_count += 1
            bytes_count += sizea
            lines_count += line_count
            if counta > 1:
                errors_count += 1
                print('%s'%(red(f_path)))
                print('    %s, %s line(s), %s byte(s)'%(f_mime[0], line_count, sizea))
                for p in a:
                    if p != '\n':
                        print('    %s'%(p.strip()))
            else:
                if showonlyerror == 0:
                    print('%s'%(green(f_path)))
                    print('    %s, %s line(s), %s byte(s)'%(f_mime[0], line_count, sizea))
                    for p in a:
                        print('    %s'%(p.strip()))
print
if errors_count > 0:
    print('    file(s): %i, lines: %i, bytes: %i, error: %s'%(files_count, lines_count, bytes_count, red(errors_count)))
else:
    print('    file(s): %i, lines: %i, bytes: %i, error: %s'%(files_count, lines_count, bytes_count, green(errors_count)))

import os
import string
import mimetypes
import Image
import ImageFilter
 
class pix:
    def __init__(self, pixdir, outputdir):
        self.pixdir = pixdir
        self.outputdir = outputdir
        self.mimeArray = ['image/jpeg', 'image/png']
        self.prepare()
        self.overwrite = 'N'
 
    def prepare(self):
        if(os.path.exists(self.outputdir) == 0):
            print("mkdir %s"%(self.outputdir))
            os.mkdir(self.outputdir)
        pixArray = {}
        i = 0
        for path, dirs, files in os.walk(self.pixdir):
            tmp = os.path.join(self.outputdir , path.replace(self.pixdir, ''))
            if os.path.exists(tmp) == 0:
                os.mkdir(tmp)
                print("mkdir %s"%(tmp))
            for file in files:
                f_path = os.path.join(path, file)
                f_mime = mimetypes.guess_type(f_path)
                if f_mime[0] in self.mimeArray:
                    f_size = os.path.getsize(f_path)
                    pixArray[i] = {'oldpath': os.path.join(path, file),
                                   'newpath': os.path.join(tmp, file.lower()),
                                   'size': self.o2ko(f_size),
                                   'mimetype': f_mime[0]}
                    i += 1
        self.count = i
        self.pixArray = pixArray
 
    def o2ko(self, o):
        return o/1024
 
    def convert(self, oldpath, newpath):
        try:
            bf_size = self.o2ko(os.path.getsize(oldpath))
            bi = Image.open(oldpath)
 
            if bi.size[0] > 2500:
                w = bi.size[0] * 50 / 100
                h = bi.size[1] * 50 / 100
            else:
                w = bi.size[0]
                h = bi.size[1]
 
            bi = bi.resize((w, h), Image.ANTIALIAS)
            bi.save(newpath, 'JPEG')     
            ai = Image.open(newpath)
            af_size = self.o2ko(os.path.getsize(newpath))
            print("\n[%ix%i %sKo %s] %s\n   to \n[%ix%i %sKo %s] %s"%(bi.size[0],
                                                                      bi.size[1],
                                                                      bf_size,
                                                                      bi.mode,
                                                                      oldpath,
                                                                      ai.size[0],
                                                                      ai.size[1],
                                                                      af_size,
                                                                      ai.mode,
                                                                      newpath))
        except IOError:
            print("\nimage file %s is endomaged"%(oldpath))
 
    def run(self):
        for i in self.pixArray:
            if os.path.exists(self.pixArray[i]['newpath']) == 1:
                if self.overwrite != 'ALL' and self.overwrite != 'NALL':
                    self.overwrite = raw_input("Overwrite %s [Y,N,ALL,NALL]: [N] "%(self.pixArray[i]['newpath']))
                if self.overwrite not in ['Y', 'N', 'ALL', 'NALL']:
                    self.overwrite = raw_input("Please answer [Y,N,ALL,NALL]: [N] ")
 
            if self.overwrite == 'Y' or self.overwrite == 'ALL':
                self.convert(self.pixArray[i]['oldpath'], self.pixArray[i]['newpath'])
            if self.overwrite == 'NALL' or os.path.exists(self.pixArray[i]['newpath']) == 0:
                self.convert(self.pixArray[i]['oldpath'], self.pixArray[i]['newpath'])
 
    def stats(self, dir):
        n_files = 0
        d_size = 0
        for path, dirs, files in os.walk(dir):
            for file in files:
                f_path = os.path.join(path, file)
                n_files += 1
                d_size = d_size + os.path.getsize(f_path)
        return {'n_files': n_files, 'd_size': d_size}
 
    def __del__(self):
        before = self.stats(self.pixdir)
        after = self.stats(self.outputdir)
        print('Before: %i files for %sKo'%(before['n_files'], self.o2ko(before['d_size'])))
        print('After : %i files for %sKo'%(after['n_files'], self.o2ko(after['d_size'])))
 
 
pix = pix('/home/hio/Photos/', # from
          '/home/hio/Photos_Web/') # to
pix.run()

/etc/udev/rules.d/70-persistent-net.rules

# This file was automatically generated by the /lib/udev/write_net_rules
# program, probably run by the persistent-net-generator.rules rules file.
#
# You can modify it, as long as you keep each rule on a single line.
# MAC addresses must be written in lowercase.
 
# PCI device 0x8086:0x100f (e1000)
SUBSYSTEM=="net", DRIVERS=="?*", ATTRS{address}=="00:0c:29:65:ae:04", NAME="eth1"
 
# PCI device 0x10ec:0x8168 (r8169)
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:1c:c0:01:5f:e0", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"