heroku buildpack texlive

¿cómo instalar texlive en una instancia de heroku? se hace con buildpacks

prefaso

conjeturas:

• como uso LaTeX desde rails, debiera escribir sobre el buildpack de ruby o perderé el deploy
• necesito hacer un binario de texlive que sea ejecutable por heroku
  para esto puedo compilarlo con vulcano (difícil) o encontrar un tarball de ubuntu (ojalá)

bin

Partiré por encontrar/hacer un binario de texlive para heroku.
Para ello, clonaré un buildpack de texlive puro como éste >>

$ git clone https://github.com/Numerico/heroku-buildpack-tex.git
$ cd heroku-buildpack-tex

dice que no funciona, veamos por qué.

Crearemos un proyecto en heroku con solo un archivo .tex adentro.

$ mkdir testapp
$ mv test.tex testapp/test.tex
$ cd testapp/
$ git init
$ git add .
$ git commit

$ heroku create --buildpack git://github.com/Numerico/heroku-buildpack-tex.git
Creating mighty-scrubland-7080... done, stack is cedar
BUILDPACK_URL=git://github.com/Numerico/heroku-buildpack-tex.git
http://mighty-scrubland-7080.herokuapp.com/ | git@heroku.com:mighty-scrubland-7080.git
Git remote heroku added

$ git push heroku master
Counting objects: 3, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 393 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
-----> Fetching custom git buildpack... done
-----> TeX Live app detected
-----> Fetching TeX Live 20121222
-----> Discovering process types
       Procfile declares types -> (none)
-----> Compiled slug size: 32.2MB
-----> Launching... done, v5
       http://mighty-scrubland-7080.herokuapp.com deployed to Heroku

To git@heroku.com:mighty-scrubland-7080.git
 * [new branch]      master -> master

Se vé bien, pero no sé si está funcionando…
Todo va bien hasta «Fetching TeX Live 20121222», de hecho me sorprende que lo baje, pues debiera necesitar la llave de S3 del autor.
En todo caso, como dice «Compiled slug size: 32.2MB» pareciera que sí lo baja. ¿Entonces lo que no estaría funcionando es que agarre el .tex y lo compile?
Porque además, el archivo bin/compile tiene la siguiente validación

if [ ! `which pdflatex` ]; then
build-warn "TeX Live installation failed"
exit 1
fi

que no estoy recibiendo… ¿cómo testearlo?

Con un Procfile >> que ejecute pdflatex

web:  yes "" | pdflatex test.tex

(le pongo tipo web para que no me lo cobren…)
Lo cual, según foreman >>, funciona

12:43:32 web.1  | Output written on test.pdf (1 page, 109090 bytes).

pero al parecer no en heroku

$ heroku ps
=== web: `yes "" | pdflatex test.tex`
web.1: crashed 2013/01/29 12:47:59 (~ 1m ago)

¿o será porque hace la pega y termina que queda crashed? ¡right! cacha

$ heroku logs
2013-01-29T15:50:54+00:00 app[web.1]: Output written on test.pdf (1 page, 896 bytes).

rubí

Ok entonces, como lo que quiero es instlar texlive para usarlo desde rails, lo que me falta es hacer esto mismo pero sobre el buildpack de ruby >>

$ git clone https://github.com/Numerico/heroku-buildpack-ruby

y… al final el buildpack luce así

#!/usr/bin/env ruby
system("aptitude search pdfinfo")

require 'net/https'
require 'open-uri'
require 'zlib'

# sync output
$stdout.sync = true

bdir=ARGV[0]
cdir=ARGV[1]
if not File.exists?(ARGV[0])
  Dir.mkdir(ARGV[0], 0777)
end
#
if not File.exists?(ARGV[1])
  Dir.mkdir(ARGV[1], 0777)
end
#
texlivehome=bdir+"/.texlive"
texlivecache=cdir+"/.texlive"
path=texlivehome+"/bin/x86_64-linux"
profiled=bdir+"/.profile.d/texlive.sh"
pdfinfohome=bdir+"/.pdfinfo"
pdfinfov="xpdfbin-linux-3.03.tar.gz"
# Prepare the various paths
if not File.exists?(texlivehome)
  Dir.mkdir(texlivehome, 0777)
end
if not File.exists?(texlivecache)
  Dir.mkdir(texlivecache, 0777)
end
if not File.exists?(File.dirname(profiled))
  Dir.mkdir(File.dirname(profiled), 0777)
end
if not File.exists?(pdfinfohome)
  Dir.mkdir(pdfinfohome, 0777)
end
#
texlivedomain="heroku-buildpack-tex.s3.amazonaws.com"
pdfinfodomain="www.numerica.cl"
#
http = Net::HTTP.new(texlivedomain, 443)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
#version=`curl #{texlivedomain}/VERSION -s`
File.open("#{texlivehome}/VERSION", 'w') {|f|
  http.get('/VERSION') do |str|
    f.write str
  end
}
version=File.read("#{texlivehome}/VERSION")
puts "TexLive v."+version
#
texliveurl="#{texlivedomain}/texlive-#{version}.tar.gz"
#
if File.exist?(texlivecache+"/VERSION") then
  oldversion=File.read("#{texlivecache}/VERSION")
  if version == oldversion then
    puts "Installing TeX Live #{version} from cache"
  end
  #cp -R $TEXLIVE_CACHE/* $TEXLIVE_HOME
  system "cp -R #{texlivecache}/* #{texlivehome}"
else
  if File.exist?(texlivecache+"/VERSION") then
    puts "Upgrading to TeX Live #{version}"
  else
    puts "Fetching TeX Live #{version}"
  end

  #curl $TEXLIVE_URL -s -o - | tar xzf - -C $TEXLIVE_HOME
  open("#{texlivehome}/tarball.tar", 'w') do |local_file|
    open("https://"+texliveurl) do |remote_file|
      local_file.write(Zlib::GzipReader.new(remote_file).read)
    end
  end
  #tar
  system "tar xf #{texlivehome}/tarball.tar -C #{texlivehome}"

  # Make sure the cache is empty
  #rm -rf $TEXLIVE_CACHE/* 
  system "rm -rf #{texlivecache}/*"

  # Store a copy of it in the cache so it doesn't have to be fetched again
  #cp -R $TEXLIVE_HOME/* $TEXLIVE_CACHE
  system "cp -R #{texlivehome}/* #{texlivecache}"

  # Store the version for later
  #echo $VERSION > $TEXLIVE_CACHE/VERSION
  File.open(texlivecache+"/VERSION", 'w') {|f| f.write(version) }
end

#pdfinfo
if not File.exist?(pdfinfohome+"/"+pdfinfov)
  http = Net::HTTP.new(pdfinfodomain, 80)
  File.open("#{pdfinfohome}/#{pdfinfov}", 'w') {|f|
    http.get("/#{pdfinfov}") do |str|
      f.write str
    end
  }
end
system "tar xzf #{pdfinfohome}/#{pdfinfov} -C #{pdfinfohome}"

# Set up the environment for runtimes now that compilation has finished
#echo 'export PATH=$HOME/.texlive/bin/x86_64-linux:$PATH' >> $PROFILE_D
#system "echo 'export PATH=$HOME/.texlive/bin/x86_64-linux:$PATH' >> #{profiled}"
`echo '#!/bin/sh' >> #{profiled}`
`echo 'PATH="$HOME/.texlive/bin/x86_64-linux:$PATH"' >> #{profiled}`
`echo 'PATH="$HOME/.pdfinfo/xpdfbin-linux-3.03/bin64:$PATH"' >> #{profiled}`
#puts File.read("#{profiled}")
#`export PATH=#{path}:$PATH`

# `which pdflatex`
# if !$?.success? then
  # puts "pdflatex NOT INSTALLED"
# end  

##########################

$:.unshift File.expand_path("../../lib", __FILE__)
require "language_pack"

if pack = LanguagePack.detect(ARGV[0], ARGV[1])
  pack.log("compile") do
    pack.compile
  end
end

Todo lo que está sobre los ###### es la instalación de los binarios de TeXLive y xpdf. El código está funcional al día de hoy, pero como Heroku al final no me sirve por su sistema de archívos efímero, que me impide trabajar con ficheros, no lo mejoraré ni mantendré. Aquí está el link >>