Schnellstart in Python (v2)

Aktualisierte

Überblick

Die Referenz-Open-Source-Bibliothek von ricloud ist in Python implementiert und wird auf GitHub gehostet.

Die Implementierung wird mit einer Dokumentation und einem Beispielskript gebündelt, das zeigt, wie es verwendet werden kann. Die Konfiguration beschränkt sich auf das ~/.ricloud.ini einer ~/.ricloud.ini Konfigurationsdatei mit einem token für die Authentifizierung gegenüber der API sowie einem Stream-Endpunktwert zum Erfassen der Ergebnisse der Serviceaktion.

Quelle und Dokumentation für diese Bibliothek finden Sie auf GitHub .

Bedarf

Die Ricloud-Bibliothek stellt nur sehr wenige Anforderungen an das Design. Es sollte auf den meisten Systemen mit Python 2.7 laufen. Um den Listener-Modus nutzen zu können, ist MySQL 5.7 oder höher erforderlich. Weitere Informationen zur Verwendung der Open Source-Bibliothek in der Produktion finden Sie unter Verwenden des Beispielclients in der Produktion.

Installation

Die Ricloud- Bibliothek kann mit einem einzigen Befehl installiert werden:

$ pip install ricloud

Um den Listener-Modus mit automatischem Ausgeben von Daten an MySQL zu verwenden, muss das Schema-Konfigurationsskript auf eine lokale Datenbank angewendet werden. Dies kann verwendet werden, um das erforderliche Schema und die erforderlichen Tabellen in der Datenbank zu erstellen:

$ mysql -u root < sql/create_schema.sql

Aufbau

Die API basiert auf einer Reihe von Sicherheitsanmeldeinformationen, die in einer Datei ricloud.ini gespeichert sind. Dieses Paket wird mit einer Standardkonfigurationsdatei geliefert, die zu Demonstrationszwecken eingeschränkten Zugriff auf die API ermöglicht.

Die Standardanmeldeinformationen können überschrieben werden, indem eine Überschreibungsdatei mit dem Namen .ricloud.ini im HOME Verzeichnis des Benutzers erstellt wird. Alternativ kann eine RICLOUD_CONF Umgebungsvariable festgelegt werden, die den vollständigen Pfad und den Dateinamen der Konfigurationsdatei angibt.

[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

Die Standarddatei ricloud.ini befindet sich in diesem Repository .

Befehlszeilenparameter

Die Bibliothek bietet eine Aufschlüsselung der Befehlszeilenargumente, wenn das Argument --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)

Interaktiver Modus mit asapi

Der interaktive Modus der Bibliothek bietet ein Beispiel dafür, wie mit asapi auf eine Reihe von Datentypen zugegriffen werden kann, die mit dem 2FA-Mechanismus von Apple kompatibel sind.

Führen Sie den folgenden Befehl aus, um das interaktive Beispielskript auszuführen:

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

Managermodus mit asmaster

Die ricloud- Beispielbibliothek wird mit einem Verwaltungsmodus für Befehlszeilenabonnements ausgeliefert. Auf diese Weise können Clients Abonnements bei Bedarf manuell verwalten und zeigen, wie eine Produktionsimplementierung erstellt werden kann.

Im Folgenden wird erläutert, wie ein Benutzer den Managermodus verwenden kann. Erstens ist es wichtig, dass dabei etwas auf einen Kanal hört.

Mal sehen, welche Abonnements registriert sind:

{ "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}

Es gibt keine. Fügen wir eins hinzu. Man könnte das falsche Datenkonto mit dieser Zeile hinzufügen:

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

Fügen wir stattdessen ein echtes Konto hinzu, das durch 2FA geschützt ist:

$ 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"
}

Dies bedeutet, dass john.appleseed@reincubate.com eine account_id von 133733 zugewiesen wurde und eine account_id 133733 für dieses Konto erforderlich ist:

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

Dadurch wird die 2FA-Eingabeaufforderung auf den Geräten des Endbenutzers ausgelöst und ein Authentifizierungscode bereitgestellt. Nehmen wir an, das ist 123456 .

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

Die Authentifizierung war also erfolgreich und das Konto ist abonniert. Das heißt, man kann Geräte auflisten und abonnieren. Mal sehen, welche verfügbar sind:

$ 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}

Lassen Sie uns auch überprüfen, welche Geräte abonniert sind:

$ 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
        }
      ]
    }
  ]
}

Dies zeigt, dass keines der Geräte abonniert wurde. Daher sollten wir eines abonnieren.

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

Mit diesen Schritten abgeschlossen ist , Daten von der john.appleseed@reincubate.com und dem gewählten Gerät wird automatisch nach unten fließen aschannel wie und wann es fertig ist.

Wenn wir versuchen, dasselbe Konto zweimal zu abonnieren, wird ein Fehler wie der folgende zurückgegeben:

$ 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"
}

Listener-Modus mit einem Kanal

Der Ricloud-Listener ist ein lokal implementierter Listener-Mechanismus für die API. Im Wesentlichen können Clients einen Dienst in ihrer eigenen Cloud oder ihrem eigenen Rechenzentrum installieren, der die von der API empfangenen Daten automatisch in eine lokale Datenbank und ein lokales Dateisystem einfügt.

Der Listener entfernt automatisch Daten aus der API, fügt Feed-Ergebnisse und Metadaten in eine lokale Datenbank ein und speichert Dateien im Dateisystem. Der Listener ist Open Source und kann von Benutzern frei geändert werden. Es gibt viele Strategien, die verwendet werden können, einschließlich des Schreibens in den gemeinsam genutzten Dateisystemspeicher oder sogar des Änderns, um Daten in den Produktionsdatenspeicher eines Clients einzufügen.

Die Listener-Datenbank schreibt nicht nur alle empfangenen Dateien auf die Festplatte, sondern enthält auch Tabellen für alle Daten, die ihr zugeführt werden.

  • feed : Hier werden JSON-Daten und Metadaten von Feed-Modulen gespeichert
  • file : Hier werden file und Metadaten gespeichert
  • message : Hier werden Informationsnachrichten gespeichert
  • system : Hier werden Systemmeldungen abgelegt

Um die empfangenen Daten zu verstehen und zu verarbeiten, ist es wichtig, diese Tabellen regelmäßig nach neuen Datensätzen zu durchsuchen. Es kann sein, dass die Client-Anwendung bereits gelesene oder importierte Zeilen einfach löscht.

Laufen

Der Listener-Prozess kann mit dem folgenden Befehl gestartet werden:

$ python -m ricloud --listen

Interpretieren von Nachrichten und Systemnachrichten

Nachrichten und Systemnachrichten werden automatisch in zwei Tabellen gespeichert: messages und system . Diese Nachrichten werden gespeichert, nachdem sie über den Stream gesendet wurden. Die meisten dieser Meldungen dienen lediglich der Information, einige sind jedoch kritisch.

Mitteilungen

  • Benutzer-Token ist abgelaufen. Token-Aktualisierung erforderlich.
  • Benutzerkonto gesperrt; Token-Aktualisierung erforderlich.
  • Andere Fehler beim Zugriff auf Daten; Keine Aktion erforderlich.

Systemhinweise

Die häufigsten Systemnachrichten werden in Systemnachrichten beschrieben. Sie werden auf Probleme hinweisen, die weiterhin aus dem Stream gelesen werden.

Zugriff auf Feed-Daten

Der Listener speichert jeden empfangenen feed in der feed Tabelle. Die Schlüsselfelder sind wie folgt:

  • received : Das Datum, an dem der Feed abgerufen wurde.
  • account_id : Die Konto-ID des Feeds.
  • device_id : Die Geräte-ID des Feeds.
  • body : Der Feed im JSON-Format.

Dateien werden abgerufen

Der Listener erstellt für jede empfangene Datei einen Eintrag in der Datenbank und schreibt die Dateien relativ zum aktuellen Pfad der ausführenden Shell in das Dateisystem im Ordner output/files .

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

Dateien werden nur durch Feed-Daten file_id Ausgangspunkt ist also eine file_id auf die durch einen Feed-Eintrag verwiesen wird.

Die file in der Datenbank enthält die folgenden Schlüsselfelder:

  • received : Das Datum, an dem die Datei abgerufen wurde.
  • account_id : Die zur Datei gehörende Konto-ID.
  • device_id : Die ID - Gerät auf die Datei beziehen.
  • location : Der Speicherort der Datei auf der Festplatte des Listeners.
  • file_id : Die ID der Datei.

Pflege der Listener-Datenbank

In keiner der Listener-Tabellen sind Daten enthalten, die für die Arbeit des Listeners kritisch sind. Sobald die Daten von der Client-Anwendung verarbeitet wurden, kann der Client die Daten daher nach Belieben löschen.

Ebenso können die heruntergeladenen Dateien jederzeit frei gelöscht werden.

Wie können wir helfen?

Unser Support-Team hilft Ihnen gerne weiter!

Unsere Bürozeiten sind Montag bis Freitag von 9 bis 17 Uhr GMT. Die Zeit ist aktuell 11:13 vorm. GMT.

Wir bemühen uns, auf alle Mitteilungen innerhalb eines Arbeitstages zu antworten.

Zum Support-Bereich gehen › Wenden Sie sich an das Unternehmensteam ›
Unser großartiges Supportteam

© 2008 - 2019 Reincubate Ltd. Alle Rechte vorbehalten. Registriert in England und Wales #5189175, VAT GB151788978. Reincubate® ist eine eingetragene Marke. Datenschutz. Wir empfehlen die Multi-Faktor-Authentifizierung. Mit Liebe in London gebaut.