Estoy en ubuntu, me conecto al celu y las fotos están en formato .heic ¯_(ツ)_/¯. Pero quiero un .jpg! Ah! Ya sé, googleo y encuentro esto. Para convertir un montón de archivos .heic a .jpg hay que instalar libheif-examples en la consola así:
$ sudo apt-get install libheif-examples
Y después se puede correr esto:
$ for file in *.heic; do heif-convert $file ${file/%.heic/.jpg}; done
Para convertir todos los .heic de un directorio.
Ajustalo si querés hacer otra cosa.
Ayer a la noche arranco mi notebook, que tiene instalado lubuntu 22.04, y en vez de abrir la GUI de siempre me abre la terminal en texto. Por suerte se sigue conectando al wifi. Así que podía instalar cosas en línea de comando. Cuando rebooteo veo que por un momento aparece el error ACPI BIOS Error (bug): Could not resolve symbol [\CTDP].
Después de tratar de tocar grub para que bootee distinto, infructuosamente, encontré una guía para instalar guis en ubuntu. En ella dice que la forma más fácil para instalar una gui es usar la utilidad tasksel, y que puedo instalar la gui de lubuntu con eso, instalando la gui lxqt. Así que hice sudo apt install tasksel, sudo tasksel, elegí lxqt, esperé a que termine, rebootié, y ahora tengo gui de nuevo!
Si por algún motivo querés aceptar invites a repos desde línea de comando en github, se puede!
Para hacer eso, hay que usar el comando gh y tener estar autenticado via
$ gh auth login
Una vez que estás autenticado, hay que usar el api de github directamente via gh api, que maneja la autenticación por nosotros y recibe parámetros de forma análoga a curl.
El comando para obtener todos los invites pendientes es:
$ gh api user/repository_invitations
y devuelve un array con todas las invitaciones pendientes del usuario (en json).
Lo importante de ese array es que cada entrada tiene un campo "id". Es algo así:
[
{
"id": 12345678,
"repository": {
"full_name": "usuario/repo",
"otras": "cosas",
},
"otras": "cosas"
},
{ "id": "23456789", "otras": "cosas" }
]
Con ese id, podés correr este otro comando para aceptar el invite así:
$ gh api -X PATCH user/repository_invitations/12345678
y si salió todo bien ahora podés hacer clone de ese repo privado así:
$ gh repo clone usuario/repo
Espero que les sirva!
PD: Las llamadas a la API las deduje de acá.
Hoy publiqué una herramienta open-source que sirve para medir el tamaño de contratos de solidity. Está en pypi, y podés instalarla corriendo pip install estimate-sol. Este es el uso:
$ estimate-sol -h usage: estimate-sol [-h] [--punctuations] [--encoding ENCODING] [--dependencies-multiplier DEPENDENCIES_MULTIPLIER] [--assembly-multiplier ASSEMBLY_MULTIPLIER] [--week-size WEEK_SIZE] [-a] [-V] files [files ...] Estimate solidity audit sizes. positional arguments: files Files to be audited. optional arguments: -h, --help show this help message and exit --punctuations, -p Use punctuations for counting (default: lines) --encoding ENCODING, -e ENCODING File encoding (default=utf-8). --dependencies-multiplier DEPENDENCIES_MULTIPLIER, -d DEPENDENCIES_MULTIPLIER Multiplier to estimate non-audited dependencies (default=1.0). --assembly-multiplier ASSEMBLY_MULTIPLIER Multiplier to estimate assembly code (default=1.0). --week-size WEEK_SIZE, -w WEEK_SIZE Number of items to audit per week. Defaults: (lines:1.0, punct:1.0) -a, --absolute_paths Show all paths as absolute (by default relative paths are shown if inside current directory). -V, --version show program's version number and exitY podés ver el anuncio original acá.
Me conecto a una VM por ssh, forwardeando X (ssh -X).
Instalo el snap de chromium (sudo snap install chromium).
Lo corro, y me da este error.
$ chromium
X11 connection rejected because of wrong authentication.
[2050513:2050513:0909/155104.874445:ERROR:ozone_platform_x11.cc(240)] Missing X server or $DISPLAY
[2050513:2050513:0909/155104.874518:ERROR:env.cc(255)] The platform failed to initialize. Exiting.
[1]+ Done XAUTHORITY=$HOME/.Xauthority chromium
Para arreglar el problema hay que setearle la variable de entorno de XAUTHORITY (¿por qué?).
Lo corro así y problema solucionado.
$ XAUTHORITY=$HOME/.Xauthority chromium
Hace 5 meses empecé a hacer pesas en el gimnasio que está a una cuadra de casa. Y estoy ganando fuerza. Para ganar fuerza en el gimnasio hay que hacer una cosa que se llama "sobrecarga progresiva". Eso quiere decir que a medida que vamos pudiendo, hay que ir haciendo los ejercicios cada vez más difíciles. En el caso de hacer pesas eso lo podés hacer subiendo el peso que usás en el ejercicio, subiendo la cantidad de repeticiones por serie y/o subiendo la cantidad de series. El problema es que subir el peso todo el tiempo no se puede porque las mancuernas suben de a 2.5kg, y los discos también (por lo que como hay que poner cantidades pares en la barra, el salto mínimo es de 5kg). Por lo tanto inventé este procedimiento, que está funcionando bárbaro.
Para cada ejercicio:
No sé porqué no te cuenta nadie que ésta es la forma de ir subiendo de peso. Lo que vi en el gimnasio es que te suben los pesos independientemente de como progresás, y entonces o subís demasiado despacio o demasiado rápido y no podés hacer los ejercicios. Me pasó de decirle a un compañero de gimnasio que no tiene que levantar los pesos solo porque lo dice en su ficha. No hagas lo mismo. No te expongas al pedo. Seguí mi procedimiento (o algo parecido).
Y contame como te fue, o si tenés algún truco extra, en los comentarios.
Etiquetas:
gimnasio,
pesas,
sobrecarga progresiva
Me gusta contectarme a mis VMs por ssh y es bastante cómodo. Pero a veces es un garrón copiar archivos desde/hacia mis VMs. Por eso prefiero montar el disco vía ssh. Saqué cómo hacerlo de acá.
Para hacer eso en ubuntu hay que instalar sshfs
$ sudo apt-get install sshfs
Hacer un directorio vacío para montar el filesystem nuevo.
$ mkdir /home/johndoe/sshfs-path/
Y montar el directorio vía ssh.
$ sshfs remoteuser@111.222.333.444:/remote/path /home/johndoe/sshfs-path/
Por último, para desmontarlo hay que correr:
$ fusermount -u /home/johndoe/sshfs-path/
A veces uno quiere ignorar archivos en git pero no quiere tocar .gitignore porque entonces aparece .gitignore como archivo modificado. Y eso es un garrón. Pensé que era inevitable, pero no. Si editan .git/info/exclude, poniendo reglas como las de .gitignore, va a ignorar siguiendo esas reglas en los comandos de git pero no van a ver .gitignore o .git/info/exclude como archivos modificados cuando corran git status (por ejemplo).
Fuente: https://stackoverflow.com/questions/653454/how-do-you-make-git-ignore-files-without-using-gitignore
Desde hace unos meses mi trabajo es hacer auditorías de smart contracts escritos en solidity. Como parte de este trabajo, tengo que buscar multiplicaciones y divisiones en código que no conozco, generalmente usando VSCode.
El tema es que las búsqueda de "*" y "/" dan bocha de falsos positivos porque estos caracteres se usan para marcar comentarios, aparte de las operaciones aritméticas. Por eso uso unas regex para buscarlos, que aunque no son perfectas, me sirven para acotar la cantidad de lugares que tengo que mirar. Quizás les sirvan a ustedes también, así que se las dejo acá abajo:
Multiplicación: [^\s].*[^/*]\*[^/*]
División: [^/*]/[^/*]
Probablemente también puedan serles útiles en otros lenguajes como Python, Java o C++.
Estoy entrando a un laburo nuevo, y como primera tarea tengo que hacer unos POCs de contratos en solidity y testearlos en la red de test de Binance.
Para hacer esto tengo que hacerlos con hardhat. Por lo tanto empecé a seguir las instrucciones que dan en Binance para setupear hardhat, pero no están del todo bien.
Los problemas que me llevé puestos son:
Si el contenido de secrets.json no tiene el formato correcto, o el archivo no existe da un error bastante críptico (Expected a value of type HttpNetworkConfig)
Pero cuando está todo bien configurado pasa esto:
$ npx hardhat compile
Compiling 2 files with 0.8.4
Compilation finished successfully
Espero que les sirva,
Aureliano.
Seguramente esto sea un retroplagio, pero estuve notando que muchos sistemas suelen andar con incentivos opuestos, que hacen que llegue a un equilibrio.
Los mercados se basan en que haya compradores y vendedores, con intereses opuestos. El sistema judicial se basa en tener acusación y defensa. Yo creo que esa cualidad de que actores actuando de forma egoísta hacen que salga un resultado bueno es una propiedad deseable de los sistemas.
En particular, hay una aplicación de esto que creo que sería buenísimo hacer y no veo que la hagan. Uno de los problemas que hay con el cobro de impuestos es valuar correctamente los activos sobre los que se aplican. Por ejemplo, el precio de mercado de una propiedad. En Argentina (y creo que en el resto del mundo también) esta valuación se hace con una declaración, por lo que aún cuando se haga bien originalmente, esta valuación se vuelve incorrecta al toque (sobre todo cuando hay mucha inflación o una burbuja inmobiliaria).
Pero esto no tiene porqué ser así. Mi propuesta es usar un "sistema egoísta" para valuar bienes registrables, como por ejemplo terrenos o campos. En este sistema cada dueño declararía el precio de su propiedad, como hasta ahora, y se cobraría un impuesto como porcentaje del valor declarado, como hasta ahora. Lo nuevo es que puede venir cualquier otra persona o empresa y comprar dicha propiedad al doble del valor declarado. Si así lo hiciera, el dueño original se quedaría con el 150% del valor declarado y el 50% restante iría para el estado, en concepto de multa por no declarar correctamente el precio de la propiedad. Esto incentivaría a no sub-declarar el precio de las propiedades.
Algunas cosas que harían andar el sistema, evitando posibles abusos son:
Creo que si se usara esto para cobrar impuestos a los latifundios de la pampa húmeda, podrían darse las condiciones para que no haya más dólares paralelos ni retenciones a las exportaciones. Y si funciona bien, aplicarla después al resto de las propiedades también.
Espero que alguien tome esta idea y la lleve a cabo.
Etiquetas:
retroplagio
En estos días empecé a jugar un poco con rust. Para esto, armé un entorno de desarrollo razonable para mi, en una VM. A mi me gusta armar entornos en VMs para desarrollar así no contamino mi compu con todas las cosas que voy instalando para probar cosas. En particular, prefiero armar VMs de lubuntu (ubuntu con lxde) y laburar conectandome via ssh como si fuera otra compu.
Para esto, armé la VM y le puse 2 placas de red virtuales (una NAT y otra host-only), le instalé lubuntu, le apliqué los últimos paquetes (apt update y apt upgrade) openssh-server (apt install openssh-server), git (apt install git), vscode (snap install --classic code), curl (apt install curl) y rust via rustup (curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh) que incluye cargo.
Para laburar más cómodo le informé mi clave de ssh a la VM usando ssh-copy-id. Después de eso, puedo sshearme a la vm (ssh -X -A aure@192.168.56.101) y operar sin poner passwords y abrir ventanas remotas para usar el vscode (y firefox) de la VM en el escritorio del host.
Para usar firefox hay que correrlo como firefox -no-remote. Para que anden los comandos de cargo y rustup que abren el browser agregué export BROWSER="$HOME/bin/firefox-remote.sh" en el final de mi .profile de la VM. y en $HOME/bin/firefox-remote.sh puse
#!/usr/bin/env bash
firefox -no-remote "$@"
y lo puse como ejecutable con chmod.
En vscode instalé 3 plugins:
Con esto creo que estoy listo para empezar a programar dentro de mi VM.
¿Creen que me faltó algo?Tengo una notebook nueva con una ssd kingston de 1 tera, modelo SA2000M81000G según smartctl. Cuando uso la notebook, en forma bastante aleatoria, se pega unos cuelgues de novela. Después de estar como un mes tratando de entender que &&*$#$#&$@#* pasa, creo que encontré la respuesta :D.
Parece que algunas memorias kinsgton tienen un bug que se manifiesta cuando cambian de estado para ahorrar energía. El manejo de energía está en el kernel.
La forma de evitarlo es pasarle un parámetro a grub como explican acá.
En mi ubuntu, edité el archivo /etc/default/grub. Cambié la línea GRUB_CMDLINE_LINUX="" para que diga GRUB_CMDLINE_LINUX="nvme_core.default_ps_max_latency_us=0". Después de eso corrí sudo update-grub y reinicié la compu.
Después de eso, parece que anda todo bien 🤞.
PD: Están trackeando este bug acá
Lamentablemente, la opción para correr memtest cuando booteamos no está disponible cuando booteamos de una compu que usa EFI en vez de BIOS.
Por suerte, hay workarround. Casi todos los pasos están documentados acá. La única diferencia para la compu en la que tuve que hacer esto es que, como bootea de memoria de estado sólido, en vez de bootear de /dev/sda4 (o parecido) bootea de /dev/nvme0n1p1, por lo que las instrucciones sobre cómo armar el script para que grub tenga la entrada son un poquitín distintas.
En mi caso el archivo /etc/grub.d/40_memtest es así (en rojo lo que cambié)
#!/bin/shexec tail -n +3 $0# This file provides an easy way to add custom menu entries. Simply type the# menu entries you want to add after this comment. Be careful not to change# the 'exec tail' line above.menuentry 'memtest86' { insmod part_gpt insmod fat set root='hd1,gpt1' chainloader /EFI/memtest86/BOOTX64.efi}No tengo muy claro porqué funciona (fue un SWAG).
Espero que les sirva,
Aureliano.
Hace un tiempo hice un scriptcito en python para monitorear la conexión de red usando ping. Hoy quise usarlo de nuevo y descubrí que no anda en python3, así que lo adapté. Solo necesitaba 2 pequeños cambios:
Dejo acá abajo la versión nueva:
#!/usr/bin/env python3
import subprocess
import sys
import re
SEQ_NUMBER_RE = re.compile(".*icmp_seq=(\d+) ttl.*")
def report(probes, count):
if len(probes) < count:
return "N/A"
return str ( count - sum(probes[-count:]) )
def monitor(ip):
probes = []
ping = subprocess.Popen(["ping", ip], stdout=subprocess.PIPE)
stdout = ping.stdout
stdout.readline() # Ignore first line
line_count = 0
last_seq_number = 0
while True:
line_count +=1
seq_number = int( SEQ_NUMBER_RE.match(stdout.readline().decode()).group(1))
probes.extend([0] * (seq_number - last_seq_number - 1))
probes.append(1)
print( "(%s) 10:%s 100:%s 1000:%s" % (
line_count, report(probes, 10), report(probes, 100), report(probes, 1000)
) )
probes = probes[-1000:] # Keep memory usage bounded
last_seq_number = seq_number
def main(argv):
monitor(argv[1])
if __name__ == '__main__':
main(sys.argv)
Happy hacking,
Aureliano
Mi vieja técnica para deshabilitar el touchpad no anda en lubuntu 20.04. Así que tuve que googlear de nuevo cómo se hace.
Para ver todos los devices de entrada de X-Windows hay que correr
$ xinput list
⎡ Virtual core pointer id=2 [master pointer (3)]
⎜ ↳ Virtual core XTEST pointer id=4 [slave pointer (2)]
⎜ ↳ Telink 2.4G Mouse id=11 [slave pointer (2)]
⎜ ↳ Telink 2.4G Mouse Consumer Control id=12 [slave pointer (2)]
⎜ ↳ SynPS/2 Synaptics TouchPad id=16 [slave pointer (2)]
⎣ Virtual core keyboard id=3 [master keyboard (2)]
↳ Virtual core XTEST keyboard id=5 [slave keyboard (3)]
↳ Power Button id=6 [slave keyboard (3)]
↳ Video Bus id=7 [slave keyboard (3)]
↳ Power Button id=8 [slave keyboard (3)]
↳ Logitech Logitech G430 Gaming Headset id=9 [slave keyboard (3)]
↳ Telink 2.4G Mouse System Control id=10 [slave keyboard (3)]
↳ CHICONY HP Basic USB Keyboard id=13 [slave keyboard (3)]
↳ HP TrueVision HD Camera: HP Tru id=14 [slave keyboard (3)]
↳ AT Translated Set 2 keyboard id=15 [slave keyboard (3)]
↳ HP Wireless hotkeys id=17 [slave keyboard (3)]
↳ HP WMI hotkeys id=18 [slave keyboard (3)]
↳ Telink 2.4G Mouse Consumer Control id=19 [slave keyboard (3)]
En mi compu el touchpad tiene el id 16, así que para apagarlo hay que correr xinput --disable "SynPS/2 Synaptics TouchPad" y para prenderlo xinput --enable "SynPS/2 Synaptics TouchPad"
Desde que me enteré de su existencia evito programar en go por su manejo de errores, porque te fuerza a implementar a mano el movimiento de los errores por el stack.
Hoy revisé la documentación. Es peor. En el documento que linkié en la oración anterior proponen, para evitar poner ifs por todos lados, seguir ejecutando código después de que los errores suceden. Eso es terrible, lamentable, parte de la documentación oficial del lenguaje y está incorporado en la biblioteca estándar.
Eviten go si pueden.
Estoy usando en mi notebook Lubuntu. Upgradié de 18.04 a 20.04.1 y después de hacer el upgrade y reinstalar en uno de mis guests (que también es LUbuntu 20.04) los guest additions, cuando intento loguearme en la GUI la VM se aborta. Para que esto no pase más, con la VM apagada fui a Settings -> Display -> Graphic Controller y elegí VMSVGA. Después de esto puedo loguearme y el autoresize anda bien :). La idea la saqué de este reporte de bug.
Espero que les sirva!
Etiquetas:
guest-additions,
lubuntu,
ubuntu,
virtualbox,
x11
En el último año empecé a usar VSCode para programar. Lo uso de una forma extraña, ya que me conecto por ssh a la máquina virtual donde está instalado, forwardeando X11. Aparte lo instalé usando el snap. Hoy lo quise arrancar y me dio una sorpresa fea. En vez de arrancar, solo apareció un rectángulo gris. Me di cuenta que había un problema así que reporté el bug y busqué un workarround. Al final me di cienta que era porque en VSCode upgradearon a Electron 9 y tiene un problema cuando corre con forwardeo de X11 adentro de un container.
Por suerte también hay un workarround. Corrí
export QT_X11_NO_MITSHM=1en bash antes de arrancarlo y se solucionó el problema.
Update: Si no quieren setear una variable de entorno pueden arrancar VSCode corriendo
code --no-xshmy también workarroundea el problema.
Ayer me contaron un comando muy cómodo para hacer screenshots en linux. Si corro `scrot -bs` puedo hacer un screenshot de un cacho de la pantalla, que elijo con el mouse.
Etiquetas:
linux,
screenshot,
scrot
Tengo que hacer espacio en mi compu (linux, lubuntu) y quiero ver qué ocupa lugar. Podría empezar a sufrir corriendo `df`, pero hay otra forma :). Corro `sudo ncdu /` y puedo ver qué es lo que ocupa más lugar y borrarlo de forma interactiva desde la línea de comando :). Para instalarlo, correr `sudo apt install ncdu`
Este es el procedimiento que sigo para entrar a mi casa durante la
pandemia de COVID-19. Si lo cambio voy a ir editando este post.
También pueden ver el checklist para salir de mi casa.
Este es el procedimiento que sigo para salir de mi casa durante la pandemia de COVID-19. Si lo cambio voy a ir editando este post.
También pueden ver el checklist para entrar a mi casa
Hace un rato hice un video donde uso un calculador de epidemias para tratar de ver cuáles son las posibles consecuencias del COVID-19, y porqué es tan importante cumplir con la cuarentena y las reglas de higiene (lavarse las manos, no tocarse la cara, etc). Pueden verlo acá abajo:
Etiquetas:
corona,
covid-19,
cuarentena,
epidemia,
virus
Ultimamente estoy usando leela-zero (con lizzie) para analizar partidas, y está re-bueno. El único problema es que mientras está corriendo el análisis, la compu se trula un poco porque leela-zero y la GUI compiten por la GPU. Para hacer que la GUI ande un poquito mejor, hice un script en bash que hace las veces de "nice" (ya que no hay un equivalente para las GPU de nvidia).
Les dejo el script abajo:
#!/usr/bin/env bash
while true; do
sudo kill -s STOP $(pgrep leelaz)
sleep 0.1
sudo kill -s CONT $(pgrep leelaz)
sleep 0.2
done
Cambien los tiempos de espera a gusto, y tengan en cuenta que puse sudo porque corro leelaz dentro de un container de docker (no sé si hará falta si lo corren afuera).
Éxitos, y que lleguen a dan pronto!
Estuve laburando en slowbreak, mi biblioteca para conectarse a servers de las bolsas de todo el mundo, y tiene algunas mejoras. Acá se las cuento:
Así hice que corra lizzie en Ubuntu 18.04 con una nVidia GeForge 940mx, compilando y corriendo en un container de docker para que no me ensucie el resto del sistema.
Requisitos:
Ayer hice una presentación de tito el robotito en la Asociación Argentina del juego de Go en el marco del 14o Congreso Argentino de go.
Dejo acá el video por si lo quieren ver:
En las últimas semanas estuve programando un robot que juegue al go usando la misma técnica que AlphaZero. Está escrito en python desde cero, valga la redundancia, y basado en keras y tensorflow.
Hay 2 papers en los que me estuve basando, que son el paper de Alphago Zero y el de Alpha Zero. Ahora estoy entrenándolo, tratando que llegue a jugar un poco mejor que el azar absoluto, en tablero de 9x9 y komi de 5.5. Si quieren mirar cómo está hecho, el código está acá.
La idea atrás de alphago zero es tener (y entrenar) una red neuronal que le das el estado del juego (indicado por las últimas 8 posiciones del juego, para tener en cuenta los kos y triple-kos) y te da 2 resultados: cuán buena es la posición (1 es gano seguro y -1 es pierdo seguro) y para cada jugada posible (o sea, cada intersección del goban) cuanto vale la pena explorar esa jugada para seguir analizando el partido por ahí.
Con esa información, corre un MCTS y busca la jugada que parece mejor. Por supuesto, los detalles están en el paper. En tito, la búsqueda en el árbol está implementada en el módulo tito.alpha.mcts.
Empezando por una red neuronal sin entrenar, se hace que el bot juegue contra sí mismo, después se toman algunas posiciones al azar y sabiendo cómo terminó el partido y cuáles son las posiciones que más exploró se usa esa información para entrenar la red para que la próxima vez que vea esa posición (y similares) de resultados como ese. El código donde hace el entrenamiento está en el módulo tito.alpha.train. Y la red neuronal está en tito.alpha.model.
También, por supuesto, programé las reglas del go, pueden verlo en los módulos, tito.game y tito.board.
Todo esto tiene tests automáticos. En tito.test puse los tests rápidos y en tito.test_slow los que llevan más tiempo.
Para acelerar un poquito esto estoy usando la placa de video de mi compu, así que tuve que hacer andar nvidia-docker y esas cosas. Por suerte la gente de tensorflow tiene imágenes preparadas con todo instalado :D, así que una vez que hacés andar los drivers el resto es fácil.
Por último, aprovecho para contarles que el 11 de mayo de 2019 voy a dar una charla en el Congreso Argentino de Go donde voy a hablar de cómo andan los robots basados en AlphaZero.
Acabo de publicar el tercer video tutorial de slowbreak, donde explico cómo hacer una aplicación que responde a los mensajes que envía el server (AKA: acceptor).
Update: Saqué al toque la versión 0.0.5, que incluye los ejemplos cuando corrés pip install
Acabo de publicar el segundo tutorial de slowbreak, que explica cómo hacer mensajes fix usando la biblioteca.
Acabo de terminar mi primer video-tutorial de slowbreak. Ahí muestro cómo hacemos para conectarnos a un server, usando como server el ejemplo más simple de server que se puede hacer en slowbreak.
Como prometí hace un mes y medio, saqué una nueva versión de slowbreak con soporte para python 3. Anda con python 3.5+, aparte de python 2.7 que sigue andando como siempre.
Para instalarlo solo hay que hacer pip install slowbreak. También estuve documentando un poco y ahora las principales clases y métodos tienen documentación.
Por ejemplo, en el intérprete de python, si hacemos:
>>> from slowbreak.message import Message
>>> help(Message)
Muestra toda la documentación de la clase, explicando cada método y cada parámetro de cada método.
Como siempre, pueden ver el avance del proyecto entrando en la página de bitbucket del proyecto.
Y si se hacen millonari@s con esto, compartan un poquito :D.
Me compré un celular nuevo (Blu Life One X3) y ya no me aparece el pop-up para copiar archivos a la compu. Para esquivar este problema, voy a la línea de comandos y me instalo jmtpfs.
sudo apt install jmtpfs
sudo mkdir /media/phone
sudo jmtpfs /media/phone -o allow_other
sudo umount /media/phone
Está recién salida del horno slowbreak, la biblioteca que hice para conectarse a servers fix. ¿Qué es fix? Fix es un protocolo que se usa para operar en mercados de acciones, bonos, futuros, opciones, etc.
Ya la usamos para conectarnos a los 2 mercados de la Argentina (BYMA y ROFEX). Por ahora anda solo con python 2.7 (tenemos pensado soportar python 3.x proximamente).
¿Por qué hice una biblioteca de fix cuando existe quickfix?
Hace un tiempo hice un script que uso para monitorear el servicio de mi proveedor de internet. Como últimamente estuvo andando mal, lo cambié un toque para que me muestre la cantidad de paquetes perdidos en los últimos 10, 100 y 1000 (en vez de los porcentajes).
Dejó acá el código fuente:
#!/usr/bin/env python
import subprocess
import sys
import re
SEQ_NUMBER_RE = re.compile(".*icmp_seq=(\d+) ttl.*")
def report(probes, count):
if len(probes) < count:
return "N/A"
return str ( count - sum(probes[-count:]) )
def monitor(ip):
probes = []
ping = subprocess.Popen(["ping", ip], stdout=subprocess.PIPE)
stdout = ping.stdout
stdout.readline() # Ignore first line
line_count = 0
last_seq_number = 0
while True:
line_count +=1
seq_number = int( SEQ_NUMBER_RE.match(stdout.readline()).group(1))
probes.extend([0] * (seq_number - last_seq_number - 1))
probes.append(1)
print "(%s) 10:%s 100:%s 1000:%s" % (
line_count, report(probes, 10), report(probes, 100), report(probes, 1000)
)
probes = probes[-1000:] # Keep memory usage bounded
last_seq_number = seq_number
def main(argv):
monitor(argv[1])
if __name__ == '__main__':
main(sys.argv)
Hasta la próxima,
Aureliano.
Tengo muchas más ideas de las que puedo hacer, y muchas me gustaría que las hagan otras personas. Por eso decidí poner un licenciamiento estándar de mis ideas. Si yo te doy una idea, podés hacer un negocio basándote en ella por una muy pequeña licencia. Los primeros 1e8 dólares que ganes basándote en mi idea son todos tuyos. De lo que quede, dame el 1%. Si no ganás 1e8 dólares, no me debés nada.
PD: El licenciamiento de esta idea aplica a esta idea.
Etiquetas:
ideas,
licenciamiento
Hace algunos años que tomé al go (AKA baduk, weiqi) como mi hobbie principal. El go es un juego de mesa de origen chino, de información completa, donde 2 jugador@s se enfrentan intentando rodear la mayor cantidad de territorio. Es un juego que tiene miles de años de historia.
Una de las cosas que más me llamó la atención del go es su elaborado sistema de handicap (AKA, ventaja) que hace posible jugar partidos equilibrados con jugador@s que son mucho mejores o peores que yo. Ese sistema de handicap, también permite medir decaimiento cognitivo. Por ejemplo, yo noto que necesito más ventaja después de un día de programar intensamente. Este sistema de handicap se usa para rankear jugador@s en las diferentes asociaciones de go (amateurs y profesionales) de todo el mundo. Por ejemplo, RANGO es la instanciación de este sistema en la Asociación Argentina del Juego de Go.
¿Y la neurociencia? Ya viene. Este sistema de ranking permite ver bastante claramente cosas que deberían tener una contrapartida en mecanismos cerebrales. Quizás pueda usarse para "ver" como funciona nuestro cerebro. Hay varias cosas que l@s jugador@s de go notamos y que seguramente puedan medirse. Por ejemplo:
Etiquetas:
baduk,
go,
neurociencia,
weiqi
En lubuntu 16.04, cuando aprieto F11 maximiza la aplicación que estoy usando. Eso es choto porque varios de los programas que uso habitualmente (por ejemplo, eclipse) usan F11 para otras cosas. Por lo tanto decidí deshabilitar esa función. Para eso, edité el archivo ~/.config/openbox/lubuntu-rc.xml, como dice acá
Y después corrí:
$ openbox --reconfigure
Ahora F11 anda como yo quiero :).
PD: Iba a poner los cambios del archivo en este post pero blogger me está haciendo mierda el XML :(
PD2: En lubuntu 20.04 hay que editar otro archivo (~/.config/openbox/lxqt-rc.xml)
Una de las cosas más molestas de conectarse vía ssl es toda la danza de los certificados, los DNS y las autoridades certificantes. Todo sería mucho más fácil si pudiéramos basarnos en el fingerprint del certificado del server y nos cagáramos en las autoridades certificantes, como hacemos en ssh.
En python podemos hacer eso.
Por ejemplo, para obtener el sha256 del certificado de uno de mis sitios favoritos para jugar al go podemos hacer:
>>> import ssl, socket, hashlib
>>> c = ssl.wrap_socket(socket.socket(socket.AF_INET,socket.SOCK_STREAM))
>>> c.connect(("www.dragongoserver.net",443))
>>> c.do_handshake(True)
hashlib.sha256(c.getpeercert(True)).hexdigest() # da '6cc78bca1293524be3bb0d6321d129d03fd244426c8c3e2ed69f454a14491623' que es el valor del fingerprint SHA 256 del certificado que veo si entro por el navegador al momento de escribir este post.
Con eso, podemos fijarnos si el certificado es el que esperábamos e implementar TOFU ('trust on first use') si nos pinta.
Espero que nos sirva,
Aureliano.
Como parte de mi trabajo, tengo que trabajar con drivers de Windows; en particular con minifilters. Ayer, mientras estaba tratando de entender cómo anda un minifilter volví a cruzarme con el método FltGetTunneledName mientras navegaba por el API disponible para los minifilters. Cómo no entendía qué catzo es un "tunneled name", googlié un poco y encontré ésta explicación del 2005 en un blog de Microsoft.
Originalmente en DOS, los nombres de archivos tenían hasta 8 caracteres, un punto y 3 caracteres de extensión. Cuando hicieron Windows NT decidieron que querían tener nombres de archivo más copados (parecidos a los de UNIX) y extendieron significativamente el largo posible para los nombres de archivo. El tema es que muchos programas solo sabían manejar nombres cortos. Entonces, para que sigan andando, hicieron que los archivos tuvieran un nombre largo (que es el que realmente querríamos) y uno corto para que estos programas lo usen. También agregaron otras cosas como que los archivos tienen asociada su fecha de creación (información que no estaba disponible en DOS).
El tema es que muchos programas (ej: editores de texto) para grabar un cambio en un archivo (ej: toto.doc) y tener backup de la versión anterior lo que hacen es renombrar el archivo a otro nombre (ej: toto.bak) y después escriben otro archivo con el nombre original. Y hay un problema; si operás solo con los nombres cortos y hacés eso se pierde el nombre largo. Entonces en MS tuvieron la idea de tener un cache de asociaciones de nombres cortos y largos y si creás de nuevo un archivo con un nombre corto que ya usaste le asocia el nombre largo correspondiente (y también su fecha de creación).
Desde el punto de vista del usuario del sistema es fabuloso, ya que un montón de programas que andarían sutilmente mal gracias a este parche andan bien. Pero cuando estás escribiendo drivers de filesystem en el kernel y tenés que lidiar con la complejidad adicional que esto implica, es horripilante.
PD: Acá agrego un artículo que explica con bastante detalle el quilombo agregado por esto a los minifilters.
Etiquetas:
DOS,
kernel,
minifilter,
tunnelling,
windows
Hace un tiempito que estoy subiendo a youtube videos donde juego al go. Hay mucha gente que juega al go mejor que yo y hace videos, así que terminé haciendo personajes mientras juego. Hay varios, algunos son imitaciones de otros youtubers, y otros no.
La gente que hace contenido en forma más o menos recurrente está haciendo cuentas en Patreon para que le paguen. Yo estoy pensando en hacer lo mismo. Y estoy pensando en qué opciones podría poner. Se me ocurren estas:
En la consola de Windows (cmd.exe), si apretás F7 aparece la historia de los comandos de la consola en un hermoso menú, hecho por daltónic@s, que podés manejar con las flechitas (y elegir el comando que quieras). Enter para ejecutarlo, flecha a la derecha para que aparezca escrito en el prompt (sin ejecutar).
Cuando instalo Ubuntu en una PC nueva, suelo copiar el ISO en un pendrive, haciendo dd. El pendrive tiene que estar enchufado y desmontado, y no queda nada de lo que había grabado antes.
# dd if=/path/to/file.iso of=/dev/sdb bs=4M
Esto no me anduvo para las ISOs de Windows :(. Así que estuve googleando un rato largo hasta que encontré acá instrucciones que logré hacer andar.
Lo que yo hice, basado en lo que linkié arriba es:
/dev/sdb (YMMV). El resto de las instrucciones asumen que el pendrive está ahí. sudo cfdisk /dev/sdb y creé adentro una partición NTFS (tipo 7) y la marqué como booteable, asegurándome que tenga suficiente lugar para copiar todo el contenido del ISO de Windows 7.sudo mkfs.ntfs -f /dev/sdb.apt-get) y corrí sudo lilo -M /dev/sdb mbr para copiarle un boot record./mnt las carpetas /mnt/iso y /mnt/usb sudo mount -o loop win7.iso /mnt/iso.sudo mount /dev/sdb1 /mnt/usb.cp -R debería andar también).sudo umount /mnt/iso) y pendrive (sudo umount /mnt/usb)sudo sync para sincronizar los filesystems (creo que no hace falta, pero lo hice igual por las dudas)sudo dd if=/dev/sdb of=/path/to/image/file.img bs=4M.Hasta hace 5 minutos sandro sólo andaba si el WAR que deployás lo deployás en el contexto ROOT. Ahora ya no es más así. A partir de ahora es posible correr sandro con toda su magia para compartir código entre cliente y server desde cualquier contexto. Eso permite que haya más de una aplicación de sandro en el mismo Tomcat.
Enjoy!
Etiquetas:
javascript,
sandro,
servlet,
war
Hace unos meses Google pateó el goban y mostró que sus computadoras juegan al go mejor que cualquier ser humano. Encima, ¡parece que entrenaron a Alpha Go un poco más y ahora es 4 piedras más fuerte que antes!
O sea, el go dejó de ser algo que nosotr@s hacemos mejor. Pero eso tiene ventajas. Una de las cosas más raras del go es el komi. A diferencia del resto del go, que tiene más de 2000 años, sólo se usa regularmente hace menos de 100 años. El es la ventaja, en puntos, que le da el jugador negro al blanco porque el negro hace la primera jugada. La idea es que esa compensación hace que el partido sea más parejo. Cuando empezaron a usar komi en los torneos profesionales, usaron 4.5 puntos (.5 para evitar empates) y subió a 5.5 y después s 6.5 en Japón y Corea y a 7.5 en China. Pero no sabemos que valor tiene que tener. Y mirar las diferencias de puntos en los partidos de profesionales no sirve porque cambian de estrategia cuando van ganando (y sí, cuentan los puntos en el medio del partido).
Por eso, quiero pedirle a la gente que trabaja en AlphaGo que entrene a AlphaGo con distintos valores de komi y nos cuente, para cada posible valor del komi que porcentaje de las partidas las gana negro en un partido de AlphaGo contra sí mismo. Así podemos elegir el valor de komi que genera menos ventaja.
Si trabajás en DeepMind o conocés a alguien que trabaje ahí, o conocés a alguien que trabaje en Google, o podés contactar a la federación internacional de go, o se te ocurre algún otro camino, por favor pediles que calculen cuál es el mejor komi.
Muchas gracias,
Aureliano.
Como parte de mi laburo necesito probar cosas que son exportadas en dlls. Como hacer un programa en C/C++ para probar cada boludez es una patada en los huevos, estoy usando ctypes y scripteando un toque en la consola de python para hacer eso. Y como mi memoria a veces falla, uso este tutorial para que me recuerde cómo hacerlo.
Quizás les sirva a ustedes también,
Aureliano.
En mi laburo necesitan que programe en C++ nuevamente, así que hace unos días estoy mirando y recordando C++. ¡Qué incómodo que es!
Default constructors, copy constructors, asignment operators, que encima en su versión generada por default andan mal. Métodos virtuales, ¿por qué hay otra opción, y encima no es el default? ¿Herencia virtual? ¿Functors o function pointers? ¿Punteros comunes, shared pointers, referencias? ¿Cómo obtengo el shared_pointer de this? ¿Y si hay herencia? ¿Templates? Encima los templates son simultáneamente complicadísimos y sumamente limitados. Por ejemplo, ¿cómo hacés un template que cambie el nombre de los métodos generados en función de algún parámetro? Creo que no se puede (si sabés cómo hacerlo sin usar #define decime). Escribir todo varias veces, forward declarations, declaraciones en el .h e implementaciones, con la signatura repetida, en el .cpp.
Y ni hablar de los quilombos asociados, sobre todo en Windows, que no son del lenguaje, pero que te complican la vida. Cambiás de compilador y linkea mal y, en el caso de Visual Studio también genera binarios incompatibles según el runtime que elegís. De regalo el Visual Studio que estoy usando no se da cuenta cuándo recompilar y genera mierda desactualizada.
Pero eso no es lo peor de C++. Para mi lo peor de C++ es que no te deja pensar. Tenés que esquivar tanta complejidad accidental que el código fuente no reflejo de las ideas subyacentes. Eso nos devalúa como programadores.
Etiquetas:
c++,
rant,
Visual Studio,
windows
En mi post anterior puse un scriptcito en python para monitorear una conexión con ping. Después de eso lo mejoré un toquecito, y ahora toma los últimos 10, 100 y 1000 probes y calcula el porcentaje que tienen respuesta. La ejecución se ve así:
$ pingmon.py 8.8.8.8
(1) 10:N/A 100:N/A 1000:N/A
(2) 10:N/A 100:N/A 1000:N/A
(3) 10:N/A 100:N/A 1000:N/A
(4) 10:N/A 100:N/A 1000:N/A
(5) 10:N/A 100:N/A 1000:N/A
(6) 10:N/A 100:N/A 1000:N/A
(7) 10:N/A 100:N/A 1000:N/A
(8) 10:N/A 100:N/A 1000:N/A
(9) 10:N/A 100:N/A 1000:N/A
(10) 10:N/A 100:N/A 1000:N/A
(11) 10:100.00% 100:N/A 1000:N/A
(12) 10:100.00% 100:N/A 1000:N/A
(13) 10:100.00% 100:N/A 1000:N/A
Y el código del script creció un poquito, pero sigue entrando en un post.
#!/usr/bin/env python
import subprocess
import sys
import re
SEQ_NUMBER_RE = re.compile(".*icmp_seq=(\d+) ttl.*")
def pct_str(probes, count):
if len(probes) < (count + 1):
return "N/A"
return "%.2f%%" % ( 100 * sum(probes[-count-1:-1]) / count )
def monitor(ip):
probes = []
ping = subprocess.Popen(["ping", ip], stdout=subprocess.PIPE)
stdout = ping.stdout
stdout.readline() # Ignore first line
line_count = 0
last_seq_number = 0
while True:
line_count +=1
seq_number = int( SEQ_NUMBER_RE.match(stdout.readline()).group(1))
probes.extend([0] * (seq_number - last_seq_number - 1))
probes.append(1)
print "(%s) 10:%s 100:%s 1000:%s" % (
line_count, pct_str(probes, 10), pct_str(probes, 100), pct_str(probes, 1000)
)
probes = probes[-1000:] # Keep memory usage bounded
last_seq_number = seq_number
def main(argv):
monitor(argv[1])
Siéntase a gusto de hackear este script si quieren algún monitoreo distinto (cambiar la salida y/o la forma de monitorear).
Espero que les sea útil,
Aureliano.
A veces mi proveedor de internet anda mal. Una de las cosas que pasan es que empieza a dropear muchos paquetes y, para ver eso, hago un ping. El problema es que el ping no te dice el porcentaje de los paquetes que se cayeron :/. Por lo tanto hice un script en python, al que llamé pingmon.py, que wrappea ping y da esa información en cada vuelta exitosa de un paquete.
La salida se ve así:
$ pingmon.py 8.8.8.8
Packets returned: 1 Packet count: 1 Return percentage: 100.00 %
Packets returned: 2 Packet count: 4 Return percentage: 50.00 %
Packets returned: 3 Packet count: 5 Return percentage: 60.00 %
Packets returned: 4 Packet count: 7 Return percentage: 57.14 %
Packets returned: 5 Packet count: 8 Return percentage: 62.50 %
Packets returned: 6 Packet count: 11 Return percentage: 54.55 %
Y el código del script es éste:
import subprocess
import sys
import re
SEQ_NUMBER_RE = re.compile(".*icmp_seq=(\d+) ttl.*")
def monitor(ip):
ping = subprocess.Popen(["ping", ip], stdout=subprocess.PIPE)
stdout = ping.stdout
stdout.readline() # Ignore first line
line_count = 0
while True:
line_count +=1
seq_number = int( SEQ_NUMBER_RE.match(stdout.readline()).group(1))
print "Packets returned: %d Packet count: %d Return percentage: %.2f %%" % (line_count, seq_number, (100.0 * line_count)/seq_number )
def main(argv):
monitor(argv[1])
Espero que les sirva,
Aureliano.
Por cuestiones laborales, tengo que hacer andar un modem 3G en Linux. Después de bucear por mercado libre, encontré un ZTE MF 110, al que le puse un chip de datos de Claro. Usándolo desde una VM con Windows 7 en VirtualBox y haciendo pass-through para que maneje el pituto usb, anduvo joya. Pero en Linux, andaba intermitentemente. Estuve googleando y descubrí que muchos MODEMs 3G andan en 2 modos. Un modo que es una unidad de mass-storage, donde tiene drivers y manuales para Windows, y otro que es el modem en sí. Y linux, en teoría, cambia de modo automáticamente con el usb_modeswitch. Bueno, cuestión que en lubuntu 14.04 está roto ese cambio, porque falla el montado de la unidad de mass-storage y aborta el proceso. Si corren
$ dmesg | tail -n 15
después de enchufar el modem van a ver una línea como esta mostrando el error.
[ 8905.896992] systemd-udevd[6462]: Failed to apply ACL on /dev/sr0: No such file or directory
Parece que udev y este modem no se llevan bien. Si miramos usando lsusb se ve que está en modo mass-storage:
$ lsusb | grep -i zte
Bus 003 Device 037: ID 19d2:2000 ZTE WCDMA Technologies MSM MF627/MF628/MF628+/MF636+ HSDPA/HSUPA
Seguí googleando y encontré cómo hacer el switch del modo manualmente en este post. Entonces ejecuté:
$ sudo usb_modeswitch -v 19d2 -p 0x2000 -K
[sudo] password for aure:
Look for default devices ...
product ID matched
Found devices in default mode (1)
Access device 035 on bus 003
Current configuration number is 1
Use interface number 0
Use endpoints 0x01 (out) and 0x81 (in)
USB description data (for identification)
-------------------------
Manufacturer: ZTE,Incorporated
Product: ZTE Configuration
Serial No.: A SERIAL NUMBER
-------------------------
Sending standard EJECT sequence
Looking for active driver ...
OK, driver detached
Set up interface 0
Use endpoint 0x01 for message sending ...
Trying to send message 1 to endpoint 0x01 ...
OK, message successfully sent
Read the response to message 1 (CSW) ...
Response reading failed (error -7)
Device is gone, skip any further commands
-> Run lsusb to note any changes. Bye!
Uso lsusb de nuevo y ahora cambió el device.
$ lsusb | grep -i zte
Bus 003 Device 038: ID 19d2:0031 ZTE WCDMA Technologies MSM MF110/MF627/MF636
Mirando en dmesg aparece un cartel que dice que lo reconoció como modem:
[ 9919.553348] usb 3-3: GSM modem (1-port) converter now attached to ttyUSB2
Y después apareció la opción de activar "Mobile broadband" en el iconito de red :D
Happy hacking,
Aureliano.
Hice 2 arreglos en sandro.
Etiquetas:
d3,
d3js,
java,
javascript,
sandro
Hace un tiempito que estoy jugando con el API de blogger para hacer posts automaticamente. Lo que me parece más complicado es autenticarse vía oauth2 desde una aplicación de línea de comando. Por eso hice un módulo de sandro que lo hace por mi, pidiendo el código de autorización solo cuando es necesario
Se puede usar como módulo de sandro así:
define({
accessToken: './accessToken'
},
function(m) {
var accessToken = m.accessToken(
'refresh_token_fname.txt',
{
clientId: 'CLIENT ID HERE',
clientSecret: 'CLIENT SECRET HERE'
}
)
// Use accessToken here!
})
Abajo les dejo accessToken.js completo (cuidado, son 134 líneas de código):
define({
javaPackages: "javaPackages",
ary: "sandro/nadaMas/array",
json: "sandro/nadaMas/json",
object: "sandro/nadaMas/object"
}, function(m) {
var URL = m.javaPackages.java.net.URL
var String = m.javaPackages.java.lang.String
var URLEncoder = m.javaPackages.java.net.URLEncoder
var StandardCharsets = m.javaPackages.java.nio.charset.StandardCharsets
var InputStreamReader = m.javaPackages.java.io.InputStreamReader
var BufferedReader = m.javaPackages.java.io.BufferedReader
var Scanner = m.javaPackages.java.util.Scanner
var System = m.javaPackages.java.lang.System
var File = java.io.File
var FileOutputStream = java.io.FileOutputStream
var OutputStreamWriter = java.io.OutputStreamWriter
var out = System.out
var in_ = new Scanner(System["in"])
var paramBytes = function(p) {
var s = new String( Object.keys(p).map(function(k) {
return "" + URLEncoder.encode(k, "UTF-8") + "=" + URLEncoder.encode(p[k])
}).join("&") )
return s.getBytes(StandardCharsets.UTF_8)
}
var postJsonResult = function(url, params) {
var parameters = paramBytes(params)
var c = new URL(url).openConnection()
try {
c.requestMethod = "POST"
c.doOutput = true
c.fixedLengthStreamingMode = parameters.length
c.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
c.connect()
c.outputStream.write(parameters)
if (200 != c.responseCode) {
return null
}
var response = ""
var reader = new BufferedReader( new InputStreamReader( c.inputStream ) )
while( true ) {
var buff = reader.readLine()
if (buff == null) {
break
}
response += buff
}
return m.json.parse( "" + response )
} finally {
c.disconnect()
}
}
var authCode2refreshToken = function(authCode, credentials) {
var rv = postJsonResult(
"https://www.googleapis.com/oauth2/v4/token", {
code: authCode,
redirect_uri: "urn:ietf:wg:oauth:2.0:oob",
client_id: credentials.clientId,
client_secret: credentials.clientSecret,
grant_type: "authorization_code"
}
)
return rv ? rv["refresh_token"] : null
}
var refreshAccessToken = function(refreshToken, credentials) {
var rv = postJsonResult(
"https://www.googleapis.com/oauth2/v4/token", {
refresh_token: refreshToken,
client_id: credentials.clientId,
client_secret: credentials.clientSecret,
grant_type: "refresh_token"
}
)
return rv ? rv["access_token"] : null
}
var readFileLine = function(fname) {
var sc = new Scanner(new File(fname))
try {
return sc.nextLine()
} finally {
sc.close()
}
}
var writeFileLine = function(fname, line) {
try {
var w = new OutputStreamWriter( new FileOutputStream(fname) )
line = "" + line
w.write(line, 0, line.length)
} finally {
w.close()
}
}
var obtainAccessToken = function(refreshTokenFname, credentials) {
var accessToken = null
var refreshToken = null
try {
refreshToken = readFileLine(refreshTokenFname)
} catch (e) {
// ignore
}
while (true) {
if (refreshToken) {
accessToken = refreshAccessToken(refreshToken, credentials)
}
if (accessToken) {
return accessToken
}
var authorizationUrl =
"https://accounts.google.com/o/oauth2/auth?scope=https://www.googleapis.com/auth/blogger&redirect_uri=urn:ietf:wg:oauth:2.0:oob&response_type=code&client_id=" +
credentials.clientId
out.println("Anda a este URL, completa la autorizacion y pega el codigo de autorizacion aca. Despues presiona ENTER")
out.println(authorizationUrl)
var authCode = in_.nextLine()
refreshToken = authCode2refreshToken(authCode, credentials)
writeFileLine(refreshTokenFname, refreshToken)
}
}
return obtainAccessToken
})
Si quieren, es bastante fácil transliterarlo a código Java.
Espero que les sirva,
Aureliano.
Sigo en mi cruzada para hacer cosas automáticamente en blogger usando sandro. En este caso, hice el código para obtener un access token a partir de un authorization code. Para eso, primero necesitás registrar una aplicación de línea de comando. Una vez que lo hayas hecho, vas a tener el client id y el client secret. Pero eso no alcanza, para obtener el access token, como el que usamos en el post anterior, hace falta un authorization code. Para obtenerlo, conectate a este URL:
https://accounts.google.com/o/oauth2/auth?scope=https://www.googleapis.com/auth/blogger&redirect_uri=urn:ietf:wg:oauth:2.0:oob&response_type=code&client_id=ACA_VA_TU_CLIENT_ID
Y te va a mostrar el authorization code después de loguearte a google y autorizar a tu aplicación a hacer cosas de blogger en tu nombre.
Una vez que obtuviste tu authorization code, hay que obtener un access token. El access token te sirve para manipular blogger con tu usuario por la próxima hora. Para renovarlo, hay que usar un refresh token, que también obtendremos, pero voy a mostrar cómo usarlo en otro post.
Acá abajo dejo el código de ejemplo para obtener estos tokens.
define({
javaPackages: "javaPackages",
ary: "sandro/nadaMas/array",
json: "sandro/nadaMas/json",
object: "sandro/nadaMas/object"
}, function(m) {
var URL = m.javaPackages.java.net.URL
var out = m.javaPackages.java.lang.System.out
var String = m.javaPackages.java.lang.String
var URLEncoder = m.javaPackages.java.net.URLEncoder
var StandardCharsets = m.javaPackages.java.nio.charset.StandardCharsets
var InputStreamReader = m.javaPackages.java.io.InputStreamReader
var BufferedReader = m.javaPackages.java.io.BufferedReader
var tokenUrl = new URL("https://www.googleapis.com/oauth2/v3/token")
var paramBytes = function(p) {
var s = Object.keys(p).map(function(k) {
return "" + URLEncoder.encode(k, "UTF-8") + "=" + URLEncoder.encode(p[k])
}).join("&")
out.println(s)
s = new String(s)
return s.getBytes(StandardCharsets.UTF_8)
}
return function(code, client_id, client_secret) {
var parameters = paramBytes({
code: code,
redirect_uri: "urn:ietf:wg:oauth:2.0:oob",
client_id: client_id,
client_secret: client_secret,
grant_type: "authorization_code"
})
var c = tokenUrl.openConnection()
c.requestMethod = "POST"
c.doOutput = true
c.fixedLengthStreamingMode = parameters.length
c.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
c.connect()
c.outputStream.write(parameters)
var response = ""
var reader = new BufferedReader( new InputStreamReader( c.inputStream ) )
while( true ) {
var buff = reader.readLine()
if (buff == null) {
break
}
response += buff
}
var jsonResponse = m.json.parse( "" + response )
out.println("Tokens: " + m.json.stringify(jsonResponse))
}
})
No uso la google-client-api de java porque es un quilombo y no entendí cómo usarla, así que me conecto a los webservices de google directamente.
Etiquetas:
blogger,
google client api,
java,
javascript,
oauth2,
sandro