/dev/null

mlshell es una interfaz sencilla para programar operaciones en ml-donkey en python e incluye, como ejemplo, un optimizador de descargas.

Como muchos uso la red ed2k (entre otras) para realizar descargas, pero mis descargas no suelen ir a toda velocidad por dos razones:

• Mi ISP apesta: Limita mi cantidad de conexiones y tiene picos de trafico muy marcados, hay horas del día en que se pone insoportablemente lento.
• Tengo gustos raros: Mi música favorita no es del tipo que suele aparecer en los rankings ni en las listas de ventas. Pocos la oímos, pocos la tenemos, pocos la compartimos.

En consecuencia me resulta muy difícil conseguir buenos recursos y, más aún, verlos en linea. Por eso me duele mucho ver los logs y enterarme que ese álbum que tanto quiero tardará una semana más en llegar porque las dos horas que estuvo enteramente disponible yo tenía un limite de descargas de 6 KB/s.

Pero tampoco puedo dejar mi mula con un limite de descarga alto porque, aunque no descargará nunca muy rápido, la velocidad de subida está siempre a tope y eso afecta muy notoriamente en la navegación.

La solución: escribir un script que ajuste la velocidad de bajada/subida de acuerdo a la disponibilidad de mis descargas.

El problema: mldonkey_command parece estar roto en las nuevas versiones de mlnet como ejecutable independiente y no parece que vaya a ser reparado pronto, de hecho... algunos script distribuidos con el proyecto lo reemplazaron con una interfaz muy primitiva escrita en perl que obtiene los datos desde la interfaz web.

Entonces, antes de escribir un script que procese la información tuve que escribir uno que la pueda obtener del servidor y, también, modificar las configuraciones sobre la marcha. Para esto escribí un modulo python que usa urllib2 para manejar mldonkey a través de su interfaz web y le agregué algo de abstracción.

Nota: Depende de /usr/bin/html2text, que se encuentra en el paquete html2text en debian.

programacion/python/mlshell.py (ver ultima versión)
1. #!/usr/bin/env python
2. #-*- coding: UTF-8 -*-
3. """mlshell: Wrapper to the web interface of ml-donkey that implement minimal
4. shell capacities and can be used to automatice operacions."""
6. import urllib2
7. import base64
8. import subprocess
9. import re
10. import os
11. import logging
12. from ConfigParser import SafeConfigParser
13. from optparse import OptionParser, OptionValueError
15. logging.root.setLevel(5)
18. def html2text(html):
19. """Process a html document to render as simple text"""
20. proc = subprocess.Popen(["/usr/bin/html2text", "-style", "compact"],
21. stdin=subprocess.PIPE, stdout=subprocess.PIPE)
22. proc.stdin.writelines(html)
23. proc.stdin.close()
24. text = unicode("".join(proc.stdout.readlines()), 'utf-8', 'replace').strip()
25. text = re.compile(r""":(\s*)""").sub(": ", text)
26. text = re.compile(r"""(\s*)wiki$""", re.MULTILINE).sub("", text)
28. return text
31. class MLSession:
32. """Wrapper to the web interface of ml-donkey"""
34. def __init__(self, user=None, password=None, host="localhost", port=4080):
36. if user and password:
37. self.header = "Basic " + base64.encodestring("%s:%s" %
38. (user, password)).strip()
39. else:
40. self.header = None
42. self.host = host
43. self.port = port
45. self.fmt_prompt = u"(d%.1fKB/s|u%.1fKB/s): "
47. self.locals = {
48. "s" : self.bw_stats,
49. "auto_rate" : lambda: self.optimize_rate_limits(
50. self.variables.get("maxdownload", None),
51. self.variables.get("maxupload", None),
52. self.variables.get("minupload", None),
53. self.variables.get("margin", None))
54. }
56. self.variables = {}
59. def bw_stats(self):
60. """Return the current bandwidth stats: (down, up)"""
61. stats = [st.strip() for st in self.execute("bw_stats").split()]
62. down_rate = float(stats[1])
63. up_rate = float(stats[4])
64. return down_rate, up_rate
67. def optimize_rate_limits(self, maxdownload=None, maxupload=None,
68. minupload=None, margin=None):
69. """Optimize the rate limits to the best download rate."""
71. maxdownload = maxdownload or self.variables.get("maxdownload", "0")
72. maxupload = maxupload or self.variables.get("maxupload", "10")
73. minupload = minupload or self.variables.get("minupload", "1")
74. margin = margin or self.variables.get("margin", "down_rate ** (1/3.)")
76. table = {36:9, 32:8, 28:7, 24:6, 20:5, 16:4, 9:3, 6:2, 3:1}
77. down_rate, up_rate = self.bw_stats()[:2]
79. self.variables.update((("down_rate", down_rate), ("up_rate", up_rate)))
81. maxdownload = eval(str(maxdownload), self.variables)
82. maxupload = eval(str(maxupload), self.variables)
84. if maxupload == 0:
85. maxupload = 10
87. minupload = eval(str(minupload), self.variables)
88. margin = eval(str(margin), self.variables)
90. down_limit = down_rate + margin
91. down_limit = min((k for k in table.iterkeys() if k >= down_limit))
93. if maxdownload:
94. if down_limit == 0:
95. down_limit = maxdownload
96. else:
97. down_limit = min(down_limit, maxdownload)
99. up_limit = min(max(table.get(down_limit, 10), minupload), maxupload)
100. # down_limit = dict((i[::-1] for i in table.iteritems()))[up_limit]
102. logging.debug(" ".join((" down_rate: %.2f", "up_rate: %.2f",
103. "margin: %.2f", "down_limit: %d", "up_limit: %d")) %
104. (down_rate, up_rate, margin, down_limit, up_limit))
106. logging.debug(self.execute("set max_hard_upload_rate %d" % up_limit))
107. logging.debug(self.execute("set max_hard_download_rate %d" %
108. down_limit))
110. return down_limit, up_limit
113. def get_prompt(self):
114. """Generate a prompt text"""
115. return self.fmt_prompt % self.bw_stats()
118. def execute(self, order):
119. """Find the method asosiated or the order on the web interface"""
121. if order in self.locals:
122. return self.locals[order]()
123. else:
124. order = order.replace(" ", "+")
125. req = urllib2.Request("http://%s:%d/submit?q=%s" % (self.host,
126. self.port, order))
127. req.add_header('Authorization', self.header)
128. response = urllib2.urlopen(req)
129. html = "".join(response.readlines())
130. return html2text(html)
133. def main():
134. """Main rutine"""
136. # == Reading the config file ==
138. # Define the defaults value
139. config = SafeConfigParser({
140. "host":"localhost",
141. "port":"4080",
142. "user":None,
143. "password":None,
144. "maxdownload":"0",
145. "maxupload":"10",
146. "minupload":"1",
147. "margin":"down_rate ** (1/3.)",
148. })
150. # Read the values on the file
151. config.read(os.path.expanduser('~/.mlshell'))
153. # == Reading the options of the execution ==
155. def define_variable(option, opt_str, value, parser):
156. """Handle the -d/--define option and populate the variables dict"""
157. logging.debug(option.dest)
158. logging.debug(value)
159. variables = getattr(parser.values, option.dest)
161. try:
162. variable = re.search(r"".join(("^\s*([a-zA-Z_][a-zA-Z\d_]*)",
163. "\s*=\s*(.*)\s*$")), value).groups()
164. except AttributeError:
165. raise OptionValueError("Declaración incorrecta: %s" % value)
166. else:
167. variables.update((variable,))
169. logging.debug(variables)
171. # Instance the parser and define the usage message
172. parser = OptionParser(usage="""
173. %prog [-vqd]
174. %prog [-vqd] file
175. %prog [-vqdc] command""", version="%prog 2")
177. # Define the options and the actions of each one
178. parser.add_option("-c", help="Read the comands from" +
179. " the arg instead of from the standard input", action="store_true",
180. dest="command")
181. parser.add_option("-v", "--verbose", action="count", dest="verbose")
182. parser.add_option("-q", "--quiet", action="count", dest="quiet")
183. parser.add_option("-d", "--define", metavar="VAR=VALUE", action="callback",
184. callback=define_variable, type="string", nargs=1, dest="variables",
185. help="Define a variable VAR to VALUE")
187. # Define the default options
188. parser.set_defaults(verbose=2, quiet=0, variables={})
190. # Process the options
191. options, args = parser.parse_args()
193. # == Execution ==
195. # Crate the wrapper instance
196. session = MLSession(
197. config.get("Server", "user"),
198. config.get("Server", "password")
199. )
201. for variable in config.options("Variables"):
202. session.variables[variable] = config.get("Variables", variable)
204. for variable in options.variables:
205. session.variables[variable] = options.variables[variable]
207. logging.debug(session.variables)
209. if options.command:
210. for order in args:
211. print(session.execute(order))
212. return 0
214. elif args:
215. print("Leyendo comandos en %s" % args[0])
217. else:
218. order = None
219. while order not in ("q", "kill"):
220. try:
221. order = raw_input(session.get_prompt()).strip()
223. except EOFError:
224. return
226. else:
227. print(session.execute(order))
230. if __name__ == "__main__":
231. exit(main())

Si se lo ejecuta como programa independiente funciona de modo similar a una shell (de ahí su nombre) leyendo los comandos de la entrada estándar o de un archivo pasado como parámetro y escribiendo en la salida estándar. Las opciones pueden ser guardadas en un archivo de configuración ~/.mlshell

.mlshell
1. [Server]
2. host = localhost
3. port = 4080
4. user = admin
5. password = mipass
7. [Variables]
8. maxdownload = 0
9. maxupload = 0
10. minupload = 1
11. margin = down_rate ** (1/3.)

Como ejemplo escribí un par de ordenes sencillas, entre ellas la mejor es auto_rate, que al ejecutarse ajustará las velocidades de bajada y subida para sacar mejor provecho a los recursos actuales sin derrochar ancho de banda . Para sacar mejor provecho lo instalé en mi crontab (usando la opción -c de mlshell):

crontab
1. # m h dom mon dow command
2. SHELL=/bin/sh
3. PATH="/sbin:/usr/sbin:/usr/local/sbin:/bin:/usr/bin:/usr/local/bin:/usr/bin/X11:/usr/games:/home/deimos/bin"
5. #m h ddm mes dds command
6. * * * * * mlshell -c auto_rate > /dev/null 2>&1

Opcionalmente podemos poner limites en franjas horarias determinadas usando "-d maxdownload=24" o "-d maxupload=4", ecetera. Otros ejemplos los dejo como ejercicio del lector, que no por nada escribí tantas opciones con sus respectivas ayudas .

A modo de ejemplo os pongo unas gráficas, esta la tomé luego de tener la primer versión instalada en crontab, observad el progreso:

Esta segunda muestra el funcionamiento normal de mis descargas usando auto_rate con un limite de descarga de 36 KB/s:

(Notad la casi perfecta simetría entre velocidad de descarga y subida)

Espero que a alguien más le sea útil mi ocurrencia .