github/vesta
1
0
Fork 0
mirror of https://github.com/serghey-rodin/vesta.git synced 2025-08-13 10:07:42 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

listing scripts refactoring + new format

Browse source
This commit is contained in:
Serghey Rodin 2016-06-09 16:26:54 +03:00
commit 6e0ef668bb
60 changed files with 3695 additions and 1991 deletions

95
bin/v-list-backup-host
View file

@ -1,6 +1,6 @@
#!/bin/bash
# info: list backup host
# options: TYPE [FORMAT]
# options: TYPE HOST [FORMAT]
#
# The function for obtaining the list of backup host parameters.
@ -10,46 +10,55 @@
#----------------------------------------------------------#
# Argument definition
TYPE=$1
type=$1
format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_ftp_host() {
i=1
fileds_count=$(echo "$fields" | wc -w)
ip_data=$(cat $VESTA/conf/$TYPE.backup.conf)
# JSON list function
json_list() {
echo '{'
echo -e "\t\"$TYPE\": {"
eval $ip_data
for field in $fields; do
eval value=$field
if [ $fileds_count -eq $i ]; then
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e '}'
echo ' "'$type'": {
"HOST": "'$HOST'",
"USERNAME": "'$USERNAME'",
"PORT": "'$PORT'",
"TYPE": "'$type'",
"BPATH": "'$BPATH'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_ftp_host() {
line=$(cat $VESTA/conf/$TYPE.backup.conf)
eval $line
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key='NULL'
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "HOST: $HOST"
echo "USERNAME: $USERNAME"
echo "PORT: $PORT"
echo "TYPE: $type"
echo "PATH: $BPATH"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -e "$HOST\t$USERNAME\t$PORT\t$type\t$BPATH\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo "HOST,USERNAME,PORT,TYPE,PATH,TIME,DATE"
echo "$HOST,$USERNAME,$PORT,$type,$BPATH,$TIME,$DATE"
}
# Type format validator
is_type_format_valid() {
exclude="[!|#|$|^|&|(|)|+|=|{|}|:|@|<|>|?|/|\|\"|'|;|%|\`| ]|\."
if [[ "$1" =~ $exclude ]]; then
check_result $E_INVALID "invalid type extention format :: $1"
fi
}
@ -58,25 +67,27 @@ shell_list_ftp_host() {
#----------------------------------------------------------#
check_args '1' "$#" 'TYPE [FORMAT]'
is_type_format_valid "$type"
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
if [ ! -e "$VESTA/conf/$TYPE.backup.conf" ]; then
# Checking backup config
if [ ! -e "$VESTA/conf/$type.backup.conf" ]; then
exit
fi
# Defining fileds to select
fields='$HOST $USERNAME $PORT $TYPE $BPATH $TIME $DATE'
# Parsing backup config
source "$VESTA/conf/$type.backup.conf"
# Listing database
case $format in
json) json_list_ftp_host ;;
plain) nohead=1; shell_list_ftp_host;;
shell) shell_list_ftp_host | column -t ;;
*) check_args '2' '0' '[FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

106
bin/v-list-cron-job
View file

@ -2,7 +2,7 @@
# info: list cron job
# options: USER JOB [FORMAT]
#
# The function of obtaining cron job settings.
# The function of obtaining cron job parameters.
#----------------------------------------------------------#
@ -17,44 +17,46 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_job() {
i=1
fileds_count=$(echo "$fields" | wc -w)
line=$(grep "JOB='$job'" $conf)
echo '{'
eval $line
for field in $fields; do
eval value=$field
value=$(echo "$value"|sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fileds_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"$value\""
else
echo -e "\t\t\"${field//$/}\": \"$value\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e "}"
# JSON list function
json_list() {
echo "{"
echo -n ' "'$job'": {
"MIN": "'$MIN'",
"HOUR": "'$HOUR'",
"DAY": "'$HOUR'",
"MONTH": "'$MONTH'",
"WDAY": "'$WDAY'",
"CMD": "'$CMD'",
"JOB": "'$JOB'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo
echo '}'
}
# Shell function
shell_list_job() {
line=$(grep "JOB='$job'" $conf)
eval $line
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key=NULL
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "MINUTE: $MIN"
echo "HOUR: $HOUR"
echo "DAY: $DAY"
echo "DAY OF WEEK: $WDAY"
echo "COMMAND: $CMD"
echo "SUSPENDED: $SUSPENDED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -e "$MIN\t$HOUR\t$DAY\t$WDAY\t$CMD\t$SUSPENDED\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo "MIN,HOUR,DAY,WDAY,CMD,SUSPENDED,TIME,DATE"
echo "$MIN,$HOUR,$DAY,$WDAY,\"$CMD\",$SUSPENDED,$TIME,$DATE'"
}
@ -63,6 +65,8 @@ shell_list_job() {
#----------------------------------------------------------#
check_args '2' "$#" 'USER JOB [FORMAT]'
is_format_valid 'user'
is_number_format_valid "$job" "job_id"
is_object_valid 'user' 'USER' "$user"
@ -70,17 +74,27 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Defining config and fields to select
# Defining config
conf=$USER_DATA/cron.conf
fields="\$JOB \$MIN \$HOUR \$DAY \$MONTH \$WDAY \$CMD \$SUSPENDED"
fields="$fields \$TIME \$DATE"
# Listing domains
case $format in
json) json_list_job ;;
plain) nohead=1; shell_list_job ;;
shell) shell_list_job |column -t ;;
*) check_args '2' '0' 'USER JOB [FORMAT]'
# Checking job id
cron_line=$(grep "JOB='$job'" $conf)
if [ -z "$cron_line" ]; then
check_result $E_NOTEXIST "cron job $job doesn't exist"
fi
# Parsing cron job
eval $cron_line
# Replacing quoted and backslahed text
CMD=$(echo "$CMD" |sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

131
bin/v-list-cron-jobs
View file

@ -16,53 +16,71 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json list function
json_list_cron() {
echo '{'
fileds_count=$(echo $fields| wc -w )
while read line; do
eval $line
if [ -n "$data" ]; then
echo -e ' },'
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep JOB $USER_DATA/cron.conf |wc -l)
echo "{"
while read str; do
eval $str
CMD=$(echo "$CMD" |sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
echo -n ' "'$JOB'": {
"MIN": "'$MIN'",
"HOUR": "'$HOUR'",
"DAY": "'$DAY'",
"MONTH": "'$MONTH'",
"WDAY": "'$WDAY'",
"CMD": "'$CMD'",
"JOB": "'$JOB'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
i=1
IFS=' '
for field in $fields; do
eval value=\"$field\"
value=$(echo "$value"|sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
data=1
fi
fi
done
done < $conf
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
((i++))
done < <(cat $USER_DATA/cron.conf)
echo '}'
}
# Shell list function
shell_list_cron() {
if [ -z "$nohead" ] ; then
echo "${fields//$/}"
for a in $fields; do
echo -e "------ \c"
done
echo
fi
while read line ; do
eval $line
eval echo "$fields" | sed -e "s/%quote%/'/g"
done < $conf
# SHELL list function
shell_list() {
IFS=$'\n'
echo "JOB^MIN^HOUR^MONTH^WDAY^COMMAND"
echo "---^---^----^-----^----^-------"
while read str; do
eval $str
CMD=$(echo "$CMD" |sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
echo "$JOB^$MIN^$HOUR^$MONTH^$WDAY^$CMD"
done < <(cat $USER_DATA/cron.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
CMD=$(echo "$CMD" |sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
echo -ne "$JOB\t$MIN\t$HOUR\t$MONTH\t$WDAY\t$CMD\t"
echo -e "$SUSPENDED\t$TIME\t$DATE"
done < <(cat $USER_DATA/cron.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "MIN,HOUR,DAY,WDAY,CMD,SUSPENDED,TIME,DATE"
while read str; do
eval $str
CMD=$(echo "$CMD" |sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
echo -n "$JOB,$MIN,$HOUR,$MONTH,$WDAY,\"$CMD\","
echo "$SUSPENDED,$TIME,$DATE"
done < <(cat $USER_DATA/cron.conf)
}
@ -71,7 +89,7 @@ shell_list_cron() {
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -79,23 +97,12 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Defining config
conf=$USER_DATA/cron.conf
# Defining fileds to select
fields='$JOB $MIN $HOUR $DAY $MONTH $WDAY $CMD $JOB $SUSPENDED $TIME $DATE'
# Listing domains
case $format in
json) json_list_cron ;;
plain) nohead=1;
fields="\"\$JOB\" \"\$SUSPENDED\" \"\$MIN\" \"\$HOUR\" \"\$DAY\""
fields="$fields \"\$MONTH\" \"\$WDAY\" \"\$CMD\" ";
fields="$fields \"\$TIME\" \"\$DATE\""
shell_list_cron ;;
shell) fields='$JOB~$SUSPENDED~$MIN~$HOUR~$DAY~$MONTH~$WDAY~$CMD';
shell_list_cron |column -t -s '~';;
*) check_args '1' '0' 'USER [FORMAT]' ;;
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t -s '^';;
esac

88
bin/v-list-database
View file

@ -17,40 +17,46 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_db() {
i=1
last_word=$(echo "$fields" | wc -w)
line=$(grep "DB='$database'" $conf)
# JSON list function
json_list() {
echo '{'
eval $line
for field in $fields; do
eval value=$field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$last_word" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e "\t}"
fi
echo -e '}'
echo ' "'$database'": {
"DATABASE": "'$DB'",
"DBUSER": "'$DBUSER'",
"HOST": "'$HOST'",
"TYPE": "'$TYPE'",
"CHARSET": "'$CHARSET'",
"U_DISK": "'$U_DISK'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell list for single database
shell_list_db() {
line=$(grep "DB='$database'" $conf)
eval $line
for field in $fields; do
eval key="$field"
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "DATABASE: $DB"
echo "DB USER: $DBUSER"
echo "HOST: $HOST"
echo "TYPE: $TYPE"
echo "CHARSET: $CHARSET"
echo "DISK: $U_DISK"
echo "SUSPENDED: $SUSPENDED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$DB\t$DBUSER\t$HOST\t$TYPE\t$CHARSET\t$U_DISK\t"
echo -e "$SUSPENDED\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo "DATABASE,DBUSER,HOST,TYPE,CHARSET,U_DISK,SUSPENDED,TIME,DATE"
echo "$DB,$DBUSER,$HOST,$TYPE,$CHARSET,$U_DISK,$SUSPENDED,$TIME,$DATE"
}
@ -59,7 +65,7 @@ shell_list_db() {
#----------------------------------------------------------#
check_args '2' "$#" 'USER DATABASE [FORMAT]'
validate_format 'user' 'database'
is_format_valid 'user' 'database'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'db' 'DB' "$database"
@ -68,17 +74,15 @@ is_object_valid 'db' 'DB' "$database"
# Action #
#----------------------------------------------------------#
# Parsing database
eval $(grep "DB='$database'" $USER_DATA/db.conf)
# Defining fileds to select
conf=$USER_DATA/db.conf
fields='$DB $DBUSER $HOST $TYPE $CHARSET $U_DISK $SUSPENDED $TIME $DATE'
# Listing database
case $format in
json) json_list_db ;;
plain) shell_list_db ;;
shell) shell_list_db | column -t ;;
*) check_args '2' '0' 'USER DATABASE [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

104
bin/v-list-database-host
View file

@ -1,8 +1,8 @@
#!/bin/bash
# info: list database server
# info: list database host
# options: TYPE HOST [FORMAT]
#
# The function for obtaining database server parameters.
# The function for obtaining database host parameters.
#----------------------------------------------------------#
@ -17,40 +17,58 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_dbhost() {
i=1
fields_count=$(echo "$fields" | wc -w)
line=$(grep "HOST='$host'" $conf)
# JSON list function
json_list() {
echo '{'
eval $line
for field in $fields; do
eval value=$field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fields_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e "\t}"
fi
echo -e "}"
echo ' "'$HOST'": {
"HOST": "'$HOST'",
"TYPE": "'$type'",
"CHARSETS": "'$CHARSETS'",
"MAX_DB": "'$MAX_DB'",
"U_SYS_USERS": "'$U_SYS_USERS'",
"U_DB_BASES": "'$U_DB_BASES'",
"TPL": "'$TPL'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_dbhost() {
line=$(grep "HOST='$host'" $conf)
eval $line
for field in $fields; do
eval key="$field"
echo "${field//$/}: $key"
done
# SHELL list function
shell_list() {
echo "HOST: $HOST"
echo "TYPE: $type"
echo "CHARSETS: $CHARSETS"
echo "MAX_DB: $MAX_DB"
echo "U_DB_BASES: $U_DB_BASES"
echo "U_SYS_USERS: $U_SYS_USERS"
echo "TPL: $TPL"
echo "SUSPENDED: $SUSPENDED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$HOST\t$type\t$CHARSETS\t$MAX_DB\t$U_SYS_USERS\t"
echo -e "$U_DB_BASES\t$TPL\t$SUSPENDED\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo -n "HOST,TYPE,CHARSETS,MAX_DB,U_SYS_USERS,"
echo "U_DB_BASES,TPL,SUSPENDED,TIME,DATE'"
echo -n "$HOST,$type,\"$CHARSETS\",$MAX_DB,\"$U_SYS_USERS\","
echo "$U_DB_BASES,$TPL,$SUSPENDED,$TIME,$DATE"
}
# Type format validator
is_type_format_valid() {
exclude="[!|#|$|^|&|(|)|+|=|{|}|:|@|<|>|?|/|\|\"|'|;|%|\`| ]|\."
if [[ "$1" =~ $exclude ]]; then
check_result $E_INVALID "invalid type extention format :: $1"
fi
}
@ -59,7 +77,7 @@ shell_list_dbhost() {
#----------------------------------------------------------#
check_args '2' "$#" 'TYPE HOST [FORMAT]'
validate_format 'host'
is_type_format_valid "$type"
is_object_valid "../../conf/$type" 'HOST' "$host"
@ -67,17 +85,15 @@ is_object_valid "../../conf/$type" 'HOST' "$host"
# Action #
#----------------------------------------------------------#
# Defining fileds to select
conf=$VESTA/conf/$type.conf
fields='$HOST $CHARSETS $MAX_DB $U_SYS_USERS $U_DB_BASES $TPL $SUSPENDED'
fields="$fields \$TIME \$DATE"
# Parsing hosts
eval $(grep "HOST='$host'" $VESTA/conf/$type.conf)
# Listing database
case $format in
json) json_list_dbhost ;;
plain) nohead=1; shell_list_dbhost ;;
shell) shell_list_dbhost | column -t;;
*) check_args '2' '0' 'TYPE HOST [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

123
bin/v-list-database-hosts
View file

@ -1,8 +1,8 @@
#!/bin/bash
# info: list database servers
# options: TYPE [FORMAT]
# info: list database hosts
# options: [FORMAT]
#
# The function for obtaining the list of all hosts of the same databases' type.
# The function for obtaining the list of all configured database hosts.
#----------------------------------------------------------#
@ -10,37 +10,122 @@
#----------------------------------------------------------#
# Argument definition
type=${1-mysql}
format=${2-shell}
format=${1-shell}
# Includes
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=0
for type in $(echo $DB_SYSTEM |sed -e 's/,/\n/'); do
if [ -e "$VESTA/conf/$type.conf" ]; then
db_hosts=$(grep HOST $VESTA/conf/$type.conf |wc -l)
objects=$((objects + db_hosts))
fi
done
echo "{"
for type in $(echo $DB_SYSTEM |sed -e 's/,/\n/'); do
if [ -e "$VESTA/conf/$type.conf" ]; then
for str in $(cat $VESTA/conf/$type.conf); do
eval $str
echo -n ' "'$HOST'": {
"HOST": "'$HOST'",
"TYPE": "'$type'",
"CHARSETS": "'$CHARSETS'",
"MAX_DB": "'$MAX_DB'",
"U_SYS_USERS": "'$U_SYS_USERS'",
"U_DB_BASES": "'$U_DB_BASES'",
"TPL": "'$TPL'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done
fi
done
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "HOST TYPE MAX_DB DB_USED SPND TIME DATE"
echo "---- ---- ------ ------- ---- ---- ----"
for type in $(echo $DB_SYSTEM |sed -e 's/,/\n/'); do
if [ -e "$VESTA/conf/$type.conf" ]; then
for str in $(cat $VESTA/conf/$type.conf); do
eval $str
echo "$HOST $type $MAX_DB $U_DB_BASES $SUSPENDED $TIME $DATE"
done
fi
done
}
# PLAIN list function
plain_list() {
IFS=$'\n'
for type in $(echo $DB_SYSTEM |sed -e 's/,/\n/'); do
if [ -e "$VESTA/conf/$type.conf" ]; then
for str in $(cat $VESTA/conf/$type.conf); do
eval $str
echo -ne "$HOST\t$type\t$CHARSETS\t$MAX_DB\t$U_SYS_USERS\t"
echo -e "$U_DB_BASES\t$TPL\t$SUSPENDED\t$TIME\t$DATE"
done
fi
done
}
# CSV list function
csv_list() {
IFS=$'\n'
echo -n "HOST,TYPE,CHARSETS,MAX_DB,U_SYS_USERS,"
echo "U_DB_BASES,TPL,SUSPENDED,TIME,DATE"
for type in $(echo $DB_SYSTEM |sed -e 's/,/\n/'); do
if [ -e "$VESTA/conf/$type.conf" ]; then
for str in $(cat $VESTA/conf/$type.conf); do
eval $str
echo -n "$HOST,$type,\"$CHARSETS\",$MAX_DB,\"$U_SYS_USERS\","
echo "$U_DB_BASES,$TPL,$SUSPENDED,$TIME,$DATE"
done
fi
done
}
# Type format validator
is_type_format_valid() {
exclude="[!|#|$|^|&|(|)|+|=|{|}|:|@|<|>|?|/|\|\"|'|;|%|\`| ]|\."
if [[ "$1" =~ $exclude ]]; then
check_result $E_INVALID "invalid type extention format :: $1"
fi
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
# Checking args
#check_args '1' "$#" 'TYPE [FORMAT]'
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Defining fileds to select
conf=$VESTA/conf/$type.conf
fields='$HOST $CHARSETS $MAX_DB $U_SYS_USERS $U_DB_BASES $TPL $SUSPENDED'
fields="$fields \$TIME \$DATE"
# Listing database
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list;;
shell) fields='$HOST $MAX_DB $U_DB_BASES $SUSPENDED $DATE';
shell_list | column -t ;;
*) check_args '2' '0' 'TYPE [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

55
bin/v-list-database-types
View file

@ -16,31 +16,40 @@ format=${1-shell}
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# Json function
json_list_dbtypes() {
types=$(echo "${DB_SYSTEM//,/ }")
t_counter=$(echo "$types" | wc -w)
# JSON list function
json_list() {
objects=$(echo "${DB_SYSTEM//,/ }" |wc -w)
i=1
echo '['
for type in $types; do
if [ "$i" -lt "$t_counter" ]; then
echo -e "\t\"$type\","
for type in ${DB_SYSTEM//,/ }; do
echo -n ' "'$type'"'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo -e "\t\"$type\""
echo
fi
(( ++i))
((i++))
done
echo "]"
}
# Shell function
shell_list_dbtypes() {
types=$(echo "${DB_SYSTEM//,/ }")
if [ -z "$nohead" ]; then
echo "TYPES"
echo "----------"
fi
for type in $types; do
# SHELL list function
shell_list() {
echo -e "TYPE\n----"
echo "$DB_SYSTEM" |sed -e "s/,/\n/"
}
# PLAIN list function
plain_list() {
for type in ${DB_SYSTEM//,/ }; do
echo "$type"
done
}
# CSV list function
csv_list() {
echo "TYPE"
for type in ${DB_SYSTEM//,/ }; do
echo "$type"
done
}
@ -50,12 +59,12 @@ shell_list_dbtypes() {
# Action #
#----------------------------------------------------------#
# Listing domains
case $format in
json) json_list_dbtypes ;;
plain) nohead=1; shell_list_dbtypes ;;
shell) shell_list_dbtypes ;;
*) check_args '1' '0' '[FORMAT]' ;;
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list;;
esac

77
bin/v-list-databases
View file

@ -16,13 +16,73 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep "DB=" $USER_DATA/db.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$DB'": {
"DATABASE": "'$DB'",
"DBUSER": "'$DBUSER'",
"HOST": "'$HOST'",
"TYPE": "'$TYPE'",
"CHARSET": "'$CHARSET'",
"U_DISK": "'$U_DISK'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $USER_DATA/db.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "DATABASE USER HOST TYPE DISK SPND DATE"
echo "-------- ---- ---- ---- ---- ---- ----"
while read str; do
eval $str
echo "$DB $DBUSER $HOST $TYPE $U_DISK $SUSPENDED $DATE"
done < <(cat $USER_DATA/db.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$DB\t$DBUSER\t$HOST\t$TYPE\t$CHARSET\t$U_DISK\t"
echo -e "$SUSPENDED\t$TIME\t$DATE"
done < <(cat $USER_DATA/db.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "DATABASE,DBUSER,HOST,TYPE,CHARSET,U_DISK,SUSPENDED,TIME,DATE"
while read str; do
eval $str
echo "$DB,$DBUSER,$HOST,$TYPE,$CHARSET,$U_DISK,$SUSPENDED,$TIME,$DATE"
done < <(cat $USER_DATA/db.conf)
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -30,17 +90,12 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Defining fileds to select
conf=$USER_DATA/db.conf
fields='$DB $DBUSER $HOST $TYPE $CHARSET $U_DISK $SUSPENDED $TIME $DATE'
# Listing databases
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$DB $DBUSER $HOST $TYPE $U_DISK $DATE';
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

108
bin/v-list-dns-domain
View file

@ -2,8 +2,7 @@
# info: list dns domain
# options: USER DOMAIN [FORMAT]
#
# The function of obtaining the list of domain parameters. This call, just as
# all v_list_* calls, supports 3 formats - json, shell and plain.
# The function of obtaining the list of dns domain parameters.
#----------------------------------------------------------#
@ -18,57 +17,52 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_domain() {
i=1
fileds_count=$(echo "$fields" | wc -w)
line=$(grep "DOMAIN='$domain'" $conf)
# Print top bracket
# JSON list function
json_list() {
echo '{'
# Assing key=value
eval $line
# Starting output loop
for field in $fields; do
# Parsing key=value
eval value=$field
# Checking first field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fileds_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"$value\""
else
echo -e "\t\t\"${field//$/}\": \"$value\","
fi
fi
# Updating iterator
(( ++i))
done
# If there was any output
if [ -n "$value" ]; then
echo -e ' }'
fi
# Printing bottom json bracket
echo -e "}"
echo ' "'$DOMAIN'": {
"IP": "'$IP'",
"TPL": "'$TPL'",
"TTL": "'$TTL'",
"EXP": "'$EXP'",
"SOA": "'$SOA'",
"SERIAL": "'$SERIAL'",
"SRC": "'$SRC'",
"RECORDS": "'$RECORDS'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_domain() {
line=$(grep "DOMAIN='$domain'" $conf)
# SHELL list function
shell_list() {
echo "DOMAIN: $DOMAIN"
echo "IP: $IP"
echo "TEMPLATE: $TPL"
echo "TTL: $TTL"
echo "EXP: $EXP"
echo "SOA: $SOA"
echo "SERIAL: $SERIAL"
echo "RECORDS: $RECORDS"
echo "SUSPENDED: $SUSPENDED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# Parsing key=value
eval $line
# Print result line
for field in $fields; do
eval key="$field"
echo "${field//$/}: $key "
done
# PLAIN list function
plain_list() {
echo -ne "$DOMAIN\t$IP\t$TPL\t$TTL\t$EXP\t$SOA\t$SERIAL\t$RECORDS\t"
echo -e "$SUSPENDED\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo "DOMAIN,IP,TPL,TTL,EXP,SOA,SERIAL,RECORDS,SUSPENDED,TIME,DATE"
echo -n "$DOMAIN,$IP,$TPL,$TTL,$EXP,$SOA,$SERIAL,$RECORDS,$SUSPENDED,"
echo "$TIME,$DATE"
}
@ -85,17 +79,15 @@ is_object_valid 'dns' 'DOMAIN' "$domain"
# Action #
#----------------------------------------------------------#
# Defining config and fields to select
conf=$USER_DATA/dns.conf
fields='$DOMAIN $IP $TPL $TTL $EXP $SOA $SERIAL $SRC $RECORDS
$SUSPENDED $TIME $DATE'
# Parsing domain
eval $(grep "DOMAIN='$domain'" $USER_DATA/dns.conf)
# Listing domains
case $format in
json) json_list_domain ;;
plain) nohead=1; shell_list_domain ;;
shell) shell_list_domain |column -t ;;
*) check_args '2' '0' 'USER DOMAIN [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

83
bin/v-list-dns-domains
View file

@ -16,13 +16,78 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep DOMAIN $USER_DATA/dns.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$DOMAIN'": {
"IP": "'$IP'",
"TPL": "'$TPL'",
"TTL": "'$TTL'",
"EXP": "'$EXP'",
"SOA": "'$SOA'",
"SERIAL": "'$SERIAL'",
"SRC": "'$SRC'",
"RECORDS": "'$RECORDS'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $USER_DATA/dns.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "DOMAIN IP TPL TTL REC SPND DATE"
echo "------ -- --- --- --- ---- ----"
while read str; do
eval $str
echo "$DOMAIN $IP $TPL $TTL $RECORDS $SUSPENDED $DATE"
done < <(cat $USER_DATA/dns.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$DOMAIN\t$IP\t$TPL\t$TTL\t$EXP\t$SOA\t$SERIAL\t"
echo -e "$SRC\t$RECORDS\t$SUSPENDED\t$TIME\t$DATE"
done < <(cat $USER_DATA/dns.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "DOMAIN,IP,TPL,TTL,EXP,SOA,SERIAL,SRC,RECORDS,SUSPENDED,TIME,DATE"
while read str; do
eval $str
echo -n "$DOMAIN,$IP,$TPL,$TTL,$EXP,$SOA,$SERIAL,"
echo "$SRC,$RECORDS,$SUSPENDED,$TIME,$DATE"
done < <(cat $USER_DATA/dns.conf)
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -30,18 +95,12 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Defining config and fields
conf=$USER_DATA/dns.conf
fields='$DOMAIN $IP $TPL $TTL $EXP $SOA $SERIAL $SRC $RECORDS
$SUSPENDED $TIME $DATE'
# Listing domains
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$DOMAIN $IP $TPL $EXP $DATE';
shell_list| column -t ;;
*) check_args '1' '0' 'USER [FORMAT]';;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

122
bin/v-list-dns-records
View file

@ -17,56 +17,67 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json func
json_list_dns() {
echo '{'
fileds_count=$(echo $fields| wc -w )
while read line; do
IFS=$'\n'
eval $line
if [ -n "$data" ]; then
echo -e ' },'
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep ID $USER_DATA/dns/$domain.conf |wc -l)
echo "{"
while read str; do
eval $str
VALUE=$(echo "$VALUE" |sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
echo -n ' "'$ID'": {
"RECORD": "'$RECORD'",
"TYPE": "'$TYPE'",
"PRIORITY": "'$PRIORITY'",
"VALUE": "'$VALUE'",
"ID": "'$ID'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
i=1
IFS=' '
for field in $fields; do
eval value=\"$field\"
value=$(echo "$value" | sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
data=1
fi
fi
done
done < $conf
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
((i++))
done < <(cat $USER_DATA/dns/$domain.conf)
echo '}'
}
# Shell function
shell_list_dns() {
# SHELL list function
shell_list() {
IFS=$'\n'
echo "ID^RECORD^TYPE^VALUE^DATE"
echo "--^------^----^-----^----"
while read str; do
eval $str
echo "$ID^$RECORD^$TYPE^${VALUE:0:30}^$DATE"
done < <(cat $USER_DATA/dns/$domain.conf)
}
if [ -z "$nohead" ] ; then
echo "${fields//$/}"
for a in $fields; do
echo -e "------ \c"
done
echo
fi
while read line ; do
IFS=$'\n'
eval $line
eval echo "$fields" | sed "s/%quote%/'/g"
done < $conf
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
VALUE=$(echo "$VALUE" |sed -e "s/%quote%/\\'/g")
echo -ne "$ID\t$RECORD\t$TYPE\t$PRIORITY\t$VALUE\t"
echo -e "$SUSPENDED\t$TIME\t$DATE"
done < <(cat $USER_DATA/dns/$domain.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "ID,RECORD,TYPE,PRIORITY,VALUE,SUSPENDED,TIME,DATE"
while read str; do
eval $str
VALUE=$(echo "$VALUE" |sed -e "s/%quote%/\\'/g")
echo -n "$ID,$RECORD,$TYPE,$PRIORITY,\"$VALUE\","
echo "$SUSPENDED,$TIME,$DATE"
done < <(cat $USER_DATA/dns/$domain.conf)
}
@ -75,7 +86,7 @@ shell_list_dns() {
#----------------------------------------------------------#
check_args '2' "$#" 'USER DOMAIN [FORMAT]'
validate_format 'user' 'domain'
is_format_valid 'user' 'domain'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'dns' 'DOMAIN' "$domain"
@ -84,17 +95,12 @@ is_object_valid 'dns' 'DOMAIN' "$domain"
# Action #
#----------------------------------------------------------#
# Defining config and fields
conf=$USER_DATA/dns/$domain.conf
fields='$ID $RECORD $TYPE $PRIORITY $VALUE $ID $SUSPENDED $TIME $DATE'
# Listing domains
case $format in
json) json_list_dns ;;
plain) nohead=1; shell_list_dns ;;
shell) fields='$ID $RECORD $TYPE $VALUE';
shell_list_dns | column -t ;;
*) check_args '2' '0' 'USER DOMAIN [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t -s '^';;
esac

115
bin/v-list-dns-template
View file

@ -17,55 +17,62 @@ format=${2-shell}
source $VESTA/func/main.sh
source $VESTA/func/domain.sh
# Json func
json_list_dns() {
echo '{'
fileds_count=$(echo $fields| wc -w )
while read line; do
IFS=$'\n'
eval $line
if [ -n "$data" ]; then
echo -e ' },'
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep ID $DNSTPL/$template.tpl |wc -l)
echo "{"
while read str; do
eval $str
VALUE=$(echo "$VALUE" |sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
echo -n ' "'$ID'": {
"RECORD": "'$RECORD'",
"TYPE": "'$TYPE'",
"PRIORITY": "'$PRIORITY'",
"VALUE": "'$VALUE'",
"ID": "'$ID'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
i=1
IFS=' '
for field in $fields; do
eval value=\"$field\"
value=$(echo "$value" | sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
data=1
fi
fi
done
done < $conf
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
((i++))
done < <(cat $DNSTPL/$template.tpl)
echo '}'
}
# Shell function
shell_list_dns() {
if [ -z "$nohead" ] ; then
echo "${fields//$/}"
for a in $fields; do
echo -e "------ \c"
done
echo
fi
# SHELL list function
shell_list() {
IFS=$'\n'
echo "ID^RECORD^TYPE^VALUE"
echo "--^------^----^-----"
while read str; do
eval $str
echo "$ID^$RECORD^$TYPE^$VALUE"
done < <(cat $DNSTPL/$template.tpl)
}
while read line ; do
eval $line
eval echo "$fields" | sed "s/%quote%/'/g"
done < $conf
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
VALUE=$(echo "$VALUE" |sed -e "s/%quote%/\\'/g")
echo -e "$ID\t$RECORD\t$TYPE\t$PRIORITY\t$VALUE"
done < <(cat $DNSTPL/$template.tpl)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "ID,RECORD,TYPE,PRIORITY,VALUE"
while read str; do
eval $str
VALUE=$(echo "$VALUE" |sed -e "s/%quote%/\\'/g")
echo "$ID,$RECORD,$TYPE,$PRIORITY,\"$VALUE\""
done < <(cat $DNSTPL/$template.tpl)
}
@ -74,7 +81,7 @@ shell_list_dns() {
#----------------------------------------------------------#
check_args '1' "$#" 'TEMPLATE [FORMAT]'
validate_format 'template'
is_format_valid 'template'
is_dns_template_valid
@ -82,16 +89,12 @@ is_dns_template_valid
# Action #
#----------------------------------------------------------#
# Defining config and fields
conf=$DNSTPL/$template.tpl
fields='$RECORD $TYPE $PRIORITY $VALUE'
# Listing templates
case $format in
json) json_list_dns ;;
plain) nohead=1; shell_list_dns ;;
shell) shell_list_dns | column -t ;;
*) check_args '1' '0' 'TEMPLATE [FORMAT]';;
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t -s '^';;
esac

58
bin/v-list-dns-templates
View file

@ -15,30 +15,41 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_dnstpl() {
templates=$(ls -t $DNSTPL |grep '\.tpl' |cut -f 1 -d '.')
t_counter=$(echo "$templates" | wc -w)
# JSON list function
json_list() {
objects=$(echo "$templates" |wc -l)
i=1
echo '['
echo "["
for template in $templates; do
if [ "$i" -lt "$t_counter" ]; then
echo -e "\t\"$template\","
echo -n ' "'$template'"'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo -e "\t\"$template\""
echo
fi
(( ++i))
((i++))
done
echo "]"
}
# Shell function
shell_list_dnstpl() {
templates=$(ls -t $DNSTPL |grep '\.tpl' |cut -f 1 -d '.')
if [ -z "$nohead" ]; then
echo "Templates"
echo "----------"
fi
# SHELL list function
shell_list() {
echo "TEMPLATE"
echo "--------"
ls -t $DNSTPL |grep '\.tpl' |cut -f 1 -d '.'
}
# PLAIN list function
plain_list() {
for template in $templates; do
echo "$template"
done
}
# CSV list function
csv_list() {
echo "TEMPLATE"
for template in $templates; do
echo "$template"
done
@ -49,12 +60,15 @@ shell_list_dnstpl() {
# Action #
#----------------------------------------------------------#
# Listing domains
case $format in
json) json_list_dnstpl;;
plain) nohead=1; shell_list_dnstpl ;;
shell) shell_list_dnstpl ;;
*) check_args '1' '0' '[FORMAT] [LIMIT] [OFFSET]';;
# Defining template list
templates=$(ls -t $DNSTPL |grep '\.tpl' |cut -f 1 -d '.')
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list;;
esac

78
bin/v-list-firewall
View file

@ -15,25 +15,77 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep RULE $VESTA/data/firewall/rules.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$RULE'": {
"ACTION": "'$ACTION'",
"PROTOCOL": "'$PROTOCOL'",
"PORT": "'$PORT'",
"IP": "'$IP'",
"COMMENT": "'$COMMENT'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $VESTA/data/firewall/rules.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "RULE^ACTION^PROTO^PORT^IP^SPND^DATE"
echo "----^------^-----^----^--^----^----"
while read str; do
eval $str
echo "$RULE^$ACTION^$PROTOCOL^$PORT^$IP^$SUSPENDED^$DATE"
done < <(cat $VESTA/data/firewall/rules.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$RULE\t$ACTION\t$PROTOCOL\t$PORT\t$IP\t$COMMENT\t"
echo -e "$SUSPENDED\t$TIME\t$DATE"
done < <(cat $VESTA/data/firewall/rules.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "RULE,ACTION,PROTOCOL,PORT,IP,COMMENT,SUSPENDED,TIME,DATE"
while read str; do
eval $str
echo -n "$RULE,$ACTION,$PROTOCOL,$PORT,$IP,\"$COMMENT\","
echo "$SUSPENDED,$TIME,$DATE"
done < <(cat $VESTA/data/firewall/rules.conf)
}
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Defining config
conf=$VESTA/data/firewall/rules.conf
# Defining fileds to select
fields="\$RULE \$ACTION \$PROTOCOL \$PORT \$IP \$COMMENT"
fields="$fields \$RULE \$SUSPENDED \$TIME \$DATE"
# Listing domains
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields="\$ACTION \$PROTOCOL \$PORT \$IP";
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t -s '^' ;;
esac

69
bin/v-list-firewall-ban
View file

@ -15,24 +15,71 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep IP $VESTA/data/firewall/banlist.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$IP'": {
"IP": "'$IP'",
"CHAIN": "'$COMMENT'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $VESTA/data/firewall/banlist.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "IP CHAIN TIME DATE"
echo "-- ----- ---- ----"
while read str; do
eval $str
echo "$IP $CHAIN $TIME $DATE"
done < <(cat $VESTA/data/firewall/banlist.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -e "$IP\t$CHAIN\t$TIME\t$DATE"
done < <(cat $VESTA/data/firewall/banlist.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "IP,CHAIN,TIME,DATE"
while read str; do
eval $str
echo "$IP,$CHAIN,$TIME,$DATE"
done < <(cat $VESTA/data/firewall/banlist.conf)
}
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Defining config
conf=$VESTA/data/firewall/banlist.conf
# Defining fileds to select
fields="\$IP:\$CHAIN \$TIME \$DATE"
# Listing domains
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$IP $CHAIN $TIME $DATE';
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

87
bin/v-list-firewall-rule
View file

@ -16,43 +16,43 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_fw_rule() {
i=1
fileds_count=$(echo "$fields" | wc -w)
line=$(grep "RULE='$rule'" $conf)
json_list() {
echo '{'
eval $line
for field in $fields; do
eval value=$field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fileds_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"$value\""
else
echo -e "\t\t\"${field//$/}\": \"$value\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e "}"
echo ' "'$RULE'": {
"ACTION": "'$ACTION'",
"PROTOCOL": "'$PROTOCOL'",
"PORT": "'$PORT'",
"IP": "'$IP'",
"COMMENT": "'$COMMENT'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_fw_rule() {
line=$(grep "RULE='$rule'" $conf)
eval $line
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key=NULL
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "ACTION: $ACTION"
echo "PROTOCOL: $PROTOCOL"
echo "PORT: $PORT"
echo "IP: $IP"
echo "COMMENT: $COMMENT"
echo "SUSPENDED: $SUSPENDED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$RULE\t$ACTION\t$PROTOCOL\t$PORT\t$IP\t$COMMENT\t"
echo -e "$SUSPENDED\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo "RULE,ACTION,PROTOCOL,PORT,IP,COMMENT,SUSPENDED,TIME,DATE"
echo "$RULE,$ACTION,$PROTOCOL,$PORT,$IP,$COMMENT,$SUSPENDED,$TIME,$DATE"
}
@ -61,6 +61,7 @@ shell_list_fw_rule() {
#----------------------------------------------------------#
check_args '1' "$#" 'RULE [FORMAT]'
is_number_format_valid "$rule" "rule id"
is_object_valid '../../data/firewall/rules' 'RULE' "$rule"
@ -68,17 +69,15 @@ is_object_valid '../../data/firewall/rules' 'RULE' "$rule"
# Action #
#----------------------------------------------------------#
# Defining config and fields to select
conf=$VESTA/data/firewall/rules.conf
fields="\$RULE \$ACTION \$PROTOCOL \$PORT \$IP \$COMMENT"
fields="$fields \$RULE \$SUSPENDED \$TIME \$DATE"
# Parsing rules
eval $(grep "RULE='$rule'" $VESTA/data/firewall/rules.conf)
# Listing fw rule
case $format in
json) json_list_fw_rule ;;
plain) nohead=1; shell_list_fw_rule ;;
shell) shell_list_fw_rule |column -t ;;
*) check_args '2' '0' 'RULE [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

93
bin/v-list-mail-account
View file

@ -18,43 +18,49 @@ format=${4-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_account() {
i=1
fileds_count=$(echo "$fields" | wc -w)
line=$(grep "ACCOUNT='$account'" $conf)
# JSON list function
json_list() {
echo '{'
eval $line
for field in $fields; do
eval value=$field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fileds_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"$value\""
else
echo -e "\t\t\"${field//$/}\": \"$value\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e "}"
echo ' "'$account'": {
"ALIAS": "'$ALIAS'",
"FWD": "'$FWD'",
"FWD_ONLY": "'$FWD_ONLY'",
"AUTOREPLY": "'$AUTOREPLY'",
"QUOTA": "'$QUOTA'",
"U_DISK": "'$U_DISK'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_account() {
line=$(grep "ACCOUNT='$account'" $conf)
eval $line
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key=NULL
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "ACCOUNT: $account"
echo "ALIAS: $ALIAS"
echo "FORWARD: $FWD"
echo "FORWARD_ONLY: $FWD_ONLY"
echo "AUTOREPLY: $AUTOREPLY"
echo "QUOTA: $QUOTA"
echo "DISK: $U_DISK"
echo "SUSPENDED: $SUSPENDED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$account\t$ALIAS\t$FWD\t$FWD_ONLY\t$AUTOREPLY\t$QUOTA\t"
echo -e "$U_DISK\t$SUSPENDED\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo -n "ACCOUNT,ALIAS,FWD,FWD_ONLY,AUTOREPLY,QUOTA,U_DISK"
echo "SUSPENDED,TIME,DATE"
echo -n "$ACCOUNT,\"$ALIAS\",\"$FWD\",$FWD_ONLY,$AUTOREPLY,$QUOTA,"
echo "$U_DISK,$SUSPENDED,$TIME,$DATE"
}
@ -63,6 +69,7 @@ shell_list_account() {
#----------------------------------------------------------#
check_args '3' "$#" 'USER DOMAIN ACCOUNT [FORMAT]'
is_format_valid 'user' 'domain' 'account'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'mail' 'DOMAIN' "$domain"
is_object_valid "mail/$domain" 'ACCOUNT' "$account"
@ -73,17 +80,15 @@ is_object_valid "mail/$domain" 'ACCOUNT' "$account"
# Action #
#----------------------------------------------------------#
# Defining config and fields to select
conf=$USER_DATA/mail/$domain.conf
fields="\$ACCOUNT \$ALIAS \$FWD \$FWD_ONLY \$QUOTA \$AUTOREPLY \$U_DISK"
fields="$fields \$SUSPENDED \$TIME \$DATE"
# Parsing mail account
eval $(grep "ACCOUNT='$account'" $USER_DATA/mail/$domain.conf)
# Listing domains
case $format in
json) json_list_account ;;
plain) nohead=1; shell_list_account ;;
shell) shell_list_account |column -t ;;
*) check_args '2' '0' 'USER DOMAIN ACCOUNT [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

36
bin/v-list-mail-account-autoreply
View file

@ -18,8 +18,8 @@ format=${4-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_msg() {
# JSON list function
json_list() {
i='1' # iterator
echo '{'
echo -e "\t\"$account\": {"
@ -27,11 +27,20 @@ json_list_msg() {
echo -e "\t}\n}"
}
# Shell function
shell_list_msg() {
if [ ! -z "$msg" ]; then
echo -e "$msg"
fi
# SHELL list function
shell_list() {
echo "$msg"
}
# PLAIN list function
plain_list() {
echo "$msg"
}
# CSV list function
csv_list() {
echo "MSG"
echo "$msg"
}
@ -39,7 +48,8 @@ shell_list_msg() {
# Verifications #
#----------------------------------------------------------#
check_args '2' "$#" 'USER DOMAIN [FORMAT]'
check_args '3' "$#" 'USER DOMAIN ACCOUNT [FORMAT]'
is_format_valid 'user' 'domain' 'account'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'mail' 'DOMAIN' "$domain"
is_object_unsuspended 'mail' 'DOMAIN' "$domain"
@ -56,12 +66,12 @@ if [ -e "$USER_DATA/mail/$account@$domain.msg" ]; then
sed ':a;N;$!ba;s/\n/\\n/g' )
fi
# Listing domains
# Listing data
case $format in
json) json_list_msg ;;
plain) nohead=1; shell_list_msg ;;
shell) shell_list_msg ;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

97
bin/v-list-mail-accounts
View file

@ -17,13 +17,90 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep ACCOUNT $USER_DATA/mail/$domain.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$ACCOUNT'": {
"ALIAS": "'$ALIAS'",
"FWD": "'$FWD'",
"FWD_ONLY": "'$FWD_ONLY'",
"AUTOREPLY": "'$AUTOREPLY'",
"QUOTA": "'$QUOTA'",
"U_DISK": "'$U_DISK'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $USER_DATA/mail/$domain.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "ACCOUNT ALIAS FWD DISK DATE"
echo "------- ----- --- ---- ----"
while read str; do
eval $str
if [ -z "$ALIAS" ]; then
ALIAS='no'
else
if [ "${#ALIAS}" -gt 12 ]; then
ALIAS="${ALIAS:0:12}..."
fi
fi
if [ -z "$FWD" ]; then
FWD='no'
else
if [ "${#FWD}" -gt 20 ]; then
FWD="${FWD:0:20}..."
fi
fi
echo "$ACCOUNT $ALIAS $FWD $U_DISK $DATE"
done < <(cat $USER_DATA/mail/$domain.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$ACCOUNT\t$ALIAS\t$FWD\t$FWD_ONLY\t$AUTOREPLY\t"
echo -e "$QUOTA\t$U_DISK\t$SUSPENDED\t$TIME\t$DATE"
done < <(cat $USER_DATA/mail/$domain.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo -n "ACCOUNT,ALIAS,FWD,FWD_ONLY,AUTOREPLY,QUOTA,U_DISK,"
echo "SUSPENDED,TIME,DATE"
while read str; do
eval $str
echo -n "$ACCOUNT,\"$ALIAS\",\"$FWD\",$FWD_ONLY,$AUTOREPLY,"
echo "$QUOTA,$U_DISK,$SUSPENDED,$TIME,$DATE"
done < <(cat $USER_DATA/mail/$domain.conf)
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '2' "$#" 'USER DOMAIN [FORMAT]'
validate_format 'user' 'domain'
is_format_valid 'user' 'domain'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'mail' 'DOMAIN' "$domain"
@ -32,18 +109,12 @@ is_object_valid 'mail' 'DOMAIN' "$domain"
# Action #
#----------------------------------------------------------#
# Defining fileds to select
conf=$USER_DATA/mail/$domain.conf
fields="\$ACCOUNT \$ALIAS \$FWD \$FWD_ONLY \$QUOTA \$AUTOREPLY \$U_DISK"
fields="$fields \$SUSPENDED \$TIME \$DATE"
# Listing domain accounts
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$ACCOUNT $AUTOREPLY $QUOTA $U_DISK $SUSPENDED $TIME $DATE';
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

97
bin/v-list-mail-domain
View file

@ -1,9 +1,8 @@
#!/bin/bash
# info: list web domain
# info: list mail domain
# options: USER DOMAIN [FORMAT]
#
# The function of obtaining the list of domain parameters. This call, just as
# all v_list_* calls, supports 3 formats - json, shell and plain.
# The function of obtaining the list of domain parameters.
#----------------------------------------------------------#
@ -18,41 +17,50 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_domain() {
i=1
fileds_count=$(echo "$fields" | wc -w)
line=$(grep "DOMAIN='$domain'" $conf)
# JSON list function
json_list() {
eval $(grep "DOMAIN='$domain'" $USER_DATA/mail.conf)
echo '{'
eval $line
for field in $fields; do
eval value=$field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fileds_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"$value\""
else
echo -e "\t\t\"${field//$/}\": \"$value\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e "}"
echo ' "'$DOMAIN'": {
"ANTIVIRUS": "'$ANTIVIRUS'",
"ANTISPAM": "'$ANTISPAM'",
"DKIM": "'$DKIM'",
"CATCHALL": "'$CATCHALL'",
"ACCOUNTS": "'$ACCOUNTS'",
"U_DISKL": "'$U_DISK'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_domain() {
line=$(grep "DOMAIN='$domain'" $conf)
eval $line
for field in $fields; do
eval key="$field"
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "DOMAIN: $DOMAIN"
echo "ANTIVIRUS: $ANTIVIRUS"
echo "ANTISPAM: $ANTISPAM"
echo "DKIM: $DKIM"
echo "CATCHALL: $CATCHALL"
echo "ACCOUNTS: $ACCOUNTS"
echo "DISK: $U_DISK"
echo "SUSPENDED: $SUSPENDED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$DOMAIN\t$ANTIVIRUS\t$ANTISPAM\t$DKIM\t$CATCHALL\t"
echo -e "$ACCOUNTS\t$U_DISK\t$SUSPENDED\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo -n "DOMAIN,ANTIVIRUS,ANTISPAM,DKIM,CATCHALL,ACCOUNTS,U_DISK,"
echo "SUSPENDED,TIME,DATE"
echo -n "$DOMAIN,$ANTIVIRUS,$ANTISPAM,$DKIM,$CATCHALL,$ACCOUNTS,$U_DISK"
echo "$SUSPENDED,$TIME,$DATE"
}
@ -61,6 +69,7 @@ shell_list_domain() {
#----------------------------------------------------------#
check_args '2' "$#" 'USER DOMAIN [FORMAT]'
is_format_valid 'user' 'domain'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'mail' 'DOMAIN' "$domain"
@ -69,17 +78,15 @@ is_object_valid 'mail' 'DOMAIN' "$domain"
# Action #
#----------------------------------------------------------#
# Defining fileds to select
conf=$USER_DATA/mail.conf
fields='$DOMAIN $ANTIVIRUS $ANTISPAM $DKIM $ACCOUNTS $U_DISK $CATCHALL
$SUSPENDED $TIME $DATE'
# Parsing mail domain
eval $(grep "DOMAIN='$domain'" $USER_DATA/mail.conf)
# Listing domains
case $format in
json) json_list_domain ;;
plain) nohead=1; shell_list_domain ;;
shell) shell_list_domain |column -t ;;
*) check_args '2' '0' 'USER DOMAIN [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

44
bin/v-list-mail-domain-dkim
View file

@ -17,8 +17,8 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_ssl() {
# JSON list function
json_list() {
echo '{'
echo -e "\t\"$domain\": {"
echo " \"PEM\": \"$pem\","
@ -26,14 +26,21 @@ json_list_ssl() {
echo -e "\t}\n}"
}
# Shell function
shell_list_ssl() {
if [ ! -z "$pem" ]; then
echo -e "$pem"
fi
if [ ! -z "$pub" ]; then
echo -e "\n$pub"
fi
# SHELL list function
shell_list() {
echo -e "$pem"
echo -e "\n$pub"
}
# PLAIN list function
plain_list() {
echo "$pem\t$pub"
}
# CSV list function
csv_list() {
echo "PEM,PUB"
echo "\"$pem\",\"$pub\""
}
@ -42,6 +49,7 @@ shell_list_ssl() {
#----------------------------------------------------------#
check_args '2' "$#" 'USER DOMAIN [FORMAT]'
is_format_valid 'user' 'domain'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'mail' 'DOMAIN' "$domain"
@ -49,20 +57,22 @@ is_object_valid 'mail' 'DOMAIN' "$domain"
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Parsing domain keys
if [ -e "$USER_DATA/mail/$domain.pem" ]; then
pem=$(cat $USER_DATA/mail/$domain.pem | sed ':a;N;$!ba;s/\n/\\n/g')
pem=$(cat $USER_DATA/mail/$domain.pem |sed ':a;N;$!ba;s/\n/\\n/g')
fi
if [ -e "$USER_DATA/mail/$domain.pub" ]; then
pub=$(cat $USER_DATA/mail/$domain.pub | sed ':a;N;$!ba;s/\n/\\n/g')
pub=$(cat $USER_DATA/mail/$domain.pub |sed ':a;N;$!ba;s/\n/\\n/g')
fi
# Listing domains
# Listing data
case $format in
json) json_list_ssl ;;
plain) nohead=1; shell_list_ssl ;;
shell) shell_list_ssl ;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

51
bin/v-list-mail-domain-dkim-dns
View file

@ -17,24 +17,38 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_dkim_dns() {
# JSON list function
json_list() {
echo '{'
echo -e "\t\"_domainkey\": {"
echo " \"TTL\": \"3600\","
echo " \"TXT\": \"'t=y; o=~;'\""
echo " \"TTL\": \"3600\","
echo " \"TXT\": \"'t=y; o=~;'\""
echo -e "\t},"
echo -e "\n\t\"mail._domainkey\": {"
echo " \"TTL\": \"3600\","
echo " \"TXT\": \"'$pub'\""
echo " \"TTL\": \"3600\","
echo " \"TXT\": \"\\\"$pub\\\"\""
echo -e "\t}\n}"
}
# Shell function
shell_list_dkim_dns() {
echo "_domainkey 3600 IN TXT \"t=y; o=~;\""
echo "mail._domainkey 3600 IN TXT \"k=rsa; p=$pub\""
# SHELL list function
shell_list() {
echo "RECORD TTL TYPE VALUE"
echo "------ --- ---- -----"
echo "_domainkey 3600 IN TXT \"t=y; o=~;\""
echo "mail._domainkey 3600 IN TXT \"k=rsa; p=$pub\""
}
# PLAIN list function
plain_list() {
echo -e "_domainkey\t3600\tIN\tTXT\t\"t=y; o=~;\""
echo -e "mail._domainkey\t3600\tIN\tTXT\t\"k=rsa; p=$pub\""
}
# CSV list function
csv_list() {
echo "RECORD,TTL,IN,TYPE,VALUE"
echo "_domainkey,3600,IN,TXT,\"\"t=y; o=~;\"\""
echo "mail._domainkey,3600,IN,TXT,\"\"k=rsa; p=$pub\"\""
}
@ -51,19 +65,20 @@ is_object_valid 'mail' 'DOMAIN' "$domain"
# Action #
#----------------------------------------------------------#
# Check pub key
# Parsing domain keys
if [ -e "$USER_DATA/mail/$domain.pub" ]; then
pub=$(cat $USER_DATA/mail/$domain.pub | sed ':a;N;$!ba;s/\n/\\n/g')
pub=$(cat $USER_DATA/mail/$domain.pub |grep -v "KEY-----")
pub=$(echo "$pub" |sed ':a;N;$!ba;s/\n/\\n/g')
else
pub="DKIM-SUPPORT-IS-NOT-ACTIVATED"
fi
# Listing domains
# Listing data
case $format in
json) json_list_dkim_dns ;;
plain) shell_list_dkim_dns ;;
shell) shell_list_dkim_dns ;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t -s '^';;
esac

82
bin/v-list-mail-domains
View file

@ -16,13 +16,77 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep DOMAIN $USER_DATA/mail.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$DOMAIN'": {
"ANTIVIRUS": "'$ANTIVIRUS'",
"ANTISPAM": "'$ANTISPAM'",
"DKIM": "'$DKIM'",
"CATCHALL": "'$CATCHALL'",
"ACCOUNTS": "'$ACCOUNTS'",
"U_DISKL": "'$U_DISK'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $USER_DATA/mail.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "DOMAIN ANTIVIRUS ANTISPAM DKIM ACC DISK SPND DATE"
echo "------ --------- -------- ---- --- ---- --- ----"
while read str; do
eval $str
echo -n "$DOMAIN $ANTIVIRUS $ANTISPAM $DKIM $ACCOUNTS $U_DISK "
echo "$SUSPENDED $DATE"
done < <(cat $USER_DATA/mail.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$DOMAIN\t$ANTIVIRUS\t$ANTISPAM\t$DKIM\t$CATCHALL\t"
echo -e "$ACCOUNTS\t$U_DISK\t$SUSPENDED\t$TIME\t$DATE"
done < <(cat $USER_DATA/mail.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo -n "DOMAIN,ANTIVIRUS,ANTISPAM,DKIM,CATCHALL,ACCOUNTS,U_DISK,"
echo "SUSPENDED,TIME,DATE"
while read str; do
eval $str
echo -n "$DOMAIN,$ANTIVIRUS,$ANTISPAM,$DKIM,$CATCHALL,$ACCOUNTS,"
echo "'$U_DISK,$SUSPENDED,$TIME,$DATE"
echo
done < <(cat $USER_DATA/mail.conf)
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -30,18 +94,12 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Defining fileds to select
conf=$USER_DATA/mail.conf
fields="\$DOMAIN \$ANTIVIRUS \$ANTISPAM \$DKIM \$ACCOUNTS \$U_DISK \$CATCHALL"
fields="$fields \$SUSPENDED \$TIME \$DATE"
# Listing domains
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$DOMAIN $ANTIVIRUS $ANTISPAM $DKIM $ACCOUNTS $U_DISK $DATE';
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

78
bin/v-list-remote-dns-hosts
View file

@ -15,30 +15,84 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep HOST $VESTA/conf/dns-cluster.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$HOST'": {
"PORT": "'$PORT'",
"TYPE": "'$TYPE'",
"USER": "'$USER'",
"DNS_USER": "'$DNS_USER'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $VESTA/conf/dns-cluster.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "HOST PORT TYPE USER DNS_USER SPND DATE"
echo "---- ---- ---- ---- -------- ---- ----"
while read str; do
eval $str
echo "$HOST $PORT $TYPE $USER $DNS_USER $SUSPENDED $DATE"
done < <(cat $VESTA/conf/dns-cluster.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$HOST\t$PORT\t$TYPE\t$USER\t$DNS_USER\t"
echo -e "$SUSPENDED\t$TIME\t$DATE"
done < <(cat $VESTA/conf/dns-cluster.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "HOST,PORT,TYPE,USER,DNS_USER,SUSPENDED,TIME,DATE"
while read str; do
eval $str
echo "$HOST,$PORT,$TYPE,$USER,$DNS_USER,$SUSPENDED,$TIME,$DATE"
done < <(cat $VESTA/conf/dns-cluster.conf)
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
if [ ! -e "$VESTA/conf/dns-cluster.conf" ]; then
exit
fi
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Check config
conf=$VESTA/conf/dns-cluster.conf
if [ ! -e "$conf" ]; then
exit
fi
# Defining fileds to select
fields='$HOST $USER $DNS_USER $SUSPENDED $TIME $DATE'
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) shell_list| column -t ;;
*) check_args '1' '0' 'USER [FORMAT]';;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

197
bin/v-list-sys-config
View file

@ -1,5 +1,5 @@
#!/bin/bash
# info: list system config
# info: list system configuration
# options: [FORMAT]
#
# The function for obtaining the list of system parameters.
@ -12,33 +12,167 @@
# Argument definition
format=${1-shell}
# Json function
json_list_conf() {
lines=$(wc -l $VESTA/conf/vesta.conf | cut -f 1 -d ' ')
i='0'
IFS=$'\n'
echo -e "{\n\t\"config\": {"
for str in $(cat $VESTA/conf/vesta.conf); do
(( ++i))
key=${str%%=*}
value=${str#*=}
if [ "$i" -lt "$lines" ]; then
echo -e "\t\t\"$key\": \"${value//\'/}\","
else
echo -e "\t\t\"$key\": \"${value//\'/}\""
fi
done
echo -e "\t}\n}"
source $VESTA/conf/vesta.conf
# JSON list function
json_list() {
echo '{
"config": {
"WEB_SYSTEM": "'$WEB_SYSTEM'",
"WEB_RGROUPS": "'$WEB_RGROUPS'",
"WEB_PORT": "'$WEB_PORT'",
"WEB_SSL": "'$WEB_SSL'",
"WEB_SSL_PORT": "'$WEB_SSL_PORT'",
"WEB_BACKEND": "'$WEB_BACKEND'",
"PROXY_SYSTEM": "'$PROXY_SYSTEM'",
"PROXY_PORT": "'$PROXY_PORT'",
"PROXY_SSL_PORT": "'$PROXY_SSL_PORT'",
"FTP_SYSTEM": "'$FTP_SYSTEM'",
"MAIL_SYSTEM": "'$MAIL_SYSTEM'",
"IMAP_SYSTEM": "'$IMAP_SYSTEM'",
"ANTIVIRUS_SYSTEM": "'$ANTIVIRUS_SYSTEM'",
"ANTISPAM_SYSTEM": "'$ANTISPAM_SYSTEM'",
"DB_SYSTEM": "'$DB_SYSTEM'",
"DNS_SYSTEM": "'$DNS_SYSTEM'",
"DNS_CLUSTER": "'$DNS_CLUSTER'",
"STATS_SYSTEM": "'$STATS_SYSTEM'",
"BACKUP_SYSTEM": "'$BACKUP_SYSTEM'",
"CRON_SYSTEM": "'$CRON_SYSTEM'",
"DISK_QUOTA": "'$DISK_QUOTA'",
"FIREWALL_SYSTEM": "'$FIREWALL_SYSTEM'",
"FIREWALL_EXTENSION": "'$FIREWALL_EXTENSION'",
"FILEMANAGER_KEY": "'$FILEMANAGER_KEY'",
"SFTPJAIL_KEY": "'$SFTPJAIL_KEY'",
"REPOSITORY": "'$REPOSITORY'",
"VERSION": "'$VERSION'",
"LANGUAGE": "'$LANGUAGE'",
"BACKUP_GZIP": "'$BACKUP_GZIP'",
"BACKUP": "'$BACKUP'",
"MAIL_URL": "'$MAIL_URL'",
"DB_PMA_URL": "'$DB_PMA_URL'",
"DB_PGA_URL": "'$DB_PGA_URL'"
}
}'
}
# Shell function
shell_list_conf() {
IFS=$'\n'
for str in $(cat $VESTA/conf/vesta.conf); do
key=${str%%=*}
value=${str#*=}
echo "$key: ${value//\'/}"
done
# Shell list
shell_list() {
if [ ! -z "$WEB_SYSTEM" ]; then
echo "WEB Server: $WEB_SYSTEM:$WEB_PORT ($WEB_RGROUPS)"
echo "SSL Support: $WEB_SSL:$WEB_SSL_PORT"
fi
if [ ! -z "$WEB_BACKEND" ]; then
echo "WEB Backend: $WEB_BACKEND"
fi
if [ ! -z "$PROXY_SYSTEM" ]; then
echo "Proxy Server: $PROXY_SYSTEM:$PROXY_PORT"
echo "Proxy SSL: $PROXY_SYSTEM:$PROXY_SSL_PORT"
fi
if [ ! -z "$STATS_SYSTEM" ]; then
echo "Web Stats: ${STATS_SYSTEM//,/, }"
fi
if [ ! -z "$FTP_SYSTEM" ]; then
echo "FTP Server: $FTP_SYSTEM"
fi
if [ ! -z "$MAIL_SYSTEM" ]; then
echo -n "Mail Server: $MAIL_SYSTEM"
if [ ! -z "$IMAP_SYSTEM" ]; then
echo -n " + $IMAP_SYSTEM"
fi
if [ ! -z "$ANTIVIRUS_SYSTEM" ]; then
echo -n " + $ANTIVIRUS_SYSTEM"
fi
if [ ! -z "$ANTISPAM_SYSTEM" ]; then
echo -n " + $ANTISPAM_SYSTEM"
fi
echo
if [ ! -z "$MAIL_URL" ]; then
echo "Web Mail: hostname + $MAIL_URL"
fi
fi
if [ ! -z "$DB_SYSTEM" ]; then
echo "Database: ${DB_SYSTEM//,/, }"
if [ ! -z "$DB_PMA_URL" ]; then
echo "PMA URL: $DB_PMA_URL"
fi
if [ ! -z "$DB_PGA_URL" ]; then
echo "PGA URL: $DB_PGA_URL"
fi
fi
if [ ! -z "$DNS_SYSTEM" ]; then
echo -n "DNS server: $DNS_SYSTEM"
if [ ! -z "$DNS_CLUSTER" ]; then
echo -n " (cluster)"
fi
echo
fi
if [ ! -z "$CRON_SYSTEM" ]; then
echo "CRON: $CRON_SYSTEM"
fi
if [ ! -z "$FIREWALL_SYSTEM" ]; then
echo -n "Firewall: $FIREWALL_SYSTEM"
if [ ! -z "$FIREWALL_EXTENSION" ]; then
echo -n "+ $FIREWALL_EXTENSION"
fi
echo
fi
if [ ! -z "$BACKUP_SYSTEM" ]; then
echo "Backups: ${BACKUP_SYSTEM//,/, }"
if [ ! -z "$BACKUP" ]; then
echo "Backup Dir: $BACKUP"
fi
fi
if [ ! -z "$DISK_QUOTA" ]; then
echo "Disk Quota: $DISK_QUOTA"
fi
if [ ! -z "$FILEMANAGER_KEY" ]; then
echo "FileManager: $FILEMANAGER_KEY"
fi
if [ ! -z "$SFTPJAIL_KEY" ]; then
echo "SFTP Chroot: $SFTPJAIL_KEY"
fi
if [ ! -z "$LANGUAGE" ] && [ "$LANGUAGE" != 'en' ]; then
echo "Language: $LANGUAGE"
fi
echo "Version: $VERSION"
}
# PLAIN list function
plain_list() {
echo -ne "$WEB_SYSTEM\t$WEB_RGROUPS\t$WEB_PORT\t$WEB_SSL\t"
echo -ne "$WEB_SSL_PORT\t$WEB_BACKEND\t$PROXY_SYSTEM\t$PROXY_PORT\t"
echo -ne "$PROXY_SSL_PORT\t$FTP_SYSTEM\t$MAIL_SYSTEM\t$IMAP_SYSTEM\t"
echo -ne "$ANTIVIRUS_SYSTEM\t$ANTISPAM_SYSTEM\t$DB_SYSTEM\t"
echo -ne "$DNS_SYSTEM\t$DNS_CLUSTER\t$STATS_SYSTEM\t$BACKUP_SYSTEM\t"
echo -ne "$CRON_SYSTEM\t$DISK_QUOTA\t$FIREWALL_SYSTEM\t"
echo -ne "$FIREWALL_EXTENSION\t$FILEMANAGER_KEY\t$SFTPJAIL_KEY\t"
echo -ne "$REPOSITORY\t$VERSION\t$LANGUAGE\t$BACKUP_GZIP\t$BACKUP\t"
echo -e "$MAIL_URL\t$DB_PMA_URL\t$DB_PGA_URL"
}
# CSV list
csv_list() {
echo -n "'WEB_SYSTEM','WEB_RGROUPS','WEB_PORT','WEB_SSL',"
echo -n "'WEB_SSL_PORT','WEB_BACKEND','PROXY_SYSTEM','PROXY_PORT',"
echo -n "'PROXY_SSL_PORT','FTP_SYSTEM','MAIL_SYSTEM','IMAP_SYSTEM',"
echo -n "'ANTIVIRUS_SYSTEM','ANTISPAM_SYSTEM','DB_SYSTEM',"
echo -n "'DNS_SYSTEM','DNS_CLUSTER','STATS_SYSTEM','BACKUP_SYSTEM',"
echo -n "'CRON_SYSTEM','DISK_QUOTA','FIREWALL_SYSTEM',"
echo -n "'FIREWALL_EXTENSION','FILEMANAGER_KEY','SFTPJAIL_KEY',"
echo -n "'REPOSITORY','VERSION','LANGUAGE','BACKUP_GZIP','BACKUP',"
echo -n "'MAIL_URL','DB_PMA_URL','DB_PGA_URL'"
echo
echo -n "'$WEB_SYSTEM','$WEB_RGROUPS','$WEB_PORT','$WEB_SSL',"
echo -n "'$WEB_SSL_PORT','$WEB_BACKEND','$PROXY_SYSTEM','$PROXY_PORT',"
echo -n "'$PROXY_SSL_PORT','$FTP_SYSTEM','$MAIL_SYSTEM','$IMAP_SYSTEM',"
echo -n "'$ANTIVIRUS_SYSTEM','$ANTISPAM_SYSTEM','$DB_SYSTEM',"
echo -n "'$DNS_SYSTEM','$DNS_CLUSTER','$STATS_SYSTEM','$BACKUP_SYSTEM',"
echo -n "'$CRON_SYSTEM','$DISK_QUOTA','$FIREWALL_SYSTEM',"
echo -n "'$FIREWALL_EXTENSION','$FILEMANAGER_KEY','$SFTPJAIL_KEY',"
echo -n "'$REPOSITORY','$VERSION','$LANGUAGE','$BACKUP_GZIP','$BACKUP',"
echo -n "'$MAIL_URL','$DB_PMA_URL','$DB_PGA_URL'"
echo
}
@ -46,11 +180,12 @@ shell_list_conf() {
# Action #
#----------------------------------------------------------#
# Listing system config
case $format in
json) json_list_conf ;;
plain) shell_list_conf ;;
shell) shell_list_conf | column -t ;;
# Listing data
case $format in
json) json_list ;;
plain) shell_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

2
bin/v-list-sys-db-status
View file

@ -65,7 +65,7 @@ for db in $(echo $DB_SYSTEM| tr ',' '\n'); do
fi
# Checking PostgreSQL
if [ "$db" = 'pgsql' ]; then
if [ "$db" = 'pgsql' ] && [ ! -z "$(which psql)" ]; then
echo "PostgreSQL $HOST status"
export PGPASSWORD="$PASSWORD"
psql -h $HOST -U $USER -c "SELECT * FROM pg_stat_activity"

63
bin/v-list-sys-info
View file

@ -15,6 +15,38 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
echo '{'
echo ' "sysinfo": {
"HOSTNAME": "'$HOSTNAME'",
"OS": "'$OS'",
"VERSION": "'$VERSION'",
"ARCH": "'$ARCH'",
"UPTIME": "'$UPTIME'",
"LOADAVERAGE": "'$LOADAVERAGE'"
}'
echo '}'
}
# SHELL list function
shell_list() {
echo "HOSTNAME OS VER ARCH UPTIME LA"
echo "-------- -- --- ---- ------ --"
echo "$HOSTNAME $OS $VERSION $ARCH $UPTIME $LOADAVERAGE"
}
# PLAIN list function
plain_list() {
echo -e "$HOSTNAME\t$OS\t$VERSION\t$ARCH\t$UPTIME\t$LOADAVERAGE"
}
# CSV list function
csv_list() {
echo "HOSTNAME,OS,VERSION,ARCH,UPTIME,LOADAVERAGE"
echo "$HOSTNAME,$OS,$VERSION,$ARCH,$UPTIME,$LOADAVERAGE"
}
#----------------------------------------------------------#
# Action #
@ -30,13 +62,13 @@ if [ -e '/etc/redhat-release' ]; then
else
OS="RHEL"
fi
VERSION=$(cat /etc/redhat-release | tr ' ' '\n' |grep [0-9])
VERSION=$(cat /etc/redhat-release| tr ' ' '\n' |grep [0-9])
else
if [ "$(lsb_release -si)" == "Ubuntu" ] && [ -e '/etc/debian_version' ]; then
OS="Ubuntu"
VERSION=$(grep DISTRIB_RELEASE /etc/lsb-release| cut -f 2 -d '=')
else
distro=$(head -n1 /etc/issue | cut -f 1 -d ' ')
distro=$(head -n1 /etc/issue |cut -f 1 -d ' ')
if [ "$distro" = 'Debian' ]; then
OS="Debian"
VERSION=$(cat /etc/debian_version)
@ -52,36 +84,19 @@ ARCH=$(arch)
# Check uptime
UPTIME=$(cat /proc/uptime |cut -f 1 -d ' '|cut -f 1 -d .)
UPTIME="$(echo $UPTIME / 60 | bc)"
UPTIME="$(echo $UPTIME / 60 |bc)"
# Check LoadAverage
LOADAVERAGE=$(cat /proc/loadavg |cut -f 1 -d ' ')
# Create tmp file
tmp_file=$(mktemp)
# Define key/value pairs
str="SYS='sysinfo' HOSTNAME='$HOSTNAME' OS='$OS' VERSION='$VERSION'"
str="$str ARCH='$ARCH' UPTIME='$UPTIME' LOADAVERAGE='$LOADAVERAGE'"
# Defining config
echo -e "$str" > $tmp_file
conf=$tmp_file
# Defining fileds to select
fields="\$SYS \$HOSTNAME \$OS \$VERSION \$ARCH \$UPTIME \$LOADAVERAGE"
# Listing services
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields="\$HOSTNAME \$OS \$VERSION \$ARCH \$UPTIME \$LOADAVERAGE"
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac
rm -f $tmp_file
#----------------------------------------------------------#
# Vesta #
#----------------------------------------------------------#

63
bin/v-list-sys-interfaces
View file

@ -15,31 +15,43 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_iface() {
dev=$(cat /proc/net/dev |grep : |cut -f 1 -d : |tr -d ' ' |grep -v lo)
int_counter=$(echo "$dev" | wc -l)
# JSON list function
json_list() {
objects=$(echo "$interfaces" |wc -l)
i=1
echo '['
for interface in $dev; do
if [ "$i" -lt "$int_counter" ]; then
echo -e "\t\"$interface\","
for interface in $interfaces; do
echo -n ' "'$interfaces'"'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo -e "\t\"$interface\""
echo
fi
(( ++i))
((i++))
done
echo "]"
echo ']'
}
# Shell function
shell_list_iface() {
dev=$(cat /proc/net/dev |grep : |cut -f 1 -d : |tr -d ' ' |grep -v lo)
if [ -z "$nohead" ]; then
echo "INTERFACES"
echo "----------"
fi
for interface in $dev; do
# SHELL list function
shell_list() {
echo "INTERFACE"
echo "---------"
for interface in $interfaces; do
echo "$interface"
done
}
# PLAIN list function
plain_list() {
for interface in $interfaces; do
echo "$interface"
done
}
# CSV list function
csv_list() {
echo "INTERFACE"
for interface in $interfaces; do
echo "$interface"
done
}
@ -49,12 +61,15 @@ shell_list_iface() {
# Action #
#----------------------------------------------------------#
# Listing domains
case $format in
json) json_list_iface ;;
plain) nohead=1; shell_list_iface ;;
shell) shell_list_iface ;;
*) check_args '1' '0' '[FORMAT]' ;;
# Defining interface list
interfaces=$(cat /proc/net/dev |grep : |cut -f 1 -d : |tr -d ' ' |grep -v lo)
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list;;
esac

103
bin/v-list-sys-ip
View file

@ -11,50 +11,57 @@
# Argument definition
ip=$1
IP=$ip
format=${2-shell}
# Includes
source $VESTA/func/main.sh
source $VESTA/func/ip.sh
# Json function
json_list_ip() {
i=1
fileds_count=$(echo "$fields" | wc -w)
ip_data=$(cat $VESTA/data/ips/$IP)
# JSON list function
json_list() {
echo '{'
eval $ip_data
for field in $fields; do
eval value=$field
if [ $i -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ $fileds_count -eq $i ]; then
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e '}'
echo ' "'$ip'": {
"OWNER": "'$OWNER'",
"STATUS": "'$STATUS'",
"NAME": "'$NAME'",
"U_SYS_USERS": "'$U_SYS_USERS'",
"U_WEB_DOMAINS": "'$U_WEB_DOMAINS'",
"INTERFACE": "'$INTERFACE'",
"NETMASK": "'$NETMASK'",
"NAT": "'$NAT'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_ip() {
line=$(cat $VESTA/data/ips/$IP)
eval $line
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key='NULL'
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "IP: $ip"
echo "NETMASK: $NETMASK"
echo "INTERFACE: $INTERFACE"
echo "NAT: $NAT"
echo "OWNER: $OWNER"
echo "STATUS: $STATUS"
echo "NAME: $NAME"
echo "USERS: $U_SYS_USERS"
echo "DOMAINS: $U_WEB_DOMAINS"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$IP\t$OWNER\t$STATUS\t$NAME\t$U_SYS_USERS\t$U_WEB_DOMAINS\t"
echo -e "$INTERFACE\t$NETMASK\t$NAT\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo -n "IP,OWNER,STATUS,NAME,U_SYS_USERS,U_WEB_DOMAINS,INTERFACE"
echo "NETMASK,NAT,TIME,DATE"
echo -n "$IP,$OWNER,$STATUS,$NAME,\"$U_SYS_USERS\",$U_WEB_DOMAINS,"
echo "$INTERFACE, $NETMASK,$NAT,$TIME,$DATE"
}
@ -62,26 +69,26 @@ shell_list_ip() {
# Verifications #
#----------------------------------------------------------#
# Checking args
check_args '1' "$#" 'IP [FORMAT]'
validate_format 'ip'
is_ip_valid
is_format_valid 'ip'
if [ ! -e "$VESTA/data/ips/$ip" ]; then
check_result $E_NOTEXIST "ip $ip doesn't exist"
fi
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
conf=$VESTA/data/ips/$IP
# Defining fileds to select
fields='$IP $OWNER $STATUS $NAME $U_SYS_USERS $U_WEB_DOMAINS $INTERFACE
$NETMASK $NAT $TIME $DATE'
# Parsing ip
source $VESTA/data/ips/$ip
# Listing ip
case $format in
json) json_list_ip ;;
plain) shell_list_ip ;;
shell) shell_list_ip | column -t ;;
*) check_args '1' '0' 'IP [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

126
bin/v-list-sys-ips
View file

@ -2,7 +2,7 @@
# info: list system ips
# options: [FORMAT]
#
# The function for obtaining the list of system ip's.
# The function for obtaining the list of system ip adresses.
#----------------------------------------------------------#
@ -15,62 +15,66 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_ips() {
# JSON list function
json_list() {
echo '{'
ip_list=$(ls --sort=time $VESTA/data/ips/)
fileds_count=$(echo "$fields" | wc -w)
for IP in $ip_list; do
ip_data=$(cat $VESTA/data/ips/$IP)
eval $ip_data
if [ -n "$data" ]; then
echo -e ' },'
ip_count=$(ls $VESTA/data/ips/ |wc -l)
i=1
while read IP; do
source $VESTA/data/ips/$IP
echo -n ' "'$IP'": {
"OWNER": "'$OWNER'",
"STATUS": "'$STATUS'",
"NAME": "'$NAME'",
"U_SYS_USERS": "'$U_SYS_USERS'",
"U_WEB_DOMAINS": "'$U_WEB_DOMAINS'",
"INTERFACE": "'$INTERFACE'",
"NETMASK": "'$NETMASK'",
"NAT": "'$NAT'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$ip_count" ]; then
echo ','
else
echo
fi
i=1
for field in $fields; do
eval value=$field
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"$value\","
else
echo -e "\t\t\"${field//$/}\": \"$value\""
data=1
fi
fi
done
done
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
((i++))
done < <(ls $VESTA/data/ips/)
echo '}'
}
# Shell function
shell_list_ips() {
ip_list=$(ls $VESTA/data/ips/)
if [ -z "$nohead" ]; then
echo "${fields//$/}"
for a in $fields; do
echo -e "--------- \c"
done
echo
fi
for IP in $ip_list; do
# SHELL list function
shell_list() {
echo "IP MASK NAT STATUS WEB DATE"
echo "-- ---- --- ------ --- ----"
while read IP; do
source $VESTA/data/ips/$IP
for field in $fields; do
eval value=$field
if [ -z "$value" ]; then
value='NULL'
fi
echo -n "$value "
done
echo
done
if [ -z "$NAT" ]; then
NAT='no'
fi
echo "$IP $NETMASK $NAT $STATUS $U_WEB_DOMAINS $DATE"
done < <(ls $VESTA/data/ips/)
}
# PLAIN list function
plain_list() {
while read IP; do
source $VESTA/data/ips/$IP
echo -ne "$IP\t$OWNER\t$STATUS\t$NAME\t$U_SYS_USERS\t$U_WEB_DOMAINS\t"
echo -e "$INTERFACE\t$NETMASK\t$NAT\t$TIME\t$DATE"
done < <(ls $VESTA/data/ips/)
}
# CSV list function
csv_list() {
echo -n "IP,OWNER,STATUS,NAME,U_SYS_USERS,U_WEB_DOMAINS,INTERFACE"
echo "NETMASK,NAT,TIME,DATE"
while read IP; do
source $VESTA/data/ips/$IP
echo -n "$IP,$OWNER,$STATUS,$NAME,\"$U_SYS_USERS\",$U_WEB_DOMAINS,"
echo "$INTERFACE, $NETMASK,$NAT,$TIME,$DATE"
done < <(ls $VESTA/data/ips/)
}
@ -78,18 +82,12 @@ shell_list_ips() {
# Action #
#----------------------------------------------------------#
# Defining fileds to select
conf=$VESTA/data/ips/*
fields="\$IP \$OWNER \$STATUS \$NAME \$U_SYS_USERS \$U_WEB_DOMAINS"
fields="$fields \$INTERFACE \$NETMASK \$NAT \$TIME \$DATE"
# Listing ip addresses
case $format in
json) json_list_ips ;;
plain) nohead=1; shell_list_ips ;;
shell) fields='$IP $NETMASK $NAT $OWNER $U_WEB_DOMAINS';
shell_list_ips | column -t ;;
*) check_args '1' '0' '[FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

47
bin/v-list-sys-languages
View file

@ -16,13 +16,13 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_lang() {
int_counter=$(echo "$languages" | wc -l)
# JSON list function
json_list() {
objects=$(echo "$languages" |wc -l)
i=1
echo '['
for lang in $languages; do
if [ "$i" -lt "$int_counter" ]; then
if [ "$i" -lt "$objects" ]; then
echo -e "\t\"$lang\","
else
echo -e "\t\"$lang\""
@ -32,12 +32,25 @@ json_list_lang() {
echo "]"
}
# Shell function
shell_list_lang() {
if [ -z "$nohead" ]; then
echo "LANGUAGES"
echo "----------"
fi
# SHELL list function
shell_list() {
echo "LANGUAGE"
echo "--------"
for lang in $languages; do
echo "$lang"
done
}
# PLAIN list function
plain_list() {
for lang in $languages; do
echo "$lang"
done
}
# CSV list function
csv_list() {
echo "LANGUAGE"
for lang in $languages; do
echo "$lang"
done
@ -48,15 +61,15 @@ shell_list_lang() {
# Action #
#----------------------------------------------------------#
# Check languages
languages=$(ls $VESTA/web/inc/i18n/|cut -f 1 -d .)
# Defining language list
languages=$(ls $VESTA/web/inc/i18n/ |cut -f 1 -d .)
# Listing domains
# Listing data
case $format in
json) json_list_lang ;;
plain) nohead=1; shell_list_lang ;;
shell) shell_list_lang ;;
*) check_args '1' '0' '[FORMAT]' ;;
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list;;
esac

81
bin/v-list-sys-rrd
View file

@ -15,10 +15,16 @@ format=${1-shell}
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# Define json function
json_list_rrd() {
# JSON list function
json_list() {
i=1
echo "{"
# Generating timestamp
time_n_date=$(date +'%T %F')
TIME=$(echo "$time_n_date" |cut -f 1 -d \ )
DATE=$(echo "$time_n_date" |cut -f 2 -d \ )
for type in $rrd_types; do
for rrd in $(ls $RRD/$type |grep rrd$ |sed "s/\.rrd$//g"); do
if [ "$i" -ne 1 ]; then
@ -61,12 +67,37 @@ json_list_rrd() {
echo "}"
}
# Define jshell function
shell_list_rrd() {
if [ -z "$nohead" ]; then
echo "PATH"
echo "---------"
fi
# SHELL list function
shell_list() {
echo "TYPE VAL_1 VAL_2 VAL_3 TIME DATE"
echo "---- ----- ----- ----- ---- ----"
for type in $rrd_types; do
for rrd in $(ls $RRD/$type |grep rrd$ |sed "s/\.rrd$//g"); do
rrd_type=$(echo "$rrd" |tr '[:lower:]' '[:upper:]')
rrd_data=$(rrdtool fetch "$RRD/$type/$rrd.rrd" AVERAGE -e 0 -s 0)
rrd_data=$(echo "$rrd_data" |tail -n 1)
rrd_timestamp=$(echo "$rrd_data" |cut -f 1 -d :)
rrd_time=$(date -d "@$rrd_timestamp" +%F)
rrd_date=$(date -d "@$rrd_timestamp" +%T)
rrd_val1=$(echo "$rrd_data" |awk '{print $2}' |cut -d. -f1)
rrd_val2=$(echo "$rrd_data" |awk '{print $3}' |cut -d. -f1)
rrd_val3=$(echo "$rrd_data" |awk '{print $4}' |cut -d. -f1)
if [ -z "$rrd_val1" ]; then
rrd_val1="-nan"
fi
if [ -z "$rrd_val2" ]; then
rrd_val2="-nan"
fi
if [ -z "$rrd_val3" ]; then
rrd_val3="-nan"
fi
echo "$rrd_type $rrd_val1 $rrd_val2 $rrd_val3 $rrd_time $rrd_date"
done
done
}
# PLAIN list function
plain_list() {
for type in $rrd_types; do
for rrd in $(ls $RRD/$type |grep rrd$ |sed "s/\.rrd$//g"); do
echo "$RRD/$type/$rrd.rrd"
@ -74,39 +105,53 @@ shell_list_rrd() {
done
}
# CSV list function
csv_list() {
for type in $rrd_types; do
echo "RRD"
for rrd in $(ls $RRD/$type |grep rrd$ |sed "s/\.rrd$//g"); do
echo "$RRD/$type/$rrd.rrd"
done
done
}
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Checking enabled systems
# Definng rrd charts
rrd_types="la mem net"
if [ -n "$WEB_SYSTEM" ] && [ "$WEB_SYSTEM" != 'no' ]; then
# Checking web system
if [ ! -z "$WEB_SYSTEM" ]; then
rrd_types="$rrd_types web"
fi
if [ -n "$MAIL_SYSTEM" ] && [ "$MAIL_SYSTEM" != 'no' ]; then
# Checking mail system
if [ ! -z "$MAIL_SYSTEM" ]; then
rrd_types="$rrd_types mail"
fi
if [ -n "$DB_SYSTEM" ] && [ "$DB_SYSTEM" != 'no' ]; then
# Checking db system
if [ ! -z "$DB_SYSTEM" ]; then
rrd_types="$rrd_types db"
fi
if [ -n "$FTP_SYSTEM" ] && [ "$FTP_SYSTEM" != 'no' ]; then
# Checking ftp system
if [ ! -z "$FTP_SYSTEM" ]; then
rrd_types="$rrd_types ftp"
fi
# Adding ssh
rrd_types="$rrd_types ssh"
# Listing domains
# Listing data
case $format in
json) json_list_rrd ;;
plain) nohead=1; shell_list_rrd ;;
shell) shell_list_rrd | column -t ;;
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

286
bin/v-list-sys-services
View file

@ -18,25 +18,80 @@ source $VESTA/conf/vesta.conf
export PATH=$PATH:/sbin
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(echo -e "$data" |grep NAME |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$NAME'": {
"SYSTEM": "'$SYSTEM'",
"STATE": "'$STATE'",
"CPU": "'$CPU'",
"MEM": "'$MEM'",
"RTIME": "'$RTIME'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(echo -e "$data" |grep NAME)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "NAME STATE CPU MEM UPTIME"
echo "---- ----- --- --- ------"
while read str; do
eval $str
echo "$NAME $STATE $CPU $MEM $RTIME"
done < <(echo -e "$data" |grep NAME)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -e "$NAME\t$SYSTEM\t$STATE\t$CPU\t$MEM\t$RTIME"
done < <(echo -e "$data" |grep NAME)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "NAME,SYSTEM,STATE,CPU,MEM,RTIME"
while read str; do
eval $str
echo "$NAME,\"$SYSTEM\",$STATE,$CPU,$MEM,$RTIME"
done < <(echo -e "$data" |grep NAME)
}
# Get service state function
get_srv_state() {
srv=$1
proc_name=${2-$1}
# Check service status
name=${2-$1}
state='running'
# Searching related pids
if [ -z $3 ]; then
pids=$(pidof $proc_name |tr ' ' '|')
pids=$(pidof $name |tr ' ' '|')
else
pids=$(pidof -x $proc_name |tr ' ' '|')
pids=$(pidof -x $name |tr ' ' '|')
fi
if [ -z "$pids" ] && [ "$proc_name" != 'nginx' ] ; then
#fallback to pgrep
pids=$(pgrep $proc_name |tr '\n' '|')
if [ -z "$pids" ] && [ "$name" != 'nginx' ]; then
pids=$(pgrep $name |tr '\n' '|')
fi
# Checking pid
if [ ! -z "$pids" ]; then
pid=$(echo $pids|cut -f 1 -d \|)
pid=$(echo "$pids" |cut -f 1 -d '|')
pids=$(egrep "$pids" $tmp_file)
# Calculating CPU usage
@ -46,25 +101,30 @@ get_srv_state() {
mem=$(echo "$pids" |awk '{sum += $3} END {print sum/1024 }')
mem=$(printf "%.0f\n" $mem)
# Searching service uptime
# Searching pid file
pid_file=''
if [ -e "/var/run/$srv.pid" ]; then
srv_file="/var/run/$srv.pid"
pid_file="/var/run/$srv.pid"
fi
if [ -z "$srv_file" ] && [ -e "/var/run/$srv/$srv.pid" ]; then
srv_file="/var/run/$srv/$srv.pid"
if [ -z "$pid_file" ] && [ -e "/var/run/$srv/$srv.pid" ]; then
pid_file="/var/run/$srv/$srv.pid"
fi
if [ -z $srv_file ] && [ -e "/proc/$pid" ]; then
srv_file="/proc/$pid"
if [ -z "$pid_file" ] && [ -e "/var/run/$name/$name.pid" ]; then
pid_file="/var/run/$name/$name.pid"
fi
if [ ! -z "$srv_file" ]; then
mtime=$(stat -c "%Y" $srv_file)
if [ -z "$pid_file" ] && [ -e "/proc/$pid" ]; then
pid_file="/proc/$pid"
fi
# Calculating uptime
if [ ! -z "$pid_file" ]; then
mtime=$(stat -c "%Y" $pid_file)
rtime=$((ctime - mtime))
rtime=$((rtime / 60))
else
rtime=0
fi
else
# Service is stopped
state='stopped'
mem=0
cpu=0
@ -77,105 +137,92 @@ get_srv_state() {
# Action #
#----------------------------------------------------------#
# Save current proccess list
# Saving current proccess list
tmp_file=$(mktemp)
ps -eo pid,pcpu,size > $tmp_file
# Get current time
# Checking current time
ctime=$(date +%s)
# Web
service=$WEB_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
if [ "$service" == 'apache' ]; then
service='httpd'
fi
get_srv_state $service
str="NAME='$service' SYSTEM='web server' STATE='$state' CPU='$cpu'"
str="$str MEM='$mem' RTIME='$rtime'"
# Checking WEB system
if [ ! -z "$WEB_SYSTEM" ] && [ "$WEB_SYSTEM" != 'remote' ]; then
get_srv_state $WEB_SYSTEM
data="NAME='$WEB_SYSTEM' SYSTEM='web server' STATE='$state' CPU='$cpu'"
data="$data MEM='$mem' RTIME='$rtime'"
fi
# Backend
service=$WEB_BACKEND
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
get_srv_state $service
str="$str\nNAME='$service' SYSTEM='backend server' STATE='$state' CPU='$cpu'"
str="$str MEM='$mem' RTIME='$rtime'"
# Checking WEB Backend
if [ ! -z "$WEB_BACKEND" ] && [ "$WEB_BACKEND" != 'remote' ]; then
get_srv_state $WEB_BACKEND
data="$data\nNAME='$WEB_BACKEND' SYSTEM='backend server' STATE='$state'"
data="$data CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# Proxy
service=$PROXY_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
get_srv_state $service
str="$str\nNAME='$service' SYSTEM='reverse proxy' STATE='$state' CPU='$cpu'"
str="$str MEM='$mem' RTIME='$rtime'"
# Checking WEB Proxy
if [ ! -z "$PROXY_SYSTEM" ] && [ "$PROXY_SYSTEM" != 'remote' ]; then
get_srv_state $PROXY_SYSTEM
data="$data\nNAME='$PROXY_SYSTEM' SYSTEM='reverse proxy' STATE='$state'"
data="$data CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# DNS
service=$DNS_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
if [ "$service" == 'bind' ] || [ "$service" == 'bind9' ]; then
# Checking DNS system
if [ ! -z "$DNS_SYSTEM" ] && [ "$DNS_SYSTEM" != 'remote' ]; then
if [ "$DNS_SYSTEM" == 'bind' ] || [ "$DNS_SYSTEM" == 'bind9' ]; then
proc_name='named'
fi
get_srv_state $service $proc_name
str="$str\nNAME='$service' SYSTEM='dns server' STATE='$state' CPU='$cpu'"
str="$str MEM='$mem' RTIME='$rtime'"
get_srv_state $DNS_SYSTEM $proc_name
data="$data\nNAME='$DNS_SYSTEM' SYSTEM='dns server' STATE='$state'"
data="$data CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# MAIL
service=$MAIL_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
get_srv_state $service
str="$str\nNAME='$service' SYSTEM='mail server' STATE='$state' CPU='$cpu'"
str="$str MEM='$mem' RTIME='$rtime'"
# Checking MAIL system
if [ ! -z "$MAIL_SYSTEM" ] && [ "$MAIL_SYSTEM" != 'remote' ]; then
get_srv_state $MAIL_SYSTEM
data="$data\nNAME='$MAIL_SYSTEM' SYSTEM='mail server' STATE='$state'"
data="$data CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# IMAP
service=$IMAP_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
get_srv_state $service
str="$str\nNAME='$service' SYSTEM='pop/imap server' STATE='$state'"
str="$str CPU='$cpu' MEM='$mem' RTIME='$rtime'"
# Checking MAIL IMAP
if [ ! -z "$IMAP_SYSTEM" ] && [ "$IMAP_SYSTEM" != 'remote' ]; then
get_srv_state $IMAP_SYSTEM
data="$data\nNAME='$IMAP_SYSTEM' SYSTEM='pop/imap server' STATE='$state'"
data="$data CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# ANTIVIRUS
service=$ANTIVIRUS_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
# Checking MAIL ANTIVIRUS
if [ ! -z "$ANTIVIRUS_SYSTEM" ] && [ "$ANTIVIRUS_SYSTEM" != 'remote' ]; then
if [ -e "/etc/redhat-release" ]; then
if [ "$ANTIVIRUS_SYSTEM" = 'clamav' ];then
service='clamd'
if [ "$ANTIVIRUS_SYSTEM" == 'clamav' ];then
ANTIVIRUS_SYSTEM='clamd'
fi
get_srv_state $service
get_srv_state $ANTIVIRUS_SYSTEM
else
if [ "$ANTIVIRUS_SYSTEM" = 'clamav-daemon' ];then
clam_proc_name='clamd'
if [ "$ANTIVIRUS_SYSTEM" == 'clamav-daemon' ];then
proc_name='clamd'
fi
get_srv_state $service $clam_proc_name
get_srv_state $ANTIVIRUS_SYSTEM $proc_name
fi
str="$str\nNAME='$service' SYSTEM='email antivirus' STATE='$state'"
str="$str CPU='$cpu' MEM='$mem' RTIME='$rtime'"
data="$data\nNAME='$ANTIVIRUS_SYSTEM' SYSTEM='email antivirus'"
data="$data STATE='$state' CPU='$cpu' MEM='$mem' RTIME='$rtime'"
proc_name=''
fi
# ANTISPAM
service=$ANTISPAM_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
get_srv_state $service spamd
str="$str\nNAME='$service' SYSTEM='email antispam' STATE='$state'"
str="$str CPU='$cpu' MEM='$mem' RTIME='$rtime'"
# Checking MAIL ANTISPAM
if [ ! -z "$ANTISPAM_SYSTEM" ] && [ "$ANTISPAM_SYSTEM" != 'remote' ]; then
get_srv_state $ANTISPAM_SYSTEM spamd
data="$data\nNAME='$ANTISPAM_SYSTEM' SYSTEM='email antispam'"
data="$data STATE='$state' CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# DB
service=$DB_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
# Checking DB system
if [ ! -z "$DB_SYSTEM" ] && [ "$DB_SYSTEM" != 'remote' ]; then
for db in ${DB_SYSTEM//,/ }; do
db_proc_name=''
proc_name=''
service="$db"
if [ "$service" = 'mysql' ]; then
if [ -e "/etc/redhat-release" ]; then
service='mysqld'
db_proc_name='mysqld'
proc_name='mysqld'
if [ -e "/usr/lib/systemd/system/mariadb.service" ]; then
service='mariadb'
fi
@ -183,39 +230,37 @@ if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
fi
if [ "$service" == 'pgsql' ]; then
service='postgresql'
db_proc_name='postmaster'
proc_name='postmaster'
if [ ! -e "/etc/redhat-release" ]; then
db_proc_name='postgres'
proc_name='postgres'
fi
if [ ! -e '/etc/init.d/postgresql' ]; then
db_proc_name='postgres'
proc_name='postgres'
fi
fi
get_srv_state $service $db_proc_name
str="$str\nNAME='$service' SYSTEM='database server' STATE='$state'"
str="$str CPU='$cpu' MEM='$mem' RTIME='$rtime'"
get_srv_state $service $proc_name
data="$data\nNAME='$service' SYSTEM='database server' STATE='$state'"
data="$data CPU='$cpu' MEM='$mem' RTIME='$rtime'"
proc_name=''
done
fi
# FTP
service=$FTP_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
get_srv_state $service
str="$str\nNAME='$service' SYSTEM='ftp server' STATE='$state' CPU='$cpu'"
str="$str MEM='$mem' RTIME='$rtime'"
# Checking FTP system
if [ ! -z "$FTP_SYSTEM" ] && [ "$FTP_SYSTEM" != 'remote' ]; then
get_srv_state $FTP_SYSTEM
data="$data\nNAME='$FTP_SYSTEM' SYSTEM='ftp server' STATE='$state'"
data="$data CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# CRON
service=$CRON_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
get_srv_state $service
str="$str\nNAME='$service' SYSTEM='job scheduler' STATE='$state'"
str="$str CPU='$cpu' MEM='$mem' RTIME='$rtime'"
# Checking CRON system
if [ ! -z "$CRON_SYSTEM" ] && [ "$CRON_SYSTEM" != 'remote' ]; then
get_srv_state $CRON_SYSTEM
data="$data\nNAME='$CRON_SYSTEM' SYSTEM='job scheduler' STATE='$state'"
data="$data CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# FIREWALL
service=$FIREWALL_SYSTEM
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
# Checking FIREWALL system
if [ ! -z "$FIREWALL_SYSTEM" ] && [ "$FIREWALL_SYSTEM" != 'remote' ]; then
state="stopped"
/sbin/iptables -L vesta >/dev/null 2>&1
if [ "$?" -eq 0 ]; then
@ -225,32 +270,21 @@ if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
str="$str STATE='$state' CPU='0' MEM='0' RTIME='0'"
fi
# Fail2ban
service=$FIREWALL_EXTENSION
if [ ! -z "$service" ] && [ "$service" != 'remote' ]; then
get_srv_state $service fail2ban-server script
str="$str\nNAME='$service' SYSTEM='brute-force monitor' STATE='$state'"
str="$str CPU='$cpu' MEM='$mem' RTIME='$rtime'"
# Checking FIREWALL Fail2ban extention
if [ ! -z "$FIREWALL_EXTENSION" ]; then
get_srv_state $FIREWALL_EXTENSION fail2ban-server script
data="$data\nNAME='$FIREWALL_EXTENSION' SYSTEM='brute-force monitor'"
data="$data STATE='$state' CPU='$cpu' MEM='$mem' RTIME='$rtime'"
fi
# Defining config
echo -e "$str" > $tmp_file
conf=$tmp_file
# Defining fileds to select
fields="\$NAME \$SYSTEM \$STATE \$CPU \$MEM \$RTIME"
# Listing services
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$NAME $STATE $CPU $MEM $RTIME'
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac
rm -f $tmp_file
#----------------------------------------------------------#
# Vesta #

48
bin/v-list-sys-shells
View file

@ -15,14 +15,12 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_sh() {
shells=$(grep -v '#' /etc/shells)
# JSON list function
json_list() {
sh_counter=$(echo "$shells" | wc -l)
i=1
echo '['
for shell in $shells; do
shell=$(basename $shell)
if [ "$i" -lt "$sh_counter" ]; then
echo -e "\t\"$shell\","
else
@ -33,15 +31,26 @@ json_list_sh() {
echo "]"
}
# Shell function
shell_list_sh() {
shells=$(grep -v '#' /etc/shells)
if [ -z "$nohead" ]; then
echo "SHELLS"
echo "----------"
fi
# SHELL list function
shell_list() {
echo "SHELL"
echo "-----"
for shell in $shells; do
echo "$shell"
done
}
# PLAIN list function
plain_list() {
for shell in $shells; do
echo "$shell"
done
}
# CSV list function
csv_list() {
echo "SHELL"
for shell in $shells; do
shell=$(basename $shell)
echo "$shell"
done
}
@ -51,12 +60,15 @@ shell_list_sh() {
# Action #
#----------------------------------------------------------#
# Listing domains
case $format in
json) json_list_sh ;;
plain) nohead=1; shell_list_sh ;;
shell) shell_list_sh ;;
*) check_args '1' '0' '[FORMAT]' ;;
# Defining system shells
shells=$(grep -v '#' /etc/shells |awk -F '/' '{print $NF}' |sort -u)
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

52
bin/v-list-sys-users
View file

@ -16,32 +16,44 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_users() {
users=$(grep @ /etc/passwd|cut -f 1 -d :)
int_counter=$(echo "$users" | wc -l)
# JSON list function
json_list() {
objects=$(echo "$users" |wc -l)
i=1
echo '['
for user in $users; do
if [ "$i" -lt "$int_counter" ]; then
while read user; do
if [ "$i" -lt "$objects" ]; then
echo -e "\t\"$user\","
else
echo -e "\t\"$user\""
fi
(( ++i))
done
done < <(grep @ /etc/passwd |cut -f 1 -d :)
echo "]"
}
# Shell function
shell_list_users() {
if [ -z "$nohead" ]; then
echo "USERS"
echo "----------"
fi
for user in $(grep @ /etc/passwd|cut -f 1 -d :); do
# SHELL list function
shell_list() {
echo "USER"
echo "----"
while read user; do
echo "$user"
done
done < <(grep @ /etc/passwd |cut -f 1 -d :)
}
# PLAIN list function
plain_list() {
while read user; do
echo "$user"
done < <(grep @ /etc/passwd |cut -f 1 -d :)
}
# CSV list function
csv_list() {
echo "USER"
while read user; do
echo "$user"
done < <(grep @ /etc/passwd |cut -f 1 -d :)
}
@ -49,12 +61,12 @@ shell_list_users() {
# Action #
#----------------------------------------------------------#
# Listing domains
# Listing data
case $format in
json) json_list_users ;;
plain) nohead=1; shell_list_users ;;
shell) shell_list_users ;;
*) check_args '1' '0' '[FORMAT]' ;;
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

43
bin/v-list-sys-vesta-autoupdate
View file

@ -16,8 +16,8 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_autoupdate() {
# JSON list function
json_list() {
echo '['
if [ -z "$check_cron" ]; then
echo -e "\t\"Disabled\","
@ -27,12 +27,28 @@ json_list_autoupdate() {
echo "]"
}
# Shell function
shell_list_autoupdate() {
if [ -z "$nohead" ]; then
echo "AUTOUPDATE"
echo "----------"
# SHELL list function
shell_list() {
echo -n "AUTOUPDATE: "
if [ -z "$check_cron" ]; then
echo "Disabled"
else
echo "Enabled"
fi
}
# PLAIN list function
plain_list() {
if [ -z "$check_cron" ]; then
echo "Disabled"
else
echo "Enabled"
fi
}
# CSV list function
csv_list() {
echo "AUTOUPDATE"
if [ -z "$check_cron" ]; then
echo "Disabled"
else
@ -48,15 +64,16 @@ shell_list_autoupdate() {
# Check cron tab
check_cron=$(grep 'v-update-sys-vesta-all' $USER_DATA/cron.conf)
# Listing domains
case $format in
json) json_list_autoupdate ;;
plain) nohead=1; shell_list_autoupdate ;;
shell) shell_list_autoupdate ;;
*) check_args '1' '0' '[FORMAT]' ;;
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list;;
esac
#----------------------------------------------------------#
# Vesta #
#----------------------------------------------------------#

109
bin/v-list-sys-vesta-updates
View file

@ -14,22 +14,55 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
fields="\$NAME \$VERSION \$RELEASE \$ARCH \$UPDATED \$DESCR \$TIME \$DATE"
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(echo -e "$data" |grep NAME |wc -l)
echo "{"
for str in $(echo -e "$data"); do
eval $str
echo -n ' "'$NAME'": {
"VERSION": "'$VERSION'",
"RELEASE": "'$RELEASE'",
"ARCH": "'$ARCH'",
"UPDATED": "'$UPDATED'",
"DESCR": "'$DESCR'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "PKG VER REL ARCH UPDT DATE"
echo "--- --- --- ---- ---- ----"
for str in $(echo -e "$data"); do
eval $str
echo "$NAME $VERSION $RELEASE $ARCH $UPDATED $DATE"
done
}
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Remove upd_flag
rm -f $VESTA/web/.update
# Checking official latest version
latest=$(wget -q -T 1 -t 1 http://c.vestacp.com/latest.txt -O -)
# Create tmp file
tmp_file=$(mktemp)
# Check latest version
wget -q -T 1 -t 1 http://c.vestacp.com/latest.txt -O $tmp_file
# Check vesta version
# Checking installed vesta version
if [ -e "/etc/redhat-release" ]; then
rpm_format="VERSION='%{VERSION}'"
rpm_format="$rpm_format RELEASE='%{RELEASE}'"
@ -41,22 +74,20 @@ if [ -e "/etc/redhat-release" ]; then
else
dpkg_data=$(dpkg-query -s vesta)
pkg_date=$(stat -c "%Y" /var/lib/dpkg/info/vesta.list)
ARCH=$(echo "$dpkg_data"|grep Architecture | cut -f 2 -d ' ')
ARCH=$(echo "$dpkg_data"|grep Architecture |cut -f 2 -d ' ')
VERSION=$(echo "$dpkg_data"|grep ^Version |cut -f 2 -d ' '|cut -f 1 -d \-)
RELEASE=$(echo "$dpkg_data"|grep ^Version |cut -f 2 -d ' '|cut -f 2 -d \-)
DATE=$(date -d @$pkg_date +"%F")
TIME=$(date -d @$pkg_date +"%T")
fi
latest=$(grep vesta $tmp_file)
UPDATED='yes'
if [ ! -z "$latest" ] && [ "$latest" != "vesta-$VERSION-$RELEASE" ]; then
UPDATED='no'
set_upd_flag='yes'
fi
str="NAME='vesta' VERSION='$VERSION' RELEASE='$RELEASE' ARCH='$ARCH'"
str="$str UPDATED='$UPDATED' DESCR='core package' TIME='$TIME' DATE='$DATE'"
data="NAME='vesta' VERSION='$VERSION' RELEASE='$RELEASE' ARCH='$ARCH'"
data="$data UPDATED='$UPDATED' DESCR='core package' TIME='$TIME' DATE='$DATE'"
# Check vesta-php version
# Checking installed vesta-php version
if [ -e "/etc/redhat-release" ]; then
eval $(rpm --queryformat="$rpm_format" -q vesta-php)
DATE=$(date -d @$UTIME +%F)
@ -70,17 +101,11 @@ else
DATE=$(date -d @$pkg_date +"%F")
TIME=$(date -d @$pkg_date +"%T")
fi
latest=$(grep php $tmp_file)
UPDATED='yes'
if [ ! -z "$latest" ] && [ "$latest" != "php-$VERSION-$RELEASE" ]; then
UPDATED='no'
set_upd_flag='yes'
fi
str="$str\nNAME='vesta-php' VERSION='$VERSION' RELEASE='$RELEASE' ARCH='$ARCH'"
str="$str UPDATED='$UPDATED' DESCR='php interpreter' TIME='$TIME'"
str="$str DATE='$DATE'"
data="$data\nNAME='vesta-php' VERSION='$VERSION' RELEASE='$RELEASE'"
data="$data ARCH='$ARCH' UPDATED='$UPDATED' DESCR='php interpreter'"
data="$data TIME='$TIME' DATE='$DATE'"
# Check vesta-nginx version
# Checking installed vesta-nginx version
if [ -e "/etc/redhat-release" ]; then
eval $(rpm --queryformat="$rpm_format" -q vesta-nginx)
DATE=$(date -d @$UTIME +%F)
@ -94,39 +119,19 @@ else
DATE=$(date -d @$pkg_date +"%F")
TIME=$(date -d @$pkg_date +"%T")
fi
latest=$(grep nginx $tmp_file)
UPDATED='yes'
if [ ! -z "$latest" ] && [ "$latest" != "nginx-$VERSION-$RELEASE" ]; then
UPDATED='no'
set_upd_flag='yes'
fi
str="$str\nNAME='vesta-nginx' VERSION='$VERSION' RELEASE='$RELEASE'"
str="$str ARCH='$ARCH' UPDATED='$UPDATED' DESCR='internal web server'"
str="$str TIME='$TIME' DATE='$DATE'"
data="$data\nNAME='vesta-nginx' VERSION='$VERSION' RELEASE='$RELEASE'"
data="$data ARCH='$ARCH' UPDATED='$UPDATED' DESCR='internal web server'"
data="$data TIME='$TIME' DATE='$DATE'"
# Create flag if updates avaiable
if [ "$set_upd_flag" == 'yes' ]; then
touch $VESTA/web/.update
chmod a+r $VESTA/web/.update
fi
# Defining config
echo -e "$str" > $tmp_file
conf=$tmp_file
# Defining fileds to select
fields="\$NAME \$VERSION \$RELEASE \$ARCH \$UPDATED \$DESCR \$TIME \$DATE"
# Listing services
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$NAME $VERSION $RELEASE $ARCH $UPDATED $TIME $DATE'
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t;;
esac
rm -f $tmp_file
#----------------------------------------------------------#
# Vesta #

201
bin/v-list-user
View file

@ -1,57 +1,151 @@
#!/bin/bash
# info: list system user
# info: list user parameters
# options: USER [FORMAT]
#
# The function for obtaining the list of all user's parameters.
# The function to obtain user parameters.
#----------------------------------------------------------#
# Variable&Function #
#----------------------------------------------------------#
# Argument definition
user=$1
format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Argument definition
user=$1
USER="$user"
format=${2-shell}
# Json function
json_list_user() {
i=1
fileds_count=$(echo "$fields" | wc -w)
source $VESTA/data/users/$user/user.conf
echo '{'
for field in $fields; do
eval value=$field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fileds_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e "}"
# JSON list function
json_list() {
echo '{
"'$USER'": {
"FNAME": "'$FNAME'",
"LNAME": "'$LNAME'",
"PACKAGE": "'$PACKAGE'",
"WEB_TEMPLATE": "'$WEB_TEMPLATE'",
"BACKEND_TEMPLATE": "'$BACKEND_TEMPLATE'",
"PROXY_TEMPLATE": "'$PROXY_TEMPLATE'",
"DNS_TEMPLATE": "'$DNS_TEMPLATE'",
"WEB_DOMAINS": "'$WEB_DOMAINS'",
"WEB_ALIASES": "'$WEB_ALIASES'",
"DNS_DOMAINS": "'$DNS_DOMAINS'",
"DNS_RECORDS": "'$DNS_RECORDS'",
"MAIL_DOMAINS": "'$MAIL_DOMAINS'",
"MAIL_ACCOUNTS": "'$MAIL_ACCOUNTS'",
"DATABASES": "'$DATABASES'",
"CRON_JOBS": "'$CRON_JOBS'",
"DISK_QUOTA": "'$DISK_QUOTA'",
"BANDWIDTH": "'$BANDWIDTH'",
"HOME": "'$HOME'",
"NS": "'$NS'",
"SHELL": "'$SHELL'",
"BACKUPS": "'$BACKUPS'",
"CONTACT": "'$CONTACT'",
"CRON_REPORTS": "'$CRON_REPORTS'",
"RKEY": "'$RKEY'",
"SUSPENDED": "'$SUSPENDED'",
"SUSPENDED_USERS": "'$SUSPENDED_USERS'",
"SUSPENDED_WEB": "'$SUSPENDED_WEB'",
"SUSPENDED_DNS": "'$SUSPENDED_DNS'",
"SUSPENDED_MAIL": "'$SUSPENDED_MAIL'",
"SUSPENDED_DB": "'$SUSPENDED_DB'",
"SUSPENDED_CRON": "'$SUSPENDED_CRON'",
"IP_AVAIL": "'$IP_AVAIL'",
"IP_OWNED": "'$IP_OWNED'",
"U_USERS": "'$U_USERS'",
"U_DISK": "'$U_DISK'",
"U_DISK_DIRS": "'$U_DISK_DIRS'",
"U_DISK_WEB": "'$U_DISK_WEB'",
"U_DISK_MAIL": "'$U_DISK_MAIL'",
"U_DISK_DB": "'$U_DISK_DB'",
"U_BANDWIDTH": "'$U_BANDWIDTH'",
"U_WEB_DOMAINS": "'$U_WEB_DOMAINS'",
"U_WEB_SSL": "'$U_WEB_SSL'",
"U_WEB_ALIASES": "'$U_WEB_ALIASES'",
"U_DNS_DOMAINS": "'$U_DNS_DOMAINS'",
"U_DNS_RECORDS": "'$U_DNS_RECORDS'",
"U_MAIL_DOMAINS": "'$U_MAIL_DOMAINS'",
"U_MAIL_DKIM": "'$U_MAIL_DKIM'",
"U_MAIL_ACCOUNTS": "'$U_MAIL_ACCOUNTS'",
"U_DATABASES": "'$U_DATABASES'",
"U_CRON_JOBS": "'$U_CRON_JOBS'",
"U_BACKUPS": "'$U_BACKUPS'",
"LANGUAGE": "'$LANGUAGE'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}
}'
}
# Shell function
shell_list_user() {
source $VESTA/data/users/$user/user.conf
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key='NULL'
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "USERNAME: $USER"
echo "FULL NAME: $FNAME $LNAME"
echo "EMAIL: $CONTACT"
echo "LANGUAGE: $LANGUAGE"
echo "SUSPENDED: $SUSPENDED"
echo "PACKAGE: $PACKAGE"
echo "SHELL: $SHELL"
echo "WEB DOMAINS: $U_WEB_DOMAINS/$WEB_DOMAINS"
echo "WEB ALIASES: $U_WEB_ALIASES/$WEB_ALIASES"
echo "DNS DOMAINS: $U_DNS_DOMAINS/$DNS_DOMAINS"
echo "DNS RECORDS: $U_DNS_RECORDS/$DNS_RECORDS"
echo "MAIL DOMAINS: $U_MAIL_DOMAINS/$MAIL_DOMAINS"
echo "MAIL ACCOUNTS: $U_MAIL_ACCOUNTS/$MAIL_ACCOUNTS"
echo "BACKUPS: $U_BACKUPS/$BACKUPS"
echo "DATABASES: $U_DATABASES/$DATABASES"
echo "CRON_JOBS: $U_CRON_JOBS/$CRON_JOBS"
echo "DISK: $U_DISK/$DISK_QUOTA"
echo "BANDWIDTH: $U_BANDWIDTH/$BANDWIDTH"
echo "IP ADDRESSES $IP_AVAIL/$IP_OWNED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$USER\t$FNAME\t$LNAME\t$PACKAGE\t$WEB_TEMPLATE\t"
echo -ne "$BACKEND_TEMPLATE\t$PROXY_TEMPLATE\t$DNS_TEMPLATE\t"
echo -ne "$WEB_DOMAINS\t$WEB_ALIASES\t$DNS_DOMAINS\t$DNS_RECORDS\t"
echo -ne "$MAIL_DOMAINS\t$MAIL_ACCOUNTS\t$DATABASES\t$CRON_JOBS\t"
echo -ne "$DISK_QUOTA\t$BANDWIDTH\t$NS\t$HOME\t$SHELL\t$BACKUPS\t"
echo -ne "$CONTACT\t$CRON_REPORTS\t$RKEY\t$SUSPENDED\t"
echo -ne "$SUSPENDED_USERS\t$SUSPENDED_WEB\t$SUSPENDED_DNS\t"
echo -ne "$SUSPENDED_MAIL\t$SUSPENDED_DB\t$SUSPENDED_CRON\t"
echo -ne "$IP_AVAIL\t$IP_OWNED\t$U_USERS\t$U_DISK\t$U_DISK_DIRS\t"
echo -ne "$U_DISK_WEB\t$U_DISK_MAIL\t$U_DISK_DB\t$U_BANDWIDTH\t"
echo -ne "$U_WEB_DOMAINS\t$U_WEB_SSL\t$U_WEB_ALIASES\t"
echo -ne "$U_DNS_DOMAINS\t$U_DNS_RECORDS\t$U_MAIL_DOMAINS\t"
echo -ne "$U_MAIL_DKIM\t$U_MAIL_ACCOUNTS\t$U_DATABASES\t"
echo -e "'$U_CRON_JOBS\t$U_BACKUPS\t$LANGUAGE\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo -n "USER,FNAME,LNAME,PACKAGE,WEB_TEMPLATE,BACKEND_TEMPLATE,"
echo -n "PROXY_TEMPLATE,DNS_TEMPLATE,WEB_DOMAINS,WEB_ALIASES,"
echo -n "DNS_DOMAINS,DNS_RECORDS,MAIL_DOMAINS,MAIL_ACCOUNTS,"
echo -n "DATABASES,CRON_JOBS,DISK_QUOTA,BANDWIDTH,NS,HOME,SHELL,"
echo -n "BACKUPS,CONTACT,CRON_REPORTS,RKEY,SUSPENDED,SUSPENDED_USERS,"
echo -n "SUSPENDED_WEB,SUSPENDED_DNS,SUSPENDED_MAIL,SUSPENDED_DB,"
echo -n "SUSPENDED_CRON,IP_AVAIL,IP_OWNED,U_USERS,U_DISK,U_DISK_DIRS,"
echo -n "U_DISK_WEB,U_DISK_MAIL,U_DISK_DB,U_BANDWIDTH,U_WEB_DOMAINS,"
echo -n "U_WEB_SSL,U_WEB_ALIASES,U_DNS_DOMAINS,U_DNS_RECORDS,"
echo -n "U_MAIL_DOMAINS,U_MAIL_DKIM,U_MAIL_ACCOUNTS,U_DATABASES"
echo "U_CRON_JOBS,U_BACKUPS,LANGUAGE,TIME,DATE"
echo -n "$USER,\"$FNAME\",\"$LNAME\",$PACKAGE,$WEB_TEMPLATE,"
echo -n "$BACKEND_TEMPLATE,$PROXY_TEMPLATE,$DNS_TEMPLATE,$WEB_DOMAINS,"
echo -n "$WEB_ALIASES,$DNS_DOMAINS,$DNS_RECORDS,$MAIL_DOMAINS,"
echo -n "$MAIL_ACCOUNTS,$DATABASES,$CRON_JOBS,$DISK_QUOTA,$BANDWIDTH,"
echo -n "\"$NS\",$HOME,$SHELL,$BACKUPS,$CONTACT,$CRON_REPORTS,\"$RKEY\","
echo -n "$SUSPENDED,$SUSPENDED_USERS,$SUSPENDED_WEB,$SUSPENDED_DNS,"
echo -n "$SUSPENDED_MAIL,$SUSPENDED_DB,$SUSPENDED_CRON,$IP_AVAIL,"
echo -n "$IP_OWNED,$U_USERS,$U_DISK,$U_DISK_DIRS,$U_DISK_WEB,"
echo -n "$U_DISK_MAIL,$U_DISK_DB,$U_BANDWIDTH,$U_WEB_DOMAINS,$U_WEB_SSL,"
echo -n "$U_WEB_ALIASES,$U_DNS_DOMAINS,$U_DNS_RECORDS,$U_MAIL_DOMAINS,"
echo -n "$U_MAIL_DKIM,$U_MAIL_ACCOUNTS,$U_DATABASES,$U_CRON_JOBS,"
echo "$U_BACKUPS,$LANGUAGE,$TIME,$DATE"
}
@ -60,7 +154,6 @@ shell_list_user() {
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_object_valid 'user' 'USER' "$user"
@ -69,26 +162,16 @@ is_object_valid 'user' 'USER' "$user"
#----------------------------------------------------------#
# Defining config
conf=$USER_DATA/user.conf
USER=$user
HOME=$HOMEDIR/$user
source $VESTA/data/users/$user/user.conf
# Defining fileds to select
fields='$USER $FNAME $LNAME $PACKAGE $WEB_TEMPLATE $BACKEND_TEMPLATE
$PROXY_TEMPLATE $DNS_TEMPLATE $WEB_DOMAINS $WEB_ALIASES $DNS_DOMAINS
$DNS_RECORDS $MAIL_DOMAINS $MAIL_ACCOUNTS $DATABASES $CRON_JOBS
$DISK_QUOTA $BANDWIDTH $NS $SHELL $BACKUPS $CONTACT $CRON_REPORTS
$RKEY $SUSPENDED $SUSPENDED_USERS $SUSPENDED_WEB $SUSPENDED_DNS
$SUSPENDED_MAIL $SUSPENDED_DB $SUSPENDED_CRON $IP_AVAIL $IP_OWNED
$U_USERS $U_DISK $U_DISK_DIRS $U_DISK_WEB $U_DISK_MAIL $U_DISK_DB
$U_BANDWIDTH $U_WEB_DOMAINS $U_WEB_SSL $U_WEB_ALIASES $U_DNS_DOMAINS
$U_DNS_RECORDS $U_MAIL_DOMAINS $U_MAIL_DKIM $U_MAIL_ACCOUNTS $U_DATABASES
$U_CRON_JOBS $U_BACKUPS $LANGUAGE $HOME $NOTIFICATIONS $TIME $DATE'
# Listing user
case $format in
json) json_list_user ;;
plain) nohead=1; shell_list_user ;;
shell) shell_list_user | column -t ;;
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

107
bin/v-list-user-backup
View file

@ -18,57 +18,55 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_backup() {
i=1
fileds_count=$(echo "$fields" | wc -w)
line=$(grep "BACKUP='$backup'" $conf)
fields="\$BACKUP \$TYPE \$SIZE \$WEB \$DNS \$DB \$MAIL \$CRON \$UDIR"
fields="$fields \$RUNTIME \$TIME \$DATE"
# Print top bracket
# JSON list function
json_list() {
echo '{'
# Assing key=value
eval $line
# Starting output loop
for field in $fields; do
# Parsing key=value
eval value=$field
# Checking first field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fileds_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"$value\""
else
echo -e "\t\t\"${field//$/}\": \"$value\","
fi
fi
# Updating iterator
(( ++i))
done
# If there was any output
if [ -n "$value" ]; then
echo -e ' }'
fi
# Printing bottom json bracket
echo -e "}"
echo ' "'$BACKUP'": {
"TYPE": "'$TYPE'",
"SIZE": "'$SIZE'",
"WEB": "'$WEB'",
"DNS": "'$DNS'",
"MAIL": "'$MAIL'",
"DB": "'$DB'",
"CRON": "'$CRON'",
"UDIR": "'$UDIR'",
"RUNTIME": "'$RUNTIME'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_backup() {
line=$(grep "BACKUP='$backup'" $conf)
# SHELL list function
shell_list() {
echo "BACKUP: $BACKUP"
echo "TYPE: $TYPE"
echo "SIZE: $SIZE mb"
echo "RUNTIME: $RUNTIME min"
echo "WEB: ${WEB//,/ }"
echo "DNS: ${DNS//,/ }"
echo "MAIL: ${MAIL//,/ }"
echo "DB: ${DB//,/ }"
echo "CRON: $CRON"
echo "UDIR: ${UDIR//,/ }"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# Parsing key=value
eval $line
# PLAIN list function
plain_list() {
echo -ne "$BACKUP\t$TYPE\t$SIZE\t$WEB\t$DNS\t$MAIL\t$DB\t$CRON\t"
echo -e "$UDIR\t$RUNTIME\t$TIME\t$DATE"
}
# Print result line
for field in $fields; do
eval key="$field"
echo "${field//$/}: $key "
done
# CSV list function
csv_list() {
echo "BACKUP,TYPE,SIZE,WEB,DNS,MAIL,DB,CRON,UDIR,RUNTIME,TIME,DATE"
echo -n "$BACKUP,$TYPE,$SIZE,\"$WEB\",\"$DNS\",\"$MAIL\",\"$DB\","
echo "\"$CRON\",\"$UDIR\",$RUNTIME,$TIME,$DATE"
}
@ -85,18 +83,15 @@ is_object_valid 'backup' 'BACKUP' "$backup"
# Action #
#----------------------------------------------------------#
# Defining config and fields to select
conf=$USER_DATA/backup.conf
# Parsing backup config
eval $(grep "BACKUP='$backup'" $USER_DATA/backup.conf)
fields="\$BACKUP \$TYPE \$SIZE \$WEB \$DNS \$DB \$MAIL \$CRON \$UDIR"
fields="$fields \$RUNTIME \$TIME \$DATE"
# Listing backup
case $format in
json) json_list_backup ;;
plain) nohead=1; shell_list_backup ;;
shell) shell_list_backup |column -t ;;
*) check_args '2' '0' 'USER BACKUP [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

167
bin/v-list-user-backup-exclusions
View file

@ -12,52 +12,134 @@
# Argument definition
user=$1
format=${2-shell}
USER=''
# Includes
source $VESTA/func/main.sh
# Json function
json_list_backup_xld() {
set -f
echo '{'
fields_count=$(echo "$fields" | wc -w)
# JSON list function
json_list() {
i=1
source $USER_DATA/backup-excludes.conf
for field in $fields; do
eval value=$field
echo '{'
echo ' "WEB": {'
objects=$(echo "${WEB//,/ }" |wc -w)
for object in $(echo "${WEB//,/ }"); do
j=1
echo -e "\t\"${field//$/}\": {"
for exlcude in ${value//,/ }; do
exlcude_obj=$(echo $exlcude |cut -f 1 -d:)
exclude_param=$(echo $exlcude |sed -e "s/$exlcude_obj://")
if [ "$exlcude_obj" = "$exclude_param" ]; then
exclude_param=''
fi
if [ $j -lt "$(echo ${value//,/ } |wc -w)" ]; then
echo -e "\t\t\"$exlcude_obj\": \"$exclude_param\","
object_keys=$(echo ${object//:/ } |wc -w)
for key in $(echo "${object/:/ }"); do
if [ "$j" -eq 1 ]; then
echo -n " \"$key\": "
if [ "$object_keys" -eq 1 ]; then
echo -n '""'
fi
else
echo -e "\t\t\"$exlcude_obj\": \"$exclude_param\""
echo -n "\"${key//:/,}\""
fi
(( ++j))
((j++))
done
if [ $i -lt $fields_count ]; then
echo -e "\t},"
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo -e "\t}"
echo
fi
(( ++i))
((i++))
done
echo ' },'
i=1
echo ' "MAIL": {'
objects=$(echo "${MAIL//,/ }" |wc -w)
for object in $(echo "${MAIL//,/ }"); do
j=1
object_keys=$(echo ${object//:/ } |wc -w)
for key in $(echo "${object/:/ }"); do
if [ "$j" -eq 1 ]; then
echo -n " \"$key\": "
if [ "$object_keys" -eq 1 ]; then
echo -n '""'
fi
else
echo -n "\"${key//:/,}\""
fi
((j++))
done
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done
echo ' },'
i=1
echo ' "DB": {'
objects=$(echo "${DB//,/ }" |wc -w)
for object in $(echo "${DB//,/ }"); do
j=1
object_keys=$(echo ${object//:/ } |wc -w)
for key in $(echo "${object/:/ }"); do
if [ "$j" -eq 1 ]; then
echo -n " \"$key\": "
if [ "$object_keys" -eq 1 ]; then
echo -n '""'
fi
else
echo -n "\"${key//:/,}\""
fi
((j++))
done
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done
echo ' },'
i=1
echo ' "USER": {'
objects=$(echo "${USER//,/ }" |wc -w)
for object in $(echo "${USER//,/ }"); do
j=1
object_keys=$(echo ${object//:/ } |wc -w)
for key in $(echo "${object/:/ }"); do
if [ "$j" -eq 1 ]; then
echo -n " \"$key\": "
if [ "$object_keys" -eq 1 ]; then
echo -n '""'
fi
else
echo -n "\"${key//:/,}\""
fi
((j++))
done
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done
echo ' }'
echo '}'
}
# Shell function
shell_list_backup_xld() {
source $USER_DATA/backup-excludes.conf
for field in $fields; do
eval value=$field
echo -e "${field//$/}: $value"
done
# SHELL list function
shell_list() {
echo "WEB: $WEB"
echo "MAIL: $MAIL"
echo "DB: $DB"
echo "USER DIRS: $USER"
}
# PLAIN list function
plain_list() {
echo "$WEB\t$MAIL\t$DB\t$USER"
}
# CSV list function
csv_list() {
echo "WEB,MAIL,DB,USER"
echo "\"$WEB\",\"$MAIL\",\"$DB\",\"$USER\""
}
@ -66,7 +148,7 @@ shell_list_backup_xld() {
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -74,24 +156,23 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Flush variables
# Flushing variables
WEB=''
DNS=''
MAIL=''
DB=''
CRON=''
USER=''
# Defining fileds to select
touch $USER_DATA/backup-excludes.conf
fields="\$WEB \$DNS \$MAIL \$DB \$CRON \$USER"
# Parsing backup exclusion list
if [ -e "$USER_DATA/backup-excludes.conf" ]; then
source $USER_DATA/backup-excludes.conf
fi
# Listing backup exclusions
# Listing data
case $format in
json) json_list_backup_xld ;;
plain) nohead=1; shell_list_backup_xld ;;
shell) shell_list_backup_xld;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

81
bin/v-list-user-backups
View file

@ -16,12 +16,76 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep BACKUP $USER_DATA/backup.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$BACKUP'": {
"TYPE": "'$TYPE'",
"SIZE": "'$SIZE'",
"WEB": "'$WEB'",
"DNS": "'$DNS'",
"MAIL": "'$MAIL'",
"DB": "'$DB'",
"CRON": "'$CRON'",
"UDIR": "'$UDIR'",
"RUNTIME": "'$RUNTIME'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $USER_DATA/backup.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "BACKUP TYPE SIZE TIME DATE"
echo "------ ---- --- ---- ----"
while read str; do
eval $str
echo "$BACKUP $TYPE $SIZE $RUNTIME $DATE"
done < <(cat $USER_DATA/backup.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$BACKUP\t$TYPE\t$SIZE\t$WEB\t$DNS\t$MAIL\t$CRON\t$UDIR\t"
echo -e "$RUNTIME\t$TIME\t$DATE"
done < <(cat $USER_DATA/backup.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "BACKUP,TYPE,SIZE,WEB,DNS,MAIL,CRON,UDIR,RUNTIME,TIME,DATE"
while read str; do
eval $str
echo -n "$BACKUP,$TYPE,$SIZE,\"$WEB\",\"$DNS\",\"$MAIL\",\"$CRON\","
echo "\"$UDIR\",$RUNTIME,$TIME,$DATE"
done < <(cat $USER_DATA/backup.conf)
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -35,17 +99,12 @@ if [ ! -e "$conf" ]; then
touch $conf
fi
# Defining fileds to select
fields="\$BACKUP \$TYPE \$SIZE \$WEB \$DNS \$DB \$MAIL \$CRON \$UDIR"
fields="$fields \$RUNTIME \$TIME \$DATE"
# Listing domains
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$BACKUP $TYPE $SIZE $RUNTIME $TIME $DATE';
shell_list |column -t;;
*) check_args '1' '0' '[FORMAT]' ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

100
bin/v-list-user-favourites
View file

@ -16,43 +16,55 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_favourites() {
i=1
fileds_count=$(echo "$fields" | wc -w)
fvrt_data=$(cat $USER_DATA/favourites.conf 2>/dev/null)
# JSON list function
json_list() {
echo '{'
eval $fvrt_data
for field in $fields; do
eval value=$field
if [ $i -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ $fileds_count -eq $i ]; then
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
fi
fi
(( ++i))
done
#if [ -n "$value" ]; then
echo -e ' }'
#fi
echo -e '}'
echo ' "Favourites": {
"USER": "'$USER'",
"WEB": "'$WEB'",
"DNS": "'$DN'",
"DNS_REC": "'$DNS_REC'",
"MAIL": "'$MAIL'",
"MAIL_ACC": "'$MAIL_ACC'",
"DB": "'$DB'",
"CRON": "'$CRON'",
"BACKUP": "'$BACKUP'",
"IP": "'$IP'",
"PACKAGE": "'$PACKAGE'",
"FIREWALL": "'$FIREWALL'"
}'
echo '}'
}
# Shell function
shell_list_favourites() {
line=$(cat $USER_DATA/favourites.conf 2>/dev/null)
eval $line
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key='NULL'
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "USER: $USER"
echo "WEB: $WEB"
echo "DNS: $DNS"
echo "DNS RECORD: $DNS_REC"
echo "MAIL: $MAIL"
echo "MAIL USER: $MAIL_ACC"
echo "DATABASE: $DB"
echo "CRON: $CRON"
echo "BACKUP: $BACKUP"
echo "IP: $IP"
echo "PACKAGE: $PACKAGE"
echo "FIREWALL: $FIREWALL"
}
# PLAIN list function
plain_list() {
echo -ne "$USER\t$WEB\t$DNS\t$DNS_REC\t$MAIL\t$MAIL_ACC\t$DB\t$CRON\t"
echo -e "$BACKUP\t$IP\t$PACKAGE\t$FIREWALL"
}
# CSV list function
csv_list() {
echo -n "USER,WEB,DNS,DNS_REC,MAIL,MAIL_ACC,DB,CRON,BACKUP,IP,"
echo "PACKAGE,FIREWALL"
echo -n "\"$USER\",\"$WEB\",\"$DNS\",\"$DNS_REC\",\"$MAIL\","
echo -n "\"$MAIL_ACC\",\"$DB\",\"$CRON\",\"$BACKUP\",\"$IP\","
echo "\"$PACKAGE\",\"$FIREWALL\""
}
@ -62,7 +74,7 @@ shell_list_favourites() {
# Checking args
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -84,17 +96,17 @@ IP=''
PACKAGE=''
FIREWALL=''
# Defining fileds to select
OBJ='Favourites'
fields='$OBJ $USER $WEB $DNS $DNS_REC $MAIL $MAIL_ACC $DB $CRON $BACKUP
$IP $PACKAGE $FIREWALL'
# Parsing user favourites
if [ -e "$VESTA/data/users/$user/favourites.conf" ]; then
source $VESTA/data/users/$user/favourites.conf
fi
# Listing favourites
# Listing data
case $format in
json) json_list_favourites ;;
plain) shell_list_favourites ;;
shell) shell_list_favourites | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

137
bin/v-list-user-ips
View file

@ -16,89 +16,59 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_user_ips() {
# JSON list function
json_list() {
echo '{'
fileds_count=$(echo "$fields" | wc -w)
for IP in $(ls $VESTA/data/ips/); do
ip_count=$(echo "$ips" |wc -l)
i=1
for IP in $ips; do
source $VESTA/data/ips/$IP
if [ "$OWNER" = "$user" ]; then
if [ -n "$data" ]; then
echo -e ' },'
fi
i=1
for field in $fields; do
eval value=$field
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
data=1
fi
fi
done
echo -n ' "'$IP'": {
"OWNER": "'$OWNER'",
"STATUS": "'$STATUS'",
"NAME": "'$NAME'",
"NAT": "'$NAT'"
}'
if [ "$i" -lt "$ip_count" ]; then
echo ','
else
if [ "$OWNER" = 'admin' ] && [ "$STATUS" = 'shared' ]; then
if [ -n "$data" ]; then
echo -e ' },'
fi
i=1
for field in $fields; do
eval value=$field
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
data=1
fi
fi
done
fi
echo
fi
((i++))
done
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
echo '}'
}
# Shell function
shell_list_user_ips() {
# SHELL list function
shell_list() {
echo "IP NAT OWNER STATUS NAME"
echo "-- --- ----- ------ ---"
for IP in $ips; do
source $VESTA/data/ips/$IP
if [ -z "$NAT" ]; then
NAT='no'
fi
if [ -z "$NAME" ]; then
NAME='no'
fi
echo "$IP $NAT $OWNER $STATUS $NAME"
done
}
# PLAIN list function
plain_list() {
for IP in $ips; do
source $VESTA/data/ips/$IP
echo -e "$IP\t$OWNER\t$STATUS\t$NAME\t$NAT"
done
}
# CSV list function
csv_list() {
echo "IP,OWNER,STATUS,NAME,NAT"
for IP in $(ls $VESTA/data/ips/); do
source $VESTA/data/ips/$IP
if [ "$OWNER" = "$user" ]; then
for field in $fields; do
eval value=$field
if [ -z "$value" ]; then
value='NULL'
fi
echo -n "$value "
done
echo
else
if [ "$OWNER" = 'admin' ] && [ "$STATUS" = 'shared' ]; then
for field in $fields; do
eval value=$field
if [ -z "$value" ]; then
value='NULL'
fi
echo -n "$value "
done
echo
fi
fi
echo "$IP,$OWNER,$STATUS,$NAME,$NAT"
done
}
@ -108,7 +78,7 @@ shell_list_user_ips() {
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -117,14 +87,21 @@ is_object_valid 'user' 'USER' "$user"
#----------------------------------------------------------#
# Defining fileds to select
owner='admin'
owner_ips=$(grep -A 1 "OWNER='$owner'" $VESTA/data/ips/*)
owner_ips=$(echo "$owner_ips" |grep "STATUS='shared'")
owner_ips=$(echo "$owner_ips" |cut -f 7 -d / |cut -f 1 -d -)
user_ips=$(grep "OWNER='$user'" $VESTA/data/ips/*)
user_ips=$(echo "$user_ips" |cut -f 7 -d / |cut -f 1 -d :)
ips=$(echo -e "$user_ips\n$owner_ips" |sort -u |sed "/^$/d")
fields='$IP $OWNER $STATUS $NAME $NAT'
# Listing ips
# Listing data
case $format in
json) json_list_user_ips ;;
plain) nohead=1; shell_list_user_ips ;;
shell) shell_list_user_ips | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]' ;;
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

108
bin/v-list-user-log
View file

@ -16,48 +16,71 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json func
json_list_history() {
echo '{'
fileds_count=$(echo $fields| wc -w )
while read line; do
IFS=$'\n'
eval $line
if [ -n "$data" ]; then
echo -e ' },'
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(echo "$logs" |wc -l)
echo "{"
for str in $logs; do
eval $str
echo -n ' "'$ID'": {
"CMD": "'$CMD'",
"UNDO": "'$UNDO'",
"DATE": "'$DATE'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
i=1
IFS=' '
for field in $fields; do
eval value=\"$field\"
value=$(echo "$value" | sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
data=1
fi
fi
done
done < $conf
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
((i++))
done
echo '}'
}
shell_list() {
IFS=$'\n'
echo "DATE~TIME~CMD"
echo "----~----~---"
for str in $logs; do
eval $str
if [ -z "$DATE" ]; then
DATE='no'
fi
if [ -z "$TIME" ]; then
TIME='no'
fi
echo "$DATE~$TIME~$CMD"
done
}
# PLAIN list function
plain_list() {
IFS=$'\n'
for str in $logs; do
eval $str
echo -e "$ID\t$CMD\t$UNDO\t$TIME\t$DATE"
done
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "ID,CMD,UNDO,TIME,DATE"
for str in $logs; do
eval $str
echo "$ID,\"$CMD\",\"$UNDO\",$TIME,$DATE"
done
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -65,19 +88,14 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Defining config
conf=$USER_DATA/history.log
# Parsing history log
logs=$(tail -n 300 $USER_DATA/history.log 2>/dev/null)
# Defining fileds to select
fields="\$ID \$DATE \$TIME \$CMD \$UNDO"
# Listing domains
case $format in
json) json_list_history ;;
plain) nohead=1; shell_list ;;
shell) fields='$ID~$DATE~$TIME~$CMD';
shell_list |column -t -s '~';;
*) check_args '1' '0' 'USER [FORMAT]'
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t -s '~';;
esac

107
bin/v-list-user-notifications
View file

@ -16,50 +16,69 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_notifications() {
echo '{'
fileds_count=$(echo $fields| wc -w )
while read line; do
eval $line
if [ -n "$data" ]; then
echo -e ' },'
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep NID $USER_DATA/notifications.conf |wc -l)
echo "{"
while read str; do
eval $str
TOPIC=$(echo "$TOPIC" |sed -e "s/%quote%/'/g")
NOTICE=$(echo "$NOTICE" |sed -e "s/%quote%/'/g")
echo -n ' "'$NID'": {
"TOPIC": "'$TOPIC'",
"NOTICE": "'$NOTICE'",
"TYPE": "'$TYPE'",
"ACK": "'$ACK'",
"TPL": "'$TPL'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
i=1
IFS=' '
for field in $fields; do
eval value=\"$field\"
value=$(echo "$value"|sed -e 's/"/\\"/g' -e "s/%quote%/'/g")
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
data=1
fi
fi
done
done < $conf
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
((i++))
done < <(cat $USER_DATA/notifications.conf)
echo '}'
}
# Shell function
shell_list_notifications() {
while read line ; do
eval $line
# SHELL list function
shell_list() {
IFS=$'\n'
while read str; do
eval $str
echo "$TOPIC" |sed -e "s/%quote%/'/g"
echo "$NOTICE" |sed -e "s/%quote%/'/g"
echo "$DATE $TIME"
echo "--"
echo
done < $conf
done < <(cat $USER_DATA/notifications.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
TOPIC=$(echo "$TOPIC" |sed -e "s/%quote%/'/g")
NOTICE=$(echo "$NOTICE" |sed -e "s/%quote%/'/g")
echo -e "$NID\t$TOPIC\t$NOTICE\t$TIME\t$DATE"
done < <(cat $USER_DATA/notifications.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo "NID,TOPIC,NOTICE,TIME,DATE"
while read str; do
eval $str
TOPIC=$(echo "$TOPIC" |sed -e "s/%quote%/'/g")
NOTICE=$(echo "$NOTICE" |sed -e "s/%quote%/'/g")
echo "$NID,\"$TOPIC\",\"$NOTICE\",$TIME,$DATE"
done < <(cat $USER_DATA/notifications.conf)
}
@ -69,7 +88,7 @@ shell_list_notifications() {
# Checking args
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -77,16 +96,12 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Defining fileds to select
conf=$USER_DATA/notifications.conf
fields='$NID $TOPIC $NOTICE $TYPE $ACK $TIME $DATE'
# Listing favourites
# Listing data
case $format in
json) json_list_notifications ;;
plain) shell_list_notifications ;;
shell) shell_list_notifications ;;
*) check_args '1' '0' 'USER [FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

56
bin/v-list-user-ns
View file

@ -16,30 +16,41 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_ns() {
ns=$(grep "^NS='" $USER_DATA/user.conf |cut -f 2 -d \')
echo '['
# JSON list function
json_list() {
i=1
nslistc=$(echo -e "${ns//,/\\n}"|wc -l)
objects=$(echo -e "${ns//,/\\n}" |wc -l)
echo '['
for nameserver in ${ns//,/ };do
if [ "$i" -ne "$nslistc" ]; then
if [ "$i" -ne "$objects" ]; then
echo -e "\t\"$nameserver\","
else
echo -e "\t\"$nameserver\""
fi
(( ++i))
done
echo "]"
echo ']'
}
# Shell function
shell_list_ns() {
ns=$(grep "^NS='" $USER_DATA/user.conf |cut -f 2 -d \')
if [ -z "$nohead" ]; then
echo "NAMESERVER"
echo "----------"
fi
# SHELL list function
shell_list() {
echo "NS"
echo "--"
for nameserver in ${ns//,/ };do
echo "$nameserver"
done
}
# PLAIN list function
plain_list() {
for nameserver in ${ns//,/ };do
echo "$nameserver"
done
}
# CSV list function
csv_list() {
echo "NAMESERVER"
for nameserver in ${ns//,/ };do
echo "$nameserver"
done
@ -51,7 +62,7 @@ shell_list_ns() {
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_format_valid 'user'
is_object_valid 'user' 'USER' "$user"
@ -59,12 +70,15 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Listing nameservers
case $format in
json) json_list_ns ;;
plain) nohead=1; shell_list_ns ;;
shell) shell_list_ns ;;
*) check_args '1' '0' 'USER [FORMAT]'
# Parsing name servers
ns=$(grep "^NS='" $USER_DATA/user.conf |cut -f 2 -d \')
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

119
bin/v-list-user-package
View file

@ -17,43 +17,73 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_package() {
i=1
fileds_count=$(echo "$fields" | wc -w)
pkg_data=$(cat $VESTA/data/packages/$PACKAGE.pkg)
# JSON list function
json_list() {
echo '{'
eval $pkg_data
for field in $fields; do
eval value=$field
if [ $i -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ $fileds_count -eq $i ]; then
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e '}'
echo ' "'$PACKAGE'": {
"WEB_TEMPLATE": "'$WEB_TEMPLATE'",
"PROXY_TEMPLATE": "'$PROXY_TEMPLATE'",
"DNS_TEMPLATE": "'$DNS_TEMPLATE'",
"WEB_DOMAINS": "'$WEB_DOMAINS'",
"WEB_ALIASES": "'$WEB_ALIASES'",
"DNS_DOMAINS": "'$DNS_DOMAINS'",
"DNS_RECORDS": "'$DNS_RECORDS'",
"MAIL_DOMAINS": "'$MAIL_DOMAINS'",
"MAIL_ACCOUNTS": "'$MAIL_ACCOUNTS'",
"DATABASES": "'$DATABASES'",
"CRON_JOBS": "'$CRON_JOBS'",
"DISK_QUOTA": "'$DISK_QUOTA'",
"BANDWIDTH": "'$BANDWIDTH'",
"NS": "'$NS'",
"SHELL": "'$SHELL'",
"BACKUPS": "'$BACKUPS'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_package() {
line=$(cat $VESTA/data/packages/$PACKAGE.pkg)
eval $line
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key='NULL'
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
echo "PACKAGE: $PACKAGE"
echo "WEB TEMPLATE: $WEB_TEMPLATE"
echo "PROXY TEMPLATE: $PROXY_TEMPLATE"
echo "DNS TEMPLATE: $DNS_TEMPLATE"
echo "WEB DOMAINS: $WEB_DOMAINS"
echo "WEB ALIASES: $WEB_ALIASES"
echo "DNS DOMAINS: $DNS_DOMAINS"
echo "DNS RECORDS: $DNS_RECORDS"
echo "MAIL DOMAINS: $MAIL_DOMAINS"
echo "MAIL ACCOUNTS: $MAIL_ACCOUNTS"
echo "DATABASES: $DATABASES"
echo "CRON JOBS: $CRON_JOBS"
echo "DISK QUOTA: $DISK_QUOTA"
echo "BANDWIDTH: $BANDWIDTH"
echo "NS: $NS"
echo "SHELL: $SHELL"
echo "BACKUPS: $BACKUPS"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$PACKAGE\t$WEB_TEMPLATE\t$PROXY_TEMPLATE\t$DNS_TEMPLATE\t"
echo -ne "$WEB_DOMAINS\t$WEB_ALIASES\t$DNS_DOMAINS\t$DNS_RECORDS\t"
echo -ne "$MAIL_DOMAINS\t$MAIL_ACCOUNTS\t$DATABASES\t$CRON_JOBS\t"
echo -e "$DISK_QUOTA\t$BANDWIDTH\t$NS\t$SHELL\t$BACKUPS\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo -n "PACKAGE,WEB_TEMPLATE,PROXY_TEMPLATE,DNS_TEMPLATE,"
echo -n "WEB_DOMAINS,WEB_ALIASES,DNS_DOMAINS,DNS_RECORDS,"
echo -n "MAIL_DOMAINS,MAIL_ACCOUNTS,DATABASES,CRON_JOBS,"
echo "DISK_QUOTA,BANDWIDTH,NS,SHELL,BACKUPS,TIME,DATE"
echo -n "$PACKAGE,$WEB_TEMPLATE,$PROXY_TEMPLATE,$DNS_TEMPLATE,"
echo -n "$WEB_DOMAINS,$WEB_ALIASES,$DNS_DOMAINS,$DNS_RECORDS,"
echo -n "$MAIL_DOMAINS,$MAIL_ACCOUNTS,$DATABASES,$CRON_JOBS,"
echo "$DISK_QUOTA,$BANDWIDTH,\"$NS\",$SHELL,$BACKUPS,$TIME,$DATE"
}
@ -63,7 +93,7 @@ shell_list_package() {
# Checking args
check_args '1' "$#" 'PACKAGE [FORMAT]'
validate_format 'package'
is_format_valid 'package'
is_package_valid
@ -71,18 +101,15 @@ is_package_valid
# Action #
#----------------------------------------------------------#
# Defining fileds to select
fields='$PACKAGE $WEB_TEMPLATE $PROXY_TEMPLATE $DNS_TEMPLATE $WEB_DOMAINS
$WEB_ALIASES $DNS_DOMAINS $DNS_RECORDS $MAIL_DOMAINS $MAIL_ACCOUNTS
$DATABASES $CRON_JOBS $DISK_QUOTA $BANDWIDTH $NS $SHELL $BACKUPS $TIME
$DATE'
# Parsing package
source $VESTA/data/packages/$PACKAGE.pkg
# Listing ip
case $format in
json) json_list_package ;;
plain) shell_list_package ;;
shell) shell_list_package | column -t ;;
*) check_args '1' '0' 'IP [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

131
bin/v-list-user-packages
View file

@ -15,53 +15,85 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_pkgs() {
echo '{'
fileds_count=$(echo "$fields" | wc -w)
for package in $(ls --sort=time $VESTA/data/packages |grep .pkg); do
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(echo "$packages" |wc -l)
echo "{"
for package in $packages; do
PACKAGE=${package/.pkg/}
pkg_data=$(cat $VESTA/data/packages/$package)
eval $pkg_data
if [ -n "$data" ]; then
echo -e ' },'
source $VESTA/data/packages/$package
echo -n ' "'$PACKAGE'": {
"WEB_TEMPLATE": "'$WEB_TEMPLATE'",
"PROXY_TEMPLATE": "'$PROXY_TEMPLATE'",
"DNS_TEMPLATE": "'$DNS_TEMPLATE'",
"WEB_DOMAINS": "'$WEB_DOMAINS'",
"WEB_ALIASES": "'$WEB_ALIASES'",
"DNS_DOMAINS": "'$DNS_DOMAINS'",
"DNS_RECORDS": "'$DNS_RECORDS'",
"MAIL_DOMAINS": "'$MAIL_DOMAINS'",
"MAIL_ACCOUNTS": "'$MAIL_ACCOUNTS'",
"DATABASES": "'$DATABASES'",
"CRON_JOBS": "'$CRON_JOBS'",
"DISK_QUOTA": "'$DISK_QUOTA'",
"BANDWIDTH": "'$BANDWIDTH'",
"NS": "'$NS'",
"SHELL": "'$SHELL'",
"BACKUPS": "'$BACKUPS'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
i=1
for field in $fields; do
eval value=$field
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\","
else
echo -e "\t\t\"${field//$/}\": \"${value//,/, }\""
data=1
fi
fi
done
((i++))
done
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
echo '}'
}
# Shell fnction
shell_list_pkgs() {
for package in $(ls -t $VESTA/data/packages |grep .pkg); do
# SHELL list function
shell_list() {
echo "PKG TPL WEB DNS MAIL DB SHELL DISK BW"
echo "--- --- --- --- ---- -- ----- ---- --"
for package in $packages; do
source $VESTA/data/packages/$package
PACKAGE=${package/.pkg/}
pkg_descr=$(cat $VESTA/data/packages/$package)
eval $pkg_descr
if [ -z "$nohead" ]; then
echo '----------'
fi
for field in $fields; do
eval value=$field
echo -e "${field//$/}: $value"
done
package_data=$(cat $VESTA/data/packages/$package)
package_data=$(echo "$package_data" |sed -e 's/unlimited/unlim/g')
eval $package_data
echo -n "$PACKAGE $WEB_TEMPLATE $WEB_DOMAINS $DNS_DOMAINS "
echo "$MAIL_DOMAINS $DATABASES $SHELL $DISK_QUOTA $BANDWIDTH"
done
}
# PLAIN list function
plain_list() {
for package in $packages; do
source $VESTA/data/packages/$package
PACKAGE=${package/.pkg/}
echo -ne "$PACKAGE\t$WEB_TEMPLATE\t$PROXY_TEMPLATE\t$DNS_TEMPLATE\t"
echo -ne "$WEB_DOMAINS\t$WEB_ALIASES\t$DNS_DOMAINS\t$DNS_RECORDS\t"
echo -ne "$MAIL_DOMAINS\t$MAIL_ACCOUNTS\t$DATABASES\t$CRON_JOBS\t"
echo -e "$DISK_QUOTA\t$BANDWIDTH\t$NS\t$SHELL\t$BACKUPS\t$TIME\t$DATE"
done
}
# CSV list function
csv_list() {
echo -n "PACKAGE,WEB_TEMPLATE,PROXY_TEMPLATE,DNS_TEMPLATE,"
echo -n "WEB_DOMAINS,WEB_ALIASES,DNS_DOMAINS,DNS_RECORDS,"
echo -n "MAIL_DOMAINS,MAIL_ACCOUNTS,DATABASES,CRON_JOBS,"
echo "DISK_QUOTA,BANDWIDTH,NS,SHELL,BACKUPS,TIME,DATE"
for package in $packages; do
PACKAGE=${package/.pkg/}
echo -n "$PACKAGE,$WEB_TEMPLATE,$PROXY_TEMPLATE,$DNS_TEMPLATE,"
echo -n "$WEB_DOMAINS,$WEB_ALIASES,$DNS_DOMAINS,$DNS_RECORDS,"
echo -n "$MAIL_DOMAINS,$MAIL_ACCOUNTS,$DATABASES,$CRON_JOBS,"
echo "$DISK_QUOTA,$BANDWIDTH,\"$NS\",$SHELL,$BACKUPS,$TIME,$DATE"
done
}
@ -70,18 +102,15 @@ shell_list_pkgs() {
# Action #
#----------------------------------------------------------#
# Defining fields
fields='$PACKAGE $WEB_TEMPLATE $BACKEND_TEMPLATE $PROXY_TEMPLATE
$DNS_TEMPLATE $WEB_DOMAINS $WEB_ALIASES $DNS_DOMAINS $DNS_RECORDS
$MAIL_DOMAINS $MAIL_ACCOUNTS $DATABASES $CRON_JOBS $DISK_QUOTA $BANDWIDTH
$NS $SHELL $BACKUPS $TIME $DATE'
# Parsing packages
packages=$(ls --sort=time $VESTA/data/packages |grep .pkg)
# Listing domains
# Listing data
case $format in
json) json_list_pkgs ;;
plain) nohead=1; shell_list_pkgs ;;
shell) shell_list_pkgs | column -t ;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

115
bin/v-list-user-stats
View file

@ -1,6 +1,6 @@
#!/bin/bash
# info: list user stats
# options: USER [FORMAT]
# options: [FORMAT]
#
# The function for listing user statistics
@ -16,13 +16,105 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep DATE $USER_DATA/stats.log |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$DATE'": {
"TIME": "'$TIME'",
"PACKAGE": "'$PACKAGE'",
"IP_OWNED": "'$IP_OWNED'",
"DISK_QUOTA": "'$DISK_QUOTA'",
"U_DISK": "'$U_DISK'",
"U_DISK_DIRS": "'$U_DISK_DIRS'",
"U_DISK_WEB": "'$U_DISK_WEB'",
"U_DISK_MAIL": "'$U_DISK_MAIL'",
"U_DISK_DB": "'$U_DISK_DB'",
"BANDWIDTH": "'$BANDWIDTH'",
"U_BANDWIDTH": "'$U_BANDWIDTH'",
"U_WEB_DOMAINS": "'$U_WEB_DOMAINS'",
"U_WEB_SSL": "'$U_WEB_SSL'",
"U_WEB_ALIASES": "'$U_WEB_ALIASES'",
"U_DNS_DOMAINS": "'$U_DNS_DOMAINS'",
"U_DNS_RECORDS": "'$U_DNS_RECORDS'",
"U_MAIL_DOMAINS": "'$U_MAIL_DOMAINS'",
"U_MAIL_DKIM": "'$U_MAIL_DKIM'",
"U_MAIL_ACCOUNTS": "'$U_MAIL_ACCOUNTS'",
"U_DATABASES": "'$U_DATABASES'",
"U_CRON_JOBS": "'$U_CRON_JOBS'",
"U_BACKUPS": "'$U_BACKUPS'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $USER_DATA/stats.log)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "DATE WEB DNS MAIL DB BACKUPS IP DISK BW"
echo "---- --- --- ---- -- ------- -- ---- --"
while read str; do
eval $str
if [ -z "$U_USERS" ]; then
U_USERS=1
fi
echo -n "$DATE $U_WEB_DOMAINS $U_DNS_DOMAINS "
echo -n "$U_MAIL_DOMAINS $U_DATABASES $U_BACKUPS $IP_OWNED "
echo "$U_DISK $U_BANDWIDTH"
done < <(cat $USER_DATA/stats.log)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$DATE\t$TIME\t$PACKAGE\t$IP_OWNED\t$DISK_QUOTA\t$U_DISK\t"
echo -ne "$U_DISK_DIRS\t$U_DISK_WEB\t$U_DISK_MAIL\t$U_DISK_DB\t"
echo -ne "$BANDWIDTH\t$U_BANDWIDTH\t$U_WEB_DOMAINS\t$U_WEB_SSL\t"
echo -ne "$U_WEB_ALIASES\t$U_DNS_DOMAINS\t$U_DNS_RECORDS\t"
echo -ne "$U_MAIL_DOMAINS\t$U_MAIL_DKIM\t$U_MAIL_ACCOUNTS\t"
echo -e "$U_DATABASES\t$U_CRON_JOBS\t$U_BACKUPS"
done < <(cat $USER_DATA/stats.log)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo -n "DATE,TIME,PACKAGE,IP_OWNED,DISK_QUOTA,U_DISK,"
echo -n "U_DISK_DIRS,U_DISK_WEB,U_DISK_MAIL,U_DISK_DB,"
echo -n "BANDWIDTH,U_BANDWIDTH,U_WEB_DOMAINS,U_WEB_SSL,"
echo -n "U_WEB_ALIASES,U_DNS_DOMAINS,U_DNS_RECORDS,"
echo -n "U_MAIL_DOMAINS,U_MAIL_DKIM,U_MAIL_ACCOUNTS,"
echo "U_DATABASES,U_CRON_JOBS,U_BACKUPS"
while read str; do
eval $str
echo -n "$DATE,$TIME,$PACKAGE,$IP_OWNED,$DISK_QUOTA,$U_DISK,"
echo -n "$U_DISK_DIRS,$U_DISK_WEB,$U_DISK_MAIL,$U_DISK_DB,"
echo -n "$BANDWIDTH,$U_BANDWIDTH,$U_WEB_DOMAINS,$U_WEB_SSL,"
echo -n "$U_WEB_ALIASES,$U_DNS_DOMAINS,$U_DNS_RECORDS,"
echo -n "$U_MAIL_DOMAINS,$U_MAIL_DKIM,$U_MAIL_ACCOUNTS,"
echo "$U_DATABASES,$U_CRON_JOBS,$U_BACKUPS"
done < <(cat $USER_DATA/stats.log)
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_object_valid 'user' 'USER' "$user"
@ -36,21 +128,12 @@ if [ ! -e "$conf" ]; then
touch $conf
fi
# Defining fileds to select
fields="\$DATE \$TIME \$PACKAGE \$IP_OWNED \$DISK_QUOTA \$U_DISK \$U_DISK_DIRS"
fields="$fields \$U_DISK_WEB \$U_DISK_MAIL \$U_DISK_DB \$BANDWIDTH"
fields="$fields \$U_BANDWIDTH \$U_WEB_DOMAINS \$U_WEB_SSL \$U_WEB_ALIASES"
fields="$fields \$U_DNS_DOMAINS \$U_DNS_RECORDS \$U_MAIL_DOMAINS \$U_MAIL_DKIM"
fields="$fields \$U_MAIL_ACCOUNTS \$U_DATABASES \$U_CRON_JOBS \$U_BACKUPS"
# Listing domains
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$DATE $PACKAGE $U_DISK $U_BANDWIDTH $U_WEB_DOMAINS';
fields="$fields \$U_DATABASES"
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

214
bin/v-list-users
View file

@ -1,8 +1,8 @@
#!/bin/bash
# info: list system users
# info: list users
# options: [FORMAT]
#
# The function for obtaining the list of all server's users.
# The function to obtain the list of all system users.
#----------------------------------------------------------#
@ -12,59 +12,148 @@
# Argument definition
format=${1-shell}
# Json function
json_list_users() {
# JSON list function
json_list() {
echo '{'
fileds_count=$(echo "$fields" | wc -w)
for USER in $(grep @ /etc/passwd|cut -f 1 -d :); do
object_count=$(grep '@' /etc/passwd |wc -l)
i=1
while read USER; do
source $VESTA/data/users/$USER/user.conf
if [ -n "$data" ]; then
echo -e ' },'
echo -n ' "'$USER'": {
"FNAME": "'$FNAME'",
"LNAME": "'$LNAME'",
"PACKAGE": "'$PACKAGE'",
"WEB_TEMPLATE": "'$WEB_TEMPLATE'",
"BACKEND_TEMPLATE": "'$BACKEND_TEMPLATE'",
"PROXY_TEMPLATE": "'$PROXY_TEMPLATE'",
"DNS_TEMPLATE": "'$DNS_TEMPLATE'",
"WEB_DOMAINS": "'$WEB_DOMAINS'",
"WEB_ALIASES": "'$WEB_ALIASES'",
"DNS_DOMAINS": "'$DNS_DOMAINS'",
"DNS_RECORDS": "'$DNS_RECORDS'",
"MAIL_DOMAINS": "'$MAIL_DOMAINS'",
"MAIL_ACCOUNTS": "'$MAIL_ACCOUNTS'",
"DATABASES": "'$DATABASES'",
"CRON_JOBS": "'$CRON_JOBS'",
"DISK_QUOTA": "'$DISK_QUOTA'",
"BANDWIDTH": "'$BANDWIDTH'",
"NS": "'$NS'",
"SHELL": "'$SHELL'",
"BACKUPS": "'$BACKUPS'",
"CONTACT": "'$CONTACT'",
"CRON_REPORTS": "'$CRON_REPORTS'",
"RKEY": "'$RKEY'",
"SUSPENDED": "'$SUSPENDED'",
"SUSPENDED_USERS": "'$SUSPENDED_USERS'",
"SUSPENDED_WEB": "'$SUSPENDED_WEB'",
"SUSPENDED_DNS": "'$SUSPENDED_DNS'",
"SUSPENDED_MAIL": "'$SUSPENDED_MAIL'",
"SUSPENDED_DB": "'$SUSPENDED_DB'",
"SUSPENDED_CRON": "'$SUSPENDED_CRON'",
"IP_AVAIL": "'$IP_AVAIL'",
"IP_OWNED": "'$IP_OWNED'",
"U_USERS": "'$U_USERS'",
"U_DISK": "'$U_DISK'",
"U_DISK_DIRS": "'$U_DISK_DIRS'",
"U_DISK_WEB": "'$U_DISK_WEB'",
"U_DISK_MAIL": "'$U_DISK_MAIL'",
"U_DISK_DB": "'$U_DISK_DB'",
"U_BANDWIDTH": "'$U_BANDWIDTH'",
"U_WEB_DOMAINS": "'$U_WEB_DOMAINS'",
"U_WEB_SSL": "'$U_WEB_SSL'",
"U_WEB_ALIASES": "'$U_WEB_ALIASES'",
"U_DNS_DOMAINS": "'$U_DNS_DOMAINS'",
"U_DNS_RECORDS": "'$U_DNS_RECORDS'",
"U_MAIL_DOMAINS": "'$U_MAIL_DOMAINS'",
"U_MAIL_DKIM": "'$U_MAIL_DKIM'",
"U_MAIL_ACCOUNTS": "'$U_MAIL_ACCOUNTS'",
"U_DATABASES": "'$U_DATABASES'",
"U_CRON_JOBS": "'$U_CRON_JOBS'",
"U_BACKUPS": "'$U_BACKUPS'",
"LANGUAGE": "'$LANGUAGE'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$object_count" ]; then
echo ','
else
echo
fi
i=1
for field in $fields; do
eval value=$field
if [ $i -eq 1 ]; then
(( ++i))
echo -e "\t\"$value\": {"
else
if [ $i -lt $fileds_count ]; then
(( ++i))
echo -e "\t\t\"${field//$/}\": \"$value\","
else
echo -e "\t\t\"${field//$/}\": \"$value\""
data=1
fi
fi
done
done
if [ -n "$data" ]; then
echo -e ' }'
fi
echo -e '}'
((i++))
done < <(grep '@' /etc/passwd |cut -f1 -d:)
echo '}'
}
# Shell function
shell_list_users() {
if [ -z "$nohead" ]; then
echo "${fields//$/}"
for a in $fields; do
echo -e "--------- \c"
done
echo
fi
for USER in $(grep @ /etc/passwd|cut -f 1 -d :); do
# SHELL list function
shell_list() {
echo "USER PKG WEB DNS MAIL DB DISK BW SPND DATE"
echo "---- --- --- --- --- -- ---- -- ---- ----"
while read USER; do
source $VESTA/data/users/$USER/user.conf
for field in $fields; do
eval value=$field
if [ -z "$value" ]; then
value='NULL'
fi
echo -n "$value "
done
echo
done
echo -n "$USER $PACKAGE $U_WEB_DOMAINS $U_DNS_DOMAINS $U_MAIL_DOMAINS"
echo " $U_DATABASES $U_DISK $U_BANDWIDTH $SUSPENDED $DATE"
done < <(grep '@' /etc/passwd |cut -f1 -d:)
}
# PLAIN list function
plain_list() {
while read USER; do
source $VESTA/data/users/$USER/user.conf
echo -ne "$USER\t$FNAME\t$LNAME\t$PACKAGE\t$WEB_TEMPLATE\t"
echo -ne "$BACKEND_TEMPLATE\t$PROXY_TEMPLATE\t$DNS_TEMPLATE\t"
echo -ne "$WEB_DOMAINS\t$WEB_ALIASES\t$DNS_DOMAINS\t$DNS_RECORDS\t"
echo -ne "$MAIL_DOMAINS\t$MAIL_ACCOUNTS\t$DATABASES\t$CRON_JOBS\t"
echo -ne "$DISK_QUOTA\t$BANDWIDTH\t$NS\t$SHELL\t$BACKUPS\t"
echo -ne "$CONTACT\t$CRON_REPORTS\t$RKEY\t$SUSPENDED\t"
echo -ne "$SUSPENDED_USERS\t$SUSPENDED_WEB\t$SUSPENDED_DNS\t"
echo -ne "$SUSPENDED_MAIL\t$SUSPENDED_DB\t$SUSPENDED_CRON\t"
echo -ne "$IP_AVAIL\t$IP_OWNED\t$U_USERS\t$U_DISK\t$U_DISK_DIRS\t"
echo -ne "$U_DISK_WEB\t$U_DISK_MAIL\t$U_DISK_DB\t$U_BANDWIDTH\t"
echo -ne "$U_WEB_DOMAINS\t$U_WEB_SSL\t$U_WEB_ALIASES\t"
echo -ne "$U_DNS_DOMAINS\t$U_DNS_RECORDS\t$U_MAIL_DOMAINS\t"
echo -ne "$U_MAIL_DKIM\t$U_MAIL_ACCOUNTS\t$U_DATABASES\t"
echo -e "$U_CRON_JOBS\t$U_BACKUPS\t$LANGUAGE\t$TIME\t$DATE\t"
done < <(grep '@' /etc/passwd |cut -f1 -d:)
}
# CSV list function
csv_list() {
echo -n "USER,FNAME,LNAME,PACKAGE,WEB_TEMPLATE,BACKEND_TEMPLATE,"
echo -n "PROXY_TEMPLATE,DNS_TEMPLATE,WEB_DOMAINS,WEB_ALIASES,"
echo -n "DNS_DOMAINS,DNS_RECORDS,MAIL_DOMAINS,MAIL_ACCOUNTS,"
echo -n "DATABASES,CRON_JOBS,DISK_QUOTA,BANDWIDTH,NS,HOME,SHELL,"
echo -n "BACKUPS,CONTACT,CRON_REPORTS,RKEY,SUSPENDED,SUSPENDED_USERS,"
echo -n "SUSPENDED_WEB,SUSPENDED_DNS,SUSPENDED_MAIL,SUSPENDED_DB,"
echo -n "SUSPENDED_CRON,IP_AVAIL,IP_OWNED,U_USERS,U_DISK,U_DISK_DIRS,"
echo -n "U_DISK_WEB,U_DISK_MAIL,U_DISK_DB,U_BANDWIDTH,U_WEB_DOMAINS,"
echo -n "U_WEB_SSL,U_WEB_ALIASES,U_DNS_DOMAINS,U_DNS_RECORDS,"
echo -n "U_MAIL_DOMAINS,U_MAIL_DKIM,U_MAIL_ACCOUNTS,U_DATABASES"
echo "U_CRON_JOBS,U_BACKUPS,LANGUAGE,TIME,DATE"
while read USER; do
source $VESTA/data/users/$USER/user.conf
echo -n "$USER,\"$FNAME\",\"$LNAME\",$PACKAGE,$WEB_TEMPLATE,"
echo -n "$BACKEND_TEMPLATE,$PROXY_TEMPLATE,$DNS_TEMPLATE,"
echo -n "$WEB_DOMAINS,$WEB_ALIASES,$DNS_DOMAINS,$DNS_RECORDS,"
echo -n "$MAIL_DOMAINS,$MAIL_ACCOUNTS,$DATABASES,$CRON_JOBS,"
echo -n "$DISK_QUOTA,$BANDWIDTH,\"$NS\",$HOME,$SHELL,$BACKUPS,"
echo -n "$CONTACT,$CRON_REPORTS,\"$RKEY\",$SUSPENDED,"
echo -n "$SUSPENDED_USERS,$SUSPENDED_WEB,$SUSPENDED_DNS,"
echo -n "$SUSPENDED_MAIL,$SUSPENDED_DB,$SUSPENDED_CRON,$IP_AVAIL,"
echo -n "$IP_OWNED,$U_USERS,$U_DISK,$U_DISK_DIRS,$U_DISK_WEB,"
echo -n "$U_DISK_MAIL,$U_DISK_DB,$U_BANDWIDTH,$U_WEB_DOMAINS,"
echo -n "$U_WEB_SSL,$U_WEB_ALIASES,$U_DNS_DOMAINS,$U_DNS_RECORDS,"
echo -n "$U_MAIL_DOMAINS,$U_MAIL_DKIM,$U_MAIL_ACCOUNTS,$U_DATABASES,"
echo "$U_CRON_JOBS,$U_BACKUPS,$LANGUAGE,$TIME,$DATE"
done < <(grep '@' /etc/passwd |cut -f1 -d:)
}
# Raw list function
raw_list() {
while read USER; do
echo $VESTA/data/users/$USER/user.conf
cat $VESTA/data/users/$USER/user.conf
done < <(grep '@' /etc/passwd |cut -f1 -d:)
}
@ -72,27 +161,12 @@ shell_list_users() {
# Action #
#----------------------------------------------------------#
# Defining fileds to select
fields="\$USER \$FNAME \$LNAME \$PACKAGE \$WEB_TEMPLATE \$BACKEND_TEMPLATE"
fields="$fields \$PROXY_TEMPLATE \$DNS_TEMPLATE \$WEB_DOMAINS \$WEB_ALIASES"
fields="$fields \$DNS_DOMAINS \$DNS_RECORDS \$MAIL_DOMAINS \$MAIL_ACCOUNTS"
fields="$fields \$DATABASES \$CRON_JOBS \$DISK_QUOTA \$BANDWIDTH \$NS \$SHELL"
fields="$fields \$BACKUPS \$CONTACT \$CRON_REPORTS \$RKEY \$SUSPENDED"
fields="$fields \$SUSPENDED_USERS \$SUSPENDED_WEB \$SUSPENDED_DNS"
fields="$fields \$SUSPENDED_MAIL \$SUSPENDED_DB \$SUSPENDED_CRON \$IP_AVAIL"
fields="$fields \$IP_OWNED \$U_USERS \$U_DISK \$U_DISK_DIRS \$U_DISK_WEB"
fields="$fields \$U_DISK_MAIL \$U_DISK_DB \$U_BANDWIDTH \$U_WEB_DOMAINS"
fields="$fields \$U_WEB_SSL \$U_WEB_ALIASES \$U_DNS_DOMAINS \$U_DNS_RECORDS"
fields="$fields \$U_MAIL_DOMAINS \$U_MAIL_DKIM \$U_MAIL_ACCOUNTS"
fields="$fields \$U_DATABASES \$U_CRON_JOBS \$U_BACKUPS \$LANGUAGE"
fields="$fields \$TIME \$DATE"
# Listing domains
case $format in
json) json_list_users ;;
plain) nohead=1; shell_list_users ;;
shell) fields='$USER $PACKAGE $U_DISK $U_BANDWIDTH $SUSPENDED $DATE';
shell_list_users | column -t ;;
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

113
bin/v-list-users-stats
View file

@ -15,6 +15,100 @@ format=${1-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep DATE $VESTA/data/users/admin/overall_stats.log |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$DATE'": {
"TIME": "'$TIME'",
"PACKAGE": "'$PACKAGE'",
"IP_OWNED": "'$IP_OWNED'",
"DISK_QUOTA": "'$DISK_QUOTA'",
"U_DISK": "'$U_DISK'",
"U_DISK_DIRS": "'$U_DISK_DIRS'",
"U_DISK_WEB": "'$U_DISK_WEB'",
"U_DISK_MAIL": "'$U_DISK_MAIL'",
"U_DISK_DB": "'$U_DISK_DB'",
"BANDWIDTH": "'$BANDWIDTH'",
"U_BANDWIDTH": "'$U_BANDWIDTH'",
"U_WEB_DOMAINS": "'$U_WEB_DOMAINS'",
"U_WEB_SSL": "'$U_WEB_SSL'",
"U_WEB_ALIASES": "'$U_WEB_ALIASES'",
"U_DNS_DOMAINS": "'$U_DNS_DOMAINS'",
"U_DNS_RECORDS": "'$U_DNS_RECORDS'",
"U_MAIL_DOMAINS": "'$U_MAIL_DOMAINS'",
"U_MAIL_DKIM": "'$U_MAIL_DKIM'",
"U_MAIL_ACCOUNTS": "'$U_MAIL_ACCOUNTS'",
"U_DATABASES": "'$U_DATABASES'",
"U_CRON_JOBS": "'$U_CRON_JOBS'",
"U_BACKUPS": "'$U_BACKUPS'",
"U_USERS": "'$U_USERS'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $VESTA/data/users/admin/overall_stats.log)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "DATE USER WEB DNS MAIL DB BACKUPS IP DISK BW"
echo "---- ---- --- --- ---- -- ------- -- ---- --"
while read str; do
eval $str
if [ -z "$U_USERS" ]; then
U_USERS=1
fi
echo -n "$DATE $U_USERS $U_WEB_DOMAINS $U_DNS_DOMAINS "
echo -n "$U_MAIL_DOMAINS $U_DATABASES $U_BACKUPS $IP_OWNED "
echo "$U_DISK $U_BANDWIDTH"
done < <(cat $VESTA/data/users/admin/overall_stats.log)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$DATE\t$TIME\t$PACKAGE\t$IP_OWNED\t$DISK_QUOTA\t$U_DISK\t"
echo -ne "$U_DISK_DIRS\t$U_DISK_WEB\t$U_DISK_MAIL\t$U_DISK_DB\t"
echo -ne "$BANDWIDTH\t$U_BANDWIDTH\t$U_WEB_DOMAINS\t$U_WEB_SSL\t"
echo -ne "$U_WEB_ALIASES\t$U_DNS_DOMAINS\t$U_DNS_RECORDS\t"
echo -ne "$U_MAIL_DOMAINS\t$U_MAIL_DKIM\t$U_MAIL_ACCOUNTS\t"
echo -e "$U_DATABASES\t$U_CRON_JOBS\t$U_BACKUPS\t$U_USERS"
done < <(cat $VESTA/data/users/admin/overall_stats.log)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo -n "DATE,TIME,PACKAGE,IP_OWNED,DISK_QUOTA,U_DISK,"
echo -n "U_DISK_DIRS,U_DISK_WEB,U_DISK_MAIL,U_DISK_DB,"
echo -n "BANDWIDTH,U_BANDWIDTH,U_WEB_DOMAINS,U_WEB_SSL,"
echo -n "U_WEB_ALIASES,U_DNS_DOMAINS,U_DNS_RECORDS,"
echo -n "U_MAIL_DOMAINS,U_MAIL_DKIM,U_MAIL_ACCOUNTS,"
echo "U_DATABASES,U_CRON_JOBS,U_BACKUPS,U_USERS"
while read str; do
eval $str
echo -n "$DATE,$TIME,$PACKAGE,$IP_OWNED,$DISK_QUOTA,$U_DISK,"
echo -n "$U_DISK_DIRS,$U_DISK_WEB,$U_DISK_MAIL,$U_DISK_DB,"
echo -n "$BANDWIDTH,$U_BANDWIDTH,$U_WEB_DOMAINS,$U_WEB_SSL,"
echo -n "$U_WEB_ALIASES,$U_DNS_DOMAINS,$U_DNS_RECORDS,"
echo -n "$U_MAIL_DOMAINS,$U_MAIL_DKIM,$U_MAIL_ACCOUNTS,"
echo "$U_DATABASES,$U_CRON_JOBS,$U_BACKUPS,$U_USERS"
done < <(cat $VESTA/data/users/admin/overall_stats.log)
}
#----------------------------------------------------------#
# Verifications #
@ -33,21 +127,12 @@ if [ ! -e "$conf" ]; then
touch $conf
fi
# Defining fileds to select
fields="\$DATE \$TIME \$PACKAGE \$IP_OWNED \$DISK_QUOTA \$U_DISK \$U_DISK_DIRS"
fields="$fields \$U_DISK_WEB \$U_DISK_MAIL \$U_DISK_DB \$BANDWIDTH"
fields="$fields \$U_BANDWIDTH \$U_WEB_DOMAINS \$U_WEB_SSL \$U_WEB_ALIASES"
fields="$fields \$U_DNS_DOMAINS \$U_DNS_RECORDS \$U_MAIL_DOMAINS \$U_MAIL_DKIM"
fields="$fields \$U_MAIL_ACCOUNTS \$U_DATABASES \$U_CRON_JOBS \$U_BACKUPS"
# Listing domains
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$DATE $U_DISK $U_BANDWIDTH $U_WEB_DOMAINS $U_DATABASES';
fields="$fields \$U_DATABASES"
shell_list | column -t ;;
*) check_args '1' '0' '[FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

141
bin/v-list-web-domain
View file

@ -1,9 +1,8 @@
#!/bin/bash
# info: list web domain
# info: list web domain parameters
# options: USER DOMAIN [FORMAT]
#
# The function of obtaining the list of domain parameters. This call, just as
# all v_list_* calls, supports 3 formats - json, shell and plain.
# The function to obtain web domain parameters.
#----------------------------------------------------------#
@ -18,43 +17,87 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_domain() {
i=1
fileds_count=$(echo "$fields" | wc -w)
line=$(grep "DOMAIN='$domain'" $conf)
# JSON list function
json_list() {
echo '{'
eval $line
for field in $fields; do
eval value=$field
if [ "$i" -eq 1 ]; then
echo -e "\t\"$value\": {"
else
if [ "$fileds_count" -eq "$i" ]; then
echo -e "\t\t\"${field//$/}\": \"$value\""
else
echo -e "\t\t\"${field//$/}\": \"$value\","
fi
fi
(( ++i))
done
if [ -n "$value" ]; then
echo -e ' }'
fi
echo -e "}"
echo ' "'$DOMAIN'": {
"IP": "'$IP'",
"IP6": "'$IP6'",
"U_DISK": "'$U_DISK'",
"U_BANDWIDTH": "'$U_BANDWIDTH'",
"TPL": "'$TPL'",
"ALIAS": "'$ALIAS'",
"STATS": "'$STATS'",
"STATS_USER": "'$STATS_USER'",
"SSL": "'$SSL'",
"SSL_HOME": "'$SSL_HOME'",
"FTP_USER": "'$FTP_USER'",
"FTP_PATH": "'$FTP_PATH'",
"AUTH_USER": "'$AUTH_USER'",
"BACKEND": "'$BACKEND'",
"PROXY": "'$PROXY'",
"PROXY_EXT": "'$PROXY_EXT'",
"DOCUMENT_ROOT": "'$HOMEDIR/$user/web/$domain/public_html'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
echo '}'
}
# Shell function
shell_list_domain() {
line=$(grep "DOMAIN='$domain'" $conf)
eval $line
for field in $fields; do
eval key="$field"
if [ -z "$key" ]; then
key='NULL'
fi
echo "${field//$/}: $key "
done
# SHELL list function
shell_list() {
source $VESTA/conf/vesta.conf
echo "DOMAIN: $DOMAIN"
echo "ALIAS: ${ALIAS//,/ }"
echo "IP: $IP"
if [ ! -z "$IP6" ]; then
echo "IP6: $IP6"
fi
if [ ! -z "$SSL" ] && [ "$SSL" != 'no' ]; then
echo "SSL: $SSL / $SSL_HOME"
fi
echo "TEMPLATE: $TPL"
if [ ! -z "$WEB_BACKEND" ]; then
echo "BACKEND: $BACKEND"
fi
if [ ! -z "$PROXY_SYSTEM" ]; then
echo "PROXY: $PROXY"
echo "PROXY EXT: ${PROXY_EXT//,/ }"
fi
if [ ! -z "$STATS" ]; then
echo "STATS: $STATS"
fi
if [ ! -z "$FTP_USER" ]; then
echo "FTP_USER: ${FTP_USER//,/, }"
fi
if [ ! -z "$AUTH_USER" ]; then
echo "HTTP_AUTH: $AUTH_USER"
fi
echo "DISK: $U_DISK"
echo "BW: $U_BANDWIDTH"
echo "SUSPENDED: $SUSPENDED"
echo "TIME: $TIME"
echo "DATE: $DATE"
}
# PLAIN list function
plain_list() {
echo -ne "$DOMAIN\t$IP\t$IP6\t$U_DISK\t$U_BANDWIDTH\t$TPL\t"
echo -ne "$ALIAS\t$STATS\t$STATS_USER\t$SSL\t$SSL_HOME\t"
echo -ne "$FTP_USER\t$FTP_PATH\t$AUTH_USER\t$BACKEND\t$PROXY\t"
echo -e "$PROXY_EXT\t$SUSPENDED\t$TIME\t$DATE"
}
# CSV list function
csv_list() {
echo -n "DOMAIN,IP,IP6,U_DISK,U_BANDWIDTH,TPL,ALIAS,STATS,STATS_USER,SSL,"
echo -n "SSL_HOME,FTP_USER,FTP_PATH,AUTH_USER,BACKEND,PROXY,PROXY_EXT,"
echo "SUSPENDED,TIME,DATE"
echo -n "$DOMAIN,$IP,$IP6,$U_DISK,$U_BANDWIDTH,$TPL,\"$ALIAS\",$STATS"
echo -n "\"$STATS_USER\",$SSL,$SSL_HOME,\"$FTP_USER\",\"$FTP_PATH\","
echo -n "\"$AUTH_USER\",$BACKEND,$PROXY,\"$PROXY_EXT\",$SUSPENDED,$TIME,"
echo "$DATE"
}
@ -71,23 +114,15 @@ is_object_valid 'web' 'DOMAIN' "$domain"
# Action #
#----------------------------------------------------------#
# Defining config
conf=$USER_DATA/web.conf
# Parsing domain
eval $(grep "DOMAIN='$domain'" $USER_DATA/web.conf)
# Defining fileds to select
fields='$DOMAIN $IP $IP6 $U_DISK $U_BANDWIDTH $TPL $ALIAS $STATS $STATS_USER
$SSL $SSL_HOME $FTP_USER $FTP_PATH $BACKEND $PROXY $PROXY_EXT $AUTH_USER
$DOCUMENT_ROOT $SUSPENDED $TIME $DATE'
# Defining document root
DOCUMENT_ROOT="$HOMEDIR/$user/web/$domain/public_html"
# Listing domains
case $format in
json) json_list_domain ;;
plain) nohead=1; shell_list_domain ;;
shell) shell_list_domain |column -t;;
*) check_args '2' '0' 'USER DOMAIN [FORMAT]'
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

36
bin/v-list-web-domain-accesslog
View file

@ -19,14 +19,14 @@ format=${4-shell}
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# Json function
json_list_log() {
# JSON list function
json_list() {
i=1
objects=$(echo "$lines" |wc -l)
echo '['
for str in $lines; do
str=$(echo "$str" |sed -e 's/"/\\"/g')
if [ "$i" -lt "$counter" ]; then
if [ "$i" -lt "$objects" ]; then
echo -e "\t\"$str\","
else
echo -e "\t\"$str\""
@ -36,17 +36,29 @@ json_list_log() {
echo "]"
}
# Shell function
shell_list_log() {
# SHELL list function
shell_list() {
echo "$lines"
}
# PLAIN list function
plain_list() {
echo "$lines"
}
# CSV list function
csv_list() {
echo "LOG"
echo "$lines"
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '2' "$#" 'USER DOMAIN [LINES] [FORMAT]'
validate_format 'user' 'domain' 'ttl'
is_format_valid 'user' 'domain' 'ttl'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'web' 'DOMAIN' "$domain"
@ -63,14 +75,14 @@ else
fi
lines=$($read_cmd /var/log/$WEB_SYSTEM/domains/$domain.log)
counter=$(echo "$lines" |wc -l)
IFS=$'\n'
# Listing logs
# Listing data
case $format in
json) json_list_log ;;
plain) shell_list_log ;;
shell) shell_list_log ;;
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

36
bin/v-list-web-domain-errorlog
View file

@ -19,14 +19,14 @@ format=${4-shell}
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# Json function
json_list_log() {
# JSON list function
json_list() {
i=1
objects=$(echo "$lines" |wc -l)
echo '['
for str in $lines; do
str=$(echo "$str" |sed -e 's/"/\\"/g')
if [ "$i" -lt "$counter" ]; then
if [ "$i" -lt "$objects" ]; then
echo -e "\t\"$str\","
else
echo -e "\t\"$str\""
@ -36,17 +36,29 @@ json_list_log() {
echo "]"
}
# Shell function
shell_list_log() {
# SHELL list function
shell_list() {
echo "$lines"
}
# PLAIN list function
plain_list() {
echo "$lines"
}
# CSV list function
csv_list() {
echo "LOG"
echo "$lines"
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '2' "$#" 'USER DOMAIN [LINES] [FORMAT]'
validate_format 'user' 'domain' 'ttl'
is_format_valid 'user' 'domain' 'ttl'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'web' 'DOMAIN' "$domain"
@ -63,14 +75,14 @@ else
fi
lines=$($read_cmd /var/log/$WEB_SYSTEM/domains/$domain.error.log)
counter=$(echo "$lines" |wc -l)
IFS=$'\n'
# Listing logs
# Listing data
case $format in
json) json_list_log ;;
plain) shell_list_log ;;
shell) shell_list_log ;;
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

93
bin/v-list-web-domain-ssl
View file

@ -17,19 +17,25 @@ format=${3-shell}
# Includes
source $VESTA/func/main.sh
# Json function
json_list_ssl() {
i='1' # iterator
# JSON list function
json_list() {
echo '{'
echo -e "\t\"$domain\": {"
echo " \"CRT\": \"$crt\","
echo " \"KEY\": \"$key\","
echo " \"CA\": \"$ca\""
echo " \"CA\": \"$ca\","
echo " \"SUBJECT\": \"$subj\","
echo " \"ALIASES\": \"$alt_dns\","
echo " \"NOT_BEFORE\": \"$before\","
echo " \"NOT_AFTER\": \"$after\","
echo " \"SIGNATURE\": \"$signature\","
echo " \"PUB_KEY\": \"$pub_key\","
echo " \"ISSUER\": \"$issuer\""
echo -e "\t}\n}"
}
# Shell function
shell_list_ssl() {
# SHELL list function
shell_list() {
if [ ! -z "$crt" ]; then
echo -e "$crt"
fi
@ -39,6 +45,50 @@ shell_list_ssl() {
if [ ! -z "$ca" ]; then
echo -e "\n$ca"
fi
if [ ! -z "$crt" ]; then
echo
echo
echo "SUBJECT: $subj"
if [ ! -z "$alt_dns" ]; then
echo "ALIASES: ${alt_dns//,/ }"
fi
echo "VALID FROM: $before"
echo "VALID TIL: $after"
echo "SIGNATURE: $signature"
echo "PUB_KEY: $pub_key"
echo "ISSUER: $issuer"
fi
}
# PLAIN list function
plain_list() {
if [ ! -z "$crt" ]; then
echo -e "$crt"
fi
if [ ! -z "$key" ]; then
echo -e "\n$key"
fi
if [ ! -z "$ca" ]; then
echo -e "\n$ca"
fi
if [ ! -z "$crt" ]; then
echo "$subj"
echo "${alt_dns//,/ }"
echo "$before"
echo "$after"
echo "$signature"
echo "$pub_key"
echo "$issuer"
fi
}
# CSV list function
csv_list() {
echo -n "CRT,KEY,CA,SUBJECT,ALIASES,NOT_BEFORE,NOT_AFTER,SIGNATURE,"
echo "PUB_KEY,ISSUER"
echo -n "\"$crt\",\"$key\",\"$ca\",\"$subj\",\"${alt_dns//,/ }\","
echo "\"$before\",\"$after\",\"$signature\",\"$pub_key\",\"$issuer\""
}
@ -50,27 +100,42 @@ check_args '2' "$#" 'USER DOMAIN [FORMAT]'
is_object_valid 'user' 'USER' "$user"
is_object_valid 'web' 'DOMAIN' "$domain"
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Parsing domain SSL certificate
if [ -e "$USER_DATA/ssl/$domain.crt" ]; then
crt=$(cat $USER_DATA/ssl/$domain.crt | sed ':a;N;$!ba;s/\n/\\n/g' )
crt=$(cat $USER_DATA/ssl/$domain.crt |sed ':a;N;$!ba;s/\n/\\n/g')
info=$(openssl x509 -text -in $USER_DATA/ssl/$domain.crt)
subj=$(echo "$info" |grep Subject: |cut -f 2 -d =)
before=$(echo "$info" |grep Before: |sed -e "s/.*Before: //")
after=$(echo "$info" |grep "After :" |sed -e "s/.*After : //")
signature=$(echo "$info" |grep "Algorithm:" |head -n1 )
signature=$(echo "$signature"| sed -e "s/.*Algorithm: //")
pub_key=$(echo "$info" |grep Public-Key: |cut -f2 -d \( | tr -d \))
issuer=$(echo "$info" |grep Issuer: |sed -e "s/.*Issuer: //")
alt_dns=$(echo "$info" |grep DNS |sed -e 's/DNS:/\n/g' |tr -d ',')
alt_dns=$(echo "$alt_dns" |tr -d ' ' |sed -e "/^$/d")
alt_dns=$(echo "$alt_dns" |sed -e ':a;N;$!ba;s/\n/,/g')
fi
if [ -e "$USER_DATA/ssl/$domain.key" ]; then
key=$(cat $USER_DATA/ssl/$domain.key | sed ':a;N;$!ba;s/\n/\\n/g' )
key=$(cat $USER_DATA/ssl/$domain.key |sed ':a;N;$!ba;s/\n/\\n/g')
fi
if [ -e "$USER_DATA/ssl/$domain.ca" ]; then
ca=$(cat $USER_DATA/ssl/$domain.ca | sed ':a;N;$!ba;s/\n/\\n/g' )
ca=$(cat $USER_DATA/ssl/$domain.ca |sed ':a;N;$!ba;s/\n/\\n/g')
fi
# Listing domains
# Listing data
case $format in
json) json_list_ssl ;;
plain) nohead=1; shell_list_ssl ;;
shell) shell_list_ssl ;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

99
bin/v-list-web-domains
View file

@ -2,7 +2,7 @@
# info: list web domains
# options: USER [FORMAT]
#
# The function of obtaining the list of all user domains.
# The function to obtain the list of all user web domains.
#----------------------------------------------------------#
@ -16,13 +16,89 @@ format=${2-shell}
# Includes
source $VESTA/func/main.sh
# JSON list function
json_list() {
IFS=$'\n'
i=1
objects=$(grep DOMAIN $USER_DATA/web.conf |wc -l)
echo "{"
while read str; do
eval $str
echo -n ' "'$DOMAIN'": {
"IP": "'$IP'",
"IP6": "'$IP6'",
"U_DISK": "'$U_DISK'",
"U_BANDWIDTH": "'$U_BANDWIDTH'",
"TPL": "'$TPL'",
"ALIAS": "'$ALIAS'",
"STATS": "'$STATS'",
"STATS_USER": "'$STATS_USER'",
"SSL": "'$SSL'",
"SSL_HOME": "'$SSL_HOME'",
"FTP_USER": "'$FTP_USER'",
"FTP_PATH": "'$FTP_PATH'",
"AUTH_USER": "'$AUTH_USER'",
"BACKEND": "'$BACKEND'",
"PROXY": "'$PROXY'",
"PROXY_EXT": "'$PROXY_EXT'",
"SUSPENDED": "'$SUSPENDED'",
"TIME": "'$TIME'",
"DATE": "'$DATE'"
}'
if [ "$i" -lt "$objects" ]; then
echo ','
else
echo
fi
((i++))
done < <(cat $USER_DATA/web.conf)
echo '}'
}
# SHELL list function
shell_list() {
IFS=$'\n'
echo "DOMAIN IP TPL SSL DISK BW SPND DATE"
echo "------ -- --- --- ---- -- ---- ----"
while read str; do
eval $str
echo "$DOMAIN $IP $TPL $SSL $U_DISK $U_BANDWIDTH $SUSPENDED $DATE"
done < <(cat $USER_DATA/web.conf)
}
# PLAIN list function
plain_list() {
IFS=$'\n'
while read str; do
eval $str
echo -ne "$DOMAIN\t$IP\t$IP6\t$U_DISK\t$U_BANDWIDTH\t$TPL\t"
echo -ne "$ALIAS\t$STATS\t$STATS_USER\t$SSL\t$SSL_HOME\t"
echo -ne "$FTP_USER\t$FTP_PATH\t$AUTH_USER\t$BACKEND\t$PROXY\t"
echo -e "$PROXY_EXT\t$SUSPENDED\t$TIME\t$DATE"
done < <(cat $USER_DATA/web.conf)
}
# CSV list function
csv_list() {
IFS=$'\n'
echo -n "DOMAIN,IP,IP6,U_DISK,U_BANDWIDTH,TPL,ALIAS,STATS,STATS_USER,"
echo -n "SSL,SSL_HOME,FTP_USER,FTP_PATH,AUTH_USER,BACKEND,PROXY,"
echo "PROXY_EXT,SUSPENDED,TIME,DATE"
while read str; do
eval $str
echo -n "$DOMAIN,$IP,$IP6,$U_DISK,$U_BANDWIDTH,$TPL,"
echo -n "\"$ALIAS\",$STATS,\"$STATS_USER\",$SSL,$SSL_HOME,"
echo -n "\"$FTP_USER\",\"$FTP_PATH\",\"$AUTH_USER\",$BACKEND,$PROXY,"
echo "\"$PROXY_EXT\",$SUSPENDED,$TIME,$DATE"
done < <(cat $USER_DATA/web.conf)
}
#----------------------------------------------------------#
# Verifications #
#----------------------------------------------------------#
check_args '1' "$#" 'USER [FORMAT]'
validate_format 'user'
is_object_valid 'user' 'USER' "$user"
@ -30,21 +106,12 @@ is_object_valid 'user' 'USER' "$user"
# Action #
#----------------------------------------------------------#
# Defining config
conf=$USER_DATA/web.conf
# Defining fileds to select
fields="\$DOMAIN \$IP \$IP6 \$U_DISK \$U_BANDWIDTH \$TPL \$ALIAS \$STATS"
fields="$fields \$STATS_USER \$SSL \$SSL_HOME \$FTP_USER \$FTP_PATH \$AUTH_USER"
fields="$fields \$BACKEND \$PROXY \$PROXY_EXT \$SUSPENDED \$TIME \$DATE"
# Listing domains
case $format in
# Listing data
case $format in
json) json_list ;;
plain) nohead=1; shell_list ;;
shell) fields='$DOMAIN $IP $U_DISK $U_BANDWIDTH $TPL $DATE';
shell_list | column -t ;;
*) check_args '1' '0' 'USER [FORMAT]'
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list |column -t ;;
esac

60
bin/v-list-web-stats
View file

@ -16,32 +16,43 @@ format=${1-shell}
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# Json function
json_list_st() {
stats=$(echo "${STATS_SYSTEM//,/ } none")
st_counter=$(echo "$stats" | wc -w)
# JSON list function
json_list() {
objects=$(echo "$stats" | wc -w)
i=1
echo '['
for st in $stats; do
if [ "$i" -lt "$st_counter" ]; then
echo -e "\t\"$st\","
for str in $stats; do
if [ "$i" -lt "$objects" ]; then
echo -e "\t\"$str\","
else
echo -e "\t\"$st\""
echo -e "\t\"$str\""
fi
(( ++i))
done
echo "]"
}
# Shell function
shell_list_st() {
stats=$(echo "none ${STATS_SYSTEM//,/ }")
if [ -z "$nohead" ]; then
echo "STATS"
echo "----------"
fi
for st in $stats; do
echo "$st"
# SHELL list function
shell_list() {
echo "PARSER"
echo "------"
for parser in $stats; do
echo "$parser"
done
}
# PLAIN list function
plain_list() {
for parser in $stats; do
echo "$parser"
done
}
# CSV list function
csv_list() {
echo "PARSER"
for parser in $stats; do
echo "$parser"
done
}
@ -50,12 +61,15 @@ shell_list_st() {
# Action #
#----------------------------------------------------------#
# Listing domains
case $format in
json) json_list_st ;;
plain) nohead=1; shell_list_st ;;
shell) shell_list_st ;;
*) check_args '1' '0' '[FORMAT]' ;;
# Parsing stats system
stats=$(echo "none ${STATS_SYSTEM//,/ }")
# Listing data
case $format in
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

52
bin/v-list-web-templates
View file

@ -16,15 +16,13 @@ format=${1-shell}
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# Json function
json_list_wtpl() {
templates=$(ls -v $WEBTPL/$WEB_SYSTEM/$WEB_BACKEND/)
templates=$(echo "$templates" | grep '\.tpl' | sed 's/\.tpl$//')
t_counter=$(echo "$templates" | wc -w)
# JSON list function
json_list() {
objects=$(echo "$templates" |wc -w)
i=1
echo '['
for template in $templates; do
if [ "$i" -lt "$t_counter" ]; then
if [ "$i" -lt "$objects" ]; then
echo -e "\t\"$template\","
else
echo -e "\t\"$template\""
@ -34,31 +32,45 @@ json_list_wtpl() {
echo "]"
}
# Shell function
shell_list_wtpl() {
templates=$(ls -v $WEBTPL/$WEB_SYSTEM/$WEB_BACKEND/)
templates=$(echo "$templates" | grep '\.tpl' | sed 's/\.tpl$//')
if [ -z "$nohead" ]; then
echo "Templates"
echo "----------"
fi
# SHELL list function
shell_list() {
echo "TEMPLATE"
echo "--------"
for template in $templates; do
echo "$template"
done
}
# PLAIN list function
plain_list() {
for template in $templates; do
echo "$template"
done
}
# CSV list function
csv_list() {
echo "TEMPLATE"
for template in $templates; do
echo "$template"
done
}
#----------------------------------------------------------#
# Action #
#----------------------------------------------------------#
# Listing domains
# Parsing templates
templates=$(ls -v $WEBTPL/$WEB_SYSTEM/$WEB_BACKEND/)
templates=$(echo "$templates" |grep '\.tpl' |sed 's/\.tpl$//')
# Listing data
case $format in
json) json_list_wtpl ;;
plain) nohead=1; shell_list_wtpl ;;
shell) shell_list_wtpl ;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

58
bin/v-list-web-templates-backend
View file

@ -16,13 +16,13 @@ format=${1-shell}
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# Json function
json_list_wtpl() {
t_counter=$(echo "$templates" | wc -w)
# JSON list function
json_list() {
i=1
objects=$(echo "$templates" |wc -w)
echo '['
for template in $templates; do
if [ "$i" -lt "$t_counter" ]; then
if [ "$i" -lt "$objects" ]; then
echo -e "\t\"$template\","
else
echo -e "\t\"$template\""
@ -30,14 +30,27 @@ json_list_wtpl() {
(( ++i))
done
echo "]"
}
}
# Shell function
shell_list_wtpl() {
if [ -z "$nohead" ]; then
echo "Templates"
echo "----------"
fi
# SHELL list function
shell_list() {
echo "TEMPLATE"
echo "--------"
for template in $templates; do
echo "$template"
done
}
# PLAIN list function
plain_list() {
for template in $templates; do
echo "$template"
done
}
# CSV list function
csv_list() {
echo "TEMPLATE"
for template in $templates; do
echo "$template"
done
@ -48,21 +61,20 @@ shell_list_wtpl() {
# Action #
#----------------------------------------------------------#
# Proxy templates
if [ -z "$WEB_BACKEND" ]; then
exit
# Parsing backend templates
if [ ! -z "$WEB_BACKEND" ]; then
templates=$(ls -t $WEBTPL/$WEB_BACKEND |\
cut -f1 -d . |\
grep -v proxy_ip |\
sort -u )
fi
templates=$(ls -t $WEBTPL/$WEB_BACKEND |\
cut -f1 -d . |\
grep -v proxy_ip |\
sort -u )
# Listing domains
# Listing data
case $format in
json) json_list_wtpl ;;
plain) nohead=1; shell_list_wtpl ;;
shell) shell_list_wtpl ;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac

58
bin/v-list-web-templates-proxy
View file

@ -16,13 +16,13 @@ format=${1-shell}
source $VESTA/func/main.sh
source $VESTA/conf/vesta.conf
# Json function
json_list_wtpl() {
t_counter=$(echo "$templates" | wc -w)
# JSON list function
json_list() {
objects=$(echo "$templates" |wc -w)
i=1
echo '['
for template in $templates; do
if [ "$i" -lt "$t_counter" ]; then
if [ "$i" -lt "$objects" ]; then
echo -e "\t\"$template\","
else
echo -e "\t\"$template\""
@ -30,14 +30,27 @@ json_list_wtpl() {
(( ++i))
done
echo "]"
}
}
# Shell function
shell_list_wtpl() {
if [ -z "$nohead" ]; then
echo "Templates"
echo "----------"
fi
# SHELL list function
shell_list() {
echo "TEMPLATE"
echo "--------"
for template in $templates; do
echo "$template"
done
}
# PLAIN list function
plain_list() {
for template in $templates; do
echo "$template"
done
}
# CSV list function
csv_list() {
echo "TEMPLATE"
for template in $templates; do
echo "$template"
done
@ -48,21 +61,20 @@ shell_list_wtpl() {
# Action #
#----------------------------------------------------------#
# Proxy templates
if [ -z "$PROXY_SYSTEM" ]; then
exit
# Parsing proxy templates
if [ ! -z "$PROXY_SYSTEM" ]; then
templates=$(ls -t $WEBTPL/$PROXY_SYSTEM |\
cut -f1 -d . |\
grep -v proxy_ip |\
sort -u )
fi
templates=$(ls -t $WEBTPL/$PROXY_SYSTEM |\
cut -f1 -d . |\
grep -v proxy_ip |\
sort -u )
# Listing domains
# Listing data
case $format in
json) json_list_wtpl ;;
plain) nohead=1; shell_list_wtpl ;;
shell) shell_list_wtpl ;;
*) check_args '1' '0' '[FORMAT]'
json) json_list ;;
plain) plain_list ;;
csv) csv_list ;;
shell) shell_list ;;
esac