Open6Hosting
/
smartos-bin
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
Bladeren bron

modifico scripts, hago adds y rms

develop
Pablo Sarria 3 maanden geleden
bovenliggende
da03ed417f
commit
1480bcc9db
11 gewijzigde bestanden met toevoegingen van 372 en 348 verwijderingen
Zij-aan-zij weergave
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -0
      LICENSE
  2. +9
    -0
      alias_vps.sh
  3. +2
    -0
      delete-cores.sh
  4. +0
    -236
      feed_graphite_sys.pl
  5. +62
    -0
      getsnap.sh
  6. +0
    -32
      perl_fastcgi.xml
  7. +38
    -0
      recursos.sh
  8. +127
    -0
      restoresnaps.sh
  9. +6
    -0
      update_alias_vps.sh
  10. +127
    -64
      zonebackuptofile.sh
  11. +1
    -16
      zonemigrate.sh

+ 0
- 0
LICENSE Bestand weergeven


+ 9
- 0
alias_vps.sh Bestand weergeven

@@ -0,0 +1,9 @@
#!/bin/bash
UUID=$1

for a in $(zoneadm list -n); do
UUID=$a
ZONEALIAS=`zonecfg -z ${UUID} info attr name=alias | awk '$1 ~ /value:/ { print $2 }' | openssl base64 -d`
IP=`zonecfg -z ${UUID} info net | awk '$2 ~ /ips/ { print $2 }' | awk -F\" '{ print $2 }' | sed 's/,/ /'`
echo ${UUID} ${ZONEALIAS} ${IP}
done

+ 2
- 0
delete-cores.sh Bestand weergeven

@@ -0,0 +1,2 @@
#!/usr/bin/bash
zfs list -H | grep "cores$" | grep -v "global" | awk '$2 ~ /G/ { print "find",$5,"-type f -delete"}' | /usr/bin/sh

+ 0
- 236
feed_graphite_sys.pl Bestand weergeven

@@ -1,236 +0,0 @@
#!/usr/bin/perl

use strict;
use IO::Socket;
use Data::Dumper;

my $graphitehost = "graphite.open6hosting.com";
my $port = "2003";
my $hostname = "o6hsmartos16";
my $grupo = "joyent";

my %ipmistatus = (
"CPU_Temp" => "cpu_temp",
"CPU_Temperature" => "cpu_temp",
"CPU1_Temperature" => "cpu_temp",
"+12V_" => "12v",
"12V" => "12v",
"12V_" => "12v",
"CPU_FAN1" => "cpu_fan1",
"CPU_FAN1_" => "cpu_fan1",
"FAN1" => "cpu_fan1",
"FAN1_" => "cpu_fan1",
);

my %mdbstatus = (
"Kernel_" => "kernel",
"Boot_pages" => "boot_pages",
"ZFS_File_Data_" => "zfs_file",
"Anon_" => "anon",
"Exec_and_libs_" => "exec_and_libs",
"Page_cache" => "page_cache",
"Free_(cachelist)" => "free_cachelist",
"Free_(freelist)" => "free_freelist",
);

# create Socket
my $socket = IO::Socket::INET -> new
(
PeerAddr => $graphitehost,
PeerPort => $port,
Proto => "tcp",
Type => SOCK_STREAM
) or die "Couldn't connect to $graphitehost:$port: $@ \n";

# enviaremos algo asi
# print $socket "$grupo.$hostname.vfsstat.read_s $estructura{read_s} $time\n";
sub enviadatos ($$$$)
{
my $hash = shift;
my $socket = shift;
my $tabla = shift;
my $tiempo = shift;

while ( my ( $keys, $values ) = each %{$hash} )
{
print $socket "$grupo.$hostname.$tabla.$keys ${$hash}{$keys} $tiempo\n";
}
}


########
#
# iostat
#
########


# numero de dispositivos
my $devices = `zpool list -v | grep -c "c[0-9]*" | tr -d '\n'`;

# r/s w/s kr/s kw/s read_t write_t
# iostat -xzr 10 2
# device,r/s,w/s,kr/s,kw/s,wait,actv,svc_t,%w,%b
# sd1,27.9,0.0,111.5,0.0,0.0,0.7,24.6,0,45
my $captura = `iostat -xr 15 2 | awk -F, '\$1 ~ /^sd[0-8]|blkdev/ { print \$1,\$2,\$3,\$4,\$5,\$7,\$8,\$9,\$10 }' | tail -n$devices`;

my @fields = split(" ", $captura);
my @wcfields = @fields;

my %estructura;
my $disco;

foreach (@fields)
{
if ( $_ =~ /^sd[0-9]|blkdev[0-9]/ )
{
$disco = $_;
shift @wcfields;
$estructura{$disco}{r_s} = shift @wcfields;
$estructura{$disco}{w_s} = shift @wcfields;
$estructura{$disco}{kr_s} = shift @wcfields;
$estructura{$disco}{kw_s} = shift @wcfields;
if ( $estructura{$disco}{kr_s} > 0 && $estructura{$disco}{r_s} > 0 )
{
$estructura{$disco}{ars} = $estructura{$disco}{kr_s} / $estructura{$disco}{r_s};
}
if ( $estructura{$disco}{kw_s} > 0 && $estructura{$disco}{w_s} > 0 )
{
$estructura{$disco}{awrs} = $estructura{$disco}{kw_s} / $estructura{$disco}{w_s};
}
$estructura{$disco}{actv} = shift @wcfields;
$estructura{$disco}{svc_t} = shift @wcfields;
$estructura{$disco}{w} = shift @wcfields;
$estructura{$disco}{b} = shift @wcfields;
}
}

my $time = time();

foreach $disco (keys %estructura)
{
&enviadatos (\%{ $estructura{$disco} }, $socket, "iostat.$disco", $time);
}


########
#
# ziostat
#
########


# numero de zonas
my $zonas = `vmadm list -H state=running | wc -l | tr -d '\n'`;

$captura = `ziostat -Z -r 15 2 | awk -F, '\$1 ~ /^[0-9]/ { print \$7,\$1,\$2,\$3,\$4,\$5,\$6 }' | tail -n$zonas`;

@fields = split(" ", $captura);
@wcfields = @fields;

my %ziostat;
my $uuid;

foreach (@fields)
{
if ( $_ =~ /.*[a-z].*/ )
{
$uuid = $_;
shift @wcfields;
$ziostat{$uuid}{r_s} = shift @wcfields;
$ziostat{$uuid}{kr_s} = shift @wcfields;
$ziostat{$uuid}{actv} = shift @wcfields;
$ziostat{$uuid}{wsvc_t} = shift @wcfields;
$ziostat{$uuid}{asvc_t} = shift @wcfields;
$ziostat{$uuid}{b} = shift @wcfields;
}
}

$time = time();

foreach $uuid (keys %ziostat)
{
&enviadatos (\%{ $ziostat{$uuid} }, $socket, "ziostat.$uuid", $time);
}


########
#
# zonememstat
#
########

my $memcommand = `zonememstat -H | awk '{ print \$1,\$2,\$4,\$5,\$6 }'`;

my %zonememstat;
my @memfields = split(" ", $memcommand);
my @wcmemfields = @memfields;
my $memuuid;


foreach (@memfields)
{
if ( $_ =~ /^([a-z0-9]{8}-|global)/ ) {
$memuuid = $_;
shift @wcmemfields;
$zonememstat{$memuuid}{rss} = shift @wcmemfields;
$zonememstat{$memuuid}{nover} = shift @wcmemfields;
$zonememstat{$memuuid}{pout} = shift @wcmemfields;
$zonememstat{$memuuid}{swap} = shift @wcmemfields;
}
}

my $memtime = time();

foreach my $uuid (keys %zonememstat)
{
&enviadatos ( \%{ $zonememstat{$uuid} }, $socket, "zonememstat.$uuid", $memtime );
}

########
#
# cerramos el descriptor
#
########

shutdown($socket,2);

########
#
# collect IPMI sensors
#
########

my $ipmicommand = "ipmitool sdr list | sed 's/|//g' | sed 's/ /_/' | awk '\$1 ~ /CPU_Temp/ || \$1 ~ /CPU1_Temp/ || \$1 ~ /CPU_FAN1/ || \$1 ~ /^FAN1/ || \$1 ~ /12V/ { print \$1,\$2 }'";

open(IPMI, "$ipmicommand |") or die("Could not execute '$ipmicommand': $!");

while (<IPMI>) {
my ($k, $v) = (m/([\+\w\d]*).*?(\d+(?:\.\d+)?)/);
next unless ($k);
if (exists $ipmistatus{$k} ) {
system("echo -n '$grupo.$hostname.ipmi.$ipmistatus{$k} $v $time' | nc -w 0 $graphitehost $port");
}
}

close (IPMI);

########
#
# collect memstat mdb data
#
########

my $mdbcommand = "mdb -ke '::memstat' | sed 's/ZFS File Data/ZFS_File_Data/' | sed 's/Exec and libs/Exec_and_libs/' | sed 's/ /_/' | awk '{ print \$1,\$3 }'";

open(MEMSTAT, "$mdbcommand |") or die("Could not execute '$mdbcommand': $!");

while (<MEMSTAT>) {
my ($k, $v) = (m/([\w_()]+)\s+?(\d+)?/);
next unless ($k);
if (exists $mdbstatus{$k} ) {
system("echo '$grupo.$hostname.memstat.$mdbstatus{$k} $v $time' | nc -w 0 $graphitehost $port");
}
}

close (MEMSTAT);

+ 62
- 0
getsnap.sh Bestand weergeven

@@ -0,0 +1,62 @@
#!/bin/bash

usage()
{
echo "Usage: $0 -z UUID -h NODE -d DIR -p PORT -i KEY -s STORAGEBOX -u USER" >&2
exit 1
}

while getopts "z:h:d:p:i:s:u:" opt;
do
case "$opt" in
z)
UUID=$OPTARG
;;
h)
NODE=$OPTARG
;;
d)
DIR=$OPTARG
;;
p)
PORT=$OPTARG
;;
i)
KEY=$OPTARG
;;
s)
STORAGEBOX=$OPTARG
;;
u)
USER=$OPTARG
;;

\?)
echo "Error: Invalid Option: -${OPTARG}" >&2
usage
;;
:)
echo "Error: -${OPTARG} requires an argument."
usage
;;
*)
usage
;;
esac
done

shift $((OPTIND-1))

if [ -z "${UUID}" ] || [ -z "${NODE}" ] || [ -z "${DIR}" ] || [ -z "${PORT}" ] || [ -z "${KEY}" ] || [ -z "${STORAGEBOX}" ] || [ -z "${USER}" ]; then
usage
fi


VPS=$UUID

#ssh -p ${PORT} -i ${KEY} -l ${USER} ${STORAGEBOX} ls -hl ${DIR}/${NODE}/${VPS}/${VPS}.zfs | awk '{ print "size;"$5",date;"$7,$6,$8 }' | tr -d '\n'
SIZE="$(ssh -p ${PORT} -i ${KEY} -l ${USER} ${STORAGEBOX} du -h ${DIR}/${NODE}/${VPS}/${VPS}.zfs | awk '{ print $1 }' | tr -d '\n')"
DATE="$(ssh -p ${PORT} -i ${KEY} -l ${USER} ${STORAGEBOX} ls -l ${DIR}/${NODE}/${VPS}/${VPS}.zfs | awk '{ print $7,$6,$8 }' | tr -d '\n')"
echo "size; ${SIZE},date; ${DATE}" | tr -d '\n'



+ 0
- 32
perl_fastcgi.xml Bestand weergeven

@@ -1,32 +0,0 @@
<?xml version='1.0'?>
<!DOCTYPE service_bundle SYSTEM '/usr/share/lib/xml/dtd/service_bundle.dtd.1'>
<service_bundle type='manifest' name='export'>
<service name='perl/fastcgi' type='service' version='0'>
<create_default_instance enabled='true'/>
<single_instance/>

<dependency name='network' grouping='require_all' restart_on='error' type='service'>
<service_fmri value='svc:/milestone/network:default'/>
</dependency>
<dependency name='filesystem-local' grouping='require_all' restart_on='none' type='service'>
<service_fmri value='svc:/system/filesystem/local:default'/>
</dependency>

<exec_method name='start' type='method' exec='%{app} -l %{address}:%{port} -n %{procs} -p %{pidfile} -e -d' timeout_seconds='60'/>
<exec_method name='stop' type='method' exec='kill `cat %{pidfile}`' timeout_seconds='60'/>

<property_group name='application' type='application'>
<propval name='app' type='astring' value='/data/www/open6hosting.com/web/o6h/script/o6h_fastcgi.pl'/>
<propval name='address' type='astring' value='127.0.0.1'/>
<propval name='port' type='astring' value='8986'/>
<propval name='procs' type='astring' value='5'/>
<propval name='pidfile' type='astring' value='/var/run/o6h_fastcgi.pid'/>
</property_group>

<template>
<common_name>
<loctext xml:lang='C'>Open6Hosting WEBAPP daemon</loctext>
</common_name>
</template>
</service>
</service_bundle>

+ 38
- 0
recursos.sh Bestand weergeven

@@ -0,0 +1,38 @@
#!/bin/bash

usage()
{
echo "Usage: $0 -z UUID" >&2
exit 1
}

while getopts "z:" opt;
do
case "$opt" in
z)
UUID=$OPTARG
;;
\?)
echo "Error: Invalid Option: -${OPTARG}" >&2
usage
;;
:)
echo "Error: -${OPTARG} requires an argument."
usage
;;
*)
usage
;;
esac
done

shift $((OPTIND-1))

if [ -z "${UUID}" ]; then
usage
fi


VPS=$UUID

zonememstat -Hz ${VPS} | awk '{ print "uso:"$2",ram:"$3",swap:"$6 }' | tr -d '\n'

+ 127
- 0
restoresnaps.sh Bestand weergeven

@@ -0,0 +1,127 @@
#!/bin/bash

usage()
{
echo "Usage: $0 [ -n NODE ] [ -z UUID ] [ -h hostname ] [ -p port ] [ -k KEY ] [ -d dir ] [ -u user ]" >&2
exit 1
}

while getopts "n:z:h:p:k:d:u:" opt;
do
case "$opt" in
n)
NODE=$OPTARG
;;
z)
UUID=$OPTARG
;;
h)
HOSTNAME=$OPTARG
;;
p)
PORT=$OPTARG
;;
k)
KEY=$OPTARG
;;
d)
DIR=$OPTARG
;;
u)
USER=$OPTARG
;;
\?)
echo "Error: Invalid Option: -${OPTARG}" >&2
usage
;;
:)
echo "Error: -${OPTARG} requires an argument."
usage
;;
*)
usage
;;
esac
done

shift $((OPTIND-1))

if [ -z "${UUID}" ] || [ -z "${NODE}" ] || [ -z ${HOSTNAME} ] || [ -z ${PORT} ] || [ -z ${KEY} ] || [ -z "${DIR}" ] || [ -z "${USER}" ]; then
usage
fi

SSH="ssh -i $KEY -p ${PORT} -l ${USER} -o StrictHostKeyChecking=no"
SCP="scp -q -i $KEY -P ${PORT} -o StrictHostKeyChecking=no"
DSTDIR="${DIR}/${UUID}"

#################
# functions
#################

check_err()
{
STATUS=$?
if [ ${STATUS} -ne 0 ]; then
echo "Unexpected error: ${STATUS}"
exit ${STATUS}
fi
}

remove_vps()
{
VPS=$1
echo "Deleteing VPS ${VPS}..."
vmadm destroy ${VPS}
check_err
echo "...done."
}

recover_dataset()
{
VPS=$1
echo "Recovering VPS ${VPS}..."
${SSH} ${HOSTNAME} "dd if=${DIR}/${NODE}/${VPS}/${VPS}.zfs bs=4M" | /usr/sbin/zfs receive zones/${VPS}
check_err
echo "...done."
}

recover_config()
{
VPS=$1
echo "Recovering config from backup..."
${SCP} ${USER}@${HOSTNAME}:${DIR}/${NODE}/${VPS}/${VPS}.cfg /zones/tools/descargas/
cat /zones/tools/descargas/${VPS}.cfg | zonecfg -z ${VPS}

check_err
echo "...done."
}

final_steps()
{
VPS=$1
echo "Attaching dataset..."
zoneadm -z ${VPS} attach
check_err
echo "...done."
echo "Booting VPS..."
zoneadm -z ${VPS} boot
check_err
echo "...done."
}

#################
# main
#################

echo "---
BACKUP_SERVER: ${HOSTNAME}
UUID to restore: ${UUID}
---"

remove_vps ${UUID}

recover_config ${UUID}

recover_dataset ${UUID}

final_steps ${UUID}

+ 6
- 0
update_alias_vps.sh Bestand weergeven

@@ -0,0 +1,6 @@
#!/bin/bash
UUID=$1
ALIAS=$2
NEWALIAS=`echo ${ALIAS} | tr -d '\n' | openssl base64`

zonecfg -z ${UUID} "select attr name=alias; set value=\"${NEWALIAS}\";end"

+ 127
- 64
zonebackuptofile.sh Bestand weergeven

@@ -2,100 +2,163 @@

usage()
{
echo "Usage: $0 -z UUID -d days -r remote_folder -l local_folder -s server -t type" >&2
echo "ex: $0 -z bbba5ecb-5bda-47a5-e103-a6bfa368bf68 -d 1 -r remote_folder -l /zone/tools/nfsshare -s 192.168.5.243 -t nfs" >&2
echo "Usage: $0 [ -z UUID ] [ -h hostname ] [ -p port ] [ -k KEY ] [ -n name ] [ -d dir ]" >&2
exit 1
}

while getopts "z:d:r:l:s:t:" opt;
while getopts "z:h:p:k:n:d:" opt;
do
case "$opt" in
z)
UUID=$OPTARG
;;
UUID=$OPTARG
;;
h)
HOSTNAME=$OPTARG
;;
n)
NAME=$OPTARG
;;
p)
PORT=$OPTARG
;;
k)
KEY=$OPTARG
;;
d)
DAYS=$OPTARG
;;
r)
RFOLDER=$OPTARG
;;
l)
LFOLDER=$OPTARG
;;
s)
SERVER=$OPTARG
;;
t)
TYPE=$OPTARG
;;
DIR=$OPTARG
;;

\?)
echo "Error: Invalid Option: -${OPTARG}" >&2
usage
;;
:)
echo "Error: -${OPTARG} requires an argument."
usage
;;
*)
usage
;;
usage
;;
esac
done

shift $((OPTIND-1))

if [ -z "${UUID}" || -z "${DAYS}" || -z "${RFOLDER}" || -z "${LFOLDER}" || -z "${SERVER}" && -z "${TYPE}" ]; then
if [ -z "${UUID}" ] || [ -z "${HOSTNAME}" ] || [ -z ${PORT} ] || [ -z ${KEY} ] || [ -z "${NAME}" ] || [ -z "${DIR}" ]; then
usage
fi

BRAND=`/usr/sbin/vmadm get $UUID | json brand | tr -d '\n'`
SSH="ssh -i $KEY -p ${PORT} -o StrictHostKeyChecking=no"
DSTDIR="${DIR}/${NAME}"

mkdir -p $LFOLDER
#################
# functions
#################

if [ $TYPE = "nfs" ]; then
OVH="/export/ftpbackup/${RFOLDER}"
mount $SERVER:$OVH $LFOLDER
create_snap()
{
DATASET=$1
echo "Creating snapshot of ${DATASET}..."
/usr/sbin/zfs snapshot zones/${DATASET}@`date +%Y%m%d`
check_err
echo "...done."
}

if [ $? != 0 ]; then
echo "MOUNT FAILED."
umount $LFOLDER
exit
fi
elif [ $TYPE = "smb" ]; then
mount -F smbfs //o6h.smartos5:c0c0l1s0@${SERVER}/${RFOLDER} $LFOLDER
send_snap()
{
DATASET=$1
echo "Sending snapshot of ${DATASET}..."

if [ $? != 0 ]; then
echo "MOUNT FAILED."
exit
# taking care for additional datasets
SLASH=`echo ${DATASET} | grep -c '/'`

if [ ${SLASH} -ne 0 ]; then
RENAME=`echo ${DATASET} | sed 's/\//-/'`
/usr/sbin/zfs send zones/${DATASET}@`date +%Y%m%d` | ${SSH} ${HOSTNAME} "dd of=${DSTDIR}/${UUID}/${RENAME}.zfs bs=4M"
else
/usr/sbin/zfs send zones/${DATASET}@`date +%Y%m%d` | ${SSH} ${HOSTNAME} "dd of=${DSTDIR}/${DATASET}/${DATASET}.zfs bs=4M"
fi
fi

mkdir -p $LFOLDER/$UUID
check_err
echo "...done."
}

if [ $? != 0 ]; then
echo "FAIL TO CREATE FOLDER $UUID."
umount $LFOLDER
exit
fi
check_snap()
{
ZONE=$1
echo "Checking for snapshot of ${ZONE}..."
zfs list -t snapshot zones/${ZONE}@`date +%Y%m%d` 2>/dev/null 1>&2
}

# mantain backups of the last N days
#find $LFOLDER/$UUID -type f -mtime +$DAYS -delete
check_err()
{
STATUS=$?
if [ ${STATUS} -ne 0 ]; then
echo "Unexpected error: ${STATUS}"
exit ${STATUS}
fi
}

snapshot()
send_config()
{
/usr/sbin/zfs snapshot zones/$1@`date +%Y%m%d`
/usr/sbin/zfs send zones/$1@`date +%Y%m%d` > $LFOLDER/$UUID/$1@`date +%Y%m%d`
echo "Sending config to ${HOSTNAME}..."
zonecfg -z ${UUID} export | ${SSH} ${HOSTNAME} "dd of=${DSTDIR}/${UUID}/${UUID}.cfg"
check_err
echo "...done."
}

snapshot $UUID
create_dir()
{
echo "Creating directory at ${HOSTNAME}..."
${SSH} ${HOSTNAME} mkdir -p ${DSTDIR}/${UUID}
check_err
echo "...done."
}

if [ $BRAND = "kvm" ]
then
snapshot ${UUID}-disk0
elif [ $BRAND = "bhyve" ]
then
snapshot ${UUID}/disk0
fi
check_multidataset()
{
echo "Looking for addtional children datasets in ${UUID}..."
DATASET=`vmadm get ${UUID} | json datasets.0 | sed 's/zones\///' | tr -d '\n'`
echo "...done."

if [ ! -z "${DATASET}" ]; then
echo "Finded children dataset: ${DATASET}"
check_snap ${DATASET}

if [ $? -ne 0 ]; then
create_snap ${DATASET}
else
echo "Snapshot of ${DATASET} already available"
echo "Skipping create snapshot..."
fi
send_snap ${DATASET}
else
echo "No children datasets finded."
fi
}

/usr/sbin/zonecfg -z $UUID export > $LFOLDER/$UUID/$UUID.`date +%Y%m%d`.cfg
#################
# main
#################

if [ $TYPE = "nfs" ]; then
umount $LFOLDER
echo "---
BACKUP_SERVER: ${HOSTNAME}
UUID to backup: ${UUID}
---"

create_dir ${UUID}

check_snap ${UUID}

if [ $? -ne 0 ]; then
create_snap ${UUID}
else
echo "Snapshot of ${UUID} already available"
echo "...done."
fi

## TODO
# smb: query for username
# smb: query for password
send_snap ${UUID}

check_multidataset

send_config

+ 1
- 16
zonemigrate.sh Bestand weergeven

@@ -97,20 +97,6 @@ echo "exportamos configuracion y enviamos a destino..."

zonecfg -z ${UUID} export | $SSH $SERVER "zonecfg -z ${UUID}"

# modificamos de acuerdo a la config de datacenter remoto
echo "modificamos config de acuerdo a datacenter remoto..."

echo "
select net physical=eth0
clear vlan-id
set global-nic=v/100
add property (name=mtu,value="1200")
remove property (name=gateway,value="194.53.148.1")
remove property (name=gateways,value="194.53.148.1")
add property (name=gateway,value="194.53.148.2")
add property (name=gateways,value="194.53.148.2")
end" | $SSH $SERVER "zonecfg -z ${UUID}"

# montamos el dataset

$SSH $SERVER zfs mount ${ZONEPATH}
@@ -125,13 +111,12 @@ zoneadm -z ${UUID} halt

# actualizamos la zona en local para que no inicie

vmadm udpate ${UUID} autoboot=false
vmadm update ${UUID} autoboot=false

# iniciamos la zona en remoto

$SSH $SERVER zoneadm -z ${UUID} boot


# TODO:
# - puede haber mas de un FILESYSTEM en la zona, necesitamos iterar por el array y lanzar la funcion snapshot sobre cada uno de ellos
# - puede haber mas de un DATASET en la zona, necesitamos iterar por el array y lanzar la funcion snapshot sobre cada uno

Schrijf Voorbeeld
Laden…
Annuleren
Opslaan