milis/bin/mps

3677 lines
97 KiB
Bash
Executable File
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/bin/bash
versiyon="1.2.1 Milis Paket Sistemi"
iletisim="milisarge@gmail.com"
betikad=${0##*/}
betikyol="$0"
shelltip=$(basename `cat $betikyol | head -n1 | cut -d'!' -f2 | cut -d' ' -f1`)
# sistem araçlarının tespiti ve atanması
#if [ ${shelltip} = "busybox" ] || [ ${shelltip} = "ash" ];then
if [ ${BASH_VERSION} ];then
wget_progress="--show-progress"
else
alias sed="busybox sed"
alias wget="busybox wget"
wget_progress=""
fi
#alias sed="sed"
if [ -f /etc/mps.conf ];then
. /etc/mps.conf
else
echo "/etc/mps.conf ayar dosyası bulunamadı!"
fi
if [ -z ${paketdepo+:} ]; then
paketdepo="/depo/paketler/"
fi
if [ -z ${sunucu+:} ]; then
sunucu="127.0.0.1:8000/"
fi
git_sunucu="https://notabug.org"
git_sunucu_eski="https://github.com"
[ -d /sources/milis.git/.git ] && cat /sources/milis.git/.git/config | grep "url =" | grep "${git_sunucu_eski}" &> /dev/null
if [ $? -eq 0 ];then
echo "eski git sunucusundan göç ediliyor."
_gockom="mv /sources/milis.git /sources/milis.git.eski"
if [ $(whoami) == "root" ];then
$_gockom
else
sudo $_gockom
fi
fi
if [ -z ${hesap_repo+:} ]; then
hesap_repo="milislinux/milis"
fi
if [ -z ${git_repo+:} ]; then
git_repo="${git_sunucu}/${hesap_repo}"
fi
if [ -z ${git_yereldepo+:} ]; then
git_yereldepo="/sources/milis.git"
fi
if [ -z ${kaynak_dizin+:} ]; then
kaynak_dizin="/sources"
fi
if [ -z ${anatalimatname+:} ]; then
anatalimatname="${git_yereldepo}/talimatname"
fi
if [ -z ${ektalimatname_repo+:} ]; then
ektalimatname_repo="${git_sunucu}/milislinux/ek-talimatlar"
fi
if [ -z ${talimatname+:} ]; then
talimatname="/root/talimatname"
fi
if [ -z ${kokdizin+:} ]; then
kokdizin="/"
fi
#temel paket koruma
if [ -z ${tpk+:} ]; then
tpk="evet"
fi
if [ -z ${lokal+:} ]; then
lokal="tr"
fi
if [ -z ${docsil+:} ]; then
docsil="evet"
fi
if [ -z ${yerelsil+:} ]; then
yerelsil="silme"
fi
if [ -z ${ektalimatname+:} ]; then
ektalimatname="/root/talimatlar"
[ ! -d /root/talimatlar ] && mkdir -p /root/talimatlar
fi
if [ -z ${sunucular+:} ]; then
sunucular="paketler.milislinux.org"
awk ' {print;} NR == 1 { print "sunucular=\"paketler.milislinux.org/\""; }' /etc/mps.conf > /etc/mps2.conf
mv /etc/mps2.conf /etc/mps.conf
else
_satirno=$(grep -nr "sunucular=(" /etc/mps.conf | cut -d':' -f1)
if [ ! -z ${_satirno} ];then
echo "mps.conf düzeltildi.kontrol ediniz."
sed "${_satirno}s/(/"\""/;${_satirno}s/)/"\""/" /etc/mps.conf > /etc/mps.conf.yeni
mv /etc/mps.conf.yeni /etc/mps.conf
fi
fi
if [ -z ${silme_esgec+:} ]; then
silme_esgec=""
fi
if [ -z ${esgec+:} ]; then
esgec=""
fi
esgec="xorg xorg-app xorg-font xorg-proto kernel-lts kernel-lts-src"
kurulum_onay="evet"
VT="/var/lib/pkg/DB"
TARIHCE_DIZIN="/var/lib/pkg/tarihce"
LOGDIZIN="/var/log/mps"
tekrarkur="hayir"
logdosya="/var/log/mps/mps.log"
GRUP_DOSYA="/sources/milis.git/ayarlar/gruplar"
# Türkçe Mesajlar
_paket_adi_gerekli="paket ismi eksik!"
_dizin_bulunamadi="dizin bulunamadı!"
_talimat_sayisi_fazla="talimatnameler altında birden fazla talimat mevcut!"
_talimat_bulunamadi="ilgili talimat bulunamadı!"
_talimatsiz_dizin="ilgili dizinde talimat bulunamadı!"
_dosya_yolu_bulunamadi="dosya yolu bulunamadı!"
_shasum_uyumsuzluk="shasum uyumsuzluğu tespit edildi!"
_gerekler_belirleniyor="bağımlılıkları belirleniyor."
_yerel_paket_yok="mevcut dizinde mps.lz paketi yok!"
_paket_kuruldu="paketi kuruldu."
_paket_kurulu="kurulu"
_paket_kurulu_degil="paketi kurulu değil!"
_paket_silindi="paketi silindi."
_paket_silinsinmi="paketi kaldırılsın mı?"
_paket_tanimsiz="paketi tanımsız!"
_paket_bulunamadi="ilgili paket bulunamadı!"
_paketvt_guncelleniyor="paket veritabanı güncelleniyor."
_paket_onbellek_depoda_var="paketi önbellek depoda bulunmakta."
_paket_depoda_yok="paket depoda bulunmuyor ve gereksiz,"
_siliniyor="siliniyor"
_git_guncelleniyor="git sunucudan güncelleme çekiliyor."
_git_guncel="git deposu güncel"
_git_guncellendi="git deposu güncellendi."
_yerel_esitlendi="yerele eşitleme tamam."
_yerel_esitlendi_olumsuz="yerele eşitleme olumsuz."
_yerel_esitleniyor="yerele eşitleniyor."
_devir_kontrol_iptal="devir kontrolü iptal edildi!"
_surum_kontrol_iptal="sürüm kontrolü iptal edildi!"
_zaten="zaten"
_indiriliyor="indiriliyor"
export _paketguncel=0
# renkli yazma öntanımlı atamaları
_yaz="ryaz 32"
_yaz_tm="ryaz 34"
_yaz_uyari="ryaz 31"
_yaz_bilgi="ryaz 33"
hata_olustu(){
local _hata _mesaj
[ -z $1 ] && exit 1
_hata=$1
case $_hata in
"_paket_adi_gerekli")
_mesaj="$_paket_adi_gerekli"
;;
"_talimatsiz_dizin")
_mesaj="$_talimatsiz_dizin"
;;
"_talimat_bulunamadi")
_mesaj="$_talimat_bulunamadi"
;;
"_yerel_paket_yok")
_mesaj="$_yerel_paket_yok"
;;
*)
_mesaj="böyle bir hata yok"
;;
esac
echo ${_mesaj}
exit 1
}
cikti_renk_ayarla(){
local cikti
cikti="--renkli"
if [ "$1" ]; then
if [ "$1" = "--normal" ];then
cikti="--normal"
fi
fi
if [ $cikti = "--renkli" ];then
_yaz="ryaz 32"
_yaz_tm="ryaz 34"
_yaz_uyari="ryaz 31"
else
_yaz="echo"
_yaz_tm="echo"
_yaz_uyari="echo"
_yaz_bilgi="echo"
fi
}
icerik_ekle(){
if [ -f "$1" ];then
paketad=`echo "$1" | cut -d'#' -f1`
paketad=`basename $paketad`
$_yaz_tm "$paketad paketi kuruluyor-> $kokdizin"
if [ -f /usr/bin/bsdtar ];then
bsdtar -C /tmp --extract --file=$1 .PRE 1 2> /tmp/$paketad_pre.log
else
tar -C /tmp --extract --file=$1 .PRE 1 2> /tmp/$paketad_pre.log
fi
#kos-kur kontrolu
if [ -f /tmp/.PRE ];then
if [ "$kokdizin" == "/" ];then
bash /tmp/.PRE
else
cp /tmp/.PRE $kokdizin/tmp/$paketad.PRE
fi
rm /tmp/.PRE
fi
mkdir -p kur.$paketad &&
if [ -f /usr/bin/bsdtar ];then
bsdtar xf $1 -C kur.$paketad
else
tar xf $1 -C kur.$paketad
fi
#istenmeyen yerellerin silinmesi
if [ -d kur.$paketad/usr/share/locale ] && [ "$yerelsil" == "evet" ];then
for lkl in `ls kur.$paketad/usr/share/locale/`;do
if [ "$lkl" != "$lokal" ];then rm -r kur.$paketad/usr/share/locale/$lkl; fi
done
fi
#doc dizini silinmesi
if [ -d kur.$paketad/usr/share/doc ] && [ "$docsil" == "evet" ];then
rm -r kur.$paketad/usr/share/doc
fi
mkdir -p $kokdizin$VT/"$paketad" &&
cp -v -afr kur.$paketad/* $kokdizin > kur.$paketad/kurulan
cp kur.$paketad/kurulan /tmp/ &&cat kur.$paketad/kurulan | cut -d '>' -f2 > $kokdizin$VT/"$paketad"/kurulan &&
#mv kur.$paketad/.MTREE $VT/"$paketad"/files &&
mv kur.$paketad/.META $kokdizin$VT/"$paketad"/META &&
#kur-kos calistirilmasi
if [ -f kur.$paketad/.POST ];then
if [ "$kokdizin" == "/" ];then
bash kur.$paketad/.POST
else
cp kur.$paketad/.POST $kokdizin/tmp/$paketad.POST
fi
rm kur.$paketad/.POST
fi
rm -r kur.$paketad
if [ -f $kokdizin/etc/ld.so.conf ];then
ldconfig -r $kokdizin
fi
$_yaz_tm "$paketad $_paket_kuruldu"
loglama "$paketad $_paket_kuruldu"
else
$_yaz_uyari "icerik_ekle:paket konum parametresi boş!!!"
exit 1
fi
}
paket_sil(){
local paket kkont sil_onay oto_silme _silinecekler
[ -z $1 ] && hata_olustu "_paket_adi_gerekli" || paket=$1
tersbag_goster="hayir"
_silinecekler=/tmp/$paket.sil
cikti="--renkli"
if [ "$2" ]; then
if [ "$2" == "--normal" ];then
cikti_renk_ayarla "--normal"
else
oto_silme="$2"
fi
fi
if [ "$3" ]; then
if [ "$3" == "--normal" ];then
cikti_renk_ayarla "--normal"
else
tersbag_goster="evet"
fi
fi
if [ "$tpk" = "evet" ] && [ -d "$talimatname/temel/$1" ];then
$_yaz_uyari "$1 temel sistem paketidir.Silinemez!!!"
hataloglama "$1 temel sistem paketidir.Silinemez!!!"
else
kkont=`kurulu_kontrol "$1"`
if [ "$kkont" = "kurulu" ];then
if [ -f "$VT/$paket/kurulan" ];then
#eski dizin koruma
#etkilenen_kurtar $1 $cikti
cat $VT/$paket/kurulan | cut -d '>' -f2 > ${_silinecekler}
if [ "$tersbag_goster" = "evet" ];then
$_yaz_uyari "ters bagimliliklar"
$_yaz_uyari "------------------"
ters_bagimli_bilgi "$paket"
$_yaz_uyari "------------------"
fi
# eski silme etkilenme kurtarma
#$_yaz_uyari "etkilenen dosyalar"
#$_yaz_uyari "------------------"
#silme_etkilenen_kontrol /tmp/$paket.sil $paket
#$_yaz_uyari "------------------"
# ------------
# yeni silme etkilenen kurtarma
silme_etkilenme_tespit $paket
# silme listesi güncelleme - dizin koruma
# bir paket silinirken dizin yapısındaki diğer paketlerin dosyaları korunacak.
if [ -f /tmp/${paket}_kd.liste ];then
for _kurtar in $(cat /tmp/${paket}_kd.liste);do
echo "$(grep -v "'${_kurtar}'" ${_silinecekler})" > ${_silinecekler}
done
$_yaz_bilgi "etkilenen konumlar korundu."
#else
#$_yaz_bilgi "kurtarılacak dosya yok."
fi
if [ "$oto_silme" = "evet" ];then
sil_onay="e"
else
while true; do
$_yaz_tm $paket" $_paket_silinsinmi";read -p "e veya h-> " eh
case $eh in
[Ee]* ) sil_onay="e"; break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
fi
if [ "$sil_onay" = "e" ];then
_konum=$(talimat_bul $paket)
[ -f "$_konum/$paket.kos-sil" ] && bash "$_konum/$paket.kos-sil"
xargs rm -r -f < ${_silinecekler} &&
rm -r -f "$VT/$paket" &&
[ -f "$_konum/$paket.sil-kos" ] && bash "$_konum/$paket.sil-kos"
$_yaz_tm $paket" $_paket_silindi"
loglama "$paket $_paket_silindi"
rm -f ${_silinecekler}
else
rm -f ${_silinecekler}
fi
else
$_yaz_uyari "kritik mesaj:kurulanlar dosyası yok."
hataloglama "kritik mesaj:kurulanlar dosyası yok."
fi
elif [ "$kkont" = "degil" ];then
$_yaz "$_zaten $paket $_paket_kurulu_degil"
hataloglama "$_zaten $paket $_paket_kurulu_degil"
else
$_yaz "$_paket_tanimsiz"
hataloglama "$_paket_tanimsiz"
fi
fi
}
paket_ara(){
paket="$1"
for pkt in `cat /depo/paketler/paket*.vt | grep $paket | awk '{print $1}'`; do
pakdesc=$(find $talimatname -name "$pkt" | xargs -I % sed -n '1{p;q}' %/talimat | sed s'/# Tanım: //g');
$_yaz_tm "$pkt - $pakdesc";
done
}
paket_liste(){
mps_paketler_listesi="/tmp/mps_paketler_listesi"
local cikti _grup
_grup="yok"
cikti="--normal"
if [ "$1" ]; then
if [ "$1" == "--json" ];then
cikti="--json"
else
_grup="$1"
fi
fi
if [ "$2" ]; then
cikti="$2"
fi
#echo "cikti:$cikti"
#echo "grup:$_grup"
#exit 1
if [ $_grup == "yok" ];then
if [ $cikti == "--json" ];then
[ -f $mps_paketler_listesi ] && rm -rf $mps_paketler_listesi
for pkt in $(cat /depo/paketler/paket*.vt | awk '{print $1}'); do
printf "$pkt," >> $mps_paketler_listesi
done
sed -i s'/.$//' $mps_paketler_listesi
else
cat /depo/paketler/paket*.vt | awk '{print $1}'
fi
else
if [ $cikti == "--json" ];then
grup_paketler_liste $_grup $cikti
else
grup_paketler_liste $_grup
fi
fi
}
paket_grup_liste(){
mps_paket_grup_listesi="/tmp/mps_paket_grup_listesi"
local cikti _altdizins _ektalname
cikti="normal"
if [ "$1" ]; then
cikti="$1"
fi
_altdizins=`find $ektalimatname/ -maxdepth 1 -type d | wc -l`
if [ $_altdizins -gt 1 ]
then
_ektalname=$ektalimatname/*
else
_ektalname=""
fi
_gruplar=`grep -ri "Grup:" $talimatname/* $_ektalname | cut -d':' -f3 | cut -d' ' -f2 | sed 's/^ *//;s/ *$//' | sort -u`
if [ $cikti == "--json" ];then
[ -f $mps_paket_grup_listesi ] && rm -rf $mps_paket_grup_listesi
#printf "[" >> $mps_paket_grup_listesi
for grp in $(grep -ri "Grup:" $talimatname/* $_ektalname | cut -d':' -f3 | cut -d' ' -f2 | sed 's/^ *//;s/ *$//' | sort -u); do
printf "$grp," >> $mps_paket_grup_listesi
done
sed -i s'/.$//' $mps_paket_grup_listesi
#printf "]" >> $mps_paket_grup_listesi
else
echo $_gruplar
fi
}
grup_paketler_liste(){
mps_grup_paketler_listesi="/tmp/mps_grup_paketler_listesi"
local cikti _grup _paketler
_grup="$1"
cikti="normal"
if [ "$2" ]; then
cikti="$2"
fi
_paketler=`grep -rli "Grup: .*$_grup" $talimatname/* $ektalimatname/* | cut -d':' -f3 | sed 's/^ *//;s/ *$//' | xargs -I {} dirname {} | xargs -I {} basename {} | sort -u`
if [ $cikti == "--json" ];then
[ -f $mps_grup_paketler_listesi ] && rm -rf $mps_grup_paketler_listesi
#printf "[" >> $mps_paket_grup_listesi
for pkt in $(grep -rli "Grup: .*$_grup" $talimatname/* $ektalimatname/* | cut -d':' -f3 | sed 's/^ *//;s/ *$//' | xargs -I {} dirname {} | xargs -I {} basename {} | sort -u); do
printf "$pkt," >> $mps_grup_paketler_listesi
done
sed -i s'/.$//' $mps_grup_paketler_listesi
#printf "]" >> $mps_paket_grup_listesi
else
echo $_paketler
fi
}
kelime_bul(){
grep --color -H -ri "$1" $talimatname
grep --color -H -ri "$1" $ektalimatname
}
kurulu_kontrol_test(){
local _paket kkont _cikti _yaz _yaz_uyari
_paket=$1
_cikti="--renkli"
[ "$2" ] && _cikti="$2"
cikti_renk_ayarla ${_cikti}
kkont=`kurulu_kontrol "$1"`
if [ "$kkont" == "degil" ];then
$_yaz_uyari "$_paket $_paket_kurulu_degil"
exit 1
elif [ "$kkont" == "tanimsiz" ];then
$_yaz_uyari "$_paket $_paket_tanimsiz"
exit 1
fi
}
paket_bilgi(){
local _paket kkont _cikti
_paket="$1"
_cikti="--renkli"
[ "$2" ] && _cikti="$2"
cikti_renk_ayarla ${_cikti}
kkont=`kurulu_kontrol "$1"`
if [ "$kkont" = "kurulu" ];then
satir=`sed -n '1p' < $VT/"${_paket}"/META`
$_yaz "ADI :" ${satir:1:${#satir}-1} #$_yaz_son
satir=`sed -n '2p' < $VT/"${_paket}"/META`
$_yaz "TANIM :" ${satir:1:${#satir}-1} #$_yaz_son
satir=`sed -n '3p' < $VT/"${_paket}"/META`
$_yaz "URL :" ${satir:1:${#satir}-1} #$_yaz_son
satir=`sed -n '5p' < $VT/"${_paket}"/META`
$_yaz "PAKETÇİ :" ${satir:1:${#satir}-1} #$_yaz_son
satir=`sed -n '6p' < $VT/"${_paket}"/META`
satir=${satir:1:${#satir}-1}
printf -v boyut '%d\n' "$satir" 2>/dev/null
if [ $boyut -lt 1048576 ];then
boyut=$(($boyut/1024))
_ek="kb"
else
boyut=$(($boyut/1024/1024))
_ek="mb"
fi
$_yaz "KUR BOYUT :" "$boyut $_ek (tahmini)" #$_yaz_son
satir=`sed -n '7p' < $VT/"${_paket}"/META`
$_yaz "SÜRÜM :" ${satir:1:${#satir}-1} #$_yaz_son
satir=`sed -n '8p' < $VT/"${_paket}"/META`
$_yaz "DEVİR :" ${satir:1:${#satir}-1} #$_yaz_son
satir=`sed -n '9p' < $VT/"${_paket}"/META`
$_yaz "PAKETLENME :" `date -d @${satir:1:${#satir}-1}` #$_yaz_son
satir=`sed -n '10p' < $VT/"${_paket}"/META`
$_yaz "MİMARİ :" ${satir:1:${#satir}-1} #$_yaz_son
satir=`sed -n '11p' < $VT/"${_paket}"/META`
$_yaz "GRUP :" ${satir:1:${#satir}-1} #$_yaz_son
elif [ "$kkont" = "degil" ];then
_konum=$(talimat_bul $1)
source ${_konum}/talimat
_ad=$(basename ${_konum})
_tanim=$(grep -ri "# Tanım:" $_konum/talimat | cut -d ':' -f2-)
_url=$(grep -ri "# Url:" $_konum/talimat | cut -d ':' -f2-)
_paketci=$(grep -ri "# Paketçi:" $_konum/talimat | cut -d ':' -f2-)
_surum=${surum}
_devir=${devir}
_grup=$(grep -ri "# Grup:" $_konum/talimat | head -1 | cut -d ':' -f2)
$_yaz "ADI :" ${_ad} #$_yaz_son
$_yaz "TANIM :" ${_tanim} #$_yaz_son
$_yaz "URL :" ${_url} #$_yaz_son
$_yaz "PAKETÇİ :" ${_paketci} #$_yaz_son
$_yaz "SÜRÜM :" ${_surum} #$_yaz_son
$_yaz "DEVİR :" ${_devir} #$_yaz_son
$_yaz "GRUP :" ${_grup} #$_yaz_son
$_yaz_uyari "${_paket} $_paket_kurulu_degil"
else
$_yaz_uyari "${_paket} $_paket_tanimsiz"
fi
}
paket_bilgi_html(){
_simgedepo="/srv/http/mpsweb/static/simgeler"
_simgehtmldepo="/static/simgeler"
_simgedosya=""
_dosya=$1
_paket=`echo "${_dosya}" | cut -d'_' -f4-5`
icerik="<table border=1>"
# ikon arşive baktırılacak varsa programın kendi ikonu yoksa öntanımlı ikon kullanılacak
if [ -f $_simgedepo/${_paket}.png ];then
_simgedosya="$_simgehtmldepo/$_paket.png"
elif [ -f /usr/share/icons/hicolor/32x32/apps/${_paket}.png ];then
cp /usr/share/icons/hicolor/32x32/apps/${_paket}.png $_simgedepo/${_paket}.png
_simgedosya="$_simgehtmldepo/$_paket.png"
elif [ `ls $_simgedepo/${_paket}_* 2>/dev/null | head -n1` ];then
_gecicidosya=`ls $_simgedepo/${_paket}_* 2>/dev/null | head -n1`
_simgedosya="$_simgehtmldepo/$(ls $_gecicidosya | xargs -I {} basename {})"
else
_simgedosya="$_simgehtmldepo/package.png"
fi
icerik+="<tr><td align=center><img src='${_simgedosya}' alt='' weight=40 height=40></img><td></tr>"
while IFS='' read -r satir || [[ -n "$line" ]]; do
icerik+="<tr>"
_sutun_baslik="$(echo $satir | cut -d':' -f1)"
_sutun_deger="$(echo $satir | cut -d':' -f2-)"
#icerik+="<td>$_sutun_deger</td>"
if [ "${_sutun_baslik}" != "${_sutun_deger}" ];then
icerik+="<td>$_sutun_baslik</td>"
icerik+="<td>$_sutun_deger</td>"
fi
icerik+="</tr>"
done < "$_dosya"
if [[ "${_sutun_baslik}" == *"${_paket_kurulu_degil}"* ]] || [[ "${_sutun_baslik}" == *"${_paket_tanimsiz}"* ]];then
icerik+="<tr bgcolor='red'><td>DURUM</td><td>${_sutun_baslik}</td></tr>"
else
icerik+="<tr bgcolor='green'><td>DURUM</td><td>kurulu</td></tr>"
fi
icerik+="</table>"
echo "$icerik" > $_dosya.html
}
# paketlerin toplu tablo gösterimi
paketler_depo_html(){
icerik="<table border=1>"
for _paket in $(ls $VT);do
# ikon arşive baktırılacak varsa programın kendi ikonu yoksa öntanımlı ikon kullanılacak
_simgedosya="/static/package.png"
#echo "dosya: $_simgedepo/${_paket}.png"
[ -f $_simgedepo/${_paket}.png ] && _simgedosya="$_simgehtmldepo/$_paket.png"
[ $(ls $_simgedepo/${_paket}_* | head -n1) ] && _simgedosya="$_simgehtmldepo/$(ls $_simgedepo/${_paket}_* | head -n1 | xargs -I {} basename {})"
icerik+="<tr><td align=center><img src='${_simgedosya}' alt='' weight=40 height=40></img><td><td>$_paket</td></tr>"
done
icerik+="</table>"
echo "$icerik" > /tmp/test.html
}
yeniden_paketle(){
cd $1
bsdtar -r -f ../"$1".mps .META
bsdtar -r -f ../"$1".mps *
cd ..
lzip -9 "$1".mps
}
talimat_bul(){
local _apaket _bulunan _sonuc _donus _konum
[ -z $1 ] && hata_olustu "_paket_adi_gerekli"
_konum="$talimatname $ektalimatname"
[ ! -z $2 ] && _konum="$2"
_donus="-1"
_apaket="$1"
_sonuc=$(find $_konum -name ${_apaket} | wc -l)
if [ ${_sonuc} -eq 0 ];then echo $_donus;return; fi
_bulunan=$(find $_konum -name ${_apaket} | head -n1)
#if [ ! -f "${_bulunan}/talimat" ];then hata_olustu "_talimatsiz_dizin";return; fi
if [ ! -f "${_bulunan}/talimat" ];then echo ${_donus};return; fi
[ ${_sonuc} -gt 1 ] && echo "$(date +'%F %T') ${_apaket} $_talimat_sayisi_fazla" >> $LOGDIZIN/mps-hata.log
echo ${_bulunan}
}
paket_analiz(){
_gcc_uyumsuz_paketler="/tmp/gcc_uyumsuz_paketler"
_pkvt="paket.vt"
if [ -z "$1" ];then echo "$_paket_adi_gerekli";exit 1;fi
local pkt _apaket _konum
pkt=$1
if [ -f $pkt ];then
_apaket=$(basename $pkt |cut -d'#' -f 1)
_konum=$(talimat_bul $_apaket $anatalimatname)
_depo_sha=$(cat "$paketdepo$_pkvt" | grep " $_apaket#" | cut -d' ' -f2)
_paket_sha=$(sha1sum $pkt | cut -d ' ' -f1)
if [[ $_konum != "-1" && $_konum != "0" ]];then
source $_konum/talimat
if [ -f $pkt ];then
bsdtar xf $pkt .META
if [ -f $PWD/.META ];then
mv .META /tmp/$_apaket.META
satir=$(sed -n '7p' < /tmp/$_apaket.META)
psurum=${satir:1:${#satir}-1}
satir2=$(sed -n '8p' < /tmp/$_apaket.META)
pdevir=${satir2:1:${#satir2}-1}
deposurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
depodevir=`echo -e "$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
_surumbilgi="gereken_sürüm:$deposurum ! paket_sürüm:$psurum"
_devirbilgi="gereken_devir:$depodevir ! paket_devir:$pdevir"
$_yaz_bilgi "$pkt"
if [ "$deposurum" != "$psurum" ];then
$_yaz_uyari "$_surumbilgi"
echo "$pkt" >> $_gcc_uyumsuz_paketler
fi
if [ "$depodevir" != "$pdevir" ];then
$_yaz_uyari "$_devirbilgi"
echo "$pkt" >> $_gcc_uyumsuz_paketler
fi
if [ "$_paket_sha" != "$_depo_sha" ];then
$_yaz_uyari "$_shasum_uyumsuzluk"
echo "$pkt" >> $_gcc_uyumsuz_paketler
fi
else
$_yaz_uyari "$_apaket depoda yok. mps -i $_apaket"
fi
else
$_yaz_uyari "$_apaket depoda yok. mps -i $_apaket"
fi
else
$_yaz_uyari "$1 $_talimat_bulunamadi"
fi
rm -f /tmp/$_apaket.META
else
$_yaz_uyari "$pkt $_dosya_yolu_bulunamadi"
exit 0
fi
}
paketdepo_analiz(){
paketvt_guncelle
_aranandepo=$1
_uyumsuz_paketler="/tmp/uyumsuz_paketler"
if [[ -d $_aranandepo && ! -f $_aranandepo ]];then
rm -f $_uyumsuz_paketler
_gcc_uyumsuz_paketler="/tmp/gcc_uyumsuz_paketler"
for pkt in $(ls $_aranandepo*mps.lz);do
paket_analiz $pkt
echo "-"
done
echo "tarama bitti"
sort -u $_gcc_uyumsuz_paketler > $_uyumsuz_paketler
echo "file://$_uyumsuz_paketler"
exit 0
else
$_yaz_uyari "$1 $_dizin_bulunamadi"
exit 1
fi
}
derleme_listyap_kontrol(){
if [ -f gerek.liste ];then
mv gerek.liste gerek.eski.liste
fi
if [ -f gerek.konum.liste ];then
mv gerek.konum.liste gerek.konum.eski.liste
fi
touch gerek.liste
touch gerek.konum.liste
}
gerekleri_dosyala(){
local _altgerek _konum
_altgerek="$1"
_konum=$(talimat_bul $_altgerek)
if [[ $konum != "-1" && $konum != "0" ]];then
printf "."
echo "$_altgerek" >> gerek.liste
if [ ! -d "$talimatname/temel/$_altgerek" ];then
echo "$_konum" >> gerek.konum.liste
fi
else
$_yaz_uyari "$1 $_talimat_bulunamadi"
fi
}
deps_recursive(){
local _talimat _deps _temp _pkt _konum _kurkon bagimd
local _ekle=1
[ $1 ] && _pkt=$1 || hata_olustu "_talimat_bulunamadi"
[ $2 ] && _kurkon=$2 || echo "kurkon tanımsız"
[ $3 ] && _depsf=$3 || echo "depsf tanımsız"
printf "-"
_konum=$(talimat_bul $_pkt)
_talimat="${_konum}/talimat"
[ $_kurkon -eq 1 ] && [ `kurulu_kontrol $_pkt` = "kurulu" ] && _ekle=0
[ $_ekle -eq 1 ] && echo "@$bag@" >> ${_depsf}
_deps=$(cat $_talimat | awk '/^#[[:blank:]]*Gerek*/ {print}' | cut -d':' -f2)
if [ -n "$_deps" ]; then
bagimd=`echo "$_deps" | sed 's/,/ /g'`
for bag in $bagimd;do
#[ $_ekle -eq 1 ] && echo "@$bag@" >> ${_depsf}
_temp=$(grep -rli "@${bag}@" ${_depsf})
[ ! -z $_temp ] || deps_recursive $bag $_kurkon ${_depsf}
done
fi
}
deps(){
local _depsf="/tmp/deps"
local _kurkon=0
local _pkt
#[ "$2" = "--normal" ] && cikti_renk_ayarla "$2"
#[ "$3" = "--normal" ] && cikti_renk_ayarla "$3"
[ $1 ] && _pkt=$1 || hata_olustu "_talimat_bulunamadi"
$_yaz "$1 $_gerekler_belirleniyor"
[ $2 ] && [ $2 == "--kurulu_atla" ] && _kurkon=1
[ -f ${_depsf} ] && rm -f ${_depsf} && touch ${_depsf}
deps_recursive $_pkt $_kurkon ${_depsf}
sed -i 's/@//g' ${_depsf}
#printf "\n"
cat ${_depsf}
}
gerekleri_listele(){
derleme_listyap_kontrol
local _paket _konum _pkvt
_konum="$talimatname $ektalimatname"
[ $1 ] && _paket=$1 || hata_olustu "_talimat_bulunamadi"
_pkvt=""
[ "$2" = "--kurulu_atla" ] && _pkvt="$VT"
#echo "arama konum: $_konum"
echo $_paket | awk -v arama_konum="$_konum" -v PKVT="$_pkvt" \
'''
function gerekbul(paket,gerekler) {
if (ISLENDI[paket]) {
return
}
while((getline satir<paket) >0) {
if (satir ~ "# Gerekler:" ){
split(satir,gerekb,":");
split(gerekb[2], gerekler, /[ ,]+/);
if ( length(gerekler) > 0 ){
for (i in gerekler){
if ( i > 1 && length(gerekler[i]) > 0 ){
ara=gerekler[i]
konum=talimat_bul(ara);
if (konum != ""){
if (length(PKVT) > 0 ){
(kk(PKVT "/" ara))? yaz("."):gerekbul(konum)
}
else {gerekbul(konum)}
}
}
}
}
}
}
ISLENDI[paket]=1 ;
printf "."
system("echo $(dirname " paket ") >> gerek.konum.liste")
system("echo $(basename $(dirname " paket ")) >> gerek.liste")
close(paket)
}
# kurulu kontrol
function kk(p) {
return !system("test -d \""p"\"");
}
function yaz(_param){
printf _param
}
function talimat_bul(ara){
cmd= "find " arama_konum " -name " ara " | head -n1 "
_bulundu=0
while ( ( cmd | getline talimatyol ) > 0 ) {
_bulundu=1
break
}
close(cmd)
if ( _bulundu == 0 ) {
print ara " talimatı bulunamadı";
exit 1
}
return talimatyol "/talimat"
}
{
#print FILENAME
_talimat=$1
_paket=talimat_bul(_talimat)
if ( length(_paket) > 0 ){gerekbul(_paket);}
else {print _talimat " talimatı bulunumadı!"}
exit 1
}
'''
[ -f gerek.liste ] && cat gerek.liste | tr "\n" " ";echo
}
derleme_listyap(){
[ "$2" = "--normal" ] && cikti_renk_ayarla "$2"
[ "$3" = "--normal" ] && cikti_renk_ayarla "$3"
$_yaz "$1 $_gerekler_belirleniyor"
gerekleri_listele $@
}
# -derlist
paket_derle_liste(){
for dpktyer in `cat $1`;do
dpkt=`basename $dpktyer`
echo $dpkt "derleniyor...."
zorla_derle="yok"
paket_derle $dpktyer
done
}
#otomatik derle kontrollu kur
# -derle
paket_derle_kur(){
tekrarkur="hayir"
derleme_listyap_kontrol
derleme_listyap "$1" && paket_derle_liste gerek.konum.liste
}
# odkp
oto_derle_kur_paketle(){
paketvt_guncelle
# mps -kur
_konum=$(talimat_bul $1)
paket_inkur_oto $1 &&
if [ -f "$_konum/$1.sira" ];then
$_yaz "sıralı derleme yapılacak."
paket_derle_liste "$_konum/$1.sira"
else
paket_derle_kur $1
fi
rm -rf {gerek.konum.eski,gerek.konum,gerek,kurulanlar,silinenler,gerek.eski}.liste
}
paket_kur_oto(){
local kpkt pkt pak kliste
if [ "$1" = "-H" ];then
ls *.mps.lz > "otokur.list"
kliste="otokur.list"
else
kliste="$1"
fi
for kpkt in `cat $kliste`;do
for pkt in `ls $kpkt* | cut -d'#' -f1`;do
pak=`ls "$pkt#"*`
yerelden_kur "$pak" && paket_inkur_oto "$pkt"
done
done
rm -rf otokur.list
}
paket_kur_oto_zorla(){
local _pak _kliste
[ ! -z $1 ] && _kliste=$1
for _kpkt in `cat $_kliste`;do
for _pkt in `ls $_kpkt* | cut -d'#' -f1`;do
_pak=`ls "$_pkt#"*`
paket_sil "$_pkt" "evet"
echo $_pak
yerelden_kur "$_pak" && paket_inkur_oto "$_pkt"
done
done
rm -rf $_kliste
}
paket_kur_liste(){
local kpkt pkt pak
for kpkt in `cat $1`;do
for pkt in `ls $kpkt* | cut -d'#' -f1`;do
pak=`ls "$pkt#"*`
yerelden_kur "$pak"
done
done
}
paket_kur_liste_zorla(){
local kpkt pkt pak
for kpkt in `cat $1`;do
for pkt in `ls $kpkt* | cut -d'#' -f1`;do
pak=`ls "$pkt#"*`
paket_sil "$kpkt" "evet"
yerelden_kur "$pak"
done
done
}
#otomatik kontrollu kur
paket_kur_oto2(){
derleme_listyap_kontrol
derleme_listyap "$1" > /dev/null && mps -ok gerek.konum.liste
}
paket_inkur_liste_direk(){
local kpkt
for kpkt in `cat $1`;do
agdan_kur "$kpkt"
done
}
paket_inkur_liste(){
local kpkt
for kpkt in `cat $1`;do
paket_inkur_oto "$kpkt"
done
}
# otomatik kontrollu kur
# -kur
paket_inkur_oto(){
local _cikti
_cikti="--renkli"
[ $1 ] && _pkt="$1" || hata_olustu "_paket_adi_gerekli"
[ $2 ] && _cikti="$2"
cikti_renk_ayarla $_cikti
local konum anakonum kurdurum _agdan_kur_onay
derleme_listyap_kontrol
derleme_listyap ${_pkt} "--kurulu_atla"
for kpkt in `cat gerek.liste`;do
# önce talimat-anatalimat karşılaştırması yapılır.
konum="`find "$talimatname" -name $kpkt`"
anakonum="`find "$anatalimatname" -name $kpkt`"
ekkonum="`find "$ektalimatname" -name $kpkt`"
if [ -f "$anakonum/talimat" ];then
# depo ve talimatname sürüm kontrolü
_gncdurum=""
[ "$(kurulu_kontrol ${kpkt})" = "kurulu" ] && _gncdurum=$(surum_karsilastir ${kpkt})
_agdan_kur_onay="x"
if [ "${_gncdurum}" == "degil" ];then
_agdan_kur_onay="h"
elif [ "`dosya_karsilastir $konum/talimat $anakonum/talimat`" = "evet" ];then
_agdan_kur_onay="e"
else
_agdan_kur_onay="h"
$_yaz_uyari "$kpkt talimat eşitsizliğinden atlandı."
fi
[ $_agdan_kur_onay == "x" ] && exit 1
[ $_agdan_kur_onay == "e" ] && agdan_kur "$kpkt" "$_cikti"
# ek talimatlar için sürüm karşılaştırma henüz yok.farklı depolara bakılarak sağlanacak
elif [ -f "$ekkonum/talimat" ];then
agdan_kur "$kpkt" "$_cikti"
else
$_yaz_uyari "$kpkt talimatı bulunamadı!"
fi
done
if [ $(kurulu_kontrol ${_pkt}) = "degil" ];then
kurdurum="kurulu değil"
elif [ $(kurulu_kontrol ${_pkt}) = "kurulu" ];then
kurdurum="kurulu"
#_gnc_kntrl=$(surum_devir_kontrol "${_pkt}" "--normal")
#if [ ${_gnc_kntrl} = "var" ];then
# paket_guncelle ${_pkt}
#else
$_yaz "${_pkt} $kurdurum"
#fi
else
kurdurum="$_paket_tanimsiz"
fi
rm -rf *.liste
}
paket_sil_oto(){
local spkt
for spkt in `cat $1`;do
oto_silme="evet"
paket_sil "$spkt" "$oto_silme"
done
}
paket_sil_oto_onayli(){
local spkt
#for spkt in `perl -e 'print reverse <>' $1`;do
for spkt in $(tac $1);do
paket_sil "$spkt" "hayir" "evet"
done
}
paket_sil_gereklerle(){
local _onay _tbsnc _paket _dosya _silindi
[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
# otomatik onay verme durum kontrolü
_onay="onay"
[ $2 ] && _onay="$2";
if [ -d $VT/${_paket} ];then
_dosya=/tmp/${_paket}.gerekler.liste
rm -f /tmp/${_paket}.silinecekler
rm -f /tmp/${_paket}.silinemezler
_sliste=`mktemp`
_eliste=`mktemp`
bagimli_bilgi_dosyala "${_paket}"
for _pk in $(cat ${_dosya});do
_silindi=0
_tbsnc=$(ters_bagimli_bilgi ${_pk} "kurulu")
for _tbb in `echo $_tbsnc`;do
for _benzer in $(grep -ri "${_tbb}" ${_dosya});do
if [ ${_tbb} = ${_benzer} ];then
echo ${_pk} >> ${_sliste}
_silindi=1
fi
done
if [ ${_tbb} = ${_paket} ];then
echo ${_pk} >> ${_sliste}
_silindi=1
fi
if [ $_silindi -eq 0 ];then
echo ${_pk} >> ${_eliste}
fi
done
done
sort -u ${_sliste} > /tmp/${_paket}.silinecekler
sort -u ${_eliste} > /tmp/${_paket}.silinemezler
rm -rf ${_eliste} ${_sliste}
#cat /tmp/${_paket}.silinecekler
#cat /tmp/${_paket}.silinemezler
if [ $_onay = "oto" ];then
paket_sil_oto "/tmp/${_paket}.silinecekler"
else
paket_sil_oto_onayli "/tmp/${_paket}.silinecekler"
fi
else
$_yaz "$_zaten ${_paket} $_paket_kurulu_degil"
exit 1
fi
}
paket_sil_gereklerle_eski(){
local _onay _tbs _tbsnc _paket _ustgerek
[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
# otomatik onay verme durum kontrolü
[ $2 ] && _onay="$2";
_onay="onay"
if [ -d $VT/${_paket} ];then
bagimli_bilgi_dosyala "${_paket}"
rm -f /tmp/${_paket}.silinecekler
touch /tmp/${_paket}.silinecekler
_tbsnc=$(ters_bagimli_bilgi ${_paket} "kurulu")
if [ -z "${_tbsnc}" ];then _tbs=0
else _tbs=$(echo "$_tbsnc" | wc -l)
fi
if [ $_tbs -gt 0 ];then
$_yaz_uyari "${_paket} silinemez."
echo "ters gerekleri:";echo "$_tbsnc"
exit 1
fi
for pkaltb in $(cat /tmp/${_paket}.gerekler.liste);do
if [ -d $VT/$pkaltb ];then
_tbsnc=""
_tbsnc=$(ters_bagimli_bilgi $pkaltb "kurulu")
if [ -z "${_tbsnc}" ];then _tbs=0
else _tbs=$(echo "$_tbsnc" | wc -l)
fi
echo "$pkaltb >"
if [ -f ${pkaltb}.tbk.txt ];then
_ustgerek=$(cat /tmp/${_paket}.silinecekler | grep -f ${pkaltb}.tbk.txt)
[ ${_ustgerek} ] && _tbs=0
fi
if [ $_tbs -eq 0 ];then
$_yaz "$pkaltb silinebilir."
echo "$pkaltb" >> /tmp/${_paket}.silinecekler
elif [ "$_tbsnc" = "${_paket}" ];then
$_yaz "$pkaltb silinebilir."
echo "$pkaltb" >> /tmp/${_paket}.silinecekler
else
$_yaz_uyari "$pkaltb silinemez."
echo "ters gerekleri: $tbsonuc"
fi
else
$_yaz "$_zaten $pkaltb $_paket_kurulu_degil"
fi
done
#cat /tmp/${_paket}.silinecekler
if [ $_onay = "oto" ];then
paket_sil_oto "/tmp/${_paket}.silinecekler"
else
paket_sil_oto_onayli "/tmp/${_paket}.silinecekler"
fi
else
$_yaz "$_zaten ${_paket} $_paket_kurulu_degil"
exit 1
fi
}
paketsiz_talimatlar(){
for talimatyol in `( ls -d $talimatname/genel/*/* & ls -d $ektalimatname/*/* ) | cat`;do
#echo $talimat
if [ -d $talimatyol ];then
talimat=$(basename $talimatyol)
if [[ ! $(cat $paketdepo/paket*.vt | grep $talimat#) ]] ;then
if [ -d $talimatname/*/*/$talimat ];then
ack=`grep -e '# Tanım:' $talimatname/genel/*/$talimat/talimat | cut -d':' -f2`
elif [ -d $ektalimatname/*/$talimat ];then
ack=`grep -e '# Tanım:' $ektalimatname/*/$talimat/talimat | cut -d':' -f2`
fi
printf '%s = %s \n' "$talimat" "$ack"
fi
fi
done
}
paket_guncelle(){
surum_kontrol $1 $2 $3
if [ -d "$VT/$1" ];then
if [ ${_paketguncel} -eq 0 ];then
devir_kontrol $1 $2 $3
else
$_yaz "$1 paketi yeni güncellendi."
$_yaz "devir güncellemesi yapılmayacak."
fi
fi
export _paketguncel=0
}
paket_guncelle_oto(){
derleme_listyap "$1" > /dev/null &&
local kpkt
GS_CIKTI="H"
for kpkt in `cat gerek.konum.liste`;do
durum=`kurulu_kontrol "$kpkt"`
if [ "$durum" = "kurulu" ]; then
paket_guncelle "$kpkt" $GS_CIKTI
fi
done
listeleri_temizle
}
dongu_gosterge(){
count=0
total=$1
pstr="[=======================================================================]"
while [ $count -lt $total ]; do
sleep 0.5 # yapılacak iş veya uyutulur.
count=$(( $count + 1 ))
pd=$(( $count * 73 / $total ))
printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
done
}
guncelleme_tespit(){
local _konum
guncelleme_dosya="/tmp/mps.guncellenecekler"
rm -f $guncelleme_dosya
touch $guncelleme_dosya
for kpaket in $(ls $VT/);do
satir=$(sed -n '7p' < $VT/$kpaket/META)
ksurum=${satir:1:${#satir}-1}
satir2=$(sed -n '8p' < $VT/$kpaket/META)
kdevir=${satir2:1:${#satir2}-1}
#deposurum=$(grep " $kpaket#" /depo/paketler/paket.vt | cut -d' ' -f3 | cut -d'#' -f 2 | cut -d'-' -f1)
_konum=$(talimat_bul $kpaket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$kpaket $_talimat_bulunamadi $_surum_kontrol_iptal"
#exit 1
else
source $_konum/talimat
deposurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
depodevir=`echo -e "$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
#echo $kpaket " : $ksurum ---> $deposurum" "$kdevir ---> $depodevir"
#sleep 3
if [ "$ksurum" != "$deposurum" ];then
printf "$kpaket -surum: ";echo "$ksurum ---> $deposurum"
echo $kpaket >> $guncelleme_dosya
elif [ "$kdevir" != "$depodevir" ];then
printf "$kpaket -devir: ";echo "$kdevir ---> $depodevir"
echo $kpaket >> $guncelleme_dosya
fi
fi
done
}
sistem_guncelle_eski(){
count=0
local kpkt _pkliste
total=`ls $VT | wc -l`
pstr="[=======================================================================]"
git_guncelle
paketvt_guncelle
GS_CIKTI="H"
_pkliste=$(mktemp)
ls -rct $VT > ${_pkliste}
for _esgec in `echo ${esgec} | tr " " "\n"`;do
_satirno=$(grep -wxnr "${_esgec}" ${_pkliste} | cut -d':' -f1)
[ ! -z ${_satirno} ] && sed -i "${_satirno}d" ${_pkliste}
done
while [ $count -lt $total ]; do
count=$(( $count + 1 ))
pd=$(( $count * 73 / $total ))
printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
kpkt=$(sed -n ${count}'p' ${_pkliste})
[ ! -z $kpkt ] && paket_guncelle "$kpkt" $GS_CIKTI
done
$_yaz "\nSistem Güncellemesi Tamamlandı."
}
sistem_guncelle_uygula(){
local _gdosya
if [ "$1" ]; then
_gdosya="$1"
fi
[ ! -f ${_gdosya} ] && exit 1
for gpkt in `cat ${_gdosya}`;do
durum=`kurulu_kontrol "$gpkt"`
if [ "$durum" = "kurulu" ]; then
paket_guncelle "$gpkt" $GS_CIKTI "E"
fi
done
}
sistem_guncelle(){
local guncelleme_dosya _onay
_onay=0
if [ "$1" = "evet" ];then
_onay=1
fi
if [ "$1" = "dosya" ];then
_onay=2
fi
if [ "$1" ] && [ -f "$1" ];then
guncelleme_dosya="$1"
[ "$2" = "evet" ] && _onay=1
else
count=0
local kpaket _pkliste _konum
guncelleme_dosya="/tmp/mps.guncellenecekler"
rm -f $guncelleme_dosya
touch $guncelleme_dosya
total=`ls $VT | wc -l`
pstr="[=======================================================================]"
git_guncelle
paketvt_guncelle
GS_CIKTI="H"
_pkliste=$(mktemp)
ls -rct $VT > ${_pkliste}
for _esgec in `echo ${esgec} | tr " " "\n"`;do
_satirno=$(grep -wxnr "${_esgec}" ${_pkliste} | cut -d':' -f1)
[ ! -z ${_satirno} ] && sed -i "${_satirno}d" ${_pkliste}
done
while [ $count -lt $total ]; do
count=$(( $count + 1 ))
pd=$(( $count * 73 / $total ))
printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
kpaket=$(sed -n ${count}'p' ${_pkliste})
_konum=$(talimat_bul $kpaket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$kpaket $_talimat_bulunamadi $_surum_kontrol_iptal"
# talimatnamede yer almadığından paketin güncellenmesi es geçilecek.
kpaket=""
fi
if [ ! -z $kpaket ];then
satir=$(sed -n '7p' < $VT/$kpaket/META)
ksurum=${satir:1:${#satir}-1}
satir2=$(sed -n '8p' < $VT/$kpaket/META)
kdevir=${satir2:1:${#satir2}-1}
#deposurum=$(grep " $kpaket#" /depo/paketler/paket.vt | cut -d' ' -f3 | cut -d'#' -f 2 | cut -d'-' -f1)
source $_konum/talimat
deposurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
depodevir=`echo -e "$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
#echo $kpaket " : $ksurum ---> $deposurum" "$kdevir ---> $depodevir"
#sleep 3
if [ "$ksurum" != "$deposurum" ];then
#printf "$kpaket -surum: ";echo "$ksurum ---> $deposurum"
echo $kpaket >> $guncelleme_dosya
elif [ "$kdevir" != "$depodevir" ];then
#printf "$kpaket -devir: ";echo "$kdevir ---> $depodevir"
echo $kpaket >> $guncelleme_dosya
fi
fi
done
$_yaz "\nSistem Güncelleme Taraması Tamamlandı."
fi
if [ -s "$guncelleme_dosya" ];then
$_yaz_tm "aşağıdaki paketler güncellenecektir:"
cat $guncelleme_dosya
$_yaz_uyari "Güncellemesini istemediğiniz paketleri $guncelleme_dosya dosyasından sildikten sonra onay veriniz!"
if [ ${_onay} -eq 0 ];then
while true; do
$_yaz_tm "listedeki paketler güncellensin mi?";read -p "e veya h-> " eh
case $eh in
[Ee]* ) sistem_guncelle_uygula $guncelleme_dosya; break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
elif [ ${_onay} -eq 1 ];then
sistem_guncelle_uygula $guncelleme_dosya
else
echo "güncelleme dosyanız: $guncelleme_dosya"
exit 1
fi
else
$_yaz_uyari "Güncellenecek paket bulunamadı!"
fi
}
surum_kontrol(){
local _konum pk_sil _paket
_paket=$1
GS_CIKTI="E"
G_ONAY="H"
if [ "$2" ]; then
GS_CIKTI="$2"
fi
if [ "$3" ]; then
G_ONAY="$3"
fi
local ksurum surum pkt dusuk yuksek durum
durum="belirsiz"
satir=`sed -n '7p' < $VT/$_paket/META`
ksurum=${satir:1:${#satir}-1}
_konum=$(talimat_bul $_paket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$_paket $_talimat_bulunamadi $_surum_kontrol_iptal"
pk_sil="e"
for _esgec in `echo ${silme_esgec} | tr " " "\n"`;do
if [ "${_esgec}" = "${_paket}" ];then
pk_sil="h"
break
fi
done
if [ "$pk_sil" = "e" ];then
$_yaz "$_paket $_paket_depoda_yok $_siliniyor"
paket_sil "$_paket" "evet"
else
$_yaz "$_paket silinmesi es geçildi"
fi
else
source $_konum/talimat
dusuk=`echo -e "$ksurum\n$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
if [ "$ksurum" = "$surum" ];then
durum="guncel"
[ $GS_CIKTI = "E" ] && $_yaz_bilgi "$_paket sürümü güncel"
#printf "."
else
if [ "$ksurum" = "$dusuk" ];then
durum="yukselt"
else
durum="dusur"
fi
gun_onay="h"
if [ "$durum" != "guncel" ];then
if [ $G_ONAY = "H" ];then
while true; do
printf "\n"
$_yaz_tm "$_paket sürüm $durum""me işlemi uygulanacak. $ksurum <> $surum ";read -p "e veya h-> " eh
case $eh in
[Ee]* ) gun_onay="e"; break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
else
gun_onay="e"
fi
if [ "$gun_onay" = "e" ];then
if [ -d "$talimatname/temel/$_paket" ]; then
kurulum_dogrulama_icerik $_paket
tpk="hayir"
paket_sil "$_paket" "evet"
paket_indir $_paket
pkt=`cat "$paketdepo""paket.vt" | grep "^$_paket " | cut -d' ' -f3`
icerik_ekle "$paketdepo$pkt"
else
paket_sil "$_paket" "evet"
paket_inkur_oto $_paket
fi
$_yaz_tm "$_paket sürüm güncellemesi yapıldı"
export _paketguncel=1
else
$_yaz_uyari "$_paket sürüm güncellemesi yapılmadı"
hataloglama "$_paket sürüm güncellemesi yapılmadı"
fi
fi
fi
fi
}
devir_kontrol(){
local _konum pk_sil _paket
_paket="$1"
GS_CIKTI="E"
G_ONAY="H"
if [ "$2" ]; then
GS_CIKTI="$2"
fi
if [ "$3" ]; then
G_ONAY="$3"
fi
local kdevir devir pkt dusuk yuksek durum gun_onay
durum="belirsiz"
satir=`sed -n '8p' < $VT/$_paket/META`
kdevir=${satir:1:${#satir}-1}
_konum=$(talimat_bul $_paket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$_paket $_talimat_bulunamadi $_devir_kontrol_iptal"
pk_sil="e"
for _esgec in `echo ${silme_esgec} | tr " " "\n"`;do
if [ "${_esgec}" = "${_paket}" ];then
pk_sil="h"
break
fi
done
if [ "$pk_sil" = "e" ];then
$_yaz "$_paket $_paket_depoda_yok $_siliniyor"
paket_sil "$_paket" "evet"
else
$_yaz "$_paket silinmesi es geçildi"
fi
else
source $_konum/talimat
dusuk=`echo -e "$kdevir\n$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
if [ "$kdevir" = "$devir" ];then
durum="guncel"
[ $GS_CIKTI = "E" ] && $_yaz_bilgi "$_paket deviri güncel"
#printf "."
else
if [ "$kdevir" = "$dusuk" ];then
durum="yukselt"
else
durum="dusur"
fi
gun_onay="h"
if [ "$durum" != "guncel" ];then
if [ $G_ONAY = "H" ];then
while true; do
printf "\n"
$_yaz_tm "$_paket devir $durum""me işlemi uygulanacak. $kdevir <> $devir ";read -p "e veya h-> " eh
case $eh in
[Ee]* ) gun_onay="e"; break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
else
gun_onay="e"
fi
if [ "$gun_onay" = "e" ];then
paket_sil "$_paket" "evet"
paket_inkur_oto "$_paket"
$_yaz_bilgi "$_paket devir güncellemesi yapıldı"
else
$_yaz_uyari "$_paket devir güncellemesi yapılmadı"
hataloglama "$_paket devir güncellemesi yapılmadı"
fi
fi
fi
fi
}
surum_karsilastir(){
local kpaket _konum
[ "$1" ] && kpaket="$1" || exit 1
deposurum=$(grep " $kpaket#" /depo/paketler/paket.vt | cut -d' ' -f3 | cut -d'#' -f 2 | cut -d'-' -f1)
_konum=$(talimat_bul $kpaket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$kpaket $_talimat_bulunamadi $_surum_kontrol_iptal"
exit 1
fi
source $_konum/talimat
tsurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
if [ "$tsurum" == "$deposurum" ];then
echo "esit"
else
echo "degil"
fi
}
surum_devir_kontrol(){
local _konum pk_sil _paket _durum pk_guncelle
_paket=$1
_durum="yaz"
pk_guncelle="e"
[ $2 ] && _durum="$2"
local kdevir devir ksurum surum pkt dusuk yuksek durum
durum="belirsiz"
if [ -d "$VT/$_paket" ];then
satir=`sed -n '7p' < $VT/$_paket/META`
ksurum="${satir:1:${#satir}-1}-"
satir=`sed -n '8p' < $VT/$_paket/META`
kdevir=${satir:1:${#satir}-1}
else
ksurum="(none)"
kdevir=""
fi
_konum=$(talimat_bul $_paket)
if [ "$_konum" = "-1" ];then
echo "$_paket $_talimat_bulunamadi $_surum_kontrol_iptal"
else
for _esgec in `echo ${esgec} | tr " " "\n"`;do
if [ "${_esgec}" = ${_paket} ];then
pk_guncelle="h"
break
fi
done
if [ $pk_guncelle == "e" ];then
source $_konum/talimat
if [ "${_durum}" == "yaz" ];then
echo "$_paket:"
echo "kurulu sürüm :$ksurum$kdevir"
echo "depo sürüm :$surum-$devir"
echo "--"
else
if [ "$ksurum$kdevir" == "$surum-$devir" ];then
echo "yok"
else
echo "var"
fi
fi
else
echo "$_paket için sürüm-devir kontrolü es geçildi."
fi
fi
}
_devir_kontrol_durum(){
local _konum pk_sil _paket
_paket="$1"
local kdevir devir pkt dusuk yuksek durum gun_onay
durum="belirsiz"
satir=`sed -n '8p' < $VT/$_paket/META`
kdevir=${satir:1:${#satir}-1}
_konum=$(talimat_bul $_paket)
if [ "$_konum" = "-1" ];then
echo "$_paket $_talimat_bulunamadi $_devir_kontrol_iptal"
else
source $_konum/talimat
echo "kurulu devir :$kdevir"
echo "depo devir :$devir"
fi
}
grup_kontrol() {
local _talimat _grup
[ -z $1 ] && exit 1
_talimat="$1"
_grup=$(LC_ALL=tr_TR.utf-8 grep -ri "Grup:" ${_talimat} | cut -d':' -f2 | sed 's/^ *//;s/ *$//' | cut -d' ' -f1)
echo "( $_grup ) içermektedir!"
if [ -z "${_grup}" ];then
_grup="bos"
grupad_kontrol $_grup ${_talimat}
else
grupad_kontrol $_grup ${_talimat}
fi
}
grupad_kontrol() {
local _grup _var _lineno _agrup _talimat
_var=0
[ -z $1 ] && exit 1
[ -z $2 ] && exit 1
_grup="$1"
_talimat="$2"
if [ -f ${GRUP_DOSYA} ];then
for grup in `cat ${GRUP_DOSYA}`;do
[ "x${_grup}x" = "x${grup}x" ] && _var=1
done
if [ $_var -eq 0 ];then
cat -n ${GRUP_DOSYA}
_lineno=$(wc -l ${GRUP_DOSYA} | cut -d' ' -f1)
if [ $_grup = "bos" ];then
echo "Talimat grup bilgisi içermemektedir!"
else
echo "Talimat geçersiz grup bilgisi( $_grup ) içermektedir!"
fi
echo "Yukarıdaki grup numaralarından birini seçiniz!";read -p "No:" _no
[ $_no -lt 1 ] && grupad_kontrol $_grup ${_talimat}
[ $_no -gt $_lineno ] && grupad_kontrol $_grup ${_talimat}
_agrup=$(cat ${GRUP_DOSYA} | sed -n ${_no}p)
sed -i '/Grup:/d' ${_talimat}
sed -i "/# Gerekler/a # Grup: $_agrup" ${_talimat}
fi
else
echo "gruplar dosyası yok: ${GRUP_DOSYA}"
fi
}
talimat_surum_takip(){
local konum _takip_uzanti
_takip_uzanti=".takip"
konum=$(talimat_bul $1)
if [[ $konum == "-1" || $konum == "0" ]];then
$_yaz_uyari "$1 $_talimat_bulunamadi"
exit 1
else
if [ -f "$konum/$1$_takip_uzanti" ];then
source $konum/$1$_takip_uzanti
if [ "`type -t surum_takip`" = "function" ];then
$_yaz "$1 paketinin kaynak kod arşivleri inceleniyor..."
surum_takip
else
$_yaz_uyari "$1 talimatının sürüm takip işlevi yok!"
fi
else
$_yaz_uyari "$1 talimatının takip betiği yok!"
fi
fi
}
kaynak_kod_indir(){
local konum adres adres2
_kk_indir="wget --no-check-certificate -q ${wget_progress}"
konum=$(talimat_bul $1)
if [[ $konum == "-1" || $konum == "0" ]];then
$_yaz_uyari "$1 $_talimat_bulunamadi"
exit 1
else
source $konum/talimat
for adres in $kaynak;do
urlkont='(https?|ftp|file)://[-A-Za-z0-9\+&@#/%?=~_|!:,.;]*[-A-Za-z0-9\+&@#/%=~_|]'
if [[ $adres =~ $urlkont ]];then
if [[ $adres =~ "::" ]];then
adres2=$(echo $adres | cut -d':' -f-2)
$_yaz "$adres2 indiriliyor."
$_kk_indir $adres2
else
$_yaz "$adres indiriliyor."
$_kk_indir $adres
fi
else
$_yaz "$adres kopyalanıyor."
[ -f $konum/$adres ] && cp $konum/$adres .
fi
done
fi
}
paket_derle(){
#parametre olarak direk konum gelecek
#eski derleme kalıntılarını temizle
rm -rf tmp.*
kaynakdizin_kontrol
local konum derleme_onay eh bagimd derpaket _gncdurum
derleme_onay="h"
if [ -d "$1" ];then
konum="$1"
derpaket=`basename $1`
else
konum=$(talimat_bul $1)
if [[ $konum == "-1" || $konum == "0" ]];then
$_yaz_uyari "$1 $_talimat_bulunamadi"
exit 1
fi
derpaket="$1"
fi
if [ -d "$konum" ];then
grup_kontrol $konum/talimat
mkdir -p tmp."$derpaket"
cp -a $konum/* tmp."$derpaket"/
cd tmp."$derpaket"
_kurulu=$(kurulu_kontrol "$derpaket")
# paket kurulu ise kurulu sürüm-devir depoyla kontrol edilir,gerekirse silinip yenisi derlenir.
if [ "$_kurulu" = "kurulu" ];then
_gncdurum=$(surum_devir_kontrol ${derpaket} --durum)
if [ "${_gncdurum}" == "var" ];then
echo "Kurulu sürüm depodaki sürümden farklı görünüyor depodaki sürüm ile eşitlemek ister misiniz? "
surum_devir_kontrol ${derpaket}
paket_sil ${derpaket}
# paket silinirse kurulu olma durumunu güncellenir.
_kurulu=$(kurulu_kontrol "$derpaket")
fi
fi
if [ "$_kurulu" = "kurulu" ] && [ "$zorla_derle" = "yok" ];then
derleme_onay="h"
else
derleme_onay="e"
fi
if [ "$derleme_onay" = "e" ];then
$_yaz_bilgi "$derpaket" "derleniyor...."
echo "------------------------"
mpsd -d 2>&1|tee /tmp/"$derpaket".log
if ( grep "^=======>" /tmp/"$derpaket".log| tail -1 |grep "ERROR" > /dev/null);then
echo "derleme sisteminde hata oluştu -----> " /tmp/"$derpaket".log
exit 1
fi
if [ "$kurulum_onay" = "evet" ];then
for kpkt in `ls $derpaket* | cut -d'#' -f1`;do
yerelden_kur "$kpkt#"*
done
fi
mv *.mps.lz ../
else
$_yaz "$derpaket $_zaten $_paket_kurulu,yine de derlemek için:
mps -zd $derpaket"
fi
cd ..
rm -r tmp."$derpaket"
else
$_yaz_uyari "talimat dosyası bulunamadı."
hataloglama "talimat dosyası bulunamadı."
fi
}
##_ bagimlilar() : talimatta yer alan gereklerin listesinin alınması.
bagimlilar(){
local bagimd konum
konum=$(talimat_bul $1)
if [[ $konum != "-1" && $konum != "0" ]];then
bagimd=`cat $konum/talimat | grep "Gerekler" | cut -d':' -f2`
bagimd=$(echo "$bagimd" | sed 's/,/ /g')
echo "$bagimd"
else
echo "$konum"
fi
}
ters_bagimli_bilgi(){
local gtbpaket _sadece_kurulu
_sadece_kurulu="hepsi"
gtbpaket=$1
[ "$2" ] && _sadece_kurulu="$2"
tbgdosya=$(mktemp)
grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}\s" $talimatname > $tbgdosya ;
grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}\s" $ektalimatname >> $tbgdosya ;
grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}$" $ektalimatname >> $tbgdosya ;
grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}$" $talimatname >> $tbgdosya ;
cat $tbgdosya | xargs -I {} dirname {} | xargs -I {} basename {} | sort > /tmp/${gtbpaket}.tb.txt
rm -f $tbgdosya
[ -f /tmp/${gtbpaket}.tbk.txt ] && rm -f /tmp/${gtbpaket}.tbk.txt
if [ $_sadece_kurulu = "kurulu" ];then
for _kurulu_pkt in $(cat /tmp/${gtbpaket}.tb.txt);do
if [ -d $VT/$_kurulu_pkt ];then
echo "$_kurulu_pkt" >> /tmp/${gtbpaket}.tbk.txt
fi
done
[ -f /tmp/${gtbpaket}.tbk.txt ] && cat "/tmp/${gtbpaket}.tbk.txt"
else
cat "/tmp/${gtbpaket}.tb.txt"
fi
rm -rf $tbgdizin
}
kirik_ters_bagimli_bilgi(){
$_yaz "Aşağıdaki kurulu ters bağımlılıklarda kırılım araması yapılacaktır."
ters_bagimli_bilgi $1
$_yaz "........"
talimatlar=$(cat /tmp/$1.tb.txt)
for tal in $talimatlar;do
#paket kuruluysa kontrolu yapılacak
if [ -d "$VT/$tal" ];then
$_yaz_bilgi "$tal paketi araştırılıyor:"
kirik_kontrol_paket $tal
$_yaz_bilgi "--------------------------"
fi
done
}
bagimli_bilgi(){
local _konum bagimd _dosya _paket
[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
_konum=$(talimat_bul $_paket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$_paket tanimsiz"
exit 0
else
bagimd=`cat $_konum/talimat | grep "Gerekler" | cut -d':' -f2`
if [ -n "$bagimd" ]; then
bagimd=`echo "$bagimd" | sed 's/,/ /g'`
for bag in $bagimd;do
if [ "$2" = "dogrula" ];then
kurulum_dogrulama_icerik "$bag"
else
echo "$bag" "`kurulu_kontrol $bag`"
fi
done
fi
if [ "$2" = "dogrula" ];then
kurulum_dogrulama_icerik "$1"
else
echo "$1" "`kurulu_kontrol $1`"
fi
fi
}
bagimli_bilgi_dosyala(){
local _konum bagimd _dosya _paket
[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
_konum=$(talimat_bul $_paket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$_paket tanimsiz"
exit 0
else
_dosya="/tmp/${_paket}.gerekler.liste"
rm -f ${_dosya}
bagimd=`cat $_konum/talimat | grep "Gerekler" | cut -d':' -f2`
if [ -n "$bagimd" ]; then
bagimd=`echo "$bagimd" | sed 's/,/ /g'`
for bag in $bagimd;do
echo "$bag" >> "/tmp/$1.gerekler.liste"
#echo "$bag"
#for _tb in $(ters_bagimli_bilgi $bag);do
# echo '|____' $_tb
#done
done
fi
fi
}
silme_etkilenen_kontrol(){
paketet="$2"
mkdir -p /var/lib/pkg/etkilenen
mkdir -p /var/lib/pkg/etkilenen/$paketet
local dizin
for f in $(cat $1) ; do
dizin="${f%\'}"
dizin="${dizin#\'}"
if [ -d "$dizin" ];then
for g in `ls "$dizin"` ; do
if ! grep -Fxq " '$dizin/$g'" "$1"
then
echo "$dizin/$g"
cp -rf "$dizin/$g" /var/lib/pkg/etkilenen/$paketet
fi
done
fi
done
}
# güncellemelerin alınması talimatname üzerinden
guncellemeler(){
#diff --changed-group-format='***%>' --unchanged-group-format='' --new-group-format='+++%>' \
#$paketdepo/paket.vt.eski $paketdepo/paket.vt | cut -d' ' -f1 | sort --version-sort
_mps_guncellenecekler="/tmp/mps.guncellenecekler.liste"
[ -f $_mps_guncellenecekler ] && rm $_mps_guncellenecekler
for _paket in $(ls $VT);do
if [ "$(surum_devir_kontrol ${_paket} x)" = "var" ];then
echo ${_paket} >> $_mps_guncellenecekler
fi
done
if [ -f $_mps_guncellenecekler ];then
echo "guncellenecek liste"
echo "-------------------"
cat $_mps_guncellenecekler
fi
}
# iki dosyanın içerik karşılaştırması yapar.
dosya_karsilastir(){
if cmp -s "$1" "$2"
then
echo "evet"
else
echo "degil"
fi
}
# ip bulma
ip_bul(){
url='[a www.google.com]'
domain=`echo $url | sed 's-^[^/]*/*\([^/]*\)/\?.*$-\1-'`
echo "< $domain"
ipaddr=`ping -c 1 $domain | sed -n 's@^.*(\([0-9]*\.[0-9]*\.[0-9]*\.[0-9]*\).*$@\1@p' | head -1`
req_url=`echo $url | sed "s-/[^/]\+-/$ipaddr-"`
echo req_url
}
# renkli mesaj
ryaz() {
[ -z "$1" ] && return
: ${color=$1}
shift
case $color in
0*) echo -e "\\033[${color:-38}m$@\\033[39m";;
*) echo -e "\\033[1;${color:-38}m$@\\033[0;39m";;
esac
unset color
}
log_analiz(){
local zaman durum
zaman=$1
durum=$2
if [ -f "/var/log/mps/mps.log" ];then
cat $logdosya | grep "$zaman" | grep "$durum" | cut -d' ' -f3
else
$_yaz_uyari "mps.log bulunamadı!"
hataloglama "mps.log bulunamadı!"
fi
}
silme_etkilenme_tespit(){
local _paket _kliste _eliste dizin
local _satir _edosya _ipaket _ustdizin
[ -z $1 ] && hata_olustu "_paket_adi_gerekli" || _paket=$1
_kliste=`mktemp`
_eliste=`mktemp`
#[ -d /tmp/${_paket}_kurtarma ] && rm -rf /tmp/${_paket}_kurtarma
#mkdir -p /tmp/${_paket}_kurtarma
[ -f /tmp/${_paket}_kd.liste ] && rm -rf /tmp/${_paket}_kd.liste
[ -f /tmp/${_paket}_ep.liste ] && rm -rf /tmp/${_paket}_ep.liste
for _temp in $(cat /var/lib/pkg/DB/${_paket}/kurulan);do
dizin=${_temp//[\']/}
if [ -d $dizin ] ;then
grep --exclude=/var/lib/pkg/DB/${_paket}/kurulan -ri "'${dizin}/" /var/lib/pkg/DB/*/kurulan \
| while read -r _isatir ; do
#echo "$_isatir"
#echo "$dizin - $_paket -"
echo "${dizin}" >> ${_kliste}
_esatir=$(echo ${_isatir} | cut -d ':' -f1)
_edosya=$(echo ${_isatir} | cut -d ':' -f2)
_ipaket=$(basename $(dirname ${_esatir}))
_ustdizin=$(dirname ${_edosya//[\']/})
#mkdir -p /tmp/${_paket}_kurtarma/${_ustdizin}
if [ ! -d ${_edosya//[\']/} ];then
[ ! -f ${_edosya//[\']/} ] && echo "${_edosya//[\']/} dosyası eksik!"
fi
# eksik dosyalar onaylı yekur yapılacak.
# /var/lib/pkg/kurtarma altına kopayalama seçimli olacak.
#\
# cp -rf ${_edosya//[\']/} /tmp/${_paket}_kurtarma/${_ustdizin}
echo "${_ipaket}" >> ${_eliste}
done
fi
done
if [ -s ${_kliste} ];then
sort -u ${_kliste} > /tmp/${_paket}_kd.liste
$_yaz "etkilenen konumlar"
cat /tmp/${_paket}_kd.liste
fi
if [ -s ${_eliste} ];then
sort -u ${_eliste} > /tmp/${_paket}_ep.liste
$_yaz "etkilenen paketler"
cat /tmp/${_paket}_ep.liste
fi
rm -rf ${_eliste} ${_kliste}
}
eski_etkilenen_kurtar(){
local dizin paket
paket=$1
if [ -f $VT/$paket/kurulan ];then
cat $VT/$paket/kurulan | cut -d '>' -f2 > /tmp/$paket.sil
for f in $(cat /tmp/$paket.sil) ; do
dizin="${f%\'}"
dizin="${dizin#\'}"
if [ -d "$dizin" ];then
for g in `ls "$dizin"` ; do
if ! grep -Fxq " '$dizin/$g'" "/tmp/$paket.sil"
then
if [ -f /tmp/$paket.kurtar ];then
rm /tmp/$paket.kurtar
fi
echo " '$dizin'" >> "/tmp/$paket.kurtar"
fi
done
fi
done
if [ -f /tmp/$paket.kurtar ];then
mv $VT/$paket/kurulan $VT/$paket/ilk.kurulan
grep -v -F -x -f "/tmp/$paket.kurtar" "/tmp/$paket.sil" > $VT/$paket/kurulan
$_yaz "$paket etkilenen dosyaları kurtarıldı."
else
$_yaz "$paket etkilenen dosyası yok."
fi
rm -f /tmp/$paket.sil
else
$_yaz_uyari "kurulan paket yok!"
hataloglama "kurulan paket yok!"
fi
}
ters_bagimli_kontrol(){
ters_bagimli_bilgi $1
cat /tmp/${1}.tb.txt | sort > tersb.liste
ls $VT/ | sed "/$1/d" | sort > simdiki.liste
comm -12 tersb.liste simdiki.liste
rm tersb.liste simdiki.liste
}
kurulu_kontrol(){
local _konum _apaket
[ -z $1 ] && hata_olustu "_paket_adi_gerekli"
_apaket=$1
cikti_renk_ayarla "--normal"
[ $2 ] && cikti_renk_ayarla "$2"
if [ -d "$kokdizin$VT/$_apaket" ];then
$_yaz "kurulu"
exit 0
fi
_konum=$(talimat_bul $_apaket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "tanimsiz"
else
$_yaz_uyari "degil"
fi
exit 1
}
sistem_kur(){
local spaket
for spaket in `cat $1`;do
./$betikad -ik "$spaket" -kok $2;
done
}
kaynakdizin_kontrol(){
if [ ! -d $kaynak_dizin ];then
mkdir $kaynak_dizin
fi
}
logdizin_kontrol(){
if [ ! -d $kokdizin$LOGDIZIN ];then
mkdir $kokdizin$LOGDIZIN
fi
if [ ! -d $kokdizin$LOGDIZIN/derleme ];then
mkdir $kokdizin$LOGDIZIN/derleme
fi
if [ ! -f $kokdizin$LOGDIZIN/mps.log ];then
touch $kokdizin$LOGDIZIN/mps.log
fi
if [ ! -f $kokdizin$LOGDIZIN/mps-hata.log ];then
touch $kokdizin$LOGDIZIN/mps-hata.log
fi
if [ ! -f $kokdizin$LOGDIZIN/mps-git.log ];then
touch $kokdizin$LOGDIZIN/mps-git.log
fi
}
tarihce_dkontrol(){
if [ ! -d $TARIHCE_DIZIN ];then
mkdir $TARIHCE_DIZIN
fi
}
temel_tarihce_kontrol(){
if [ ! -f $TARIHCE_DIZIN/temel-pkvt.tar.lz ];then
tarihce_olustur "temel"
fi
}
tarihce_liste(){
tarihce_dkontrol
ls $TARIHCE_DIZIN/
}
tarihce_yap(){
tarihce_dkontrol
local t_isim
if [ "$temel_tarihce" = "evet" ];then
t_isim="temel"
else
t_isim=`date +%m-%d-%y.%H%M%S`
fi
tarihce_olustur "$t_isim"
}
tarihce_olustur(){
bsdtar -P -r -f $TARIHCE_DIZIN/"$1"-pkvt.tar $VT
lzip -9 $TARIHCE_DIZIN/"$1"-pkvt.tar
}
tarihce_yukle(){
tarihce_dkontrol
local islem_onay cikis
sil_onay="h"
if [ -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz" ];then
bsdtar -p -o -C /tmp -xf $TARIHCE_DIZIN/"$1-pkvt.tar.lz" 2>/dev/null
ls /tmp$VT/ > hedef.pkvt
ls $VT/ > simdiki.pkvt
grep -v -F -x -f hedef.pkvt simdiki.pkvt > sil.liste
grep -v -F -x -f simdiki.pkvt hedef.pkvt > kur.liste
#rm hedef.pkvt simdiki.pkvt
rm -r /tmp/var
cikis=""
if [ -s sil.liste ];then
$_yaz "silinecekler"
$_yaz "------------"
cat sil.liste
fi
if [ -s kur.liste ];then
$_yaz "kurulacaklar"
$_yaz "------------"
cat kur.liste
fi
if [ ! -s sil.liste ] && [ ! -s kur.liste ];then
$_yaz "sistem zaten hedef durumda!"
exit 1
fi
while true; do
$_yaz_tm "otomatik geri dönüşüm başlasın mı?";read -p "e veya h-> " eh
case $eh in
[Ee]* ) islem_onay="e"; break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
if [ "$islem_onay" = "e" ];then
mps -os sil.liste
mps kurul kur.liste
mv sil.liste silinenler.liste
mv kur.liste kurulanlar.liste
exit 1
fi
mv sil.liste sil_iptal.liste
mv kur.liste kur_iptal.liste
else
$_yaz_uyari "ilgili tarihce dosyası bulunamadı!"
hataloglama "ilgili tarihce dosyası bulunamadı!"
fi
[ -f $PWD/hedef.pkvt ] && rm $PWD/hedef.pkvt
[ -f $PWD/simdiki.pkvt ] && rm $PWD/simdiki.pkvt
}
tarihce_sil(){
tarihce_dkontrol
if [ -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz" ];then
rm -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz"
else
$_yaz_uyari "ilgili tarihce dosyası bulunamadı!"
hataloglama "ilgili tarihce dosyası bulunamadı!"
fi
}
sunucu_ayarla(){
wget -q --spider "$1/paket.vt"
yenisun="$1"
if [ $? -eq 0 ]; then
sed -i.bak 's/^\(sunucu=\).*/\1"xverix\/"/' /etc/mps.conf
sed -i "s|xverix|$1|" /etc/mps.conf
mps -sun
else
$_yaz_uyari "Tanımsız paket sunucusu!"
hataloglama "Tanımsız paket sunucusu!"
fi
}
loglama(){
logdizin_kontrol
echo "$(date +'%F %T') $1" >> "$kokdizin/$LOGDIZIN/mps.log"
}
hataloglama(){
logdizin_kontrol
echo "$(date +'%F %T') $1" >> "$kokdizin/$LOGDIZIN/mps-hata.log"
}
indir_talimat_paketle(){
local dosya _ip _talkonum _ek_talimat_link
_wget="wget --quiet --no-check-certificate"
if [ ! -z "$1" ];then dosya=$1;else $_yaz_uyari "link parametre eksik";exit 1;fi
if [ ! -z "$2" ];then _ip=$2;else $_yaz_uyari "ip tipi parametresi eksik";exit 1;fi
if [ ! -z "$3" ];then _talkonum=$3;else $_yaz_uyari "talimatname konum parametre eksik";exit 1;fi
# ek-talimatname altında ilgili talimat var mı kontrol edilir
_ek_talimat_link="${ektalimatname_repo}/raw/master/${dosya}/talimat"
wget -q --spider ${_ek_talimat_link}
[ $? -eq 0 ] && dosya=${_ek_talimat_link}
urlkont='(https?|ftp|file)://[-A-Za-z0-9\+&@#/%?=~_|!:,.;]*[-A-Za-z0-9\+&@#/%=~_|]'
if [[ $dosya =~ $urlkont ]];then
gdosya=`mktemp`
if [[ $_ip =~ "-6" ]]; then
$_yaz "talimat IPv6: ${dosya} linkinden indirildi."
$_wget $_ip $dosya -O $gdosya
else
$_yaz "talimat IPv4: ${dosya} linkinden indirildi."
$_wget $_ip $dosya -O $gdosya
fi
dosya=$gdosya
else
$_yaz_uyari "link geçersiz"
exit 1
fi
if [ ! -f $dosya ];then
$_yaz_uyari "$dosya talimat dosyasi yok!"
exit 1
fi
local _isim
_isim=`grep "^name=" $dosya | head -n1 | cut -d'=' -f 2`
[ -z "${_isim}" ] && _isim=`grep "^isim=" $dosya | head -n1 | cut -d'=' -f 2`
if [ ! -n "${_isim}" ]; then
$_yaz_uyari "paket ismi degiskeni bulunamadı!"
exit 1
fi
if [ ! -d $_talkonum/${_isim:0:1}/${_isim} ];then
mkdir -p $_talkonum/${_isim:0:1}/${_isim}
cp -f $dosya $_talkonum/${_isim:0:1}/${_isim}/talimat
talimat_degisken_cevrim $_talkonum/${_isim:0:1}/${_isim}/talimat
$_yaz "${_isim} talimatı hazırlandı."
else
$_yaz_uyari "${_isim} talimatı zaten talimatnamede var!"
fi
}
talimat_degisken_cevrim(){
_dosya=$1
if [ -f $_dosya ];then
sed -i 's/name=/isim=/g' $_dosya
sed -i 's/$name/$isim/g' $_dosya
sed -i 's/${name}/${isim}/g' $_dosya
sed -i 's/version=/surum=/g' $_dosya
sed -i 's/$version/$surum/g' $_dosya
sed -i 's/${version}/${surum}/g' $_dosya
sed -i 's/${version%.*}/${surum%.*}/g' $_dosya
sed -i 's/release=/devir=/g' $_dosya
sed -i 's/$release/$devir/g' $_dosya
sed -i 's/${release}/${devir}/g' $_dosya
sed -i 's/source=/kaynak=/g' $_dosya
sed -i 's/build()/derle()/g' $_dosya
sed -i 's/build ()/derle()/g' $_dosya
sed -i 's/Description:/Tanım:/g' $_dosya
sed -i 's/Description=/Tanım:/g' $_dosya
sed -i 's/Url=/Url:/g' $_dosya
sed -i 's/description:/Tanım:/g' $_dosya
sed -i 's/Description :/Tanım:/g' $_dosya
sed -i 's/Packager:/Paketçi:/g' $_dosya
sed -i 's/packager:/Paketçi:/g' $_dosya
sed -i 's/Packagers:/Paketçi:/g' $_dosya
sed -i 's/Packager :/Paketçi:/g' $_dosya
sed -i 's/Depends on:/Gerekler:/g' $_dosya
sed -i 's/Depends:/Gerekler:/g' $_dosya
sed -i 's/Depends on :/Gerekler:/g' $_dosya
sed -i '/Maintainer:/d' $_dosya
sed -i '/Optional:/d' $_dosya
else
$_yaz_uyari "ilgili talimat dosyası bulunamadı."
fi
}
talimat_olustur(){
if [ "$1" = '?' ];then
$_yaz_tm "kullanım : mps -to paket_ismi"
else
local isim
isim=$1
mkdir -p $isim
tee "$isim/talimat" > /dev/null <<EOF
# Tanım: paket açıklaması
# Url: paketin ilgili web sayfası
# Paketçi: paketçi
# Gerekler:
# Grup:
isim=$isim
surum=1
devir=1
kaynak=()
derle() {
cd \$isim-\$surum
./autogen.sh
./configure --prefix=/usr
make
make DESTDIR=\$PKG install
}
EOF
$_yaz_tm $isim "talimatı oluşturuldu."
fi
}
git_guncelle() {
kaynakdizin_kontrol
gitayar_kontrol
local _yerel
#git deponun sunucudan güncellenmesi
$_yaz_bilgi "$_git_guncelleniyor : $git_sunucu"
if [ $(sunucu_erisim ${git_repo}) = "aktif" ];then
if [ ! -d ${git_yereldepo} ];then
git clone ${git_repo} ${git_yereldepo}
#rsync -av ${git_yereldepo}/rootfs/* /
else
cd ${git_yereldepo}
git pull >& $LOGDIZIN/mps-git.log
if grep -q "Already\ up-to-date" $LOGDIZIN/mps-git.log; then
$_yaz "$_git_guncel"
else
#ryaz 32 `cat $LOGDIZIN/mps-git.log`
$_yaz "$_git_guncellendi"
fi
fi
else
$_yaz_uyari "${git_repo} erişim olumsuz.Uzaktan güncelleme alınamadı."
fi
if [ -d ${git_yereldepo} ];then
# git depodan yerel güncellemelerin yapılması
#baslangic betiklerinin guncellenmesi
#rsync -aviz -q --delete ${git_yereldepo}/rootfs/lib/services/* /lib/services/
[ -d /lib/services/ ] && cp --remove-destination -rf ${git_yereldepo}/rootfs/lib/services/* /lib/services/
# talimatname ve betiklerin güncellenmesi
_yerel=$(dirname $talimatname)
cd ${_yerel}
rm -rf $talimatname ${_yerel}/bin ${_yerel}/ayarlar
cp -rf ${git_yereldepo}/talimatname/ ${_yerel}/
cp -rf ${git_yereldepo}/bin ${_yerel}/
cp -rf ${git_yereldepo}/ayarlar ${_yerel}/
#ikili dosyaların /usr/bin altına kısayol atılması
for i in ${_yerel}/bin/*; do
j=`basename $i`
if [ ! -L /usr/bin/$j ];then
ln -sf ${_yerel}/bin/$j /usr/bin/$j
fi
done
#kırık linklerin temizlenmesi
find -L /usr/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
find -L ${_yerel}/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
[ -d /root/bin ] && find -L /root/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
$_yaz "$_yerel_esitlendi"
else
$_yaz "$_yerel_esitlendi_olumsuz"
fi
}
git_proje_kur(){
local proje proj_dizin git_link
git_link="https://notabug.org/milisarge"
proje="$1"
proj_dizin="/opt"
mkdir -p $proj_dizin
if [ -d "$proj_dizin/$proje" ];then
cd $proj_dizin/$proje
git pull
if [ -f mops ];then
. mops
mops_gun
fi
else
git clone "$git_link/$proje" "$proj_dizin/$proje"
cd $proj_dizin/$proje
if [ -f mops ];then
. mops
mops_kur
mops_sil
mops_gun
fi
fi
}
op_kur(){
local mopsyol mops
mops=$1
mopsyol="~/mops/$mops"
# talimatnameye bak
if [ -d $mopsyol ]; then
$mopsyol/talimat kur
# yerelde ara
elif [ -f $PWD/"$mops" ]; then
./"$mops" kur
else
$_yaz_uyari "$1 mops talimatı bulunamadı!"
fi
}
op_sil(){
local mopsyol mops
mops=$1
mopsyol="~/mops/$mops"
# talimatnameye bak
if [ -d $mopsyol ]; then
$mopsyol/talimat sil
# yerelde ara
elif [ -f $PWD/"$mops" ]; then
./"$mops" sil
else
$_yaz_uyari "$1 mops talimatı bulunamadı!"
fi
}
servis_kur(){
cd ${git_yereldepo}/ayarlar/servisler
if make kur-$1
then
$_yaz "$1 servisi kuruldu"
else
$_yaz_uyari "$1 servisi kurulum olumsuz!!!"
hataloglama "$1 servisi kurulum olumsuz!!!"
fi
cd -
}
servis_sil(){
cd ${git_yereldepo}/ayarlar/servisler
if make sil-$1
then
$_yaz "$1 servisi silindi"
else
$_yaz_uyari "$1 servisi silme olumsuz!!!"
hataloglama "$1 servisi silme olumsuz!!!"
fi
cd -
}
servisler_kontrol(){
servisler=`ls ${git_yereldepo}/ayarlar/servisler/mbd/init.d`
for ser in $(ls /etc/init.d/) ; do
if [ ! -f ${git_yereldepo}/ayarlar/servisler/mbd/init.d/$ser ];then
printf "%12s %s\n" "$ser mbd kaydı bulunamadı!"
else
if cmp -s "${git_yereldepo}/ayarlar/servisler/mbd/init.d/$ser" "$ser"
then
printf "%12s %s\n" "$ser" "mbd uyumsuz"
else
#ryaz 32 "$ser mbd +++++"
printf "%12s %s\n" "$ser" "mbd +++++"
fi
fi
done
}
talimat_bilgi(){
local _konum _apaket
_apaket=$1
[ "$2" ] && cikti_renk_ayarla "$2"
_konum=$(talimat_bul $_apaket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$_apaket $_paket_bulunamadi"
exit 1
else
grep "derle()" -B 12 $_konum/talimat |sed '$ d'
$_yaz "file://$_konum/talimat"
#$_yaz "https://raw.githubusercontent.com/milisarge/malfs-milis/master/$(echo $_konum | cut -d'/' -f3-6)/talimat"
$_yaz "${git_sunucu}/${hesap_repo}/raw/master/$(echo $_konum | cut -d'/' -f3-6)/talimat"
fi
}
talimat_yazdir(){
local _konum _apaket
_apaket=$1
_konum=$(talimat_bul $_apaket)
if [ "$_konum" = "-1" ];then
$_yaz_uyari "$_apaket $_paket_bulunamadi"
exit 1
else
cat $_konum/talimat
fi
}
sistem_kontrol(){
paketvt_kontrol
sunucu_kontrol
}
sunucu_erisim(){
local _sunucu
[ $1 ] && _sunucu="$1"
wget --no-check-certificate -q --spider "${_sunucu}"
if [ $? -eq 0 ]; then
echo "aktif"
else
echo "pasif"
fi
}
sunucu_kontrol(){
local _sunucular=$(echo ${sunucular} | tr " " "\n")
for _sunucu in ${_sunucular}; do
[ $(sunucu_erisim ${_sunucu}/paket.vt) = "aktif" ] && $_yaz "${_sunucu} paket sunucu aktif" \
|| $_yaz_uyari "${_sunucu} sunucu erişim dışı"
done
}
gitayar_kontrol(){
if [ ! -f /root/.gitconfig ];then
[ `which git_ssl_iptal` ] && git_ssl_iptal
[ `which git_otokimlik` ] && git_otokimlik
fi
}
kirik_kontrol_sistem(){
local onek sonek
onek="'"
sonek="'"
for paket in `ls $VT/`
do
$_yaz_bilgi $paket "kontrol ediliyor."
kirik_kontrol_paket $paket
$_yaz_bilgi $paket "kontrol edildi."
done
}
kirik_kontrol_paket(){
local onek sonek
onek="'"
sonek="'"
for kdosya in `kurulum_dosya_listele $1`
do
dosya=${kdosya#$onek}
dosya=${dosya%$sonek}
#echo "${dosya}"
if [ -f $dosya ];then
if [[ $(milis-ldd -d $dosya | grep not\ found) ]] ;then
echo $kdosya
fi
fi
done
}
kurulum_dogrulama(){
for kuruland in `ls $VT`
do
if [ ! -f "$VT/$kuruland/kurulan" ]; then
$_yaz "$kuruland hasarlı kurulum tesbiti!"
rm -r $VT/$kuruland
paket_indir $kuruland
yerelden_kur "$paketdepo/$kuruland"*.mps.lz
$_yaz "$kuruland hasarlı kurulum onarıldı."
fi
done
}
paket_icerik_dogrulama(){
local dosyayol kontpaketadi tempmpslz pidanayol
kontpaketadi="$1"
if [ -f "$paketdepo/$kontpaketadi#"*.mps.lz ];then
tempmpslz=$(mktemp)
if [ -d $2 ];then
pidanayol="$2"
tar tf "$paketdepo/$kontpaketadi#"*.mps.lz > $tempmpslz
IFS=''
while read dosyayol;do
if [ ! -f $pidanayol$dosyayol ] && [ ! -d $pidanayol$dosyayol ] && [ $dosyayol != ".MTREE" ] && [ $dosyayol != ".META" ]; then
$_yaz_uyari "$pidanayol$dosyayol hasarlı"
while true; do
$_yaz_tm $kontpaketadi" paketi yenilensin mi?";read -p "e veya h-> " eh
case $eh in
[Ee]* ) tekrarkur="evet";agdan_kur "$kontpaketadi";break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
fi
done < $tempmpslz
else
$_yaz_uyari "$2 kök dizini bulunamadı!"
exit 1
fi
else
$_yaz_uyari "$1 paketi bulunamadı!"
exit 1
fi
}
kurulum_dogrulama_icerik_tum(){
$_yaz_bilgi "paket veritabanı yedekleniyor"
tarihce_yap
for kurulanpak in `ls $VT`
do
if [ -f "$VT/$kurulanpak/kurulan" ]; then
kurulum_dogrulama_icerik $kurulanpak
$_yaz "$kurulanpak kurulum icerik onarıldı."
fi
done
}
chr_yordam() {
[ "$1" -lt 256 ] || return 1
printf "\\$(printf '%03o' "$1")"
}
ord_yordam() {
LC_CTYPE=C printf '%d' "'$1"
}
kurulum_dogrulama_icerik(){
paketadi="$1"
onar="hayir"
#echo $VT
#tarihce_yap
$_yaz_uyari "$paketadi içeriği kontrol ediliyor."
if [ -f "$VT/$paketadi/kurulan" ]; then
ilksatir=`head -n 1 $VT/$paketadi/kurulan`
if [[ `echo ${ilksatir}` =~ ^ ]] ; then
$_yaz "temel sistem paket kurulan hatası düzeltildi!"
sed -i 's//'\''\//;s//'\''/' $VT/$paketadi/kurulan
fi
#for dosyayol in $(cat $VT/$paketadi/kurulan);do
while read dosyayol; do
#for dosyayol in $(<$VT/$paketadi/kurulan);do
dosyayol=$(echo $dosyayol | sed 's/^.\(.*\).$/\1/')
netdosyayol="${dosyayol:1:${#dosyayol}-1}"
if [ ! -f $dosyayol ] && [ ! -d $dosyayol ] ; then
$_yaz_uyari "$dosyayol hasarlı"
onar="evet"
fi
done < $VT/$paketadi/kurulan
if [ $onar = "evet" ];then
$_yaz_tm "$paketadi hasarlı dosya barındırıyor,düzeltilsin mi?";read -p "e veya h-> " eh
case $eh in
[Ee]* ) tekrarkur="evet";agdan_kur "$paketadi";;
[Hh]* ) $_yaz_uyari "$paketadi pas geçildi.";;
* ) echo "e veya h";;
esac
fi
$_yaz "$paketadi kurulum doğrulama tamamlandı."
elif [ -d "$VT/$paketadi" ]; then
cp -rf $VT $VT.yedek
$_yaz_uyari "$paketadi hasarlı kurulum tesbiti!"
#onarma
rm -r $VT/$paketadi
paket_indir $paketadi
yerelden_kur "$paketdepo/$paketadi#"*.mps.lz
$_yaz "$paketadi hasarlı kurulum onarıldı."
else
$_yaz_uyari "$paketadi $_paket_kurulu_degil"
fi
}
tamir_temel_kurulan(){
if [ ! -d $VT ] ; then
$_yaz_uyari "paket kurulum vt bulunamadı!"
exit 1
fi
for paketadi in `ls $VT`
do
sed -i 's//'\''\//;s//'\''/' $VT/$paketadi/kurulan
done
}
depo_paketler_liste(){
ls $paketdepo*.mps.lz
}
depo_paketler_sil(){
while true; do
pktsay="0"
[[ $(ls $paketdepo*.mps.lz) ]] && pktsay=$(ls $paketdepo/*.mps.lz | wc -l)
$_yaz_tm "$paketdepo altındaki $pktsay paket silinecek?";read -p "e veya h-> " eh
case $eh in
[Ee]* ) rm $paketdepo/*.mps.lz; $_yaz "$paketdepo paketler temizlendi."; break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
}
etkilenenler_sil(){
while true; do
$_yaz_tm "etkilenen önbellek silinecek?";read -p "e veya h-> " eh
case $eh in
[Ee]* ) rm -rf /var/lib/pkg/etkilenen; $_yaz "etkilenen önbellek temizlendi."; break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
}
kurulum_dosya_listele(){
cat "$VT/$1/kurulan"
}
# bir dosyanın kurulmuş hangi pakette olduğunu bulur.
kurulan_dosya_bul(){
grep -rli "$1" "$VT/" | cut -d "/" -f6
}
paketvt_kontrol(){
mkdir -p /depo/paketler
if [ ! -f /depo/paketler/paket.vt ];then
touch /depo/paketler/paket.vt
fi
}
pvt_olustur(){
if [ ! -f paket.vt ];then
touch paket.vt
fi
if [ -f "paket.vt" ];then
mv "paket.vt" "paket.vt.eski"
fi
$_yaz "paket.vt oluşturuluyor...."
for paket in `ls *.mps.lz`
do
paketad="`echo $paket|cut -d "#" -f1`"
shaek=`sha1sum $paket`
echo $paketad $shaek >> paket.vt
done
$_yaz "paket.vt oluşturuldu."
}
paketvt_guncelle(){
local _bakim _sunucular _bakim _sira
_sunucular=$(echo ${sunucular} | tr " " "\n")
_bakim="yok"
_sira=0
for pktsunucu in ${_sunucular}; do
pkvt=""
let _sira=_sira+1
if [ ${_sira} = 1 ];then
pktvt="paket.vt"
else
pktvt="paket${_sira}.vt"
fi
# sunucu bakım kontrolü
[ $(sunucu_erisim "$pktsunucu""paket.vt.yeni") = "aktif" ] && _bakim="var"
if [ $_bakim = "yok" ];then
if [ $(sunucu_erisim "$pktsunucu""paket.vt") = "aktif" ]; then
$_yaz $pktsunucu
$_yaz "$_paketvt_guncelleniyor" "$paketdepo""$pktvt"
if [ -f "$paketdepo""$pktvt" ];then
mv "$paketdepo""$pktvt" "$paketdepo""$pktvt.eski"
fi
wget --no-check-certificate -q ${wget_progress} -P "$paketdepo" "$pktsunucu""paket.vt" -O "$paketdepo""$pktvt"
#rm /tmp/paket.vt*
else
$_yaz_uyari "$pktsunucu paket veritabanı erişim olumsuz."
hataloglama "paket veritabanı güncelleme olumsuz."
fi
else
$_yaz_bilgi "$pktsunucu paket veritabanı bakımı yapılıyor."
$_yaz_bilgi "5dk içinde tekrar deneyiniz."
fi
done
}
yuzdelik_filtre ()
{
local flag=false c count cr=$'\r' nl=$'\n'
while IFS='' read -d '' -rn 1 c
do
if $flag
then
printf '%c' "$c"
else
if [[ $c != $cr && $c != $nl ]]
then
count=0
else
((count++))
if ((count > 1))
then
flag=true
fi
fi
fi
done
}
listeleri_temizle(){
[ -f gerek.liste ] && rm -rf gerek.liste
[ -f gerek.konum.liste ] && rm -rf gerek.konum.liste
}
paket_indir(){
if [ -f "$paketdepo""paket.vt" ];then
local _ipaket pkt
[ $1 ] && _ipaket="$1" || hata_olustu "_paket_adi_gerekli"
[ "$2" ] && cikti_renk_ayarla "$2"
local _sunucular _sira
_sunucular=$(echo ${sunucular} | tr " " "\n")
_sira=0
for pktsunucu in ${_sunucular}; do
pkvt=""
let _sira=_sira+1
if [ ${_sira} = 1 ];then
pktvt="paket.vt"
else
pktvt="paket${_sira}.vt"
fi
if [ -f $paketdepo$pktvt ];then
pkt=`cat "$paketdepo$pktvt" | grep "^${_ipaket} " | cut -d' ' -f3`
#ryaz 32 "${_ipaket} paketi $pktsunucu altında aranıyor"
if [ $pkt ];then
#ryaz 32 "${_ipaket} paketi $pktsunucu altında bulundu"
ekontdeg=`cat "$paketdepo$pktvt" | grep "^${_ipaket} " | cut -d' ' -f2`
cpaket="${pkt/'#'/'%23'}"
#paketin sunucuda varlık kontrolu
wget -q --spider "$pktsunucu$cpaket"
if [ $? -eq 0 ]; then
$_yaz "${_ipaket} $_indiriliyor"
if [ "$cikti" == "--normal" ];then
wget --progress=dot:force -nc --no-check-certificate -P "$paketdepo" "$pktsunucu$cpaket" 2>&1 | tee /tmp/${_ipaket}_indirme.log | sed -u -n 's/[0-9]*%/&/p'
else
wget --no-check-certificate -nc -q ${wget_progress} -P "$paketdepo" "$pktsunucu$cpaket" #2>&1 | tee /tmp/${_ipaket}_indirme.log
fi
if [[ "$?" != 0 ]]; then
$_yaz_uyari "indirme hatalı"
hataloglama "indirme hatalı"
else
mkontdeg=`sha1sum "$paketdepo$pkt" | cut -d' ' -f1`
if [ "$ekontdeg" != "$mkontdeg" ];then
$_yaz_uyari "$_shasum_uyumsuzluk,paket tekrar indiriliyor."
hataloglama "sha1sum uyusmaslik tespit edildi,paket tekrar indiriliyor."
rm -f "$paketdepo$pkt"
paket_indir "${_ipaket}" "$cikti"
#else
#$_yaz "$_zaten ${_ipaket} $_paket_onbellek_depoda_var"
fi
fi
else
$_yaz_uyari "${_ipaket} paketi bulunamadı $pktsunucu dan silinmiş olmalı!"
fi
else
$_yaz_uyari "$pktsunucu ${_ipaket} paketi bulunmuyor!"
fi
else
$_yaz_uyari "$paketdepo altında $pktvt dosyanız yok.Güncelleme yapınız!"
fi
done
else
$_yaz_uyari "$paketdepo altında paket.vt dosyanız yok.Güncelleme yapınız!"
fi
}
yerelden_kur(){
local silme _ypaket
[ $1 ] && _ypaket=$1 || hata_olustu "_yerel_paket_yok"
if [ $2 ];then
if [ "$2" == "-kok" ] && [ -d "$3" ]; then
kokdizin="$3"
tekrarkur="evet"
fi
fi
pkontrol=`basename ${_ypaket} | grep -w "mps.lz"`
if [ ! -z "$pkontrol" -a "$pkontrol" != "" ]; then
paketad=`echo "${_ypaket}" | cut -d'#' -f1`
paketad=`basename $paketad`
kkont=`kurulu_kontrol "$paketad"`
if [ "$kkont" = "degil" ];then
icerik_ekle "${_ypaket}"
elif [ "$kkont" = "kurulu" ];then
if [ "$tekrarkur" = "hayir" ];then
while true; do
$_yaz_uyari "${_ypaket} paketi zaten kurulu silinip kurulsun mu?"
read -p "e veya h -> " eh
case $eh in
[Ee]* ) silme="e"; break;;
[Hh]* ) break;;
* ) echo "e veya h";;
esac
done
fi
if [ "$silme" = "e" ];then
$_yaz_bilgi "silinecekelerin kontrolu için"
paket_sil "$paketad"
icerik_ekle "${_ypaket}"
fi
else
icerik_ekle "${_ypaket}"
#while true; do
#ryaz 31 "${_ypaket} paketi talimatname dışı.Yine de kurulsun mu? (kokdizin=$kokdizin) "
#read -p "e veya h -> " eh
#case $eh in
# [Ee]* ) icerik_ekle "${_ypaket}"; break;;
# [Hh]* ) break;;
# * ) echo "e veya h";;
#esac
#done
fi
else
$_yaz_uyari "yerelde mps paketi bulunamadı."
fi
}
agdan_kur(){
local kontroldeg _cikti _yaz _yaz_tm _yaz_uyari
_cikti="--normal"
[ $2 ] && _cikti="$2"
cikti_renk_ayarla $_cikti
kkont=$(kurulu_kontrol "$1")
if [ "$kkont" = "degil" ] || [ "$tekrarkur" = "evet" ];then
paket_indir "$1" "$2"
if [ $(find $paketdepo -name $1#* | head -1) ];then
if [ -f $(ls -1t "$paketdepo$1#"* | head -1) ];then
if [ "$kurulum_onay" = "evet" ];then
if [ "$tekrarkur" = "evet" ];then
paket_sil "$1" "evet"
fi
#depo/paketler altında birden fazla sürüm kontrolü yapılır,güncel olan seçilir.
surumler=$(ls "$paketdepo$1#"* | wc -l)
if [ $surumler = 1 ];then
icerik_ekle $(ls "$paketdepo$1#"*) $cikti
elif [ $surumler -gt 1 ];then
$_yaz_uyari "$1 paketinin birden fazla sürümü var!"
kurulacak_guncel_paket=$(ls -1t "$paketdepo$1#"* | head -1)
$_yaz "$kurulacak_guncel_paket sürümü kuruluyor"
icerik_ekle $kurulacak_guncel_paket $cikti
fi
fi
else
$_yaz_uyari "$1 indirme hatası"
fi
fi
elif [ "$kkont" = "kurulu" ];then
#ryaz 32 "$1 paketi zaten kurulu!"
printf "."
else
$_yaz_uyari "$1 tanımsız paket veya tekrar kurulum iptali var!"
fi
}
ayarlar() {
args="${@:2}"
while [ "$1" ]; do
case $1 in
### Milis_Paket_Sistemi_Yardim
### --------------------------
### mps -i paketismi = sadece paketi indirir,paket kurulmaz.
-i|--indir)
kurulum_onay="olumsuz"
paket_indir $args
exit 0 ;;
### mps -ik paketismi = ilgili paketi indirir ve kurar.
-ik|--inku)
if [ "$3" == "-kok" ] && [ -d "$4" ]; then
kokdizin="$4"
fi
agdan_kur "$2" ;;
### mps -ikz|yekur paketismi = ilgili indirip tekrardan kurar,kurulu olmasına bakılmaz.
-ikz|yekur)
tekrarkur="evet"
agdan_kur "$2"
exit 0 ;;
### mps -k paketismi..mps.lz = yerel dizindeki paketi kurar.
-k)
yerelden_kur $args
exit 0 ;;
### mps sil|-s paketismi = ilgili paketi onaylı kaldırır.
-s|sil)
paket_sil $args
exit 0 ;;
### mps zorsil|-sz paketismi = ilgili paketi onaysız kaldırır.
-sz|zorsil)
paket_sil "$2" "evet" "$3"
exit 0 ;;
### mps gsil paketismi = ilgili paketi güvenli(ters bağımlılıklarına da bakarak) kaldırır.
gsil)
paket_sil "$2" "hayir" "evet"
exit 0 ;;
### mps -S paketismi = ilgili paketi altbağımlılıklarını da sorarak kaldırır.
### mps -S paketismi = ve oto eklenirse ilgili paketi altbağımlılıklarını da sormadan sırayla kaldırır.
-S)
paket_sil_gereklerle $args
exit 0 ;;
### mps ara aranan = paket isimleri ve açıklamalarında anahtar kelime arar.
-pa|ara)
paket_ara "$2"
exit 0 ;;
### mps bul aranan = talimat dosyaları içinde anahtar kelimeyi arar.
bul)
kelime_bul "$2"
exit 0 ;;
### mps -d paketisimi = sadece paketi bağımlıksız derler.Genelde bağımlılığı olmayan paketler için kullanılır.
-d|--pkde)
zorla_derle="yok"
kurulum_onay="olumsuz"
paket_derle "$2"
exit 0 ;;
### mps -zd paketismi = Pake kurulu olsa bile derleme yapılır.Bağımlıksız derleme için kullanılır.
-zd|--pkzde)
zorla_derle="evet"
kurulum_onay="olumsuz"
paket_derle "$2"
exit 0 ;;
### mps odkp paketismi = bir paketi bağımlılık zinciri çıkarıp gereklileri önce kurar gerekli olanları derler,paketler ve kurar.
odkp)
if [ -d "$talimatname/temel/$2" ] ; then
$_yaz_uyari "temel paket için odkp kullanılamaz!"
exit 1
fi
oto_derle_kur_paketle "$2"
exit 0 ;;
### mps god paketismi = mps guncelle && mps odkp paketismi.
god)
git_guncelle
oto_derle_kur_paketle "$2"
exit 0 ;;
-dk|--pkdk)
paket_derle "$2" ;;
### mps -derlist liste = verilen liste dosyasındaki paketleri derler.Alt alta yazılı olmalıdır.
-derlist)
paket_derle_liste "$2"
exit 0;;
### mps derle paketismi = paketismi için bağımlılık zinciri çıkarıp gerekli tüm paketleri derler,paketler ve kurar.
derle)
paket_derle_kur "$2"
exit 0 ;;
-ok|--pkok)
paket_kur_oto "$2" ;;
-okz)
paket_kur_oto_zorla "$2" ;;
-okl|--pkokl)
paket_kur_liste "$2" ;;
-oklz)
paket_kur_liste_zorla "$2" ;;
### mps -kh . = mevcut dizindeki mps.lz uzantılı paketleri onaysız kurar.
-kh)
local templist
templist=`mktemp`
ls *.mps.lz > $templist
paket_kur_oto_zorla $templist
exit 0 ;;
-ko|--pkko)
paket_kur_oto2 "$2" ;;
-kuruld)
paket_inkur_liste_direk "$2" ;;
### mps kurul liste = verilen liste dosyasındaki paketleri kurar.Alt alta yazılı olmalıdır.
kurul)
if [ -f $PWD/mps-liste ]; then
paket_inkur_liste mps-liste
else
paket_inkur_liste "$2"
fi ;;
-kur)
paket_inkur_oto "$2" ;;
### mps gkur paketismi = git-paketvt günceller ve yerelde mps.lz varsa yereldekini yoksa sunucudan paketi indirip kurar.
gkur)
git_guncelle && paketvt_guncelle && paket_inkur_oto "$2"
exit 0 ;;
### mps kur paketismi = yerelde mps.lz varsa yereldekini yoksa sunucudan paketi indirip kurar.
kur)
if [[ "$2" == *"mps.lz"* ]]; then
if [ "$3" == "-kok" ] && [ -d "$4" ]; then
kokdizin="$4"
tekrarkur="evet"
fi
yerelden_kur "$2" "$3"
else
paket_inkur_oto "$2" "$3"
fi
exit 0 ;;
### mps kaynak paketismi = ilgili paketin kaynak kodunu indirir.
kaynak)
if [ ! "$2" ]; then
$_yaz_uyari "paket ismi eksik"
exit 1
fi
kaynak_kod_indir "$2"
exit 0 ;;
# özel git projesi kurmak için
gitkur)
git_proje_kur "$2" ;;
# otomatik proje sistemi
# özel git projesi kurmak için
opk)
op_kur "$2" ;;
# özel git projesi silmek için
ops)
op_sil "$2" ;;
### mps serkur paketismi = ilgili paketin servisini kurar
serkur)
servis_kur "$2"
exit 0 ;;
### mps sersil paketismi = ilgili paketin servisini siler
sersil)
servis_sil "$2"
exit 0 ;;
### mps serkon paketismi = servislerin değişmemezlik kontrolünü yapar.
serkon)
servisler_kontrol
exit 0 ;;
### mps kurkos paketismi = ilgili paketin kurulumdan sonraki çalışması gereken betiğini çalıştırır.
kurkos)
local pkt
pkt=$(talimat_bul $2)
if [ -f $pkt/$2.kur-kos ];then
bash $pkt/$2.kur-kos
exit 0
else
$_yaz_uyari "$2 kur-kos yok!"
hataloglama "$2 kur-kos yok!"
exit 1
fi;;
### mps koskur paketismi = ilgili paketin kurulumdan önceki çalışması gereken betiğini çalıştırır.
koskur)
local pkt
pkt=$(talimat_bul $2)
if [ -f $pkt/$2.kos-kur ];then
bash $pkt/$2.kos-kur
exit 0
else
$_yaz_uyari "$2 kos-kur yok!"
hataloglama "$2 kos-kur yok!"
exit 1
fi ;;
### mps silkos paketismi = ilgili paketin silindikten sonraki çalışması gereken betiğini çalıştırır.
silkos)
local pkt
pkt=$(talimat_bul $2)
if [ -f $pkt/$2.sil-kos ];then
bash $pkt/$2.sil-kos
exit 0
else
$_yaz_uyari "$2 sil-kos yok!"
hataloglama "$2 sil-kos yok!"
exit 1
fi ;;
### mps kossil paketismi = ilgili paketin silindikten önceki çalışması gereken betiğini çalıştırır.
kossil)
local pkt
pkt=$(talimat_bul $2)
if [ -f $pkt/$2.kos-sil ];then
bash $pkt/$2.kos-sil
exit 0
else
$_yaz_uyari "$2 kos-sil yok!"
hataloglama "$2 kos-sil yok!"
exit 1
fi ;;
### mps -kdl paketismi = ilgili paketin sistemdeki kurulmuş olması gereken dosyalarını gösterir.
-kdl)
if [ ! "$2" ]; then
$_yaz_uyari "paket ismi eksik"
hataloglama "(-kdl) paket ismi eksik"
exit 1
fi
kurulu_kontrol_test "$2" "$3"
kurulum_dosya_listele "$2" "$3"
exit 0 ;;
### mps -kkp paketismi = ilgili paketin çalışması için eksik olan dosyaları tespit eder.
-kkp)
if [ ! "$2" ]; then
$_yaz_uyari "paket ismi eksik"
hataloglama "(-kkp) paket ismi eksik"
exit 1
fi
kirik_kontrol_paket "$2"
exit 0 ;;
### mps kirma paketismi = ilgili paketin sistemde kırdığı paketler tespit edilir.
kirma)
if [ ! "$2" ]; then
$_yaz_uyari "paket ismi eksik"
hataloglama "(kirma) paket ismi eksik"
exit 1
fi
kirik_ters_bagimli_bilgi "$2"
exit 0 ;;
### mps -kks . = sistemde kurulu tüm paketlerin kırık kontrolünü yapar.Eksik dosyaları tespit eder.
-kks)
revdep-rebuild
#kirik_kontrol_sistem
exit 0 ;;
### mps -sdk paketismi = bir paketin güncel sürüm numarasını denetler.
-sdk)
if [ ! "$2" ]; then
$_yaz_uyari "paket ismi eksik"
exit 1
fi
surum_devir_kontrol "$2" "$3"
exit 0 ;;
### mps -dk paketismi = bir paketin güncel devir numarasını denetler.
-devk)
if [ ! "$2" ]; then
$_yaz_uyari "paket ismi eksik"
exit 1
fi
devir_kontrol_durum "$2"
exit 0 ;;
-pak|--paketle)
if [ ! "$2" ]; then
$_yaz_uyari "paketlenecek dizin ismi eksik"
hataloglama "paketlenecek dizin ismi eksik"
exit 1
fi
yeniden_paketle "$2"
exit 0 ;;
-psk|--paksiskur)
if [ ! "$2" ]; then
$_yaz_uyari "paket liste yok"
hataloglama "paket liste yok"
exit 1
fi
if [ ! "$3" ]; then
$_yaz_uyari "hedef dizin yok"
hataloglama "hedef dizin yok"
exit 1
fi
sistem_kur "$2" "$3"
exit 0 ;;
## mps -po . = mps paketlerinin olduğu dizinde paket.vt oluşturur.
-po)
pvt_olustur
exit 0 ;;
## mps -os dosya = ilgili dosyadaki altalta sıralı paketleri onaysız siler.
-os)
if [ ! "$2" ]; then
$_yaz_uyari "silme listesi yok"
hataloglama "silme listesi yok"
exit 1
fi
paket_sil_oto "$2"
exit 0 ;;
### mps liste . = sistemde kurulu olan paket listesini verir.
-kl|liste)
ls ${kokdizin}${VT}
exit 0 ;;
### mps dliste . = sistemde kurulu olan ama talimatnamede yer almayan paket listesini verir.
-dkl|dliste)
ls ${kokdizin}${VT} | sort > /tmp/mps_krl_pkt.txt
paket_liste | sort > /tmp/mps_tum_pkt.txt
comm -23 "/tmp/mps_krl_pkt.txt" "/tmp/mps_tum_pkt.txt"
rm -rf /tmp/mps_krl_pkt.txt
rm -rf /tmp/mps_tum_pkt.txt
exit 0 ;;
### mps paketler grup_ismi = paket deposundaki paket listesini verir.(grup_ismi verilmezse tüm paketler)
-ptl|paketler)
paket_liste "$2" "$3"
exit 0 ;;
### mps gruplar . = paket deposundaki paket grup listesini verir.
-pgl|gruplar)
paket_grup_liste "$2"
exit 0 ;;
### mps -dly paketismi = ilgili paketin genel ve tüm bağımlılık listesini verir,oluşturur.
-dly|dliste)
derleme_listyap $args
exit 0 ;;
### mps -ykp paketismi = ilgili paketin kurulmak istenirse,kurulacak yeni paketleri listeler.
-ykp)
#yeni_kurulacak_paketler "$2"
derleme_listyap "$2" "--kurulu_atla"
listeleri_temizle
exit 0 ;;
#sunucu bilgisi alma
-sun2|sunucu)
$_yaz $sunucu ;;
### mps sunucular . = paket sunucularını verir.
-sun|sunucular)
#ryaz 32 ${sunucular} ;;
echo ${sunucular} | tr " " "\n"
exit 0 ;;
sun)
if [ ! "$2" ]; then
$_yaz_uyari "sunucu bilgi eksik"
hataloglama "sunucu bilgi eksik"
exit 1
fi
sunucu_ayarla "$2" ;;
### mps -bb paketismi = ilgili paketin gereklerinin durumunu listeler.
-bb|bagbil)
bagimli_bilgi "$2" | column -t
exit 0;;
-bbdog|bdogrula)
bagimli_bilgi "$2" "dogrula";;
-bbd)
bagimli_bilgi_dosyala $args
exit 0 ;;
### mps -tb talimatismi = ilgili talimata gerek duyan(ters-gerekler) talimatları listeler.
-tb|tersbag)
ters_bagimli_bilgi "$2"
exit 0;;
-tbk)
ters_bagimli_kontrol "$2" ;;
### mps pka paketismi = ilgili paketin depo-gitdepo uyumluluğunu kontrol eder.
pka)
paket_analiz "$2"
exit 0;;
### mps pda paketdepo = paketlerin olduğu dizindeki paketlerin depo-gitdepo uyumluluğunu kontrol eder.
pda)
paketdepo_analiz "$2"
exit 0 ;;
### mps tbilgi paketismi = ilgili paketin talimat bilgilerini verir.
tbilgi)
talimat_bilgi $args
exit 0 ;;
### mps talimat paketismi = ilgili paketin talimatını yazdırır.
talimat)
talimat_yazdir "$2"
exit 0 ;;
### mps -b paketismi = ilgili paketin kurulum bilgilerini verir.
-b)
if [ $2 ];then
touch "/tmp/mps_paket_bilgi_$2"
paket_bilgi "$2" "$3" | tee "/tmp/mps_paket_bilgi_$2"
if [ $3 ];then
[ $3 == "--html" ] && paket_bilgi_html "/tmp/mps_paket_bilgi_$2"
fi
else
$_yaz_uyari "paket ismi eksik"
exit 1
fi
exit 0 ;;
bil)
if [ $2 ];then
if [ $3 ];then
[ $2 == "surum" ] && paket_bilgi "$3" "--normal" | sed -n 6p | cut -d':' -f2 | sed 's/^ *//;s/ *$//'
[ $2 == "devir" ] && paket_bilgi "$3" "--normal" | sed -n 7p | cut -d':' -f2 | sed 's/^ *//;s/ *$//'
else
$_yaz_uyari "paket ismi eksik"
exit 1
fi
else
$_yaz_uyari "islev ismi eksik"
exit 1
fi
exit 0 ;;
phtml)
paketler_depo_html
exit 0 ;;
### mps bilgi paketismi = ilgili paketin talimat ve kurulum bilgilerini verir.
bilgi)
paket_bilgi "$2"
talimat_bilgi "$2"
exit 0 ;;
### mps -to talimat_ismi = ilgili talimat ismine göre talimat şablonu oluşturur.
-to)
if [ ! "$2" ]; then
$_yaz_uyari "talimat ismi eksik"
hataloglama "talimat ismi eksik"
exit 1
fi
talimat_olustur "$2"
exit 0 ;;
### mps log yyyy-aa-gg olay = mps.log verisi çekmek için (ör: mps log 2017-01-01 silindi)
log)
local logyardim
logyardim="mps log zaman durum (ör: mps log 2017-01-01 silindi)"
if [ ! "$2" ]; then
$_yaz_uyari "zaman parametresi eksik"
hataloglama "zaman parametresi eksik"
$_yaz $logyardim
exit 1
fi
if [ ! "$3" ]; then
$_yaz_uyari "durum parametresi eksik"
hataloglama "durum parametresi eksik"
$_yaz $logyardim
exit 1
fi
log_analiz "$2" "$3" ;;
### mps guncelle . = paket veritabanı ve git güncellemesi-talimatname bilgilerini günceller.
guncelle)
[ "$2" ] && cikti_renk_ayarla "$2"
git_guncelle && paketvt_guncelle && kurulum_dogrulama
exit 0 ;;
### mps -GG . = git güncellemelerini ve talimatname bilgilerini günceller.
-Ggit|-GG)
[ "$2" ] && cikti_renk_ayarla "$2"
git_guncelle
exit 0 ;;
### mps -G . = paket veritabanı bilgilerini günceller.
-G|--pvtg)
[ "$2" ] && cikti_renk_ayarla "$2"
paketvt_guncelle
kurulum_dogrulama
exit 0 ;;
### mps tespit . = tüm sistemin güncellemesi için güncellenecek paket listesini gösterir.
tespit)
[ "$2" ] && cikti_renk_ayarla "$2"
guncelleme_tespit
exit 0 ;;
### mps gun . = güncellenmesi gereken ve depoya yeni eklenen paketleri gösterir.
gun)
guncellemeler
exit 0 ;;
### mps yukselt . = tüm sistemin güncellemesini gerçekleştirir.
-GS|yukselt)
sistem_guncelle $args
exit 0 ;;
### mps yukselt2 . = tüm sistemin güncellemesini gerçekleştirir.
-GS2|yukselt2)
sistem_guncelle_eski
exit 0 ;;
#tekil temel paket guncelleme-single base package updating
-tg)
paket_sil "$2" "evet" && mps -ik $2 ;;
### mps -g paketismi = ilgili paketi tekil günceller.
-g|--pkgu)
git_guncelle && paketvt_guncelle
if [ ! "$2" ]; then
$_yaz_uyari "paket ismi eksik"
hataloglama "paket ismi eksik"
exit 1
fi
local durum
durum=`kurulu_kontrol "$2"`
if [ "$durum" = "kurulu" ]; then
paket_guncelle "$2"
elif [ "$durum" = "degil" ]; then
$_yaz_uyari "$2 $_paket_kurulu_degil"
hataloglama "$2 $_paket_kurulu_degil"
else
$_yaz_uyari "$2 $_paket_tanimsiz"
hataloglama "$_paket_tanimsiz"
fi
exit 0 ;;
#bagimliliklariyla beraber paket guncelleme-package updating with depencies
-go|--pkgo)
if [ ! "$2" ]; then
$_yaz_uyari "$_paket_adi_gerekli"
exit 1
fi
paket_guncelle_oto "$2";;
### mps -kk paketismi = ilgili paketin kurulu olma durumunu gösterir.
-kk)
kurulu_kontrol $args
exit 0 ;;
-kudo)
kurulum_dogrulama
exit 0 ;;
-kdi|dogrula)
if [ ! "$2" ]; then
$_yaz_uyari "$_paket_adi_gerekli"
exit 1
fi
kurulum_dogrulama_icerik "$2" ;;
-pid|pdogrula)
kokdzn=""
if [ ! "$2" ]; then
$_yaz_uyari "$_paket_adi_gerekli"
exit 1
elif [ ! "$3" ]; then
kokdzn="/"
else
kokdzn="$3"
fi
paket_icerik_dogrulama "$2" "$kokdzn";;
-kdit|tumdogrula)
kurulum_dogrulama_icerik_tum
exit 0 ;;
### mps -set paketismi = ilgili paket silindiğinde etkilenen paketleri ve konumları tespit eder.
-set)
silme_etkilenme $args
exit 0 ;;
### mps -suko . = sunucuların erişim kontrolünü yapar.
-suko)
sunucu_kontrol
exit 0 ;;
### mps -pot . = talimatı olup ta paketi henüz depoda yer almayan talimatları listeler.
-pot)
paketsiz_talimatlar
exit 0 ;;
-dpl|deplist)
depo_paketler_liste
exit 0 ;;
### mps depsil . = depo/paketler altındaki paket önbelleğini temizler.
-dps|depsil)
depo_paketler_sil
exit 0 ;;
### mps etksil . = /var/lib/pkg/etkilenen altındaki kurtarılmış paket önbelleğini temizler.
-etks|etksil)
etkilenenler_sil
exit 0 ;;
### mps link url_adres = verilen url adresindeki talimatı ektalimatname/topluluk altına indirir.
link)
mkdir -p $ektalimatname/topluluk
indir_talimat_paketle $2 "-4" "$ektalimatname/topluluk"
exit 0 ;;
### mps ti url_adres = verilen url adresindeki talimatı talimatname/genel altına indirir.
ti)
indir_talimat_paketle $2 "-4" "$talimatname/genel"
exit 0 ;;
-cf|--config-file)
if [ ! "$2" ]; then
echo "ayardosyası gerek $1"
exit 1
fi
ayar_dosyasi="$2"
shift ;;
### mps -hp aranan = ilgili aranan ifadenin hangi paketlerde olabileceğini listeler.
-hp)
if [ ! "$2" ]; then
$_yaz_uyari "paket ismi eksik"
exit 1
fi
kurulan_dosya_bul "$2"
exit 0 ;;
### mps tgs talimat = ilgili talimatın kaynak kodunun yeni sürümü olup olmadığını kontrol eder.
tgs)
if [ ! "$2" ]; then
$_yaz_uyari "talimat ismi eksik"
exit 1
fi
talimat_surum_takip "$2"
exit 0 ;;
### mps -tro . = tarihçe noktası oluşturur.
-tro)
tarihce_yap
exit 0 ;;
### mps -trot . = temel tarihçe noktası oluşturur.
-trot)
temel_tarihce="evet"
tarihce_yap
exit 0 ;;
### mps -try tarihce_nokta = tarihçe noktasına göre paketleri yükler-siler.
-try)
if [ ! "$2" ]; then
$_yaz_uyari "tarihce dosyasi eksik $1"
hataloglama "tarihce dosyasi eksik $1"
exit 1
fi
tarihce_yukle "$2"
exit 1 ;;
### mps -trl . = tarihçe noktalarını listeler.
-trl)
tarihce_liste ;;
### mps tdc talimat_dosyası = ilgili talimat dosyasının Türkçe değişken çevrimini yapar.
tdc)
talimat_degisken_cevrim $2
exit 0 ;;
-tamir-tk)
tamir_temel_kurulan ;;
### mps dos . = derleme ortamını sıfırlar.temel tarihçeye geri döner.
dos)
tarihce_yukle "temel"
exit 0 ;;
-trs)
if [ ! "$2" ]; then
$_yaz_uyari "parametre eksik $1"
hataloglama "parametre eksik $1"
exit 1
fi
tarihce_sil "$2"
exit 1 ;;
### mps itest islev_ismi = mps içindeki işlevlerin testi için kullanılmaktadır.
itest)
if [ $2 ];then
_islev="$2"
if [ "`type -t $_islev`" == "function" ];then
shift;shift
$_islev $@
else
echo "$_islev işlevi bulunamadı"
fi
else
echo "test edilecek işlev parametresi eksik"
fi
exit 0 ;;
### mps -v . = mps sürüm bilgisini gösterir.
-v)
$_yaz_bilgi "$betikad $versiyon $iletisim $shelltip"
#echo "$betikad $versiyon $iletisim $shelltip" | bilgi_kutusu
exit 0 ;;
-y|-h|yardim)
yardim_icerik
exit 0 ;;
*)
$_yaz_uyari "Geçersiz Parametre! --> mps yardim "
exit 0 ;;
esac
done
}
yardim_icerik(){
cat $betikyol | sed -e 's/^[ \t]*//' | sed -n '/^###/p' | sed '/ /s/^###//g' | awk '{split($0,a,"="); printf "%-6s %-13s %-18s %-40s \n",$1,$2,$3,a[2]}'
}
bilgi_kutusu() {
: ${title='Bilgi'}
: ${icon=dialog-information}
yad --title="$title" --window-icon="$icon" \
--geometry='600x220+0-24' --fore='#ffffff' --back='#000033' \
--text-info --fontname=monospace --wrap $opts \
--button='gtk-close:1'
}
ana(){
if [ `id -u` = 0 ] ; then
ayarlar "$@"
else
sudo mps "$@"
fi
}
ana "$@"
#31 kirmizi
#32 yesil
#33 sari
#34 mavi
#34 mor