Avvio rapido in Python (v2)

aggiornato

Panoramica

La libreria Open Source di riferimento di ricloud è implementata in Python e ospitata su GitHub.

L'implementazione è in bundle con la documentazione e uno script di esempio che mostra come può essere utilizzato. La configurazione è limitata alla ~/.ricloud.ini file di configurazione ~/.ricloud.ini con la specifica di un token per l'autenticazione rispetto all'API e un valore dell'endpoint del flusso per raccogliere i risultati dell'azione di servizio.

L'origine e la documentazione di questa libreria sono disponibili su GitHub .

Requisiti

La libreria ricloud ha pochissime esigenze in base alla progettazione. Dovrebbe funzionare sulla maggior parte dei sistemi con Python 2.7 . Per utilizzare la modalità listener è necessario un ulteriore requisito per MySQL 5.7 o successivo. Vedere l' utilizzo del client di esempio in produzione per le prospettive sull'utilizzo della libreria Open Source in produzione.

Installazione

La libreria ricloud può essere installata con un singolo comando:

$ pip install ricloud

Per utilizzare la modalità listener con il dumping automatico dei dati su MySQL, lo script di configurazione dello schema deve essere applicato a un database locale. Questo può essere usato per creare lo schema e le tabelle richieste nel database:

$ mysql -u root < sql/create_schema.sql

Configurazione

L'API si basa su un insieme di credenziali di sicurezza, che sono memorizzate in un file ricloud.ini . Questo pacchetto viene fornito con un file di configurazione predefinito che consente un accesso limitato all'API a scopo dimostrativo.

Le credenziali predefinite possono essere sovrascritte creando un file di sostituzione denominato .ricloud.ini nella directory HOME dell'utente. In alternativa, è possibile impostare una variabile di ambiente RICLOUD_CONF , specificando il percorso completo e il nome file del file di configurazione.

[mysql]
# Database config is only needed for listen mode.
host = 127.0.0.1
port = 3306
database = ricloud
username = your-ricloud-mysql-user-here
password = your-ricloud-mysql-password-here

[hosts]
api_host = https://asapi.reincubate.com
asmaster_host = https://asmaster.reincubate.com
stream_host = https://aschannel.reincubate.com

[endpoints]
account_information = /account/
register_account = /register-account/
task_status = /task-status/
result_consumed = /results-consumed/

[asmaster_endpoints]
list_services = /list-services/
list_subscriptions = /list-subscriptions/
subscribe_account = /subscribe-account/
perform_2fa_challenge = /perform-2fa-challenge/
submit_2fa_challenge = /submit-2fa-challenge/
list_devices = /list-devices/
subscribe_device = /subscribe-device/
resubscribe_account = /resubscribe-account/
unsubscribe_device = /unsubscribe-device/
unsubscribe_account = /unsubscribe-account/

[stream]
# This value provided by Reincubate.
stream_endpoint = your-aschannel-stream-name-here

[auth]
# This value provided by Reincubate.
token = your-ricloud-api-access-token-here

[output]
output_directory = output

[logging]
logs_directory = logs
time_profile = False
level = WARNING

[performance]
object_store_greenlets = 50

Il file predefinito ricloud.ini può essere trovato in questo repository .

Parametri della riga di comando

La libreria fornisce una ripartizione degli argomenti della riga di comando se ha passato l'argomento --help :

$ python -m ricloud --help
ricloud API Client.

Usage, interactive mode:
    ricloud <account> [--password=<password>] [--timeout=<timeout>]

Options, interactive mode:
    -h --help               Show this screen.
    --timeout=<timeout>     How long should we wait for tasks to complete, in seconds. (default: 600s or 10 minutes)
    --password=<password>   The password for this account.

Usage, manager mode:
    ricloud --list-subscriptions <service> [--timeout=<timeout>]
    ricloud --subscribe-account <username> <password> <service> [--timeout=<timeout>]
    ricloud --perform-2fa-challenge <account_id> <device_id> [--timeout=<timeout>]
    ricloud --submit-2fa-challenge <account_id> <code> [--timeout=<timeout>]
    ricloud --resubscribe-account <account_id> <password> [--timeout=<timeout>]
    ricloud --unsubscribe-account <account_id> [--timeout=<timeout>]
    ricloud --list-devices <account_id> [--timeout=<timeout>]
    ricloud --subscribe-device <account_id> <device_id> [--timeout=<timeout>]
    ricloud --unsubscribe-device <account_id> <device_id> [--timeout=<timeout>]

Options, manager mode:
    -h --help               Show this screen.
    --timeout=<timeout>     How long should we wait for tasks to complete, in seconds. (default: 600s or 10 minutes)

Usage, listener mode:
    ricloud --listen [--timeout=<timeout>]

Options, listener mode:
    -h --help               Show this screen.
    --timeout=<timeout>     How long should we wait for tasks to complete, in seconds. (default: 600s or 10 minutes)

Modalità interattiva con asapi

La modalità interattiva della libreria fornisce un esempio di come asapi può essere utilizzato per accedere a una gamma di tipi di dati in un modo compatibile con il meccanismo 2FA di Apple.

Per eseguire lo script interattivo di esempio, eseguire il seguente comando:

$ python -m ricloud john.appleseed@reincubate.com --password=joshua

Modalità Manager con asmaster

La libreria di esempio ricloud viene fornita con una modalità di gestione della sottoscrizione della riga di comando. Ciò consente ai clienti di gestire manualmente gli abbonamenti laddove necessario e dimostra come sia possibile realizzare un'implementazione di produzione.

Ecco una panoramica di come un utente potrebbe utilizzare la modalità amministratore. In primo luogo, è importante che qualcosa ascolti l' ascannel quando lo fai.

Vediamo quali sono le iscrizioni registrate:

{ "services": [{
    "name": "iCloud",
    "actions": [{
      "description": "",
      "parameters": [{
        "type": "string",
        "description": "",
        "optional": false,
        "name": "Device",
        "slug": "device"
      }, {
        "type": "date",
        "description": "",
        "optional": true,
        "name": "Since",
        "slug": "since"
      }],
      "name": "Fetch Data",
      "execution": "Asynchronous",
      "slug": "fetch-data",
      "permissions": {
        "data": ["sms"]
      }
    }],
    "slug": "icloud"
  }],
  "stream_endpoints": [{
    "host": "aschannel.reincubate.com",
    "protocol": "https",
    "uri": "/stream/"
  }]
}
python -m ricloud --list-subscriptions icloud
{u'accounts': [], u'success': True}

Non ce ne sono. Aggiungiamolo uno. Si potrebbe aggiungere l'account di dati fittizi con questa linea:

$ python -m ricloud --subscribe-account john.appleseed@reincubate.com joshua icloud

Invece, aggiungiamo un account reale che è protetto da 2FA:

$ python -m ricloud --subscribe-account john.appleseed@reincubate.com "xxxx" icloud
{
  "message": "This account has Multi Factor Authentication enabled, please select a device to challenge.",
  "data": {
    "trusted_devices": [
      "Challenge all 2FA devices"
    ]
  },
  "account_id": 133733,
  "success": false,
  "error": "2fa-required"
}

Ciò significa che a john.appleseed@reincubate.com è stato assegnato un account_id di 133733 e che è necessaria una sfida 2FA per tale account:

$ python -m ricloud --perform-2fa-challenge 133733 0
{u'message': u'Challenge has been submitted.', u'success': True}

Ciò attiva il prompt 2FA sui dispositivi dell'utente finale, fornendo un codice di autenticazione. Diciamo che è 123456 .

$ python -m ricloud --submit-2fa-challenge 133733 123456
{u'account_id': 133733, u'success': True}

Quindi l'autenticazione ha avuto successo e l'account è stato sottoscritto. Ciò significa che è possibile elencare e iscriversi ai dispositivi. Vediamo quali sono disponibili:

$ python -m ricloud --list-devices 133733
{u'devices': [
  {u'ios_version': u'10.2', u'name': u'iPhone 7 Plus', u'colour': u'1', u'device_name': u'Johnny\'s iP7 iOS10 Black', u'latest-backup': u'2017-01-31 22:06:06.000000', u'model': u'D111AP', u'device_tag': u'3d0d7e5fb2ce288813306e4d4636395e047a3d28', u'serial': u'ABC123AAAAAA', u'device_id': 2},
  {u'ios_version': u'10.3.1', u'name': u'iPad Pro', u'colour': u'#e4e7e8', u'device_name': u'Johnny\'s iPad', u'latest-backup': u'2017-04-22 15:39:25.000000', u'model': u'J127AP', u'device_tag': u'b39bac0d347adfaf172527f97c3a5fa3df726a3a', u'serial': u'ABC123BBBBBB', u'device_id': 3},
  {u'ios_version': u'10.3.1', u'name': u'iPhone 7 Plus', u'colour': u'1', u'device_name': u'Johnny\'s other iPhone', u'latest-backup': u'2017-04-13 21:08:47.000000', u'model': u'D111AP', u'device_tag': u'a49bfab36504be1bf563c1d1813b05efd6076717', u'serial': u'DFVDASDDSVAS', u'device_id': 4}
], u'success': True}

Controlliamo anche quali dispositivi sono abbonati:

$ python -m ricloud --list-subscriptions
{
  "accounts": [
    {
      "status": "ok",
      "service": "icloud",
      "account_id": 133733,
      "devices": [
        {
          "status": "ok",
          "device_id": 2
        },
        {
          "status": "ok",
          "device_id": 3
        },
        {
          "status": "ok",
          "device_id": 4
        }
      ]
    }
  ]
}

Questo dimostra che nessuno dei dispositivi è stato sottoscritto, quindi dovremmo abbonarci a uno.

$ python -m ricloud --subscribe-device 133733 2
{u'account_id': 133733, u'device_id': 2, u'success': True}

Completati questi passaggi, i dati di john.appleseed@reincubate.com e il dispositivo selezionato scorreranno automaticamente verso l' aschannel man mano che è pronto.

Se proviamo ad abbonarci allo stesso account due volte, verrà restituito un errore come questo:

$ python -m ricloud --subscribe-account john.appleseed@reincubate.com josha icloud
{
  "message": "You are already subscribed to receive content for this account.",
  "account_id": 133733,
  "success": false,
  "error": "asmaster-account-already-active"
}

Modalità di ascolto con canale ascendente

Il listener ricloud è un meccanismo di listener distribuito localmente per l'API. In sostanza, consente ai client di installare un servizio nel proprio cloud o datacenter che inserisce automaticamente i dati ricevuti dall'API in un database e un filesystem locali.

Il listener decifra automaticamente i dati dall'API, inserisce i risultati del feed e i metadati in un database locale e memorizza i file sul filesystem. L'ascoltatore è Open Source e può essere modificato liberamente dagli utenti. Esistono molte strategie che possono essere utilizzate con esso, incluso averlo scritto su storage condiviso del filesystem o anche modificarlo per inserire dati nell'archivio dati di produzione di un cliente.

Oltre a scrivere qualsiasi file che riceve sul disco, il database del listener ha tabelle per tutti i dati che gli vengono forniti.

  • feed : qui vengono archiviati i dati JSON e i metadati dei moduli di alimentazione
  • file : qui vengono memorizzati i puntatori e i metadati dei file
  • message : i message informativi sono memorizzati qui
  • system : i messaggi di sistema sono memorizzati qui

Per comprendere e agire sui dati ricevuti, è importante eseguire regolarmente la scansione di queste tabelle per i nuovi record. Può essere che l'applicazione client cancelli semplicemente le righe che ha già letto o importato.

In esecuzione

Il processo listener può essere avviato con il seguente comando:

$ python -m ricloud --listen

Interpretazione di messaggi e notifiche di sistema

Messaggi e avvisi di sistema vengono automaticamente memorizzati in due tabelle: messages e system . Questi messaggi vengono memorizzati dopo essere stati inviati tramite lo stream. La maggior parte di questi messaggi sono puramente informativi, ma alcuni sono critici.

messaggi

  • Il token utente è scaduto; necessario aggiornamento del token.
  • Account utente bloccato; necessario aggiornamento del token.
  • Altro errore durante l'accesso ai dati; nessuna azione richiesta.

Avvisi di sistema

I messaggi di sistema più comuni sono descritti nei messaggi di sistema . Indicano eventuali problemi continuando a leggere dallo stream.

Accesso ai dati del feed

Il listener memorizza ogni feed che riceve nella tabella dei feed . I campi chiave sono i seguenti:

  • received : la data in cui il feed è stato recuperato.
  • account_id : l'ID account relativo al feed.
  • device_id : l'ID del dispositivo relativo al feed.
  • body : il feed in formato JSON.

Recupero di file

Il listener crea una voce nel database per ogni file che riceve e scrive i file nel filesystem nella cartella di output/files , relativa al percorso corrente della shell in esecuzione.

mysql> SELECT id, received, account_id, device_id, location, file_id FROM file LIMIT 1000;
+----+---------------------+------------+-----------+--------------------------------------+---------+
| id | received            | account_id | device_id | location                             | file_id |
+----+---------------------+------------+-----------+--------------------------------------+---------+
|  1 | 2017-04-14 15:38:39 |       NULL |      NULL | 91f49a4f-3368-4350-ae90-a944d4652fbe |         |
|  2 | 2017-04-14 15:38:40 |       NULL |      NULL | 9b0381b6-244d-4d82-8198-57798d89a379 |         |
|  3 | 2017-04-14 15:38:41 |       NULL |      NULL | b9ccd1ed-8d80-4b33-be99-a3a7f1af73ce |         |
|  4 | 2017-04-14 15:38:42 |       NULL |      NULL | b3666148-a17e-4ca8-90db-975e1850a72b |         |
+----+---------------------+------------+-----------+--------------------------------------+---------+
4 rows in set (0.00 sec)
$ ls -l output/files
-rw-r--r-- 1 renate 1143 Apr 14 13:47 91f49a4f-3368-4350-ae90-a944d4652fbe
-rw-r--r-- 1 renate 2866 Apr 14 14:09 9b0381b6-244d-4d82-8198-57798d89a379
-rw-r--r-- 1 renate 2866 Apr 14 15:18 b9ccd1ed-8d80-4b33-be99-a3a7f1af73ce
-rw-r--r-- 1 renate 1143 Apr 14 13:49 b3666148-a17e-4ca8-90db-975e1850a72b

file_id file viene dato un contesto solo dai dati del feed, quindi il punto da cui iniziare è con un file file_id riferito da una voce del feed.

La tabella file nel database ha i seguenti campi chiave:

  • received : la data in cui il file è stato recuperato.
  • account_id : l'ID account relativo al file.
  • device_id : l'ID del dispositivo relativo al file.
  • location : la posizione del file sul disco del listener.
  • file_id : l'ID del file.

Manutenzione del database listener

Nessuna delle tabelle listener contiene alcun dato critico per il funzionamento del listener. Di conseguenza, una volta che i dati sono stati consumati dall'applicazione client, il cliente può cancellare liberamente i dati.

Allo stesso modo, i file scaricati possono essere cancellati liberamente in qualsiasi momento.

Come possiamo aiutare?

Il nostro team di supporto è qui per aiutarti!

I nostri orari di ufficio sono dal lunedì al venerdì, dalle 9:00 alle 17:00 GMT. L'ora è attualmente 2:33 PM GMT.

Miriamo a rispondere a tutti i messaggi entro un giorno lavorativo.

Vai alla sezione di supporto › Contatta il team aziendale ›
Il nostro fantastico team di supporto

© 2008 - 2019 Reincubate Ltd. Tutti i diritti riservati. Registrato in Inghilterra e Galles #5189175, VAT GB151788978. Reincubate® è un marchio registrato. Termini e Condizioni. Raccomandiamo 2FA. Costruito con a Londra.