AmberDB

 view release on metacpan or  search on metacpan

lib/AmberDB/Base.pm  view on Meta::CPAN

            $p = quotemeta($p);
            $p =~ s/\\\*/.*/g;
            $p =~ s/\\\?/./g;
            $regex = qr/^$p$/;
        }
    }

    opendir my $dh, $dir or return ();
    my @entries = grep { $_ ne '.' && $_ ne '..' } readdir($dh);
    closedir $dh;

    my @results;
    foreach my $entry (@entries) {
        if ( $regex ) {
            next unless $entry =~ $regex;
        }

        my $path = File::Spec->catfile( $dir, $entry );
        if ( $files_only ) {
            next unless -f $path;
        }

        push @results, $full_path ? $path : $entry;
    }

    return $do_sort ? sort { $a cmp $b } @results : @results;
}

# ============================================================================
# RECORD SORTING BY ID (Fallback utility)
# ============================================================================

# @liste = $self->db_sortid("_", @liste);       # if no table
# @liste = $self->db_sortid("table_id", @liste);
# ------------------------------------------------
sub db_sortid {
    my ( $self, $table, @records ) = @_;

    scalar @records or return ();

    my $is_simple = $self->config('use_simple') || ( $table && $self->table_attr( $table, 'use_simple' ) );
    my $field     = ( ref( $records[0] ) eq "ARRAY" ) ? 0 : undef;
    my $sort_type = $is_simple ? 'ascii' : 'num';

    return $self->array_sort( $sort_type, 'desc', $field, @records );
}

# ============================================================================
# PATHS AND CONFIGURATION
# ============================================================================

# $self->set_datadir("/path/to/dbase")
# ------------------------------------------------
sub set_datadir {
    my ( $self, $dbase_dir ) = @_;

    $dbase_dir or return;

    # declarations (persistent storage only; ramdisk directories are dynamically provisioned on mount)
    my @dirs = qw(
      dbase_dir table_dir schema_dir backup_dir
      buffer_dir journal_dir lock_dir session_dir config_dir
    );
    foreach my $dir (@dirs) {
        $self->{_path}->{$dir} //= "";
    }

    $self->{_path}->{dbase_dir} = $dbase_dir;

    # db_ext tanımlı ve "db" değil ise simple moduna al
    my $db_ext = $self->config('db_ext');
    if ( length($db_ext) && $db_ext ne "db" ) {
        $self->config( use_simple => 1 );
    }

    # do not proceed if simple mode
    if ( $self->config('use_simple') ) {
        $self->{_path}->{backup_dir}  = $dbase_dir;
        $self->{_path}->{buffer_dir}  = $dbase_dir;
        $self->{_path}->{journal_dir} = $dbase_dir;
        $self->{_path}->{schema_dir}  = $dbase_dir;
        $self->{_path}->{table_dir}   = $dbase_dir;
        $self->{_path}->{lock_dir}    = "$dbase_dir/lock";
        $self->{_path}->{session_dir} = "$dbase_dir/session";
        $self->{_path}->{config_dir}  = "$dbase_dir/config";
        return 1;
    }

    $self->{_path}->{journal_dir} = "$dbase_dir/journal";
    $self->{_path}->{backup_dir}  = "$dbase_dir/backup";
    $self->{_path}->{buffer_dir}  = "$dbase_dir/buffer";
    $self->{_path}->{schema_dir}  = "$dbase_dir/schema";
    $self->{_path}->{table_dir}   = "$dbase_dir/table";
    $self->{_path}->{lock_dir}    = "$dbase_dir/lock";
    $self->{_path}->{session_dir} = "$dbase_dir/session";
    $self->{_path}->{config_dir}  = "$dbase_dir/config";

    # Auto-load connect.pl if present in datadir
    my $conn_file = "$dbase_dir/config/connect.pl";
    if ( -f $conn_file ) {
        my $target = ( $conn_file =~ m{^(?:\./|[a-zA-Z]:|/|\\)} ) ? $conn_file : "./$conn_file";
        my $cfg = do $target;
        if ( $cfg && ref($cfg) eq 'HASH' && $cfg->{database} ) {
            $self->{_connect}->{database} = $cfg->{database};
        }
    }

    unless ( $self->config('test') || $self->config('no_mkdir') || $^C ) {
        if ( defined $dbase_dir && $dbase_dir ne "." && $dbase_dir ne "" ) {
            for my $dir (
                $self->{_path}->{dbase_dir},
                $self->{_path}->{table_dir},
                $self->{_path}->{schema_dir},
                $self->{_path}->{backup_dir},
                $self->{_path}->{buffer_dir},
                $self->{_path}->{journal_dir},
                $self->{_path}->{lock_dir},
                $self->{_path}->{session_dir},
            ) {
                if ( defined $dir && length($dir) && !$self->dir_exist($dir) ) {
                    $self->make_path($dir);
                }
            }
        }
    }

    $self->ramdisk_setup() unless $^C || $self->config('no_mkdir');
    return 1;
}

# Utility method to create a directory path.
# ------------------------------------------------
sub make_path {
    my ( $self, $path ) = @_;
    return 1 if $^C;
    unless ( -d $path ) {
        require File::Path;
        File::Path::make_path($path);
    }
    return 1;
}

# my $cfg_val = $adb->config("language");
# ------------------------------------------------
sub config {
    my ( $self, @args ) = @_;

    # 1. No arguments: return shallow copy of all configuration
    if ( !@args ) {
        return { %{ $self->{_cfg} || {} } };
    }

    # 2. Single scalar argument: getter -> $adb->config('language')
    if ( @args == 1 && !ref( $args[0] ) ) {
        my $key = $args[0];
        if ( $key eq 'user' ) {
            return $self->{_connect}->{username} // $self->{_cfg}->{user} // 'user_system';
        }
        if ( $key eq 'simple' || $key eq 'use_simple' ) {
            return $self->{_cfg}->{use_simple} // '';
        }
        return $self->{_cfg}->{ $key } // '';
    }

    # 3. Setter: key-value list or hashref
    my %pairs = ( @args == 1 && ref( $args[0] ) eq 'HASH' ) ? %{ $args[0] } : @args;

    my $hooks = {
        language => sub {
            my $val = shift;
            $self->{_cfg}->{language} = $val;
            $self->_load_locale($val);
        },
        db_ext => sub {
            my $val = shift;
            $self->{_cfg}->{db_ext} = $val;
            $self->{db_ext} = $val;
            if ( defined $val && $val ne "db" ) {
                $self->{_cfg}->{use_simple} = 1;
            }
            $self->_invalidate_table_paths();
        },
        use_simple => sub {
            my $val = shift;
            $self->{_cfg}->{use_simple} = $val ? 1 : 0;
            $self->_invalidate_table_paths();
        },
        simple => sub {
            my $val = shift;
            $self->{_cfg}->{use_simple} = $val ? 1 : 0;
            $self->_invalidate_table_paths();
        },
        use_ramdisk => sub {
            my $val = shift;
            my $tier = $self->_normalize_ramdisk_tier($val);
            if ( $tier == 3 ) {
                $tier = 0;
            }
            $self->{_cfg}->{use_ramdisk} = $tier;
            $self->_invalidate_table_paths();
        },
    };

    while ( my ( $key, $val ) = each %pairs ) {
        if ( exists $hooks->{$key} ) {
            $hooks->{$key}->($val);
        }
        else {
            $self->{_cfg}->{$key} = $val;
            if ( $key eq 'user' ) {
                $self->{_connect}->{username} = $val;
            }
        }
    }

    return $self;
}

# my $dbase_dir = $adb->path("dbase_dir");         # getter
# $adb->path({ backup_dir => "$tmpdir/backup" });  # setter
# $adb->path( custom_path => "/opt/data" );        # setter
# ------------------------------------------------
sub path {
    my ( $self, @args ) = @_;

    # 1. No arguments: return shallow copy of all path mappings
    if ( !@args ) {
        return { %{ $self->{_path} || {} } };
    }

    # 2. Single scalar argument: getter -> $adb->path('dbase_dir')
    if ( @args == 1 && !ref( $args[0] ) ) {
        return $self->{_path}->{ $args[0] } // '';
    }

    # 3. Setter: key-value list or hashref
    my %pairs = ( @args == 1 && ref( $args[0] ) eq 'HASH' ) ? %{ $args[0] } : @args;

    for my $key ( keys %pairs ) {
        $self->{_path}->{$key} = $pairs{$key};
    }
    $self->_invalidate_table_paths();

    return $self;
}

# Invalidate cached table paths if global path-affecting configurations change
# ------------------------------------------------
sub _invalidate_table_paths {
    my ($self) = @_;

    if ( $self->{_table} && ref( $self->{_table} ) eq 'HASH' ) {
        for my $tbl ( keys %{ $self->{_table} } ) {
            delete $self->{_table}->{$tbl}->{_path}
              if ref( $self->{_table}->{$tbl} ) eq 'HASH';
        }
    }
}

# ============================================================================
# AUTHENTICATION & PASSWORD CRYPTOGRAPHY (Salted SHA-256)
# ============================================================================

# my $shadow = $adb->hash_password($password, [$salt]);
# ---------------------------------------------------------------------
sub hash_password {
    my ( $self, $password, $salt ) = @_;
    return '' unless defined $password && length $password;

    # 16-character cryptographically secure hex salt
    $salt //= sprintf( "%08x%08x", int( rand(0xFFFFFFFF) ), int( rand(0xFFFFFFFF) ) );

    my $hash = sha256_hex( $salt . $password );
    return "sha256\$$salt\$$hash";
}

# my $ok = $adb->verify_password($password, $stored_shadow);
# ---------------------------------------------------------------------
sub verify_password {
    my ( $self, $password, $stored_shadow ) = @_;



( run in 0.902 second using v1.01-cache-2.11-cpan-99fa8243a42 )