1 #!/bin/bash

2 

3 #

10 function rsync ()

11 {

12 local RSYNC

13 [ "$(arch)" == "i686" -a -x $OPENGNSYS/bin/rsync ] && RSYNC=$OPENGNSYS/bin/rsync

14 RSYNC=${RSYNC:-$(which rsync)}

15 

16 $RSYNC "$@"

17 }

18 

19 

20 #

30 function ogCreateFileImage () {

31 local SIZEREQUIRED IMGDIR IMGFILE DIRMOUNT LOOPDEVICE IMGSIZE IMGEXT KERNELVERSION

32 

33 if [ "$*" == "help" ]; then

34  ogHelp "$FUNCNAME" \

35  "$FUNCNAME [ REPO|CACHE ] image_name extension size(K)" \

36  "$FUNCNAME REPO Ubuntu12 img 300000" \

37  "$FUNCNAME CACHE Windows7 diff 20000000"

38  return

39 fi

40 

41 

42 if [ $# -lt 4 ]; then

43  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name extension size(k)"

44  return $?

45 fi

46 

47 SIZEREQUIRED=$4

48 [ $SIZEREQUIRED -lt 300000 ] && SIZEREQUIRED=300000

49 KERNELVERSION=$(uname -r| awk '{printf("%d",$1);sub(/[0-9]*\./,"",$1);printf(".%02d",$1)}')

50 

51 if [ "$1" == "CACHE" -o "$1" == "cache" ]; then

52  IMGDIR="$(ogGetParentPath "$1" "/$2")"

53  [ "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"

54  IMGFILE="${IMGDIR}/$(basename "/$2").$IMGEXT"

55  ## Si no existe, crear subdirectorio de la imagen.

56  if [ $? != 0 ]; then

57  ogEcho log session " $MSG_HELP_ogMakeDir \"$1 $(dirname "$2")."

58  ogMakeDir "$1" "$(dirname "/$2")" || return $(ogRaiseError $OG_ERR_NOTWRITE "$3 /$4"; echo $?)

59  IMGDIR="$(ogGetParentPath "$1" "/$2")" || return $(ogRaiseError $OG_ERR_NOTWRITE "$3 /$4"; echo $?)

60  fi

61  DIRMOUNT="/tmp/$(ogGetMountImageDir "$2" "$3")"

62  mkdir -p "$DIRMOUNT"

63  LOOPDEVICE=$(losetup -f)

64  # Si existe el fichero de la imagen se hace copia de seguridad, si no existe se crea.

65  if [ -f "$IMGFILE" ]; then

66  # Si la imagen esta montada la desmonto

67  if [ -r "$DIRMOUNT/ogimg.info" ]; then

68  umount "$DIRMOUNT"

69  [ $? -ne 0 ] && return $(ogRaiseError $OG_ERR_DONTUNMOUNT_IMAGE "$1 $2.$IMGEXT"; echo $?)

70  fi

71 

72  if [ "$BACKUP" == "true" -o "$BACKUP" == "TRUE" ]; then

73  # Copia seguridad

74  ogEcho log session " $MSG_SCRIPTS_FILE_RENAME \"$IMGFILE\" -> \"$IMGFILE.ant\"."

75  cp -f "$IMGFILE" "$IMGFILE.ant"

76  mv -f "$IMGFILE.torrent" "$IMGFILE.torrent.ant" 2>/dev/null

77  rm -f "$IMGFILE.sum"

78  fi

79 

80  IMGSIZE=$(ls -l --block-size=1024 "$IMGFILE" | awk '{print $5}')

81  if [ $IMGSIZE -lt $SIZEREQUIRED ];then

82  ogEcho log session " $MSG_SYNC_RESIZE"

83  echo " truncate --size=>$SIZEREQUIRED k $IMGFILE"

84  truncate --size=">$SIZEREQUIRED"k "$IMGFILE" &> $OGLOGCOMMAND

85  # FS de la imagen segun el contenido del archivo .img

86  if file "$IMGFILE" |grep -i -e " ext4 filesystem " 2>&1 > /dev/null ; then

87  losetup $LOOPDEVICE "$IMGFILE"

88  echo " resize2fs -f $LOOPDEVICE"

89  resize2fs -f $LOOPDEVICE &> $OGLOGCOMMAND

90 

91  else

92  echo " ogMountImage $1 "$2" $3"

93  ogMountImage $1 "$2" $3

94  echo " btrfs filesystem resize max $DIRMOUNT"

95  btrfs filesystem resize max "$DIRMOUNT" &> $OGLOGCOMMAND

96  fi

97  fi

98  else

99  touch "$IMGFILE"

100  echo " truncate --size=>$SIZEREQUIRED k $IMGFILE"

101  truncate --size=">$SIZEREQUIRED"k "$IMGFILE" &> $OGLOGCOMMAND

102  #Formateamos imagen

103  losetup $LOOPDEVICE $IMGFILE

104  # FS de la imagen segun la configuracion y la version del kernel: < 3.7 ext4, si >= btrfs

105  [ $KERNELVERSION \< 3.07 ] && IMGFS="EXT4" || IMGFS=${IMGFS:-"BTRFS"}

106 

107  if [ "$IMGFS" == "EXT4" ]; then

108  echo " mkfs.ext4 -i 4096 -b 4096 -L "${2##*\/}" $LOOPDEVICE"

109  mkfs.ext4 -i 4096 -b 4096 -L "${2##*\/}" $LOOPDEVICE 2>&1 |tee -a $OGLOGCOMMAND

110  else

111  echo " mkfs.btrfs -L ${2##*\/} $LOOPDEVICE "

112  mkfs.btrfs -L "${2##*\/}" $LOOPDEVICE 2>&1 | tee -a $OGLOGCOMMAND

113  fi

114  fi

115  # Monto la imagen

116  ogMountImage $1 "$2" $3 &>/dev/null

117  [ $? -eq 0 ] || return $( ogRaiseError $OG_ERR_IMAGE "$3 $4"; echo $?)

118  echo "mounted"> $IMGFILE.lock

119 

120  # Si existe dispositivo de loop lo borro.

121  [ $LOOPDEVICE ] && losetup -d $LOOPDEVICE 2>&1 &>/dev/null

122 

123 else

124  [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)

125  echo " hose $REPOIP 2009 --out sh -c \"echo -ne CREATE_IMAGE $2 $3 $SIZEREQUIRED \""

126  hose $REPOIP 2009 --out sh -c "echo -ne CREATE_IMAGE \"$2\" $3 $SIZEREQUIRED"

127 fi

128 

129 }

130 

131 

132 #

142 function ogCreateInfoImage () {

143 local IMGTYPE IMGDIRAUX DIRMOUNT DESTRSYNC PASSWORD USERRSYNC ORIG FSTYPE PART DIREMPTY IMGLIST IMGINFO IMGACL KERNELVERSION

144 # Ayuda o menos de 5 parametros y la imagen no es basica

145 if [ "$*" == "help" -o $# -lt 5 -a "$3" != "img" ]; then

146  ogHelp "$FUNCNAME" \

147  "$FUNCNAME num_disk num_part [ REPO|CACHE ] [ base_image_name ] extension " \

148  "base image -> $FUNCNAME 1 2 img" \

149  "diff image -> $FUNCNAME 1 1 CACHE Windows7 diff "

150  return

151 fi

152 

153 if [ $# -lt 3 ]; then

154  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME num_disk num_part [ REPO|CACHE ] [ base_image_name] extension "

155  return $?

156 fi

157 

158 # Comprobar errores.

159 PART=$(ogDiskToDev "$1" "$2") || return $?

160 ORIG=$(ogMount $1 $2) || return $?

161 

162 if [ $3 == "img" ]; then

163  IMGTYPE="img"

164 else

165  # Comprobamos que las extension sea valida

166  ogCheckStringInGroup $5 "img diff" || return $( ogRaiseError $OG_ERR_FORMAT "$MSG_SYNC_EXTENSION"; echo $?)

167  IMGTYPE=$5

168  if [ "$IMGTYPE" == "diff" ]; then

169  # Imagen completa con la que comparo la particion.

170  IMGDIRAUX="$(ogGetMountImageDir "$4" "img")"

171  if [ "$3" == "CACHE" -o "$3" == "cache" ]; then

172  DIRMOUNT="/tmp/$IMGDIRAUX"

173  DESTRSYNC="$DIRMOUNT"

174  else

175  [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)

176  DIRMOUNT="$OGIMG/$IMGDIRAUX"

177  USERRSYNC="opengnsys"

178  PASSWORD="--password-file=/scripts/passrsync"

179  DESTRSYNC="$USERRSYNC@$REPOIP::ogimages/$IMGDIRAUX"

180  fi

181  fi

182 fi

183 

184 

185 FSTYPE=$(ogGetFsType $1 $2)

186 

187 # Creamos la lista del contenido y lo situamos en la particion a copiar.

188 DIREMPTY="/tmp/empty$$"

189 IMGLIST="/tmp/ogimg.list"

190 IMGINFO="/tmp/ogimg.info"

191 IMGACL="/tmp/ogimg.acl"

192 

193 # Borramos archivos antiguos.

194 rm -f /tmp/ogimg.* 2>/dev/null

195 rm -f $ORIG/ogimg.* 2>/dev/null

196 

197 # En las diferenciales no sabemos el tamaño -> ponemos una constante.

198 SIZEDATA=${SIZEDATA:-"SIZEDATA"}

199 

200 # Incluimos información de la imagen. Segun el kernel sera ext4 o btrfs.

201 KERNELVERSION=$(uname -r| awk '{printf("%d",$1);sub(/[0-9]*\./,"",$1);printf(".%02d",$1)}')

202 [ $KERNELVERSION \< 3.07 ] && IMGFS="EXT4" || IMGFS=${IMGFS:-"BTRFS"}

203 echo "#$IMGFS:NO:$FSTYPE:$SIZEDATA" > $IMGINFO

204 

205 if [ "$IMGTYPE" == "img" ]; then

206  # Imagen Basica

207  echo " rsync -aHAXWvn --delete $ORIG/ $DIREMPTY >> $IMGINFO"

208  rsync -aHAXWvn --delete $ORIG/ $DIREMPTY>> $IMGINFO

209  sed -i -e s/"^sent.*.bytes\/sec"//g -e s/^total.*.speedup.*.$//g -e s/"sending.*.list"//g $IMGINFO

210  sed -i '/^\.\//d' $IMGINFO

211 

212 else

213  # Imagen Diferencial

214  echo " rsync -aHAXWvn --delete $ORIG/ $DESTRSYNC a $IMGLIST"

215  rsync -aHAXWvn $PASSWORD --delete "$ORIG/" "$DESTRSYNC" >> $IMGLIST

216  sed -i -e s/"^sent.*.bytes\/sec"//g -e s/^total.*.speedup.*.$//g -e s/"sending.*.list"//g $IMGLIST

217  sed -i '/^\.\//d' $IMGLIST

218 

219  # Creamos informacion de la imagen

220  grep -e '\->' -e '\=>' $IMGLIST > /tmp/ogimg.ln

221  grep -e ^deleting $IMGLIST | sed s/^deleting\ //g | grep -v ^ogimg > /tmp/ogimg.rm

222  #grep -v -e '\->' -e '\=>' -e ^deleting $IMGLIST >> $IMGINFO

223  grep -v -e '\->' -e '\=>' -e ^deleting -e ^created $IMGLIST >> $IMGINFO

224 

225  rm -f $IMGLIST

226 

227  # Comprobamos que los ficheros de diferencias no esten vacios o salimos con error.

228  if [ $(grep -v -e "^$" -e "^#" $IMGINFO /tmp/ogimg.ln /tmp/ogimg.rm |wc -l) -eq 0 ]; then

229  ogRaiseError $OG_ERR_NOTDIFFERENT "$1 $2 $3 $4 $5"

230  return $?

231  fi

232 

233 fi

234 

235 # Guardamos el contenido de las acl (Solo win) Necesario particion desmontada (esta asi)

236 ogUnmount $1 $2

237 if [ $FSTYPE == "NTFS" ]; then

238  echo " ntfs-3g.secaudit -b $PART /"

239  ntfs-3g.secaudit -b $PART / > $IMGACL

240 fi

241 

242 }

243 

244 

245 #

251 function ogAclFilter () {

252 local IMGACL IMGINFO FILES ACLTMP

253 

254 # Ayuda

255 if [ "$*" == "help" ]; then

256  ogHelp "$FUNCNAME" "$FUNCNAME"

257  return

258 fi

259 

260 IMGACL="/tmp/ogimg.acl"

261 IMGINFO="/tmp/ogimg.info"

262 FILES="/tmp/files$$"

263 ACLTMP="/tmp/acl$$.tmp"

264 ACLFILES="/tmp/aclfiles$$"

265 

266 # comprobamos que existan los archivos de origen. Si no salimos sin error.

267 [ -f $IMGACL -a -f $IMGINFO ] || return 0

268 

269 echo "" > $ACLTMP

270 grep -n -e "File" -e "Directory" $IMGACL > $ACLFILES

271 

272 # Al listado de ficheros le quitamos las líneas sobrantes: comentarios y lineas vacias.

273 sed -e s/"^#.*$"//g -e '/^$/d' $IMGINFO > $FILES

274 

275 

276 # Recorremos el listado y extraemos la acl correspondiente al fichero o directorio.

277 while read LINE; do

278  read END INI <<< "$(grep -A 1 "$LINE" $ACLFILES | awk -F : '!(NR%2){print $1" "p}{p=$1}' )"

279  let NUM=$END-$INI-1

280  # Si algún archivo no se encuentra, el error lo mandamos a /dev/null

281  sed -n -e $INI,+"$NUM"p $IMGACL 2>/dev/null >> $ACLTMP

282  echo "aclfilter: $LINE" >> $OGLOGCOMMAND

283 done < $FILES

284 

285 cp $ACLTMP $IMGACL

286 rm -f $FILES $ACLTMP $ACLFILES

287 }

288 

289 

290 #

296 function ogRestoreInfoImage () {

297 local DEST PART IMGACL IMGLN OPTLN LINEA DESTLN ORIGLN TYPELN

298 

299 # Ayuda o menos de 5 parametros y la imagen no es basica

300 if [ "$*" == "help" ]; then

301  ogHelp "$FUNCNAME" \

302  "$FUNCNAME num_disk num_part" \

303  "base image -> $FUNCNAME 1 2 " \

304  "diff image -> $FUNCNAME 1 1 "

305  return

306 fi

307 

308 if [ $# -lt 2 ]; then

309  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME num_disk num_part "

310  return $?

311 fi

312 

313 # Control de errores.

314 PART=$(ogDiskToDev "$1" "$2") || return $?

315 DEST=$(ogMount $1 $2) || return $?

316 

317 IMGACL="ogimg.acl"

318 IMGLN="ogimg.ln"

319 IMGINFO="ogimg.info"

320 

321 # Copiamos informacion de la imagen a /tmp (para basicas)

322 [ -r $DEST/$IMGINFO ] && cp $DEST/ogimg.* /tmp

323 

324 #Creamos o modificamos los enlaces.

325 # La imagen diferencial tiene ogimg.ln

326 # para la completa lo generamos con los enlaces que contengan /mnt/

327 [ -r "/tmp/$IMGLN" ] || grep -e "->" -e "=>" "/tmp/$IMGINFO"|grep "/mnt/" > "/tmp/$IMGLN"

328 if [ $(wc -l "/tmp/$IMGLN"|cut -f1 -d" ") -ne 0 ]; then

329  while read LINEA

330  do

331  ORIGLN="${LINEA#*> }"

332  # Si origen hace referencia a la particion lo modificamos

333  echo $ORIGLN|grep "/mnt/"> /dev/null && ORIGLN="$DEST/${ORIGLN#/mnt/*/}"

334  # rsync marca - los enlaces simbolicos y = enlaces "duros"

335  LINEA="${LINEA%>*}"

336  TYPELN="${LINEA##* }"

337  DESTLN="${LINEA% *}"

338 

339  if [ "$TYPELN" == "-" ]

340  then

341  OPTLN='-s'

342  else

343  OPTLN=''

344  fi

345  cd "$DEST/$(dirname "$DESTLN")"

346  rm -f "$(basename "$DESTLN")"

347  ln $OPTLN "$ORIGLN" "$(basename "$DESTLN")"

348  echo -n "."

349  done < "/tmp/$IMGLN" 2>/dev/null

350  echo ""

351 

352 fi

353 cd /

354 }

355 

356 

357 #

363 function ogRestoreAclImage () {

364 local PART IMGACL

365 

366 if [ "$*" == "help" ]; then

367  ogHelp "$FUNCNAME" \

368  "$FUNCNAME num_disk num_part" \

369  "$FUNCNAME 1 1"

370  return

371 fi

372 

373 PART=$(ogDiskToDev "$1" "$2") || return $?

374 IMGACL="ogimg.acl"

375 

376 # Restauramos acl

377 if [ "$(ogGetFsType $1 $2)" == "NTFS" -a -f "/tmp/$IMGACL" ] ; then

378  cd /

379  ogUnmount "$1" "$2"

380  echo "ntfs-3g.secaudit -se $PART /tmp/$IMGACL"

381  ntfs-3g.secaudit -se $PART /tmp/$IMGACL

382  # Para evitar que de falso error

383  echo ""

384 fi

385 }

386 

387 

388 #

397 function ogSyncCreate () {

398 local ORIG DIRAUX DIRMOUNT DESTRSYNC USERRSYNC PASSWORD OPTRSYNC RETVAL

399 

400 # Limpiamos los archivo de log

401 echo "" >$OGLOGCOMMAND;

402 

403 if [ "$*" == "help" ]; then

404  ogHelp "$FUNCNAME" \

405  "$FUNCNAME num_disk num_part [ REPO|CACHE ] image_name extension " \

406  "$FUNCNAME 1 2 REPO Ubuntu12 img" \

407  "$FUNCNAME 1 1 CACHE Windows7 diff "

408  return

409 fi

410 

411 

412 if [ $# -lt 4 ]; then

413  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME num_disk num_part [ REPO|CACHE ] image_name extension "

414  return $?

415 fi

416 

417 ORIG=$(ogMount $1 $2) || return $?

418 

419 DIRMOUNT="$(ogGetMountImageDir "$4" $5)"

420 # Si la imagen es diferencial la lista de ficheros a transferir esta dentro de la imagen.

421 if [ "$5" == "diff" ]; then

422  FILESFROM=" --files-from=/tmp/ogimg.info"

423  # Borramos los directorios

424  sed -i '/\/$/d' /tmp/ogimg.info

425 else

426  FILESFROM=""

427 fi

428 

429 if [ "$3" == "CACHE" -o "$3" == "cache" ]; then

430  DESTRSYNC="/tmp/$DIRMOUNT"

431 else

432  [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)

433  PASSWORD="--password-file=/scripts/passrsync"

434  [ "$ogrsyncz" == "true" ] && OPTRSYNC="z "

435  [ "$ogrsyncw" == "true" ] && OPTRSYNC="W$OPTRSYNC"

436  USERRSYNC="opengnsys"

437  DESTRSYNC="$USERRSYNC@$REPOIP::ogimages/$DIRMOUNT"

438 fi

439 # Sincronizamos los datos de la partición a la imagen

440 echo " rsync -aHAX$OPTRSYNC --progress --inplace --delete $FILESFROM $ORIG/ $DESTRSYNC"

441 rsync -aHAX$OPTRSYNC $PASSWORD --progress --inplace --delete $FILESFROM "$ORIG/" "$DESTRSYNC" 2>$OGLOGCOMMAND | egrep "^deleting|^sent|^sending|^total|%" |tee -a $OGLOGCOMMAND

442 RETVAL=${PIPESTATUS[0]}

443 echo " rsync -aHAX$OPTRSYNC --inplace /tmp/ogimg* $DESTRSYNC"

444 rsync -aHAX$OPTRSYNC $PASSWORD --inplace /tmp/ogimg* "$DESTRSYNC"

445 

446 return $RETVAL

447 }

448 

449 

450 #

459 function ogSyncRestore () {

460 local DIRMOUNT ORIG DESTRSYNC PASSWORD OPTRSYNC USERRSYNC IMGINFO FILESFROM

461 

462 # Limpiamos los archivo de log

463 echo "" >$OGLOGCOMMAND;

464 

465 if [ "$*" == "help" ]; then

466  ogHelp "$FUNCNAME" \

467  "$FUNCNAME [ REPO|CACHE ] image_name extension num_disk num_part " \

468  "$FUNCNAME REPO Ubuntu12 img 1 2" \

469  "$FUNCNAME CACHE Windows7 diff 1 1"

470  return

471 fi

472 

473 

474 if [ $# -lt 5 ]; then

475  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name extension num_disk num_part "

476  return $?

477 fi

478 

479 

480 DIRMOUNT="$(ogGetMountImageDir "$2" "$3")"

481 DESTRSYNC=$(ogGetMountPoint $4 $5)

482 

483 # Borramos ficheros de informacion de restauraciones antiguas

484 rm -rf $DESTRSYNC/ogimg.*

485 rm -rf /tmp/ogimg.*

486 

487 # Origen y destino de la sincronizacion y en REPO opciones rsync

488 if [ "$1" == "CACHE" -o "$1" == "cache" ]; then

489  ORIG="/tmp/$DIRMOUNT"

490 else

491  [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)

492  PASSWORD="--password-file=/scripts/passrsync"

493  [ "$ogrsyncz" == "true" ] && OPTRSYNC="z "

494  [ "$ogrsyncw" == "true" ] && OPTRSYNC="W$OPTRSYNC"

495  USERRSYNC="opengnsys"

496  ORIG="$USERRSYNC@$REPOIP::ogimages/$DIRMOUNT"

497 fi

498 

499 # Opciones rsync en cache y repo

500 # Para la imagen basica, opcion de borrar archivos de la particion que no existen en la imagen

501 [ "$3" == "img" ] && [ "$ogrsyncdel" != "false" ] && OPTRSYNC="$OPTRSYNC --delete"

502 

503 # Nos traemos listado ficheros y bajamos la imagen

504 

505 ogEcho log session " $MSG_SYNC_RESTORE"

506 

507 # Si la imagen es diferencial nos traemos los archivos de informacion de la imagen.

508 if [ "$3" == "diff" ]; then

509  # Lista de archivos a copiar:

510  IMGINFO="ogimg.info"

511  FILESFROM=" --files-from=/tmp/$IMGINFO"

512 

513  echo " rsync -aHAX$OPTRSYNC --progress $ORIG/ogimg* /tmp"

514  rsync -aHAX$OPTRSYNC $PASSWORD --progress "$ORIG"/ogimg* /tmp

515  # Borramos linea de información de la imagen, sino busca un fichero con ese nombre

516  sed -i '/^\#/d' /tmp/$IMGINFO

517 

518  cd $DESTRSYNC

519  # Diferencial: Borramos archivos sobrantes.

520  ogEcho log session " $MSG_SYNC_DELETE"

521  sed -e s/^/\"/g -e s/$/\"/g "/tmp/ogimg.rm" 2>/dev/null | xargs rm -rf

522 

523 fi

524 

525 echo " rsync -aHAX$OPTRSYNC --progress $FILESFROM $ORIG/ $DESTRSYNC"

526 rsync -aHAX$OPTRSYNC $PASSWORD --progress $FILESFROM "$ORIG/" "$DESTRSYNC" 2>$OGLOGCOMMAND | egrep "^deleting|^sent|^sending|^total|%" |tee -a $OGLOGCOMMAND

527 RETVAL=${PIPESTATUS[0]}

528 cd /

529 #*/ " Comentario Doxygen

530 }

531 

532 

533 #

541 function ogMountImage () {

542 local IMGEXT IMGFILE DIRMOUNT KERNELVERSION

543 

544 if [ "$*" == "help" ]; then

545  ogHelp "$FUNCNAME" \

546  "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \

547  "$FUNCNAME REPO Ubuntu12" \

548  "$FUNCNAME CACHE Windows7 diff"

549  return

550 fi

551 

552 

553 if [ $# -lt 2 ]; then

554  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name [ extension ]"

555  return $?

556 fi

557 

558 [ "$3" == "" -o "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"

559 

560 DIRMOUNT="$(ogGetMountImageDir "$2" ${IMGEXT#*\.})"

561 

562 if [ "$1" == "REPO" -o "$1" == "repo" ]; then

563  [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)

564  hose $REPOIP 2009 --out sh -c "echo -ne MOUNT_IMAGE \"$2\" ${IMGEXT#*\.}"

565  echo "$OGIMG/$DIRMOUNT"

566 else

567  # Si está montado nada que hacer.

568  df | grep "$DIRMOUNT$" 2>&1 >/dev/null && echo "/tmp/$DIRMOUNT" && return 0

569 

570  IMGFILE="$(ogGetPath "$1" /"$2.$IMGEXT")" \

571  || return $(ogRaiseError $OG_ERR_NOTFOUND "$1 $2.$IMGEXT"; echo $?)

572  mkdir -p "/tmp/$DIRMOUNT"

573 

574 

575  # FS de la imagen segun el contenido del archivo .img

576  if file "$IMGFILE" |grep -i -e " ext4 filesystem " 2>&1 > /dev/null ; then

577  mount -t ext4 -o loop "$IMGFILE" "/tmp/$DIRMOUNT" 1>/dev/null

578  else

579  mount -o compress=lzo "$IMGFILE" "/tmp/$DIRMOUNT" 1>/dev/null

580  fi

581 

582  # Comprobamos que se ha montado bien

583  [ $? -eq 0 ] || return $(ogRaiseError $OG_ERR_DONTMOUNT_IMAGE "$1 $2 $3"; echo $?)

584  echo "/tmp/$DIRMOUNT"

585 fi

586 

587 }

588 

589 

590 #

597 function ogUnmountImage () {

598 local IMGTYPE DIRMOUNT

599 

600 if [ "$*" == "help" ]; then

601  ogHelp "$FUNCNAME" \

602  "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \

603  "$FUNCNAME REPO Ubuntu12" \

604  "$FUNCNAME CACHE Windows7 diff"

605  return

606 fi

607 

608 if [ $# -lt 2 ]; then

609  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name [ extension ]"

610  return $?

611 fi

612 

613 [ "$3" == "" ] && IMGTYPE="img" || IMGTYPE="$3"

614 

615 if [ "$1" == "CACHE" -o "$1" == "cache" ]; then

616  DIRMOUNT="/tmp/$(ogGetMountImageDir "$2" $IMGTYPE)"

617  umount "$DIRMOUNT"

618  rmdir "$DIRMOUNT"

619  [ -f $IMGFILE.lock ] && sed -i s/"mounted"//g $IMGFILE.lock

620 else

621  [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)

622  echo " hose $REPOIP 2009 --out sh -c echo -ne UMOUNT_IMAGE \"$2\" $IMGTYPE"

623  hose $REPOIP 2009 --out sh -c "echo -ne UMOUNT_IMAGE \"$2\" $IMGTYPE"

624 fi

625 }

626 

627 

628 #

634 function ogGetMountImageDir () {

635 local DIRMOUNT

636 if [ "$*" == "help" ]; then

637  ogHelp "$FUNCNAME" \

638  "$FUNCNAME image_name [ extension ]" \

639  "$FUNCNAME Ubuntu12" \

640  "$FUNCNAME Windows7 diff"

641  return

642 fi

643 

644 

645 if [ $# -lt 1 ]; then

646  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME image_name [ extension ]"

647  return $?

648 fi

649 

650 

651 DIRMOUNT="mount/$1"

652 [ "$2" == "diff" ] && DIRMOUNT="$DIRMOUNT.diff"

653 echo "$DIRMOUNT"

654 

655 }

656 

657 

658 #

668 function ogWaitSyncImage () {

669 local SIZE TIME DIRMOUNT TIMEOUT TIMEAUX LOCKFILE IMGDIR IMGEXT STATE

670 

671 TIME=$SECONDS

672 

673 # Ayuda o menos de 5 parametros y la imagen no es basica

674 if [ "$*" == "help" ]; then

675  ogHelp "$FUNCNAME" \

676  "$FUNCNAME [ REPO | CACHE ] image_name extension state [ image_size ] " \

677  "$FUNCNAME REPO Ubuntu12 img 30000000" \

678  "$FUNCNAME CACHE Windows7 diff "

679  return

680 fi

681 

682 if [ $# -lt 4 ]; then

683  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO | CACHE ] image_name extension state [ image_size ] "

684  return $?

685 fi

686 

687 SIZE=${5:-"300000"}

688 STATE="$4"

689 ogCheckStringInGroup "$STATE" "mounted reduced" || \

690  return $(ogRaiseError command $OG_ERR_FORMAT "STATE = [ mounted | reduced ]" )

691 

692 IMGDIR="$(ogGetParentPath "$1" "/$2")"

693 [ "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"

694 LOCKFILE="${IMGDIR}/$(basename "/$2").$IMGEXT.lock"

695 

696 if [ "$1" == "CACHE" -o "$1" == "cache" ]; then

697  DIRMOUNT="/tmp/$(ogGetMountImageDir "$2" $3)"

698 else

699  DIRMOUNT="$OGIMG/$(ogGetMountImageDir "$2" $3)"

700 fi

701 

702 echo -n -e " $MSG_SYNC_SLEEP: $DIRMOUNT\n #" | tee -a $OGLOGSESSION $OGLOGFILE

703 

704 # Comprobamos: mounted -> que exista $DIRMOUNT/ogimg.info o que el fichero de lock contenga mounted

705 # reduced -> que el fichero de lock contenga reduced.

706 

707 # time-out segun el tamaño de la imagen. por defecto: 100000k -> 3s

708 let TIMEOUT=$SIZE/$CREATESPEED

709 [ $TIMEOUT -lt 60 ] && TIMEOUT=60

710 until $(grep -i $STATE $LOCKFILE &>/dev/null) ; do

711  [ $STATE = "mounted" -a -f "$DIRMOUNT/ogimg.info" ] && ogEcho log session "" && return 0

712  TIMEAUX=$[SECONDS-TIME]

713  [ "$TIMEAUX" -lt "$TIMEOUT" ] || return $(ogRaiseError $OG_ERR_DONTMOUNT_IMAGE "$3 $4 $IMGEXT: time_out."; echo $?)

714  echo -n "#" | tee -a $OGLOGSESSION $OGLOGFILE

715  sleep 5

716 done

717 echo "" | tee -a $OGLOGSESSION $OGLOGFILE

718 

719 }

720 

721 

722 #

732 function ogReduceImage () {

733 local IMGEXT DIRMOUNT AVAILABLE USED IMGDIR IMGFILE ENDSIZE LOOPDEVICE

734 if [ "$*" == "help" ]; then

735  ogHelp "$FUNCNAME" \

736  "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \

737  "$FUNCNAME REPO Ubuntu12" \

738  "$FUNCNAME CACHE Windows7 diff"

739  return

740 fi

741 

742 if [ $# -lt 2 ]; then

743  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name [ extension ]"

744  return $?

745 fi

746 

747 

748 [ "$3" == "" -o "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"

749 IMGDIR="$(ogGetParentPath "$1" "/$2")"

750 IMGFILE="${IMGDIR}/$(basename "/$2").$IMGEXT"

751 

752 

753 if [ "$1" == "CACHE" -o "$1" == "cache" ]; then

754  # Para imagenes EXT4 reduzco, para BTRFS solo desmonto.

755  if file "$IMGFILE" | grep -i " ext4 filesystem " 2>&1 > /dev/null; then

756  # Al montar se comprueba la existencia de la imagen

757  DIRMOUNT="$(ogMountImage $1 "$2" ${IMGEXT#*\.})"

758  AVAILABLE=$(df -k|grep "$DIRMOUNT$"|awk '{print $4}')

759  # Si el espacio libre menor que 500Mb nos salimos

760  if [ $AVAILABLE -lt 200000 ]; then

761  ogUnmountImage $1 "$2" ${IMGEXT#*\.}

762  echo "reduced" > "$IMGFILE.lock"

763  return 0

764  fi

765 

766  # Calculamos la diferencia entre el tamaño interno y externo

767  EXTSIZE=$(ls -l --block-size=1024 "$IMGFILE" | cut -f5 -d" ")

768  INTSIZE=$(df -k|grep "$DIRMOUNT"|awk '{print $2}')

769  let EDGESIZE=$EXTSIZE-$INTSIZE

770  ogUnmountImage $1 "$2" ${IMGEXT#*\.}

771  LOOPDEVICE=$(losetup -f)

772  losetup $LOOPDEVICE "$IMGFILE"

773 

774  # Redimensiono sistema de ficheros

775  echo " resize2fs -fpM $LOOPDEVICE"

776  resize2fs -fpM $LOOPDEVICE |tee -a $OGLOGCOMMAND

777  ogMountImage $1 "$2" ${IMGEXT#*\.} >/dev/null

778 

779  # Calculamos el tamaño final del archivo

780  INTSIZE=$(df -k|grep "$DIRMOUNT"|awk '{print $2}')

781  let EXTSIZE=$INTSIZE+$EDGESIZE

782  umount "$DIRMOUNT"

783 

784  # Si existe dispositivo de loop lo borro.

785  [ $LOOPDEVICE ] && losetup -d $LOOPDEVICE

786 

787  # Corto el archivo al tamaño del sistema de ficheros.

788  echo " truncate --size=\"$EXTSIZE\"k $IMGFILE "

789  truncate --size="$EXTSIZE"k "$IMGFILE"

790  else

791  # Desmonto la imagen

792  umount "$DIRMOUNT"

793  fi

794 

795  echo "reduced" > "$IMGFILE.lock"

796  rmdir "$DIRMOUNT"

797 

798 else

799  [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)

800  echo " hose $REPOIP 2009 --out sh -c echo -ne REDUCE_IMAGE \"$2\" ${IMGEXT#*\.}"

801  hose $REPOIP 2009 --out sh -c "echo -ne REDUCE_IMAGE \"$2\" ${IMGEXT#*\.}"

802 fi

803 

804 }

805 

806 

807 

808 #

818 function ogIsSyncImage () {

819 local IMGEXT IMGDIR IMGFILE

820 

821 if [ "$*" == "help" ]; then

822  ogHelp "$FUNCNAME" \

823  "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \

824  "$FUNCNAME REPO Ubuntu12" \

825  "$FUNCNAME CACHE Windows7 diff"

826  return

827 fi

828 

829 if [ $# -lt 2 ]; then

830  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name [ extension ]"

831  return $?

832 fi

833 

834 [ "$3" == "" -o "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"

835 IMGDIR="$(ogGetParentPath "$1" "/$2")"

836 IMGFILE="${IMGDIR}"/$(basename "/$2").$IMGEXT

837 

838 file "$IMGFILE" | grep -i -e " BTRFS Filesystem " -e " ext4 filesystem " >/dev/null

839 [ $? -eq 0 ] && return 0 || return $OG_ERR_DONTSYNC_IMAGE

840 

841 }

842 

843 

844 #

854 function ogCheckSyncImage () {

855 local IMGEXT IMGDIR IMGFILE DIRMOUNT ISMOUNT RETVAL KERNELVERSION

856 

857 if [ "$*" == "help" ]; then

858  ogHelp "$FUNCNAME" \

859  "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \

860  "$FUNCNAME REPO Ubuntu12" \

861  "$FUNCNAME CACHE Windows7 diff"

862  return

863 fi

864 

865 if [ $# -lt 2 ]; then

866  ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name [ extension ]"

867  return $?

868 fi

869 

870 [ "$3" == "" -o "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"

871 IMGDIR="$(ogGetParentPath "$1" "/$2")"

872 IMGFILE="${IMGDIR}/$(basename "/$2").$IMGEXT"

873 

874 ogIsSyncImage $1 "$2" "${IMGEXT#*\.}" || return $(ogRaiseError $OG_ERR_DONTSYNC_IMAGE "$3 $4"; echo $?)

875 

876 # Comprobamos que no esté montada (daria falso error)

877 if [ "$1" == "CACHE" -o "$1" == "cache" ]; then

878  $(df | grep "/tmp/mount/$2${IMGEXT#img}$" &>/dev/null) && ISMOUNT=TRUE

879 else

880  [ -f "$OGIMG/mount/$2${IMGEXT#img}/ogimg.info" ] && ISMOUNT=TRUE

881 fi

882 [ "$ISMOUNT" == TRUE ] && ogEcho log session warning "$MSG_SYNC_NOCHECK" && return 0

883 

884 DIRMOUNT="/tmp/ogCheckImage$$"

885 mkdir "$DIRMOUNT"

886 # FS de la imagen segun el contenido del archivo .img

887 if file "$IMGFILE" |grep -i -e " ext4 filesystem " 2>&1 > /dev/null ; then

888  mount -t ext4 -o loop "$IMGFILE" "$DIRMOUNT" 2>&1 | tee -a $OGLOGCOMMAND

889  RETVAL=${PIPESTATUS[0]}

890 else

891  mount -o compress=lzo "$IMGFILE" "$DIRMOUNT" 2>&1 | tee -a $OGLOGCOMMAND

892  RETVAL=${PIPESTATUS[0]}

893 fi

894 ls -C "$DIRMOUNT" | tee -a $OGLOGCOMMAND

895 umount "$DIRMOUNT"

896 

897 rmdir "$DIRMOUNT"

898 return $RETVAL

899 }

900