Running with Ruby

Tag: pictures

Paperclip, interpolations (interpolacje) i zmiany nazwy plików

Wstęp

Są sytuacje w których chcemy aby nasze pliki z Paperclipa miały konkretne nazwy. Np. takie odpowiadające nazwom obiektów do których są dopięte (np po atrybucie name). Dla leniwych – gotowy kod na githubie.

Interpolacje

Paperclip daje nam taką możliwość dzięki interpolacjom. Możemy w bardzo prosty sposób tworzyć własne reguły nazewnictwa. Aby tego dokonać, modyfikujemy (lub tworzymy jeśli go nie mamy) plik config/initializers/paperclip_extensions.rb wpisując w nim (przykładowo):

Paperclip.interpolates :instance_name do |attachment, style|
  attachment.instance.name.to_url
end

gdzie metoda to_url (opisana tutaj) zamienia tekst na jego odpowiednik w formie nadającej się do linków (a także na nazwy plików, katalogów, itp). Przykładowo z nazwy “Przykładowa nazwa” powstanie “przykladowa-nazwa”. Dzięki temu, możemy sobie poskładać nazwę dla pliku w modelu w taki oto sposób:

  has_attached_file :photo,
    :url => "/images/photos/:instance_name_:style.:extension"

Pozwala nam to tworzyć ładniejsze linki do obrazków.

Interpolacja po parametrach == problem

Interpolując z pomocą parametrów, nazwijmy to “zmiennych”, pojawia się nam pewien problem. Paperclip nie zmienia samoczynnie nazw plików już utworzonych, tak więc zmieni ścieżki do plików w bazie, nie zmieniając położenia (bądź nazw) samych plików. W skutek tego jeśli utworzymy sobie model z polem :name, po którym interpolujemy, a następnie zaktualizujemy wartość tego pola, utracimy dostęp do plików będących już na serwerze. Przykładowo:

  1. Mamy model z polem :name oraz plikiem :image
  2. Interpolujemy nazwę pliku po atrybucie :name: ‘images/:instance_name.:extension’
  3. Tworzymy obiekt, przypisując name => “Susanoo”, dołączamy zdjęcie
  4. Otrzymujemy obiekt ze ścieżką do pliku => “images/susanoo.jpg”
  5. Aktualizujemy nazwę w naszym obiekcie, zmieniając ją na “Nokogiri”. Paperclip zmieni scieżkę w bazie, na “images/nokogiri.jpg”, jednak nie zmieni nazw plików, przez co w systemie plików dalej będzie plik “images/susanoo.jpg”, zamiast “images/nokogiri.jpg”

Rozwiązanie – has_interpolated_attached_file

Rozwiązaniem takiej sytuacji jest wykorzystanie callbacków z ActiveRecord. Musimy “przechwycić” stary (poprawny) adres pliku na serwerze a następnie przenieść go pod nowy adres. Musimy także zachować transakcyjność. Aby tego dokonać wykorzystamy trzy callbacki:

  1. before_update – zapamiętamy w nim nasz “stary”, poprawny adres pliku – dla każdego ze stylów.
  2. after_update – mając stare nazwy oraz nowe (bo już po aktualizacji), w tym callbacku przeniesiemy pliki pod nowe adresy
  3. after_rollback – gdyby coś poszło nie tak, wycofamy zmiany wprowadzone w plikach tak aby odzyskały swoje pierwotne położenie

Całość zamkniemy w metodzie która będzie rozszerzeniem do Paperclipa, dzięki czemu będziemy mogli z niej korzystać zamiast standardowego has_attached_file.

before_update

Najpierw before_update. Tutaj sprawa jest prosta. Tworzymy sobie zmienną instancyjną która będzie hashem przechowującym. oryginalne nazwy plików (dla wszystkich styli jeśli są). Cała sztuczka polega na tym, że aby uzyskać dostęp do pierwotnych nazw. musimy odpytać bazę danych o samych siebie ale z bazy – tak żeby mieć te “poprzednie” ścieżki z nazwami. Reszta to już tylko iteracja po wartościach i przypisanie do hasha:

      before_update do |record|
        @interpolated_names = {} unless @interpolated_names
        @interpolated_names[name] = {} unless @interpolated_names[name]
        old_record = self.class.find(record.id)
        (record.send(name).styles.keys+[:original]).each do |style|
          @interpolated_names[name][style] = old_record.send(name).path(style)
        end
      end

after_update

Mamy już potrzebne nam stare i nowe ścieżki. Nie pozostaje nam nic innego, jak je pozamieniać:

      after_update do |record|
        (record.send(name).styles.keys+[:original]).each do |style|
          orig_path = @interpolated_names[name][style]
          dest_path = record.send(name).path(style)
          if orig_path && dest_path && File.exist?(orig_path) && orig_path != dest_path
            FileUtils.move(orig_path, dest_path)
          end
        end
      end

after_rollback

Dla pewności, musimy zapewnić sobie także możliwość odwrócenia zmian. Jak to zrobić? Po prostu pozamieniamy nazwy plików z powrotem, wracając do punktu wyjścia:

      after_rollback do |record|
        return unless @interpolated_names
        (record.send(name).styles.keys+[:original]).each do |style|
          dest_path = @interpolated_names[name][style]
          orig_path = record.send(name).path(style)
          if orig_path && dest_path && File.exist?(orig_path) && orig_path != dest_path
            FileUtils.move(orig_path, dest_path)
          end
        end
      end

Całość

Całość zamkniemy w metodzie has_interpolated_attached_file. Dodając do niej przy okazji oryginalny has_attached_file, co pozwoli nam korzystać z naszej metody zamiast has_attached_file:

require 'fileutils'
# Some usefull paperclip extensions
module Paperclip
  module ClassMethods

    def has_interpolated_attached_file name, options = {}

      # Get old pathes to all files from file and save in instance variable
      before_update do |record|
        @interpolated_names = {} unless @interpolated_names
        @interpolated_names[name] = {} unless @interpolated_names[name]
        old_record = self.class.find(record.id)
        (record.send(name).styles.keys+[:original]).each do |style|
          @interpolated_names[name][style] = old_record.send(name).path(style)
        end
      end

      # If validation has been passed - move files to a new location
      after_update do |record|
        (record.send(name).styles.keys+[:original]).each do |style|
          orig_path = @interpolated_names[name][style]
          dest_path = record.send(name).path(style)
          if orig_path && dest_path && File.exist?(orig_path) && orig_path != dest_path
            FileUtils.move(orig_path, dest_path)
          end
        end
      end

      # If renaming (or other callbacks) went wrong - restore old names to files
      after_rollback do |record|
        return unless @interpolated_names
        (record.send(name).styles.keys+[:original]).each do |style|
          dest_path = @interpolated_names[name][style]
          orig_path = record.send(name).path(style)
          if orig_path && dest_path && File.exist?(orig_path) && orig_path != dest_path
            FileUtils.move(orig_path, dest_path)
          end
        end
      end

      has_attached_file name, options
    end

  end
end

Źródełka dostępne na moim Githubie.

Rails + przechowywanie wielu obrazów (miniaturek, avatarów, zdjęć) w systemie

Przeglądając devpytania natknąłem się na pytanie dotyczące przechowywania zdjęć użytkowników w serwisie – biorąc pod uwagę ilości “hurtowe” (link).

Nie miałem potrzeby aby wdrażać takie rozwiązanie, ponieważ nie pisałem nigdy części systemu, która miałaby przechowywać ponad 32k plików (chociaż ostatnio się to zmieniło ;) ). Wychodząc naprzeciw wyzwaniu, postanowiłem dodać taką opcję i jak to bywa w wypadku Railsów – nie zajęło mi to zbyt wiele czasu.

Rozwiązanie znalazłem tutaj. Jest ono proste jak konstrukcja cepa a jego wdrożenie nie zajmuje zbyt wiele czasu.

W katalogu config/initializers tworzymy sobie plik, np o nazwie: paperclip_extensions.rb czy tam czymś podobnym, po czym wstawiamy do tego pliku taki oto kod:

Paperclip.interpolates :hashed_path do |attachment, style|
  hash = Digest::MD5.hexdigest(attachment.instance.id.to_s + 'cos_tam_tajnego')
  hash_path = ''
  3.times { hash_path += '/' + hash.slice!(0..2) }
  hash_path[1..12]
end

Mimo że pierwotny autor na blogu uważa że cos_tam_tajnego nie jest istotne, ja pozwolę się z nim nie zgodzić ;)

Dodanie soli do tego hasha, sprawia że ktoś kto chciałby “zassać” nasze zdjęcia, przy pomocy jakiegoś kodu automatycznego, będzie miał utrudnione zadanie.

Nie dając soli, potencjalny “złodziej” bardzo szybko zauważy prawidłowość pt: MD5(id) i podział na 3 części. Stosując tutaj sól oraz moje rozwiązanie z tego wątku – zabezpieczamy się w dużym stopniu przed tego typu zagrywkami.

Po dodaniu tego rozszerzenia do Paperclipa, otrzymujemy nowe słowo “klucz” do wykorzystania z tym pluginem. Jest to :hashed_path który możemy wykorzystać tak samo jak np: :id_:style.:extension, tworząc przykładowo taką oto ścieżkę:

:url => "/pictures/:hashed_path/:id/:id_:style.:extension"

:hashed_path zostanie zamieniony na strukturę katalogów w stylu /ghw/jre/fhw. Dzięki temu w jednym katalogu nie będzie przechowywana zbyt duża liczba plików co mogłoby się skończyć problemami z systemem plików.

Według mnie implementacja tego kodu jest na tyle prosta i szybka, że warto ją włączać nawet w projekty które nie mają w założeniach być “super obciążone”, ponieważ jak to w internecie bywa – wszyscy wiemy ;)

Copyright © 2018 Running with Ruby

Theme by Anders NorenUp ↑