#!/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=""
# 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+=" | |
"
while IFS='' read -r satir || [[ -n "$line" ]]; do
icerik+=""
_sutun_baslik="$(echo $satir | cut -d':' -f1)"
_sutun_deger="$(echo $satir | cut -d':' -f2-)"
#icerik+="| $_sutun_deger | "
if [ "${_sutun_baslik}" != "${_sutun_deger}" ];then
icerik+="$_sutun_baslik | "
icerik+="$_sutun_deger | "
fi
icerik+="
"
done < "$_dosya"
if [[ "${_sutun_baslik}" == *"${_paket_kurulu_degil}"* ]] || [[ "${_sutun_baslik}" == *"${_paket_tanimsiz}"* ]];then
icerik+="| DURUM | ${_sutun_baslik} |
"
else
icerik+="| DURUM | kurulu |
"
fi
icerik+="
"
echo "$icerik" > $_dosya.html
}
# paketlerin toplu tablo gösterimi
paketler_depo_html(){
icerik=""
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+=" | | $_paket |
"
done
icerik+="
"
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 satir0) {
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 <& $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