Einträge von badblock

root@lynch:~# ls -l /srv/video/Der_Sinn_des_Lebens/2007-10-04.00.25.99.99.rec/001.vdr
-rw-r--r-- 1 vdr vdr 0 2007-10-04 02:44 /srv/video/Der_Sinn_des_Lebens/2007-10-04.00.25.99.99.rec/001.vdr

 CREATE FUNCTION get_comment(text, text, text) RETURNS text
    AS $_$
DECLARE
    e TEXT;
BEGIN

    e := NULL;
    IF $2 IS NULL THEN

        SELECT description
        INTO e
        FROM pg_description
            JOIN pg_namespace ON (pg_description.objoid = pg_namespace.oid)
        WHERE nspname = $1
        AND objsubid = 0;

    ELSIF $3 IS NULL THEN

        SELECT description
        INTO e
        FROM pg_description
            JOIN pg_class ON (pg_description.objoid = pg_class.oid)
            JOIN pg_namespace ON (pg_class.relnamespace = pg_namespace.oid)
        WHERE nspname = $1
        AND relname = $2
        AND objsubid = 0;

    ELSE
        SELECT description
        INTO e
        FROM pg_description
            JOIN pg_class ON (pg_description.objoid = pg_class.oid)
            JOIN pg_namespace ON (pg_class.relnamespace = pg_namespace.oid)
            JOIN pg_attribute ON (pg_description.objsubid = pg_attribute.attnum AND pg_class.oid = pg_attribute.attrelid)
        WHERE nspname = $1
        AND relname = $2
        AND attname = $3;

    END IF;

    RETURN e;

END;
$_$ LANGUAGE plpgsql IMMUTABLE;

DROP TABLE public.audit_table;
CREATE TABLE public.audit_table (
    ts TIMESTAMP default current_timestamp,
    usr VARCHAR(10) default current_user,
    sch VARCHAR(64),
    tab VARCHAR(64),
    fld VARCHAR(64),
    pk_cols VARCHAR(128),
    pk_vals VARCHAR(128),
    event CHAR(1),
    old_val VARCHAR,
    new_val VARCHAR
);
GRANT INSERT ON public.audit_table TO PUBLIC;

CREATE OR REPLACE FUNCTION public.log_to_audit_table () RETURNS TRIGGER AS $body$

    #
    # Schema + Tabelle ermitteln
    #
    my $rv_tab = spi_exec_query(qq/

    SELECT  pg_class.relname        AS tab,
            pg_namespace.nspname    AS sch
    FROM    pg_class
    JOIN    pg_namespace ON (pg_class.relnamespace = pg_namespace.oid)
    WHERE   pg_class.oid = $_TD->{relid}

    /);

    my $sch = $rv_tab->{rows}[0]->{sch};
    my $tab = $rv_tab->{rows}[0]->{tab};

    #
    # Spalten des PK ermitteln
    #
    my $rv_pk = spi_exec_query(qq/

    SELECT  a.attname AS pk
    FROM    pg_class c, pg_attribute a, pg_index i
    WHERE   c.relname = '$_TD->{relname}'
    AND     c.oid = i.indrelid
    AND     a.attrelid = i.indexrelid
    AND     a.attnum > 0
    AND     i.indisprimary = 't'

    /);

    my @pk_cols = map { $rv_pk->{rows}[$_]->{pk} } (0 .. $rv_pk->{processed}-1);
    my $pk_cols = join ',', @pk_cols;

    #
    # Attribute der Tabelle ermitteln
    #
    my $rv_att = spi_exec_query(qq/

    SELECT  attname
    FROM    pg_attribute
    WHERE   attnum > 0
    AND     attisdropped = 'f'
    AND     attrelid = $_TD->{relid}
    ORDER BY attnum

    /);

    my @cols = map { $rv_att->{rows}[$_]->{attname} } (0 .. $rv_att->{processed}-1);


    #
    # Audit-Table fuellen
    #
    if ($_TD->{event} eq "INSERT") {

        #
        # PK Wert ermitteln
        #
        my $pk_vals = join ',', map { quote($_TD->{new}{$_}) } @pk_cols;

        foreach (@cols) {
            my $val = quote($_TD->{new}{$_});
            spi_exec_query(qq/

            INSERT INTO public.audit_table (
                pk_cols, pk_vals, sch, tab, event, fld, new_val
            ) VALUES (
                '$pk_cols', '$pk_vals', '$sch', '$tab', 'I', '$_', '$val'
            )

            /);
        }

    }
    elsif ($_TD->{event} eq "UPDATE") {

        #
        # PK Wert ermitteln
        #
        my $pk_vals = join ',', map { quote($_TD->{new}{$_}) } @pk_cols;

        foreach (@cols) {
            my $val_old = quote($_TD->{old}{$_});
            my $val_new = quote($_TD->{new}{$_});
            if ($val_old ne $val_new) {
                spi_exec_query(qq/

                INSERT INTO public.audit_table (
                    pk_cols, pk_vals, sch, tab, event, fld, old_val, new_val
                ) VALUES (
                    '$pk_cols', '$pk_vals', '$sch', '$tab', 'U', '$_', '$val_old', '$val_new'
                )

                /);
            }
        }
    }
    elsif ($_TD->{event} eq "DELETE") {

        #
        # PK Wert ermitteln
        #
        my $pk_vals = join ',', map { quote($_TD->{old}{$_}) } @pk_cols;

        foreach (@cols) {
            my $val = quote($_TD->{old}{$_});
            spi_exec_query(qq/

            INSERT INTO public.audit_table (
                pk_cols, pk_vals, sch, tab, event, fld, old_val
            ) VALUES (
                '$pk_cols', '$pk_vals', '$sch', '$tab', 'D', '$_', '$val'
            )

            /);
        }
    }

    return;

    sub quote
    {
        my ($val) = @_;
        $val =~ s/'/''/g;
        return $val;
    }

$body$ LANGUAGE 'plperl' VOLATILE CALLED ON NULL INPUT SECURITY INVOKER;


DROP TRIGGER tg_audit_test1 ON public.test;
DROP table public.test;
CREATE table public.test (
    id INTEGER NOT NULL,
    nam CHAR(20) NOT NULL,
    foo DATE,
    bar FLOAT
);
ALTER TABLE public.test ADD CONSTRAINT pk_test PRIMARY KEY (id, nam);
CREATE TRIGGER "tg_audit_test1"
    AFTER INSERT OR DELETE OR UPDATE ON public.test
    FOR EACH ROW EXECUTE PROCEDURE public.log_to_audit_table();

INSERT INTO public.test (id, nam, foo, bar) VALUES (1, 'test1', '20070101', 123.4);
INSERT INTO public.test (id, nam) VALUES (2, 'test2');
UPDATE public.test SET nam = 'test zwei' WHERE id = 2;
DELETE FROM public.test WHERE id = 1;
UPDATE public.test SET nam = 'test''zwei' WHERE id = 2;
UPDATE public.test SET foo = current_date where id = 1;
UPDATE public.test SET bar = 1.234 where id = 1;
UPDATE public.test SET bar = NULL where id = 1;

SELECT * FROM public.audit_table;

#!/usr/bin/perl

use warnings;
use strict;

use File::Find;
use File::Copy;
use Digest::MD5 'md5_hex';

my @queue = qw(/Linktest/Files /Linktest/Files_copy);
my $archiv   = '/Linktest/Archive';

find(\&callback, @queue);

sub callback
{
    return if ! -f;

    my (undef, undef, undef, $links) = stat;
    return if ($links > 1);

    my $new = $archiv . "/" . md5_file($File::Find::name);

    if (-f $new) {
        unlink($_);
    }
    elsif (move($File::Find::name, $new) == 0) {
        print "ERROR, can't move $File::Find::name to $new: $!\n";
        return;
    }

    link $new, $File::Find::name;
}

sub md5_file
{
    my ($filename) = @_;

    open my $fh, '<', $filename or die $!;
    binmode $fh;
    my $md5 = Digest::MD5->new->addfile($fh)->hexdigest;
    close $fh;

    return $md5;
}