De acordo com as Leis 12.965/2014 e 13.709/2018, que regulam o uso da Internet e o tratamento de dados pessoais no Brasil, ao me inscrever na newsletter do portal DICAS-L, autorizo o envio de notificações por e-mail ou outros meios e declaro estar ciente e concordar com seus Termos de Uso e Política de Privacidade.

Utilizando o Installwatch

Colaboração: André Marques Saunite

Data de Publicação: 25 de Julho de 2007

Para quem usa Slackware, Debian ou RedHat um ótimo software para se usar na hora de instalar programas a partir do código fonte é o checkinstall, ele gera um pacote com o software sendo compilado para que depois possa ser instalado/desinstalado com facilidade,

A maior utilidade desse software para mim é a facilidade de desinstalação.

Porém agora estou utilizando o gentoo, pois foi a melhor distro que encontrei para 64 bits.

Por causa disso descobri que o checkinstall é baseado em um outro software chamado installwatch, que faz toda a parte de gerenciamento dos arquivos que estão sendo instalados.

Depois de muito tempo procurando pelo installwatch pela internet eu descobri que ele se encontra no próprio fonte do checkinstall,

Então para se instalar façamos o seguinte:

Baixe o checkinstall: http://asic-linux.com.mx/~izto/checkinstall/ E faça o seguinte:

  $ tar xvfz checkinstall-1.6.0.tgz
  $ cd checkinstall-1.6.0/installwatch-0.7.0beta4/
  $ make
  # make install

Agora crie os diretórios onde teremos informações dos pacotes instalados e removidos:

  # mkdir /var/{install,uninstall}

E pronto, agora sempre que compilar um pacote, ao invés de utilizar o famoso "make install", use:

  # installwatch -o /var/install/<NOME_DO_SOFTWARE> make install

Será criado um arquivo em /var/install com o nome do software instalado e informação de todos arquivos criados,

Para facilitar o processo de instalação pode-se criar um alias:

  # alias iw='installwatch -o /var/install/$(basename $(pwd))'

A linha acima pode ser adicionada ao arquivo /etc/profile, para que tenhamos esse alias sempre que iniciarmos uma sessão, apenas note que o nome do arquivo que ficará no diretório /var/install é o nome do diretório onde você se encontra, tome os devidos cuidados para não estar num diretório com o nome incorreto ou com o nome que pode sobrescrever a informação de outro pacote previamente instalado, particularmente eu tive apenas esse "problema" quando compilando pacotes cvs que tinham o diretório "trunk".

E ao invés de digitar toda a enorme linha acima para se instalar o pacote é só utilizar:

  # iw make install

Para se desinstalar podemos utilizar o script nuke da seguinte forma:

  # nuke /var/install/<NOME_DO_SOFTWARE>

Abaixo segue o script nuke:

  #!/usr/bin/perl
  # Author: Robert Park <feztaa@shaw.ca>
  # License: GNU General Public License
  
  # Revision 1.13  2002/08/08 00:51:34  feztaa
  # Added experimental --package and --install options for tarring up
  # and untarring packages from installwatch logfiles.
  #
  # Revision 1.12  2002/07/31 07:11:43  feztaa
  # Fixed major problem with symlinks that point to directories.
  #
  # Revision 1.11  2002/07/27 00:45:39  feztaa
  # Major overhaul; reduced LOC and increased efficiency all around.
  #
  # Revision 1.10  2002/07/26 19:41:00  feztaa
  # Incorporated fixes from Zenith Lau <zenithlau@sniic.com>, fixing
  # issues with symlinks.
  
  use strict;
  
  die "You must be root!\n" unless ($< == 0);
  
  # Underline a string by appending with with a newline and hyphens
  sub underline
  {
   my $str = join("", @_);
   my $chomp = 1;
  
   $chomp++ while (chomp $str);
  
   return "$str\n" . ("-" x length $str) . ("\n" x $chomp);
  }
  
  # Take an array, and return a string that's been properly commified,
  # ie ("one", "two", "three") becomes "one, two, and three".
  sub commify
  {
   (@_ == 0) ? ''                                      :
   (@_ == 1) ? $_[0]                                   :
   (@_ == 2) ? join(" and ", @_)                       :
               join(", ", @_[0 .. ($#_-1)], "and $_[-1]");
  }
  
  my %opts;
  my @args;
  
  foreach my $arg (@ARGV)
  {
   ($arg =~ m/^(-r|--report)$/) ?  $opts{report}  = 1 :
   ($arg =~ m/^(-p|--package)$/) ? $opts{package} = 1 :
   ($arg =~ m/^(-i|--install)$/) ? $opts{install} = 1 :
                                   push @args, $arg;
  }
  
  # Process all the logfiles
  foreach my $arg (@args)
  {
   $arg =~ s#^.*/##g;
   chomp $arg;
  
   my $install = "/var/install/" . $arg;
   my $package = "/var/packages/" . $arg . ($opts{install} ? "" : ".tar.bz2");
   my $uninstall = "/var/uninstall/" . $arg;
  
   unless ((-f $install and not $opts{install}) or (-f $package and $opts{install}))
   {
     print "Can't find $arg\n";
     next;
   }
  
   if ($opts{install})
   {
     print "Unpacking files from $package ... \n";
     system("tar", "-Pxjvpf", $package);
   }
   else
   {
     open "INSTALL", "<$install" or die "$!\n";
  
     print "Processing $arg ... ";
  
     my %files;
     my $error = 0;
  
     while (<INSTALL>)
     {
       chomp;
       my @fields = split;
  
       my $action = $fields[1];
       my $file = $action eq "symlink" ? $fields[3] : $fields[2];
  
       # Don't delete stuff that wasn't created properly;
       # prevents deletion of /usr or similar.
       if ($fields[-1] eq "#success")
       {
         push @{ $files{$file} }, $action if (-f $file or -l $file or -d $file);
       }
     }
  
     print "done.\n";
  
     if ($opts{report})
     {
       # Reporting mode, don't delete anything.
       print underline("Files/Directories installed by $arg\n");
  
       foreach my $file (sort { length $b <=> length $a } keys %files)
       {
         print "$file:  ", commify (@{ $files{$file} }), "\n";
       }
     }
     elsif ($opts{package})
     {
       print "Packing files from $arg into $package ... \n";
  
       system("tar", "-cpPvjf", $package, (sort keys %files), $install);
     }
     else
     {
       # Nuke mode, delete stuff...
       print "Uninstalling $arg ... ";
  
       open "UNINSTALL", ">$uninstall" or die "$!\n";
  
       select UNINSTALL;
  
       print underline("Removed Files/Directories");
  
       foreach my $file (sort { length $b <=> length $a } keys %files)
       {
         if (grep /open|symlink|mkdir/, @{ $files{$file} })
         {
           $! = "";
  
           print "\n$file";
  
           # -d returns true for symlinks that point to directories,
           # so this is actually necessary.
           (-l "$file") ? unlink "$file" :
           (-d "$file") ? rmdir "$file"  :
                          unlink "$file";
  
           if ($!)
           {
             print " -- $!";
             $error++;
           }
         }
       }
  
       close "INSTALL";
       close "UNINSTALL";
       select STDOUT;
  
       # Let the user know what happened
       if ($error)
       {
         print "$error files/directories could not be removed.\n";
       }
       else
       {
         unlink $install;
         print "successful.\n";
       }
     }
   }
  }

Um muito obrigado aos criadores desses softwares! Meu sistema estaria cheio de lixo sem eles!