Page 1 sur 41234

Go – installation

go

Depuis que j’ai préparé mon serveur web, je n’ai pas avancé sur la création de ma wishlist …
J’ai décidé de créer ce site avec l’outil Hugo ceci pour des raisons simples :

  • Découverte de cet nouvel outil
  • Utilisation du go

Cependant je me retrouve dors et déjà bloqué … Bien que je sois actuellement sur une distribution Debian rescente, mais l’installation de go me donne une version non à jour.

$ go version
go version go1.3.3 linux/amd64

En effet il me faut une version 1.5+ pour faire tourner l’outil voulu … Dès colègues de boulot m’avaient prévenu qu’avec Debian les paquets sont souvent « en retard » pour des souci de proposer uniquement des version dite « stable »

Je risque d’ailleur de ne pas être à jour pour nginx aussi … je mettrais donc à jour mon serveur web dans un second temps.

Je vais donc installer GO en suivant le guide officiel :
Installation de Go

Je commence donc a télécharger la dernière version actuellement disponible sur :
Téléchargement de Go

Puis installation de celui-ci en suivant les guide.
Résumé de l’installation :

# going to temp folder to dl files
$ cd /tmp

# downlad go
$ wget https://storage.googleapis.com/golang/go1.6.2.linux-amd64.tar.gz

# extract it to my custom bin folder
$ tar -C $HOME/bin -xzf go1.6.2.linux-amd64.tar.gz

# add some var environement var
$ echo 'export GOROOT=$HOME/bin/go' >> $HOME/.zsh_local
$ echo 'export PATH=$PATH:$GOROOT/bin' >> $HOME/.zsh_local

# refresh environnement to get the news values setted
$ source ~/.zshrc

# test go version
$ go version
go version go1.6.2 linux/amd64

Au final l’installation via les binaires fut très simple.

J’avais souhaité faire l’installation directement via les sources git en compilant moi même les sources.
Mais je me suis heurté à de nouvelles problématiques … la volonté principale actuellement étant de tester différents outils, je ferais donc cela plus tard.

Installation de nginx

Il y a les outils pour créer des sites web (symfony2, gohugo, ghost, …) mais il y a aussi les outils derrières pour que ceux-ci puissent fonctionner sur le serveur.

Pour faire tourner un serveur web beaucoup utilisent apache2. Mais depuis plusieurs année nginx (une alternative) est utilisé par une grand nombre.

NGINX_logo_rgb-01

J’ai pu travailler sur différent projet où un serveur web sur nginx tournait. Mais je n’ai jamais eu le loisir d’un installer un moi-même ni d’en configurer un. (… shame one me …)

Ayant plusieurs outil de création de site que je souhaite tester, je vais profiter de ces projets pour utiliser ce serveur web dont j’ai beaucoup entendu parlé, mais que je n’ai pas testé.

La première étape sera donc l’installation.

$ sudo apt-get install nginx

Après installation, on pourra voir constater que l’arborescence du programme ressemble sensiblement à ce que l’on peut retrouver avec apache2 :

$ tree /etc/nginx          
/etc/nginx
├── conf.d
├── fastcgi.conf
├── fastcgi_params
├── koi-utf
├── koi-win
├── mime.types
├── nginx.conf
├── proxy_params
├── scgi_params
├── sites-available
│   └── default
├── sites-enabled
│   └── default -> /etc/nginx/sites-available/default
├── snippets
│   ├── fastcgi-php.conf
│   └── snakeoil.conf
├── uwsgi_params
└── win-utf

Mon projet web sera un site pour ma « whislist ». Je créer donc un fichier qui contiendra la configuration du serveur web pour ce projet

$ sudo vim /etc/nginx/sites-available/whislist
server {
    listen 80;
    server_name www.whishlist.scorfly.ovh whishlist.scorfly.ovh;

    # log file
    access_log /var/log/nginx/default.access.whishlist.log;

    # hide nginx version on error page
    server_tokens off;

    # Allow only GET and HEAD request
    # i'm creating a full static web site
    if ($request_method !~ ^(GET|HEAD)$ ) {
        return 444; # No Response
    }

    location / {
        # Be sure this folder and file are created
        root   /var/www/whishlist;
        index  index.html;
    }
}

On active le host :

$ sudo ln -s /etc/nginx/site-available/whishlist /etc/nginx/sites-enabled/

Et pour finir on restart notre serveur web :

$ sudo /etc/init.d/nginx restart
[ ok ] Restarting nginx (via systemctl): nginx.service.

Mon site est maintenant accessible grace à cette configuration très basique.
Nous verrons par la suite les changements qui seront apporté a cette configuration suivant les besoins que je pourrais avoir au fur et à mesure des différents projets.

Gérer sa configuration par défaut Debian

On passe souvent beaucoup de temps à configurer puis reconfigurer sa ou ses machines.

Le plus long n’est pas d’installer zsh, vim, screen, … mais bien de réaliser l’ensemble des configurations propre à chaque outil.

Afin d’être plus rapide dans ces manipulations il devient de plus en plus répandu de versionner ces fichiers.
Ces dépôts « dotfiles » sont souvent publique sur github.

github
Vous pourrez le constater en faisant la recherche de « dotfiles » sur ce site :

Je viens donc de créer mon propre dépôt pour pouvoir mieux gérer mes configurations et je vous propose d’y accéder :

Vous avez sur celui-ci les commandes que j’utilise pour configurer mes machines. Mes fichier de configuration et quelque base sur la sécurité qui doit être mise en place.

Le dépôt évoluera au fur et à mesure de mes besoins. En effet je ne ferais plus aucune config sur mes machine en direct sans que ceci soit versionné.

Cependant il est a noté que les fichier peuvent inclure d’autre fichier s’ils sont présent sur la machine.
Par exemple zshrc inclu ~/.zshrc_local
Ceci me permet d’avoir des bouts de configuration tel que certain alias que je veut sur certaine machine, sans que ceux-ci soit disponible au grand publique.

Codingame : Skynet Revolution : Solution PERL

Nouveau concours codingame auquel j’ai participé (d’ailleurs si vous avez d’autre lien de site réalisant des concours ça m’intéresse !)

Voici comment réaliser un 100% en Perl

Première question, assez simple :

#!/usr/bin/perl
select(STDOUT); $| = 1; # DO NOT REMOVE

# @author   : Scorfly
# @mail     : scorfly at gmail dot com

use Data::Dumper;

# My personal constant
use constant false => 0;
use constant true  => 1;

($r) = split(/ /, <STDIN>);
$r =~ s/\n//g;

($g) = split(/ /, <STDIN>);
$g =~ s/\n//g;

($l) = split(/ /, <STDIN>);
$l =~ s/\n//g;

$hasJumped = false;

while (1) {
    ($s) = split(/ /, <STDIN>);
    $s =~ s/\n//g;
    
    ($x) = split(/ /, <STDIN>);
    $x =~ s/\n//g;
    
    if ($hasJumped)
    {
        print "SLOW\n";
    }
    else
    {
        if ($s <= $g)
        {
            print "SPEED\n";
        }
        elsif ($s > $g+1 )
        {
            print "SLOW\n";
        }
        else
        {
            $tmp = $x+$s;
            if ($tmp > $r)
            {
                $hasJumped = true;
                print "JUMP\n";
            }
            else
            {
                print "WAIT\n";
            }
        }
    }
    
    # DEBUG
    print STDERR "$g - goufre \n";
    print STDERR "$r - size before goufre init \n";
    print STDERR "$l - size of plateform \n";
    print STDERR " \n";
    print STDERR "$s - speed \n";
    print STDERR "$x - pos \n";
    print STDERR "----------------";
    
}

Pour la seconde question j’ai du refaire le concours après car je n’ai pas réussi à obtenir le 100% lors de l’épreuve.

#!/usr/bin/perl
select(STDOUT); $| = 1; # DO NOT REMOVE

# @author   : Scorfly
# @mail     : scorfly at gmail dot com
# inspired by : http://www.codingame.com/cg/#!report:304298abe9483e149208d0eb19b780d62b7ae1
#   - Author : NewboO
#   - Infos : PHP 100%

use Data::Dumper;
use Switch 'Perl6';

my $m = <STDIN>; chomp $m;
my $v = <STDIN>; chomp $v;

my %roads;
for (my $i = 0 ; $i < 4; $i++)
{
    $roads->{$i} = <STDIN>; chomp $roads->{$i};
}

# Let's go to infinite
my @solution;

while(1)
{
    my $s = <STDIN>; chomp $s;
    my @motos;
    for(my $i=0; $i<$m; $i++)
    {
        my ($x, $y, $a) = split(/ /, <STDIN>); chomp $a;
        
        if($a)
        {
            push(@motos, [$x, $y]);
        }
    }
    
    @solution = getPath(\@motos, $s, $roads, $v);
    
    MyLogger(\@solution, "sol", 1);
    
    #$action = unshift(@solution);
    if (@solution)
    {
        print $solution[0];
    }
    else
    {
        print "SPEED";
    }
    print "\n";
}

##############
#   Sub part

# depending on speed, is there hole betweed our position and next round ?
#   - $s : speed
#   - $x : position on road
#   - $roads : road list
sub canDrive
{
    my ($s, $x, $roads) = @_;

    my @safe = qw(1 1 1 1);
    foreach $roadId (keys $roads)
    {
        my @cutedRoad = split("", $roads->{$roadId});
        for($i=$x; $i<=$x+$s; $i++)
        {
            if(defined($cutedRoad[$i]) && $cutedRoad[$i] eq "0")
            {
                $safe[$roadId] = 0;
                last;
            }
        }
    }
    return @safe;
}

# Check if we jump, who survive
#   - $s : speed
#   - $x : positon
#   - $roads : list of road
sub canJump
{
    my ($s, $x, $roads) = @_;

    my @safe;
    foreach my $roadId (keys $roads)
    {
        my @cutedRoad = split("", $roads->{$roadId});
        $safe[$roadId] = int (!defined($cutedRoad[$s+$x]) || $cutedRoad[$s+$x] eq '.');
    }
    return @safe;
}

#
# Check if some moto survive depending on the action
#
sub checkAction
{
    my ($motosH, $s, $action) = @_;
    my @motos = @$motosH;

    $x = $motos[0][0];
    if($action eq 'SPEED') { $s++; }
    elsif($action eq 'SLOW') { $s--; }
    
    if ($s == 0) { return (0, undef); }
    
    my @nMotos;
    given($action)
    {
        when (/(WAIT|SPEED|SLOW)/)
        {
            my @dSafe = canDrive($s, $x, $roads);
            foreach $moto (@motos)
            {
                if($dSafe[@$moto[1]])
                {
                    push(@nMotos, [@$moto[0]+$s, @$moto[1]]);
                }
            }
        }
        when ("DOWN")
        {
            my @dSafe = canDrive($s, $x, $roads);
            my @dOSafe = canDrive($s-1, $x, $roads);
            foreach my $moto (@motos)
            {
                if($dOSafe[@$moto[1]] && $dSafe[@$moto[1]+1] && @$moto[1]+1 < 4)
                {
                    push(@nMotos, [@$moto[0]+$s, @$moto[1]+1]);
                }
            }
        }
        when ("UP")
        {
            my @dSafe = canDrive($s, $x, $roads);
            my @dOSafe = canDrive($s-1, $x, $roads);

            foreach my $moto (@motos)
            {
                if($dOSafe[@$moto[1]] && $dSafe[@$moto[1]-1] && @$moto[1]-1 >= 0)
                {
                    push(@nMotos, [@$moto[0]+$s, @$moto[1]-1]);
                }
            }
        }
        when ("JUMP")
        {
            my @jSafe = canJump($s, $x, $roads);
            foreach my $moto (@motos)
            {
                if($jSafe[@$moto[1]])
                {
                    push(@nMotos, [@$moto[0]+$s, @$moto[1]]);
                }
            }
        }
    }
    
    if (@nMotos > 0)
    {
        return ($s, @nMotos);
    }
    else
    {
        return ($s, qw());
    }
}

#
# Check recursivly each action to finish the road
#
sub getPath
{
    my ($motosH, $s, $roads, $v, @current) = @_;
    my @motos = @$motosH;

    my @actionList = qw(SPEED UP DOWN WAIT JUMP SLOW);
    foreach my $action (@actionList)
    {
        my ($nS, @nMotos) = checkAction(\@motos, $s, $action);
        
        if(@nMotos >= $v)
        {
            push(@current, $action);
            my @cutedRoad = split("", $roads->{0});
            if($nMotos[0][0] >= @cutedRoad)
            {
                return @current;
            }
            else
            {
                @solution = getPath(\@nMotos, $nS, $roads, $v, @current);
                if (@solution)
                {
                    if ($solution[0] ne "")
                    {
                        return @solution;
                    }
                }
            }
            pop(@current);
        }
    }
}

# /**
#  * MyLogger  print data in STDERR to debug during developpement
#  *    - $value : value to print
#  *    - $comment : info about the value
#  *    - $debug (optionnal) : print $value in Data::Dumper
#  */
sub MyLogger {
    my ($value, $comment, $debug) = @_;
    
    if (!defined($debug)) {$debug = 0;}
    
    if($debug)
    {
        print STDERR "$comment : \n";
        print STDERR Dumper($value);
    }
    else
    {
        print STDERR "$comment : $value \n";
    }
}

Je me suis fait au passage une petite fonction pour le debug que je pense utiliser à chaque concours maintenant vu qu’il faut print les valeurs dans la STDERR pour débuguer son script.

Page 1 sur 41234