Category: OS

Installer une nouvelle application et la sauvegarder sur (clé USB ou carte SD)

Charger les applis via aptoid

Puis sur ES explorer

Afficher les fichiers cachés :
* Paramètres généraux
* Paramètres d’affichage
* Afficher les fichiers cachés

(les fichiers cachés commencent par un . )

A la racine du local dans .aptoide
*  apks
* fichier .apk

Maintenir la touche OK sur un fichier, pour voir le bandeau en bas d’écran, qui permet de manipuler un (plusieurs) fichier(s) copier / coller / supprimer / renommer.

Faire copier.

Changer de volume (aller sur la clé USB ou la carte SD)

(annuler) Coller puis renommer

Restauration de la corbeille Nexus

Suite à suppression d’un dossier ou ficher dans Nexus (ex :releases)

Sur vlbid16x :

La corbeille est dans :
/soft/Talend-6.1.1/tac/Artifact-Repository-Nexus-V2.11.3-01/sonatype-work/nexus/trash

récupérer le fichier ou dossier à restaurer (copy ou move) dans :
/soft/Talend-6.1.1/tac/Artifact-Repository-Nexus-V2.11.3-01/sonatype-work/nexus/storage

Redonner les bons droits au fichier ou dossier (chown -R talenduser talendgroup).

Sur Nexus :

Il faut ajouter le dossier restauré (si c’est un fichier il faut juste l’indexer)

 

Les dossiers doivent porter le même nom :
sur le serveur :  

et via l’IHM :

Il faut ensuite reconstruire les index :

Et les Metadada :

espace dans les noms de fichiers

Remplacer les espaces par des _ dans les noms de fichier d’un dossier.

Sous Windows

cd mon_dossier
for /f "delims=" %%a in ('dir /b') do call :cmd "%%a"
exit
:cmd
set fichierbck=%~1
set fichier=%fichierbck: =_%
ren "%fichierbck%" "%fichier%"

Sous Linux

rename 's/[[:blank:]]/_/g' *

Remplacement temporaire

#IFS = field separator, so only accept end of line and not space as filename may contain space
SAVEIFS=$IFS
IFS=$(echo -en "\n\b")

for v_fic in `find ${w_rep_purge}/ -type f -mtime ${w_jour_purge} -name "*.${w_extension}" | grep ${w_grep}`
 do
    echo " - Suppression du fichier [${v_fic}] ..."
#    rm -f ${v_fic}
    ls -la ${v_fic}
 done
#IFS = restore old filed separator to not changed stand shell comportement
IFS=$SAVEIFS

nombre de process insuffisant

Pb Vtom : Error setuid(500), Resource temporarily unavailable

Le user Vtom passé dans le job n’est pas pris en compte.

PDTB9
root 9316 0.0 0.0 6808 1308 pts/3 S 10:59 0:00 /opt/vtom/abm/bin/bdaemon
root 14882 0.0 0.0 108248 1500 pts/3 S 13:17 0:00 \_ -bash /opt/vtom/admin/tom_submit.bash
root 14898 0.0 0.0 108248 620 pts/3 S 13:17 0:00 \_ -bash /opt/vtom/admin/tom_submit.bash
root 14899 0.0 0.0 100952 468 pts/3 S 13:17 0:00 \_ sleep 60

PDTB4
root 19864 0.0 0.0 6808 1320 ? S Jun09 0:21 /opt/vtom/abm/bin/bdaemon
ora112 62072 0.0 0.0 108356 1668 ? S 13:18 0:00 \_ -bash /opt/vtom/admin/tom_submit.bash
ora112 62092 0.0 0.0 108356 780 ? S 13:18 0:00 \_ -bash /opt/vtom/admin/tom_submit.bash
ora112 62093 0.0 0.0 100952 468 ? S 13:18 0:00 \_ sleep 120

Le nombre de process max sur la machine est insuffisant (nproc).

Modification du fichier /etc/security/limits.d/90-nproc.conf pour augmenter le nombre de process sur la machine pour tous les users

passage de 1024 à 2048

cat /etc/security/limits.d/90-nproc.conf
# Default limit for number of user's processes to prevent
# accidental fork bombs.
# See rhbz #432903 for reasoning.

*          soft    nproc     2048

test dossier ou fichier exist

backup=/backups/${sid_oracle}/cold/

if [ ! -d ${backup} ]; then
mkdir ${backup}
else
rm -f ${backup}*
fi

FILE=/etc/resolv.conf
if test -f "$FILE"; then
    echo "$FILE exist"
fi

FILE=/etc/resolv.conf
if [ -f "$FILE" ]; then
    echo "$FILE exist"
fi

FILE=/etc/resolv.conf
if [[ -f "$FILE" ]]; then
    echo "$FILE exist"
fi

FILE=/etc/resolv.conf
if [ -f "$FILE" ]; then
    echo "$FILE exist"
else 
    echo "$FILE does not exist"
fi

Traitement fichier (ligne vide, taille zéro …)

Supprimer retour chariot dans le fichier file1.txt et ecriture dans file2.txt

findstr /vir « ^$ » file1.txt > file2.txt

 

Recherche de \In dans file2.txt et ecriture dans file3.txt

findstr « \In »  file2.txt  > file3.txt

 

Fichier non vide

for %%I in (file3.txt ) do ( set size=%%~zI )
If %size% LEQ 0 goto fin_prg1

Manipuler les chaînes de caractères

http://abs.traduc.org/abs-5.3-fr/ch09s02.html

 

Bash supporte un nombre surprenant d’opérations de manipulation de chaînes de caractères. Malheureusement, ces outils manquent d’unité. Certains sont un sous-ensemble de la substitution de paramètre et les autres font partie des fonctionnalités de la commande UNIX expr. Ceci produit une syntaxe de commande non unifiée et des fonctionnalités qui se recoupent, sans parler de la confusion engendrée.

Longueur de chaînes de caractères

${#chaine}
expr length $chaine
C’est l’équivalent de la fonction strlen() en C.
expr « $chaine » : ‘.*’
chaineZ=abcABC123ABCabc

echo ${#chaineZ}                 # 15
echo `expr length $chaineZ`      # 15
echo `expr "$chaineZ" : '.*'`    # 15

Exemple 9.10. Insérer une ligne blanche entre les paragraphes d’un fichier texte

#!/bin/bash
# paragraph-space.sh

# Insère une ligne blanche entre les paragraphes d'un fichier texte.
# Usage: $0 <NOMFICHIER

LONGUEUR_MINI=45        # Il peut être nécessaire de changer cette valeur.
#  Suppose que les lignes plus petites que $LONGUEUR_MINI caractères
#+ terminent un paragraphe.

while read ligne  # Pour toutes les lignes du fichier...
do
  echo "$ligne"   # Afficher la ligne.

  longueur=${#ligne}
  if [ "$longueur" -lt "$LONGUEUR_MINI" ]
    then echo    # Ajoute une ligne blanche après chaque petite ligne.
  fi  
done

exit 0

 

Longueur de sous-chaînes correspondant à un motif au début d’une chaîne

expr match « $chaine » ‘$souschaine’
$souschaine est une expression rationnelle.
expr « $chaine » : ‘$souschaine’
$souschaine est une expression rationnelle.

chaineZ=abcABC123ABCabc
#       |------|

echo `expr match "$chaineZ" 'abc[A-Z]*.2'`   # 8
echo `expr "$chaineZ" : 'abc[A-Z]*.2'`       # 8

Index

expr index $chaine $souschaine
Position numérique dans $chaine du premier caractère dans $souschaine qui correspond.

chaineZ=abcABC123ABCabc
echo `expr index "$chaineZ" C12`             # 6
                                             # C position.

echo `expr index "$chaineZ" 1c`              # 3
# 'c' (à la position #3) correspond avant '1'.

Ceci est l’équivalent le plus proche de strchr() en C.

Extraction d’une sous-chaîne

${chaine:position}
Extrait une sous-chaîne de $chaine à partir de la position $position.

Si le paramètre $chaine est « * » ou « @ », alors cela extrait les paramètres de position, [36] commençant à $position.

${chaine:position:longueur}
Extrait $longueur caractères d’une sous-chaîne de $chaine à la position $position.

chaineZ=abcABC123ABCabc
#       0123456789.....
#       indexage base 0.

echo ${chaineZ:0}                            # abcABC123ABCabc
echo ${chaineZ:1}                            # bcABC123ABCabc
echo ${chaineZ:7}                            # 23ABCabc

echo ${chaineZ:7:3}                          # 23A
                                             # Trois caractères de la sous-chaîne.

# Est-il possible d'indexer à partir de la fin de la chaîne ?

echo ${chaineZ:-4}                           # abcABC123ABCabc
# Par défaut la chaîne complète, comme dans ${parametre:-default}.
# Néanmoins...

echo ${chaineZ:(-4)}                         # Cabc
echo ${chaineZ: -4}                          # Cabc
# Maintenant, cela fonctionne.
#  Des parenthèses ou des espaces ajoutés permettent un échappement du paramètre
#+ de position.

# Merci, Dan Jacobson, pour cette indication.

Les arguments position et longueur peuvent devenir des « paramètres », c’est-à-dire représentés par une variable, plutôt que par une constante numérique.

Exemple 9.11. Générer « aléatoirement » une chaîne de huit caractères

#!/bin/bash
# rand-string.sh
# Générer aléatoirement une chaîne de huit caractères.

if [ "-n $1" ]  #  Si présence d'un argument en ligne de commande,
then            #+ alors l'utiliser comme chaîne de départ.
  chaine0="$1"
else            #  Sinon, utiliser le PID du script.
  chaine0="$$"
fi

POS=2  # On commence en position 2.
LONG=8  # Extraction de huit caractères.

chaine1=$( echo "$chaine0" | md5sum | md5sum )
# Double mixage :            ^^^^^^   ^^^^^^

chainealeatoire="${chaine1:$POS:$LONG}"
# Peut se paramétrer       ^^^^ ^^^^^

echo "$chainealeatoire"

exit $?

# bozo$ ./rand-string.sh mon-motdepasse
# 1bdd88c4

#  Non, ceci n'est pas recommandé
#+ comme méthode sûre de génération de mots de passe.

 

Si le paramètre $chaine est « * » ou « @ », alors ceci extrait un maximum de $longueur du paramètre de position, en commençant à $position.

echo ${*:2}          # Affiche le deuxième paramètre de position et les suivants.
echo ${@:2}          # Identique à ci-dessus.

echo ${*:2:3}        # Affiche trois paramètres de position, en commençant par le deuxième.
expr substr $chaine $position $longueur
Extrait $longueur caractères à partir de $chaine en commençant à $position.

chaineZ=abcABC123ABCabc
#       123456789......
#       indexage base 1.

echo `expr substr $chaineZ 1 2`              # ab
echo `expr substr $chaineZ 4 3`              # ABC

expr match « $chaine » ‘\($souschaine\)’
Extrait $souschaine à partir du début de $chaine, et où $souschaine est une expression rationnelle.
expr « $chaine » : ‘\($souschaine\)’
Extrait $souschaine à partir du début de $chaine, et où $souschaine est une expression rationnelle.

chaineZ=abcABC123ABCabc
#       =======

echo `expr match "$chaineZ" '\(.[b-c]*[A-Z]..[0-9]\)'`   # abcABC1
echo `expr "$chaineZ" : '\(.[b-c]*[A-Z]..[0-9]\)'`       # abcABC1
echo `expr "$chaineZ" : '\(.......\)'`                   # abcABC1
# Toutes les formes ci-dessus donnent un résultat identique.
expr match « $chaine » ‘.*\($souschaine\)’
Extrait $souschaine à la fin de $chaine, et où $souschaine est une expression rationnelle.
expr « $chaine » : ‘.*\($souschaine\)’
Extrait $souschaine à la fin de $chaine, et où $souschaine est une expression rationnelle.

chaineZ=abcABC123ABCabc
#                ======

echo `expr match "$chaineZ" '.*\([A-C][A-C][A-C][a-c]*\)'`    # ABCabc
echo `expr "$chaineZ" : '.*\(......\)'`                       # ABCabc

Suppression de sous-chaînes

${chaine#souschaine}
Supprime la correspondance la plus petite de $souschaine à partir du début de $chaine.
${chaine##souschaine}
Supprime la correspondance la plus grande de $souschaine à partir du début de $chaine.

chaineZ=abcABC123ABCabc
#       |----|
#       |----------|

echo ${chaineZ#a*C}      # 123ABCabc
# Supprime la plus petite correspondance entre 'a' et 'C'.

echo ${chaineZ##a*C}     # abc
# Supprime la plus grande correspondance entre 'a' et 'C'.
${chaine%souschaine}
Supprime la plus petite correspondance de $souschaine à partir de la fin de $chaine.

Par exemple :

# Renomme tous les fichiers de $PWD
#+ en remplaçant le suffixe "TXT" par "txt".
# Par exemple, "fichier1.TXT" devient "fichier1.txt" . . .

SUFF=TXT
suff=txt

for i in $(ls *.$SUFF)
do
  mv -f $i ${i%.$SUFF}.$suff
  #  Ne modifie rien *en dehors* de la correspondance la plus courte
  #+ commençant du côté droit de $i . . .
done ### Ceci pourrait être condenser en une ligne si nécessaire.

# Thank you, Rory Winston.
${chaine%%souschaine}
Supprime la plus grande correspondance de $souschaine à partir de la fin de $chaine.

chaineZ=abcABC123ABCabc
#                    ||
#        |------------|

echo ${chaineZ%b*c}      # abcABC123ABCa
#  Supprime la plus petite correspondance entre 'b' et 'c', à partir de la fin
#+ de $chaineZ.

echo ${chaineZ%%b*c}     # a
#  Supprime la plus petite correspondance entre 'b' et 'c', à partir de la fin
#+ de $chaineZ.

Cet opérateur est utilisé pour générer des noms de fichier.

Exemple 9.12. Convertir des formats de fichiers graphiques avec une modification du nom du fichier

#!/bin/bash
#  cvt.sh:
#  Convertit les fichiers image MacPaint contenus dans un répertoire dans le
#+ format "pbm".

#  Utilise le binaire "macptopbm" provenant du paquetage "netpbm",
#+ qui est maintenu par Brian Henderson (bryanh@giraffe-data.com).
#  Netpbm est un standard sur la plupart des distributions Linux.

OPERATION=macptopbm
SUFFIXE=pbm         # Suffixe pour les nouveaux noms de fichiers.

if [ -n "$1" ]
then
  repertoire=$1      # Si le nom du répertoire donné en argument au script...
else
  repertoire=$PWD    # Sinon, utilise le répertoire courant.
fi  

#  Suppose que tous les fichiers du répertoire cible sont des fichiers image
# + MacPaint avec un suffixe de nom de fichier ".mac".

for fichier in $repertoire/*  # Filename globbing.
do
  nomfichier=${fichier%.*c} #  Supprime le suffixe ".mac" du nom du fichier
                            #+ ('.*c' correspond à tout ce qui se trouve
                            #+ entre '.' et 'c', inclus).
  $OPERATION $fichier > $nomfichier.$SUFFIXE
    # Redirige la conversion vers le nouveau nom du fichier.
    rm -f $fichier          # Supprime le fichier original après sa convertion.
  echo "$nomfichier.$SUFFIXE"  # Trace ce qui se passe sur stdout.
done

exit 0

# Exercice
# --------
#  À ce stade, ce script convertit *tous* les fichiers du répertoire courant.
#  Modifiez le pour qu'il renomme *seulement* les fichiers dont l'extension est
#+ ".mac".

Exemple 9.13. Convertir des fichiers audio en ogg

#!/bin/bash
# ra2ogg.sh : Convertit des fichiers audio de streaming (*.ra) en ogg.

# Utilise le programme "mplayer" :
#      http://www.mplayerhq.hu/homepage
#      Vous aurez peut-être besoin d'installer les codecs appropriés
#+     pour que ce script fonctionne.
# Utilise la bibliothèque "ogg" et "oggenc" :
#      http://www.xiph.org/

PREFIXE_FICHIER_RESULTAT=${1%%ra}      # Supprime le suffixe "ra".
SUFFIXE_FICHIER_RESULTAT=wav           # Suffixe pour le fichier wav.
FICHIER_RESULTAT="$PREFIXE_FICHIER_RESULTAT""$SUFFIXE_FICHIER_RESULTAT"
E_SANSARGS=65

if [ -z "$1" ]          # Un nom de fichier à convertir doit être spécifié.
then
  echo "Usage: `basename $0` [nom_fichier]"
  exit $E_SANSARGS
fi

##########################################################################
mplayer "$1" -ao pcm:file=$FICHIER_RESULTAT
oggenc "$FICHIER_RESULTAT"  # Corrige l'extension du fichier ajoutée automatiquement pas oggenc.
##########################################################################

rm "$FICHIER_RESULTAT"      # Supprime le fichier temporaire *.wav.
                   # Si vous voulez le conserver, commentez la ligne ci-dessus.

exit $?

#  Note :
#  -----
#  Sur un site web, cliquer seulement sur un fichier audio *.ram
#+ récupère l'URL du fichier audio, le fichier *.ra.
#  Vous pouvez ensuite utiliser "wget" ou un autre outil similaire
#+ pour télécharger vous-même le fichier *.ra.

#  Exercices :
#  ----------
#  Actuellement, ce script convertit seulement les noms de fichier *.ra.
#  Ajoutez de la flexibilité en autorisant l'utilisation de *.ram et d'autres noms de fichier.
#
#  Si vous êtes réellement ambitieux, étendez le script pour réaliser automatiquement
#+ les téléchargements et les convertions des fichiers audio.
#  À partir d'une URL, récupérez les fichiers audio (en utilisant "wget")
#+ et convertissez-les.

Une simple émulation de getopt en utilisant des constructions d’extraction de sous-chaînes.

Exemple 9.14. Émuler getopt

#!/bin/bash
# getopt-simple.sh
# Auteur : Chris Morgan
# Utilisé dans le guide ABS avec sa permission.

getopt_simple()
{
    echo "getopt_simple()"
    echo "Les paramètres sont '$*'"
    until [ -z "$1" ]
    do
      echo "Traitement du paramètre : '$1'"
      if [ ${1:0:1} = '/' ]
      then
          tmp=${1:1}               # Supprime le '/' devant...
          parametre=${tmp%%=*}     # Extrait le nom.
          valeur=${tmp##*=}        # Extrait la valeur.
          echo "Paramètre : '$parametre', valeur: '$valeur'"
          eval $parametre=$valeur
      fi
      shift
    done
}

# Passe toutes les options à getopt_simple().
getopt_simple $*

echo "test vaut '$test'"
echo "test2 vaut '$test2'"

exit 0

---

sh getopt_example.sh /test=valeur1 /test2=valeur2

Les paramètres sont '/test=valeur1 /test2=valeur2'
Traitement du paramètre : '/test=valeur1'
Paramètre : 'test', valeur: 'valeur1'
Traitement du paramètre : '/test2=valeur2'
Paramètre : 'test2', valeur : 'valeur2'
test vaut 'valeur1'
test2 vaut 'valeur2'

Remplacement de sous-chaîne

${chaine/souschaine/remplacement}
Remplace la première correspondance de $souschaine par $remplacement.
${chaine//souschaine/remplacement}
Remplace toutes les correspondances de $souschaine avec $remplacement.

chaineZ=abcABC123ABCabc

echo ${chaineZ/abc/xyz}           # xyzABC123ABCabc
                                  #  Remplace la première correspondance de
                                  #+ 'abc' avec 'xyz'.

echo ${chaineZ//abc/xyz}          # xyzABC123ABCxyz
                                  #  Remplace toutes les correspondances de
                                  #+ 'abc' avec 'xyz'.
${chaine/#souschaine/remplacement}
Si $souschaine correspond au début de $chaine, substitue $remplacement à $souschaine.
${chaine/%souchaine/remplacement}
Si $souschaine correspond à la fin de $chaine, substitue $remplacement à $souschaine.

chaineZ=abcABC123ABCabc

echo ${chaineZ/#abc/XYZ}          # XYZABC123ABCabc
                                  #  Remplace la correspondance de fin de
                                  #+ 'abc' avec 'XYZ'.

echo ${chaineZ/%abc/XYZ}          # abcABC123ABCXYZ
                                  #  Remplace la correspondance de fin de
                                  #+ 'abc' avec 'XYZ'.

9.2.1. Manipuler des chaînes de caractères avec awk

Un script Bash peut utiliser des fonctionnalités de manipulation de chaînes de caractères de awk comme alternative à ses propres fonctions intégrées.

Exemple 9.15. Autres moyens d’extraire des sous-chaînes

#!/bin/bash
# substring-extraction.sh

Chaine=23skidoo1
#      012345678    Bash
#      123456789    awk
# Notez les différents systèmes d'indexation de chaînes :
# Bash compte le premier caractère d'une chaîne avec '0'.
# Awk  compte le premier caractère d'une chaîne avec '1'.

echo ${Chaine:2:4} # position 3 (0-1-2), longueur de quatre caractères
                                         # skid

# L'équivalent awk de ${string:position:longueur} est substr(string,position,longueur).
echo | awk '
{ print substr("'"${Chaine}"'",3,4)      # skid
}
'
#  Envoyé un "echo" vide à awk donne une entrée inutile, et donc permet d'éviter
#+ d'apporter un nom de fichier.

exit 0

find fichier dans arborescence

Recherche les fichiers context.xml à partir du point d’arborescence où je suis.

find . -name *web.xml -exec ls -ltrh {} \;

find -iname *web.xml -printf « %u %g %a %s %h/%f\n »

Chercher la chaîne pdtb2 dans les fichiers context.xml

grep pdtb2 $(find . -name « context.xml »)

Recherche des fichers *.dmp depuis hier avec leur date

find . -mtime -1 -name *.dmp -ls | awk ‘{print $8″ « $9 » « $10 » « $11}’

 

supprimer le message stdin: is not a tty

message : mesg: ttyname failed: Inappropriate ioctl for device
ou
stdin: is not a tty

cat /root/.profile

# ~/.profile: executed by Bourne-compatible login shells.
if [ "$BASH" ]; then
   if [ -f ~/.bashrc ]; then
      . ~/.bashrc
   fi
fi
mesg n
 dernière ligne remplacer

mesg n

par

tty -s && mesg n

Pas de reboot nécessaire pour la prise en compte.

vlbid24p, wctsrv0011 et 12 Ubuntu 18

Format date (horodatage)

echo date_av : %date%

rem Permet de changer le format de date pour le current user
reg add « HKCU\Control Panel\International » /v sShortDate /d « dd-MM-yyyy » /f
echo date_ap : %date%
for /F « tokens=1-4 delims=- » %%a in (‘echo %date:~0,10%’) do set w_date=%%c%%b%%a
echo w_date : %w_date%

set horo=%w_date%_%w_time%
rem Horodatage d’un fichier log
set f_log=%d_log%\%horo%_%TOM_JOB%.log

On peut aussi changer temporairement le format de date.

rem save the existing format definition
for /f "skip=2 tokens=3" %%a in ('reg query "HKCU\Control Panel\International" /v sShortDate') do set FORMAT=%%a
rem set ISO specific format definition
reg add "HKCU\Control Panel\International" /v sShortDate /t REG_SZ /f /d yyyy-MM-dd 1>nul:
rem query the date in the ISO specific format 
set ISODATE=%DATE%
rem restore previous format definition
reg add "HKCU\Control Panel\International" /v sShortDate /t REG_SZ /f /d %FORMAT% 1>nul:

 

 

Chaine de boot Linux

Sur Redhat 7.1 (Fonctionne sur Vldtb01p)

Les  scripts lancés au démarrage sont dans le fichier /etc/rc.local Ce fichier doit être exécutable

ll /etc/rc.local
chmod +x /etc/rc.local
lrwxrwxrwx. 1 root root 13 Sep 22 16:11 /etc/rc.local -> rc.d/rc.local

Exemple :

[root@vldtb02x ~]# cat /etc/rc.local
 #!/bin/bash
 # THIS FILE IS ADDED FOR COMPATIBILITY PURPOSES
 #
 # It is highly advisable to create own systemd services or udev rules
 # to run scripts during boot instead of using this file.
 #
 # In contrast to previous versions due to parallel execution during boot
 # this script will NOT be run after all other services.
 #
 # Please note that you must run 'chmod +x /etc/rc.d/rc.local' to ensure
 # that this script will be executed during boot.
# touch /var/lock/subsys/local
echo Start Vtom Agent
 . /etc/init.d/boot_start_vtom.sh
echo Start Oracle
 . /etc/init.d/start_oracle.sh
echo Zabbix Agent
. /etc/init.d/zabbix_agent_start.sh
 echo su -l ora112 -c /exploit/scripts/start_oracle.sh> /etc/init.d/start_oracle.sh

chmod +x /etc/init.d/start_oracle.sh