Come aggiornare automaticamente l'editor Atom?

L'aggiornamento automatico della funzione Atom non è ancora supportato per Ubuntu. Dal loro repository GitHub:

Attualmente è disponibile solo una versione a 64 bit.

Scarica atom-amd64.deb dalla pagina delle versioni di Atom. Esegui sudo dpkg --install atom-amd64.deb sul pacchetto scaricato. Avviare Atom utilizzando il comando atom installato. Al momento la versione di Linux non si aggiorna automaticamente, quindi dovrai ripetere questi passaggi per passare alle versioni future.

Ho provato a utilizzare Webupd8 PPA ma non funziona per me.

TL; DR Se non si desidera utilizzare il PPA , è possibile utilizzare uno script per scaricare e installare automaticamente tramite cron.

1. Crea un nuovo file atom-auto-update

   sudo nano /usr/local/bin/atom-auto-update
   

2. Aggiungi le seguenti righe

   #!/bin/bash
   wget -q https://github.com/atom/atom/releases/latest -O /tmp/latest
   wget -q $(awk -F '[<>]' '/href=".*atom-amd64.deb/ {match($0,"href=\"(.*.deb)\"",a); print "https://github.com/" a[1]} ' /tmp/latest) -O /tmp/atom-amd64.deb
   dpkg -i /tmp/atom-amd64.deb
   

3. Salvare il file e renderlo eseguibile

   sudo chmod +x /usr/local/bin/atom-auto-update
   

4. Prova lo script

   sudo atom-auto-update
   

5. Crea un cronjob per lo script

   sudo crontab -e
   

6. Aggiungi questa linea

   es: alle 10 ogni settimana

   0 10 * * 1 /usr/local/bin/atom-auto-update
   

   ad es .: alle 10 ogni giorno

   0 10 * * * /usr/local/bin/atom-auto-update      
   

Spiegazione

• wget -q https://github.com/atom/atom/releases/latest -O /tmp/latest

  Scarica il sito con le informazioni sulla versione più recente

• wget -q $(awk -F '[<>]' '/href=".*atom-amd64.deb/ {match($0,"href=\"(.*.deb)\"",a); print "https://github.com/" a[1]} ' /tmp/latest) -O /tmp/atom-amd64.deb

  1. … awk -F '[<>]' '/href=".*atom-amd64.deb/ {match($0,"href=\"(.*.deb)\"",a); print "https://github.com/" a[1]} ' /tmp/latest …

     Estrai il link per il download

  2. wget -q $( … ) -O /tmp/atom-amd64.deb

     Scarica il file DEB

• dpkg -i /tmp/atom-amd64.deb

  Installa il file DEB

La risposta di AB è una bella soluzione! Ho aggiunto l'opzione Mostra barra di avanzamento nel codice bash per notificare l'avanzamento: 

#!/bin/bash
wget -q https://github.com/atom/atom/releases/latest -O /tmp/latest
wget --progress=bar -q 'https://github.com'$(cat /tmp/latest | grep -o -E 'href="([^"#]+)atom-amd64.deb"' | cut -d'"' -f2 | sort | uniq) -O /tmp/atom-amd64.deb -q --show-progress
dpkg -i /tmp/atom-amd64.deb

Come risposta precedente con modifiche minori, per consentire l'aggiornamento all'avvio, ecco la procedura

1. Crea il file eseguendo il comando:

   sudo nano /usr/local/bin/atom-update  
   

quindi digitare lo script seguente (utilizzare l'editor di testo come "gedit" o "mousepad" invece di "nano" è più conveniente) e quindi salvarlo.

#!/bin/bash    
wget -q https://github.com/atom/atom/releases/latest -O /tmp/latest
MATCHEDROW=$(awk -F '[<>]' '/href=".*atom-amd64.deb/' /tmp/latest)
LATEST=$(echo $MATCHEDROW | grep -o -P '(?<=href=").*(?=" rel)')
VER_LATEST=$(echo $MATCHEDROW | rev | cut -d"/" -f 2 | rev | sed 's/v//g')
VER_INST=$(dpkg -l atom | tail -n1 | tr -s ' ' | cut -d" " -f 3)

if [ "$VER_LATEST" != "$VER_INST" ]; then
   wget --progress=bar -q "https://github.com/$LATEST" -O /tmp/atom-amd64.deb --show-progress
   dpkg -i /tmp/atom-amd64.deb
   echo "Atom has been update from $VER_LATEST to $VER_INST"
   logger -t atom-update "Atom has been update from $VER_INST to $VER_LATEST"
else
   echo "Atom version $VER_INST is the latest version, no update require"
   logger -t atom-update "Atom version $VER_INST is the latest version, no update require"
fi

2. Per rendere eseguibile il file:

   sudo chmod +x /usr/local/bin/atom-update
   

3. Ora puoi aggiornare manualmente Atom digitando il comando:

   sudo atom-update
   

4. Accedi al tuo root, quindi aggiungi la riga seguente a /etc/rc.local ( sudo nano /etc/rc.local) appena prima del exit 0comando:

   /usr/local/bin/atom-update  
   

Ciò consentirà l'esecuzione dello script di aggiornamento atom ogni volta che si accende il PC.

5. Per verificare che lo script sia stato eseguito correttamente all'avvio, riavvia il PC e apri il terminale quindi digita:

   cat /var/log/syslog | grep 'atom.*'  
   

Vedrai il messaggio di registro di conseguenza.

Sulla base della risposta di AB , ho aggiunto il controllo della versione per evitare download / installazione non necessari:

#!/bin/bash

TMP_DIR=$(mktemp -d)

TMP_LATEST="${TMP_DIR}/latest"
TMP_FILE="${TMP_DIR}/atom-amd64.deb"

wget -q https://github.com/atom/atom/releases/latest -O ${TMP_LATEST}
LATEST=$(awk -F '[<>]' '/href=".*atom-amd64.deb/ {match($0,"href=\"(.*.deb)\"",a); print "https://github.com/" a[1]} ' ${TMP_LATEST})
VER_LATEST=$(echo $LATEST | rev | cut -d"/" -f 2 | rev | sed 's/v//g')

VER_INST=$(dpkg -l atom | tail -n1 | tr -s ' ' | cut -d" " -f 3)

if [ "$VER_LATEST" != "$VER_INST" ]; then
  wget -q $LATEST -O $TMP_FILE
  VER_DOWN=$(dpkg-deb -f $TMP_FILE Version)
  if [ "$VER_DOWN" != "$VER_INST" ]; then
    dpkg -i $TMP_FILE
  fi
fi

rm -rf "${TMP_DIR}"

Modifica: dovrei chiarire che ciò sostituirà il contenuto dello script / usr / local / bin / atom-auto-update che cita la risposta di AB. Gli altri passaggi della risposta sono gli stessi.

Bene, un'altra versione più elegante con supporto del ramo beta, se lo script è stato lanciato con argomento beta: $ update-atom beta

#!/bin/bash
DLPATH="https://atom.io/download/deb"
DLDEST="$HOME/Downloads/atom-amd64.deb"

if ! [ -z "$1" ] && [ $1=="beta" ];  then
  echo "Updating beta"
  DLPATH="$DLPATH?channel=beta"
  DLDEST="$HOME/Downloads/atom-amd64-beta.deb"
else
  echo "Updating stable"
fi

rm -f $DLDEST
wget -O $DLDEST $DLPATH 
sudo dpkg -i $DLDEST

L'installazione di Atom tramite uno snap ti garantirà sempre la versione più recente:

sudo snap install atom --classic

Ho scritto uno script Python che può essere utilizzato per aggiornare il pacchetto DEB a 64 bit da GitHub. È possibile salvare il seguente contenuto come update-atom, ad esempio in /etc/cron.hourlyo /etc/cron.daily:

#!/usr/bin/env python

import os
import requests


def msg(text):
    """Give message to user."""
    os.system('notify-send "Atom updater" "{}"'.format(text))


def current():
    """Get current version."""
    f = os.popen("apt show atom 2>/dev/null | grep Ver")
    return f.read().split(' ')[1].strip()


def latest():
    """Get latest version."""
    upd_url = 'https://github.com/atom/atom/releases/latest'
    final = requests.get(upd_url).url
    return final.split('tag/v')[1]


def compare(cv, lv):
    """Compare versions."""
    return lv.split('.') > cv.split('.')


def upgrade(version):
    """Perform upgrade."""
    tempfile = '/tmp/atom.deb'
    url = (
        'https://github.com/atom/atom/releases/download/'
        'v{}/atom-amd64.deb'.format(version)
    )
    code = os.system(
        'rm -f {} && '
        'wget "{}" -O {} && '
        'dpkg -i {}'.format(tempfile, url, tempfile, tempfile)
    )
    return code == 0

if __name__ == '__main__':
    cv = current()
    try:
        lv = latest()
    except requests.exceptions.ConnectionError:
        print 'No network'
        exit(0)
    print 'Current version', cv
    print 'Latest version', lv
    result = compare(cv, lv)
    if result:
        print 'A new version is available!'
        msg('Updating Atom to version {}...'.format(lv))
        if upgrade(lv):
            msg('Update completed.')
        else:
            msg('Problem during update.')
    else:
        print 'Atom is updated.'

Per un approccio meno specifico di Ubuntu, ho scritto un piccolo pacchetto atom che verifica la presenza di nuove versioni all'avvio (oppure è possibile controllare manualmente con un comodo comando all'interno di Atom).

È indipendente dalla piattaforma (quindi funziona su qualsiasi distribuzione Linux, Windows, ecc ...).

Puoi configurare alcune cose come monitorare solo il canale stabile o anche la beta, avere notifiche, che tipo e se dovrebbero essere liquidabili, ecc ...).

Lo fa non (almeno per ora!) Aggiornare automaticamente il pacchetto. Potrei aggiungere quella funzione in futuro se c'è abbastanza interesse in essa.

Feedback di benvenuto, migliore come biglietto su github.

Se stai costruendo da fonti, lo faccio tramite un piccolo script:

cd "/home/YOUR_USER/gitmisc/atom/"
git pull
cd script/
sudo ./build --install                   

6 maggio 2016

Andy Richardson ha creato atom-updater-linux . È un pacchetto atom, puoi averlo sul tuo atom eseguendo:

apm install atom-updater-linux

consultare il repository per ulteriori informazioni

Un paio di modifiche allo script Python di Andrea Lazzarotto per rimuovere la dipendenza da notifica-invio che altre varianti di Ubuntu non hanno per impostazione predefinita e gestire il caso in cui non è già installata una copia di Atom. Inoltre, va notato che ci sono anche altre dipendenze che ti serviranno:

sudo apt-get install python-request git gvfs-bin

Ho anche dovuto eseguire quanto segue per ottenere alcune altre dipendenze secondarie ...

sudo apt-get -f install

#!/usr/bin/env python
import os
import requests

def msg(text):
  """Give message to user."""
  os.system('notify-send "Atom updater" "{}"'.format(text)
  + ' 2>/dev/null '
  +'|| echo "{}"'.format(text))

def current():
    """Get current version."""
    f = os.popen("apt show atom 2>/dev/null | grep Ver")
    result = f.read()
    if result:
      return result.split(' ')[1].strip()
    return "0.0"

def latest():
    """Get latest version."""
    upd_url = 'https://github.com/atom/atom/releases/latest'
    final = requests.get(upd_url).url
    return final.split('tag/v')[1]

def compare(cv, lv):
    """Compare versions."""
    return lv.split('.') > cv.split('.')

def upgrade(version):
    """Perform upgrade."""
    tempfile = '/tmp/atom.deb'
    url = (
        'https://github.com/atom/atom/releases/download/'
        'v{}/atom-amd64.deb'.format(version)
    )
    code = os.system(
        'rm -f {} && '
        'wget "{}" -O {} && '
        'dpkg -i {}'.format(tempfile, url, tempfile, tempfile)
    )
    return code == 0

if __name__ == '__main__':
    cv = current()
    try:
        lv = latest()
    except requests.exceptions.ConnectionError:
        print 'No network'
        exit(0)
    print 'Current version', cv
    print 'Latest version', lv
    result = compare(cv, lv)
    if result:
        print 'A new version is available!'
        msg('Updating Atom to version {}...'.format(lv))
        if upgrade(lv):
            msg('Update completed.')
        else:
            msg('Problem during update.')
    else:
        msg('Atom is updated.')

Ancora un altro Pythonscript personalizzato ( ) per aiutare ad aggiornare Atom: https://gist.github.com/DusanMadar/8f094ef647a0ad54cff1